blob: 91ac90a94a98feff3915dc6405621c0bc93a2dc8 [file]
// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <unistd.h>
#include <cstring>
#include <thread>
#include <vector>
#include <gtest/gtest.h>
#include "src/starnix/tests/syscalls/cpp/test_helper.h"
TEST(ReadWriteTest, preadv_pwritev) {
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
// Add some data to the file and seek back to the beginning so we know the offset took effect.
constexpr int kOffset = 7;
const char kOffsetBuffer[kOffset + 1] = "zzzzzzz";
EXPECT_EQ(kOffset, HANDLE_EINTR(write(temp_file.fd(), kOffsetBuffer, kOffset)));
constexpr size_t kWriteBufferSize = 32;
char kWriteBuffer[kWriteBufferSize + 1] = "aaaaaaaabbbbbbbbccccccccdddddddd";
struct iovec iov[] = {
{
.iov_base = &kWriteBuffer[8], // Pick 8 b's.
.iov_len = 8,
},
{
.iov_base = &kWriteBuffer[0], // a's followed by b's
.iov_len = 16,
},
{
.iov_base = &kWriteBuffer[16], // c's followed by d's.
.iov_len = 16,
},
};
// Technically this can do partial writes but our implementation doesn't support this.
constexpr ssize_t kExpectedSize = 40;
ssize_t result = HANDLE_EINTR(pwritev(temp_file.fd(), iov, std::size(iov), kOffset));
EXPECT_EQ(kExpectedSize, result);
lseek(temp_file.fd(), 0, SEEK_SET);
// Generate read the vector using the same offsets as above, but pointing into the read buffer.
char read_buffer[kWriteBufferSize + 1] = {0};
iov[0].iov_base = &read_buffer[8];
iov[1].iov_base = &read_buffer[0];
iov[2].iov_base = &read_buffer[16];
result = HANDLE_EINTR(preadv(temp_file.fd(), iov, std::size(iov), kOffset));
EXPECT_EQ(kExpectedSize, result);
read_buffer[kWriteBufferSize] = 0; // Null terminate input for comparison.
EXPECT_STREQ(read_buffer, kWriteBuffer);
}
// TODO(https://fxbug.dev/42068846) implement partial read/write support (we'll
// also need tests for read(), writev(), and readv()).
TEST(ReadWriteTest, DISABLED_PartialWrite) {
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
// Allocate 2 pages and remove permission from the second.
constexpr size_t kPageSize = 4096;
const size_t size = 2 * kPageSize;
void* addr = mmap(0, size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
ASSERT_TRUE(addr);
void* bad_addr = reinterpret_cast<char*>(addr) + kPageSize;
ASSERT_EQ(0, mprotect(bad_addr, kPageSize, PROT_NONE));
// Complete bad write.
errno = 0;
ssize_t sresult = write(temp_file.fd(), bad_addr, 2);
EXPECT_EQ(-1, sresult);
EXPECT_EQ(EFAULT, errno);
// Partial write, should write the first page and stop on the (invalid) second one.
errno = 0;
sresult = write(temp_file.fd(), addr, size);
EXPECT_EQ(ssize_t(kPageSize), sresult);
EXPECT_EQ(0, errno);
// The seek offset should reflect the last partial write.
off_t off = lseek(temp_file.fd(), 0, SEEK_CUR);
EXPECT_EQ(off_t(kPageSize), off);
munmap(addr, size);
}
TEST(ReadWriteTest, PwriteOAppendAtomicity) {
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
int flags = fcntl(temp_file.fd(), F_GETFL);
ASSERT_NE(flags, -1);
ASSERT_EQ(fcntl(temp_file.fd(), F_SETFL, flags | O_APPEND), 0);
constexpr size_t kNumThreads = 100;
constexpr size_t kWriteSize = 1000;
constexpr size_t kNumWrites = 10;
std::vector<std::thread> threads;
for (size_t i = 0; i < kNumThreads; ++i) {
threads.emplace_back([fd = temp_file.fd(), i]() {
char buf[kWriteSize];
memset(buf, static_cast<int>('a' + i), kWriteSize);
for (size_t j = 0; j < kNumWrites; ++j) {
ssize_t written = pwrite(fd, buf, kWriteSize, 0);
EXPECT_EQ(written, static_cast<ssize_t>(kWriteSize));
}
});
}
for (auto& t : threads) {
t.join();
}
// Check file size. If atomicity fails, size will likely be less than expected.
struct stat st;
ASSERT_EQ(fstat(temp_file.fd(), &st), 0);
EXPECT_EQ(st.st_size, static_cast<off_t>(kNumThreads * kWriteSize * kNumWrites));
}
// This test is somewhat best-effort; it won't reliably fail, necessarily.
// It attempts to verify the atomicity of concurrent write and truncate operations
// on an O_APPEND file by spawning multiple writer and truncater threads and
// checking if holes are created in the file.
TEST(ReadWriteTest, TruncateWriteAtomicity) {
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
int fd = temp_file.fd();
int flags = fcntl(fd, F_GETFL);
ASSERT_NE(flags, -1);
ASSERT_EQ(fcntl(fd, F_SETFL, flags | O_APPEND), 0);
// Write some initial data.
constexpr size_t kBufferSize = 1000;
char buf[kBufferSize];
memset(buf, 'A', kBufferSize);
ASSERT_EQ(write(fd, buf, kBufferSize), static_cast<ssize_t>(kBufferSize));
constexpr size_t kNumIterations = 1000;
constexpr size_t kNumThreads = 10;
std::vector<std::thread> writers;
std::vector<std::thread> truncaters;
for (size_t i = 0; i < kNumThreads; ++i) {
writers.emplace_back([fd, buf]() {
for (size_t j = 0; j < kNumIterations; ++j) {
HANDLE_EINTR(write(fd, buf, kBufferSize));
}
});
truncaters.emplace_back([fd]() {
for (size_t j = 0; j < kNumIterations; ++j) {
HANDLE_EINTR(ftruncate(fd, 0));
}
});
}
for (auto& t : writers)
t.join();
for (auto& t : truncaters)
t.join();
// Check if the file contains holes.
lseek(fd, 0, SEEK_SET);
char read_buf[kBufferSize];
ssize_t n = read(fd, read_buf, kBufferSize);
if (n > 0) {
EXPECT_NE(read_buf[0], 0) << "Found hole at beginning of file!";
}
}