| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <assert.h> |
| #include <stdint.h> |
| #include <gtest/gtest.h> |
| |
| #include <trusty/lib/storage.h> |
| |
| #define TRUSTY_DEVICE_NAME "/dev/trusty-ipc-dev0" |
| |
| #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) |
| |
| static inline bool is_32bit_aligned(size_t sz) |
| { |
| return ((sz & 0x3) == 0); |
| } |
| |
| static inline bool is_valid_size(size_t sz) { |
| return (sz > 0) && is_32bit_aligned(sz); |
| } |
| |
| static bool is_valid_offset(storage_off_t off) |
| { |
| return (off & 0x3) == 0ULL; |
| } |
| |
| static void fill_pattern32(uint32_t *buf, size_t len, storage_off_t off) |
| { |
| size_t cnt = len / sizeof(uint32_t); |
| uint32_t pattern = (uint32_t)(off / sizeof(uint32_t)); |
| while (cnt--) { |
| *buf++ = pattern++; |
| } |
| } |
| |
| static bool check_pattern32(const uint32_t *buf, size_t len, storage_off_t off) |
| { |
| size_t cnt = len / sizeof(uint32_t); |
| uint32_t pattern = (uint32_t)(off / sizeof(uint32_t)); |
| while (cnt--) { |
| if (*buf != pattern) |
| return false; |
| buf++; |
| pattern++; |
| } |
| return true; |
| } |
| |
| static bool check_value32(const uint32_t *buf, size_t len, uint32_t val) |
| { |
| size_t cnt = len / sizeof(uint32_t); |
| while (cnt--) { |
| if (*buf != val) |
| return false; |
| buf++; |
| } |
| return true; |
| } |
| |
| using testing::TestWithParam; |
| |
| class StorageServiceTest : public virtual TestWithParam<const char *> { |
| public: |
| StorageServiceTest() {} |
| virtual ~StorageServiceTest() {} |
| |
| virtual void SetUp() { |
| port_ = GetParam(); |
| test_buf_ = NULL; |
| aux_session_ = STORAGE_INVALID_SESSION; |
| int rc = storage_open_session(TRUSTY_DEVICE_NAME, &session_, port_); |
| ASSERT_EQ(0, rc); |
| } |
| |
| virtual void TearDown() { |
| if (test_buf_) { |
| delete[] test_buf_; |
| test_buf_ = NULL; |
| } |
| storage_close_session(session_); |
| |
| if (aux_session_ != STORAGE_INVALID_SESSION) { |
| storage_close_session(aux_session_); |
| aux_session_ = STORAGE_INVALID_SESSION; |
| } |
| } |
| |
| void WriteReadAtOffsetHelper(file_handle_t handle, size_t blk, size_t cnt, bool complete); |
| |
| void WriteZeroChunk(file_handle_t handle, storage_off_t off, size_t chunk_len, bool complete ); |
| void WritePatternChunk(file_handle_t handle, storage_off_t off, size_t chunk_len, bool complete); |
| void WritePattern(file_handle_t handle, storage_off_t off, size_t data_len, size_t chunk_len, bool complete); |
| |
| void ReadChunk(file_handle_t handle, storage_off_t off, size_t chunk_len, |
| size_t head_len, size_t pattern_len, size_t tail_len); |
| void ReadPattern(file_handle_t handle, storage_off_t off, size_t data_len, size_t chunk_len); |
| void ReadPatternEOF(file_handle_t handle, storage_off_t off, size_t chunk_len, size_t exp_len); |
| |
| protected: |
| const char *port_; |
| uint32_t *test_buf_; |
| storage_session_t session_; |
| storage_session_t aux_session_; |
| }; |
| |
| INSTANTIATE_TEST_CASE_P(SS_TD_Tests, StorageServiceTest, ::testing::Values(STORAGE_CLIENT_TD_PORT)); |
| INSTANTIATE_TEST_CASE_P(SS_TDEA_Tests, StorageServiceTest, ::testing::Values(STORAGE_CLIENT_TDEA_PORT)); |
| INSTANTIATE_TEST_CASE_P(SS_TP_Tests, StorageServiceTest, ::testing::Values(STORAGE_CLIENT_TP_PORT)); |
| |
| |
| void StorageServiceTest::WriteZeroChunk(file_handle_t handle, storage_off_t off, |
| size_t chunk_len, bool complete) |
| { |
| int rc; |
| uint32_t data_buf[chunk_len/sizeof(uint32_t)]; |
| |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| ASSERT_PRED1(is_valid_offset, off); |
| |
| memset(data_buf, 0, chunk_len); |
| |
| rc = storage_write(handle, off, data_buf, sizeof(data_buf), |
| complete ? STORAGE_OP_COMPLETE : 0); |
| ASSERT_EQ((int)chunk_len, rc); |
| } |
| |
| void StorageServiceTest::WritePatternChunk(file_handle_t handle, storage_off_t off, |
| size_t chunk_len, bool complete) |
| { |
| int rc; |
| uint32_t data_buf[chunk_len/sizeof(uint32_t)]; |
| |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| ASSERT_PRED1(is_valid_offset, off); |
| |
| fill_pattern32(data_buf, chunk_len, off); |
| |
| rc = storage_write(handle, off, data_buf, sizeof(data_buf), |
| complete ? STORAGE_OP_COMPLETE : 0); |
| ASSERT_EQ((int)chunk_len, rc); |
| } |
| |
| void StorageServiceTest::WritePattern(file_handle_t handle, storage_off_t off, |
| size_t data_len, size_t chunk_len, bool complete) |
| { |
| ASSERT_PRED1(is_valid_size, data_len); |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| |
| while (data_len) { |
| if (data_len < chunk_len) |
| chunk_len = data_len; |
| WritePatternChunk(handle, off, chunk_len, (chunk_len == data_len) && complete); |
| ASSERT_FALSE(HasFatalFailure()); |
| off += chunk_len; |
| data_len -= chunk_len; |
| } |
| } |
| |
| void StorageServiceTest::ReadChunk(file_handle_t handle, |
| storage_off_t off, size_t chunk_len, |
| size_t head_len, size_t pattern_len, |
| size_t tail_len) |
| { |
| int rc; |
| uint32_t data_buf[chunk_len/sizeof(uint32_t)]; |
| uint8_t *data_ptr = (uint8_t *)data_buf; |
| |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| ASSERT_PRED1(is_valid_offset, off); |
| ASSERT_EQ(head_len + pattern_len + tail_len, chunk_len); |
| |
| rc = storage_read(handle, off, data_buf, chunk_len); |
| ASSERT_EQ((int)chunk_len, rc); |
| |
| if (head_len) { |
| ASSERT_TRUE(check_value32((const uint32_t *)data_ptr, head_len, 0)); |
| data_ptr += head_len; |
| off += head_len; |
| } |
| |
| if (pattern_len) { |
| ASSERT_TRUE(check_pattern32((const uint32_t *)data_ptr, pattern_len, off)); |
| data_ptr += pattern_len; |
| } |
| |
| if (tail_len) { |
| ASSERT_TRUE(check_value32((const uint32_t *)data_ptr, tail_len, 0)); |
| } |
| } |
| |
| void StorageServiceTest::ReadPattern(file_handle_t handle, storage_off_t off, |
| size_t data_len, size_t chunk_len) |
| { |
| int rc; |
| uint32_t data_buf[chunk_len/sizeof(uint32_t)]; |
| |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| ASSERT_PRED1(is_valid_size, data_len); |
| ASSERT_PRED1(is_valid_offset, off); |
| |
| while (data_len) { |
| if (chunk_len > data_len) |
| chunk_len = data_len; |
| rc = storage_read(handle, off, data_buf, sizeof(data_buf)); |
| ASSERT_EQ((int)chunk_len, rc); |
| ASSERT_TRUE(check_pattern32(data_buf, chunk_len, off)); |
| off += chunk_len; |
| data_len -= chunk_len; |
| } |
| } |
| |
| void StorageServiceTest::ReadPatternEOF(file_handle_t handle, storage_off_t off, |
| size_t chunk_len, size_t exp_len) |
| { |
| int rc; |
| size_t bytes_read = 0; |
| uint32_t data_buf[chunk_len/sizeof(uint32_t)]; |
| |
| ASSERT_PRED1(is_valid_size, chunk_len); |
| ASSERT_PRED1(is_32bit_aligned, exp_len); |
| |
| while (true) { |
| rc = storage_read(handle, off, data_buf, sizeof(data_buf)); |
| ASSERT_GE(rc, 0); |
| if (rc == 0) |
| break; // end of file reached |
| ASSERT_PRED1(is_valid_size, (size_t)rc); |
| ASSERT_TRUE(check_pattern32(data_buf, rc, off)); |
| off += rc; |
| bytes_read += rc; |
| } |
| ASSERT_EQ(bytes_read, exp_len); |
| } |
| |
| TEST_P(StorageServiceTest, CreateDelete) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "test_create_delete_file"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // one more time (expect -ENOENT only) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // create file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // try to create it again while it is still opened (expect -EEXIST) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EEXIST, rc); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // try to create it again while it is closed (expect -EEXIST) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EEXIST, rc); |
| |
| // delete file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // one more time (expect -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, DeleteOpened) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "delete_opened_test_file"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // one more time (expect -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // open/create file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // delete opened file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // one more time (expect -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // one more time (expect -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenNoCreate) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "test_open_no_create_file"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // open non-existing file (expect -ENOENT) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // create file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // open existing file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // delete file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenOrCreate) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "test_open_create_file"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // open/create a non-existing file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // open/create an existing file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // delete file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenCreateDeleteCharset) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "ABCDEFGHIJKLMNOPQRSTUVWXYZ-abcdefghijklmnopqrstuvwxyz_01234.56789"; |
| |
| // open/create file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // open/create an existing file (expect 0) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // delete file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open again |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, WriteReadSequential) { |
| int rc; |
| size_t blk = 2048; |
| file_handle_t handle; |
| const char *fname = "test_write_read_sequential"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // create file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks (sequentially) |
| WritePattern(handle, 0, 32 * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPattern(handle, 0, 32 * blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // open the same file again |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // read data back (sequentially) and check pattern again |
| ReadPattern(handle, 0, 32 * blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenTruncate) { |
| int rc; |
| uint32_t val; |
| size_t blk = 2048; |
| file_handle_t handle; |
| const char *fname = "test_open_truncate"; |
| |
| // make sure test file does not exist (expect success or -ENOENT) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| |
| // create file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write some data and read it back |
| WritePatternChunk(handle, 0, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPattern(handle, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // reopen with truncate |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_TRUNCATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| /* try to read data back (expect no data) */ |
| rc = storage_read(handle, 0LL, &val, sizeof(val)); |
| ASSERT_EQ(0, rc); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenSame) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| file_handle_t handle3; |
| const char *fname = "test_open_same_file"; |
| |
| // open/create file (expect 0) |
| rc = storage_open_file(session_, &handle1, fname, STORAGE_FILE_OPEN_CREATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle1); |
| |
| // open an existing file first time (expect 0) |
| rc = storage_open_file(session_, &handle1, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // open the same file second time (expect error) |
| rc = storage_open_file(session_, &handle2, fname, 0, 0); |
| ASSERT_NE(0, rc); |
| |
| storage_close_file(handle1); |
| |
| // delete file (expect 0) |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open deleted file (expect -ENOENT) |
| rc = storage_open_file(session_, &handle3, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, OpenMany) { |
| int rc; |
| file_handle_t handles[10]; |
| char filename[10]; |
| const char *fname_fmt = "mf%d"; |
| |
| // open or create a bunch of files (expect 0) |
| for (uint i = 0; i < ARRAY_SIZE(handles); ++i) { |
| snprintf(filename, sizeof(filename), fname_fmt, i); |
| rc = storage_open_file(session_, &handles[i], filename, |
| STORAGE_FILE_OPEN_CREATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| } |
| |
| // check that all handles are different |
| for (uint i = 0; i < ARRAY_SIZE(handles)-1; i++) { |
| for (uint j = i+1; j < ARRAY_SIZE(handles); j++) { |
| ASSERT_NE(handles[i], handles[j]); |
| } |
| } |
| |
| // close them all |
| for (uint i = 0; i < ARRAY_SIZE(handles); ++i) { |
| storage_close_file(handles[i]); |
| } |
| |
| // open all files without CREATE flags (expect 0) |
| for (uint i = 0; i < ARRAY_SIZE(handles); ++i) { |
| snprintf(filename, sizeof(filename), fname_fmt, i); |
| rc = storage_open_file(session_, &handles[i], filename, 0, 0); |
| ASSERT_EQ(0, rc); |
| } |
| |
| // check that all handles are different |
| for (uint i = 0; i < ARRAY_SIZE(handles)-1; i++) { |
| for (uint j = i+1; j < ARRAY_SIZE(handles); j++) { |
| ASSERT_NE(handles[i], handles[j]); |
| } |
| } |
| |
| // close and remove all test files |
| for (uint i = 0; i < ARRAY_SIZE(handles); ++i) { |
| storage_close_file(handles[i]); |
| snprintf(filename, sizeof(filename), fname_fmt, i); |
| rc = storage_delete_file(session_, filename, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| } |
| } |
| |
| |
| TEST_P(StorageServiceTest, ReadAtEOF) { |
| int rc; |
| uint32_t val; |
| size_t blk = 2048; |
| file_handle_t handle; |
| const char *fname = "test_read_eof"; |
| |
| // open/create/truncate file |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write block at offset 0 |
| WritePatternChunk(handle, 0, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // open same file again |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // read the whole block back and check pattern again |
| ReadPattern(handle, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read at end of file (expected 0 bytes) |
| rc = storage_read(handle, blk, &val, sizeof(val)); |
| ASSERT_EQ(0, rc); |
| |
| // partial read at end of the file (expected partial data) |
| ReadPatternEOF(handle, blk/2, blk, blk/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read past end of file |
| rc = storage_read(handle, blk + 2, &val, sizeof(val)); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, GetFileSize) { |
| int rc; |
| size_t blk = 2048; |
| storage_off_t size; |
| file_handle_t handle; |
| const char *fname = "test_get_file_size"; |
| |
| // open/create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (expect success and size == 0) |
| size = 1; |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, size); |
| |
| // write block |
| WritePatternChunk(handle, 0, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check size |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ(blk, size); |
| |
| // write another block |
| WritePatternChunk(handle, blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check size again |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ(blk*2, size); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, SetFileSize) { |
| int rc; |
| size_t blk = 2048; |
| storage_off_t size; |
| file_handle_t handle; |
| const char *fname = "test_set_file_size"; |
| |
| // open/create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (expect success and size == 0) |
| size = 1; |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, size); |
| |
| // write block |
| WritePatternChunk(handle, 0, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check size |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ(blk, size); |
| |
| storage_close_file(handle); |
| |
| // reopen normally |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check size again |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ(blk, size); |
| |
| // set file size to half |
| rc = storage_set_file_size(handle, blk/2, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check size again (should be half of original size) |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ(blk/2, size); |
| |
| // read data back |
| ReadPatternEOF(handle, 0, blk, blk/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // set file size to 0 |
| rc = storage_set_file_size(handle, 0, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check size again (should be 0) |
| rc = storage_get_file_size(handle, &size); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0LL, size); |
| |
| // try to read again |
| ReadPatternEOF(handle, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| void StorageServiceTest::WriteReadAtOffsetHelper(file_handle_t handle, size_t blk, size_t cnt, bool complete) |
| { |
| storage_off_t off1 = blk; |
| storage_off_t off2 = blk * (cnt-1); |
| |
| // write known pattern data at non-zero offset1 |
| WritePatternChunk(handle, off1, blk, complete); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write known pattern data at non-zero offset2 |
| WritePatternChunk(handle, off2, blk, complete); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read data back at offset1 |
| ReadPattern(handle, off1, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read data back at offset2 |
| ReadPattern(handle, off2, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read partially written data at end of file(expect to get data only, no padding) |
| ReadPatternEOF(handle, off2 + blk/2, blk, blk/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read data at offset 0 (expect success and zero data) |
| ReadChunk(handle, 0, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read data from gap (expect success and zero data) |
| ReadChunk(handle, off1 + blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read partially written data (start pointing within written data) |
| // (expect to get written data back and zeroes at the end) |
| ReadChunk(handle, off1 + blk/2, blk, 0, blk/2, blk/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read partially written data (start pointing withing unwritten data) |
| // expect to get zeroes at the beginning and proper data at the end |
| ReadChunk(handle, off1 - blk/2, blk, blk/2, blk/2, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| } |
| |
| |
| TEST_P(StorageServiceTest, WriteReadAtOffset) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t blk_cnt = 32; |
| const char *fname = "test_write_at_offset"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with zeroes |
| for (uint i = 0; i < blk_cnt; i++) { |
| WriteZeroChunk(handle, i * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| } |
| |
| WriteReadAtOffsetHelper(handle, blk, blk_cnt, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, WriteSparse) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "test_write_sparse"; |
| |
| // open/create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write value past en of file |
| uint32_t val = 0xDEADBEEF; |
| rc = storage_write(handle, 1, &val, sizeof(val), STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| // Persistent 32k |
| |
| TEST_P(StorageServiceTest, CreatePersistent32K) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t file_size = 32768; |
| const char *fname = "test_persistent_32K_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with pattern |
| WritePattern(handle, 0, file_size, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, ReadPersistent32k) { |
| int rc; |
| file_handle_t handle; |
| size_t exp_len = 32 * 1024; |
| const char *fname = "test_persistent_32K_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| ReadPatternEOF(handle, 0, 2048, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle, 0, 1024, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle, 0, 332, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, CleanUpPersistent32K) { |
| int rc; |
| const char *fname = "test_persistent_32K_file"; |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| } |
| |
| // Persistent 1M |
| TEST_P(StorageServiceTest, CreatePersistent1M_4040) { |
| int rc; |
| file_handle_t handle; |
| size_t file_size = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with pattern |
| WritePattern(handle, 0, file_size, 4040, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, CreatePersistent1M_2032) { |
| int rc; |
| file_handle_t handle; |
| size_t file_size = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with pattern |
| WritePattern(handle, 0, file_size, 2032, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| |
| TEST_P(StorageServiceTest, CreatePersistent1M_496) { |
| int rc; |
| file_handle_t handle; |
| size_t file_size = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with pattern |
| WritePattern(handle, 0, file_size, 496, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, CreatePersistent1M_240) { |
| int rc; |
| file_handle_t handle; |
| size_t file_size = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write a bunch of blocks filled with pattern |
| WritePattern(handle, 0, file_size, 240, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, ReadPersistent1M_4040) { |
| int rc; |
| file_handle_t handle; |
| size_t exp_len = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| ReadPatternEOF(handle, 0, 4040, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, ReadPersistent1M_2032) { |
| int rc; |
| file_handle_t handle; |
| size_t exp_len = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| ReadPatternEOF(handle, 0, 2032, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, ReadPersistent1M_496) { |
| int rc; |
| file_handle_t handle; |
| size_t exp_len = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| ReadPatternEOF(handle, 0, 496, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, ReadPersistent1M_240) { |
| int rc; |
| file_handle_t handle; |
| size_t exp_len = 1024 * 1024; |
| const char *fname = "test_persistent_1M_file"; |
| |
| // create/truncate file. |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| ReadPatternEOF(handle, 0, 240, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close but do not delete file |
| storage_close_file(handle); |
| } |
| |
| TEST_P(StorageServiceTest, CleanUpPersistent1M) { |
| int rc; |
| const char *fname = "test_persistent_1M_file"; |
| rc = storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| rc = (rc == -ENOENT) ? 0 : rc; |
| ASSERT_EQ(0, rc); |
| } |
| |
| TEST_P(StorageServiceTest, WriteReadLong) { |
| int rc; |
| file_handle_t handle; |
| size_t wc = 10000; |
| const char *fname = "test_write_read_long"; |
| |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| test_buf_ = new uint32_t[wc]; |
| fill_pattern32(test_buf_, wc * sizeof(uint32_t), 0); |
| rc = storage_write(handle, 0, test_buf_, wc * sizeof(uint32_t), STORAGE_OP_COMPLETE); |
| ASSERT_EQ((int)(wc * sizeof(uint32_t)), rc); |
| |
| rc = storage_read(handle, 0, test_buf_, wc * sizeof(uint32_t)); |
| ASSERT_EQ((int)(wc * sizeof(uint32_t)), rc); |
| ASSERT_TRUE(check_pattern32(test_buf_, wc * sizeof(uint32_t), 0)); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| // Negative tests |
| |
| TEST_P(StorageServiceTest, OpenInvalidFileName) { |
| int rc; |
| file_handle_t handle; |
| const char *fname1 = ""; |
| const char *fname2 = "ffff$ffff"; |
| const char *fname3 = "ffff\\ffff"; |
| char max_name[STORAGE_MAX_NAME_LENGTH_BYTES+1]; |
| |
| rc = storage_open_file(session_, &handle, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| rc = storage_open_file(session_, &handle, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| rc = storage_open_file(session_, &handle, fname3, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| /* max name */ |
| memset(max_name, 'a', sizeof(max_name)); |
| max_name[sizeof(max_name)-1] = 0; |
| |
| rc = storage_open_file(session_, &handle, max_name, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| max_name[sizeof(max_name)-2] = 0; |
| rc = storage_open_file(session_, &handle, max_name, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| storage_close_file(handle); |
| storage_delete_file(session_, max_name, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, BadFileHnadle) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle1; |
| const char *fname = "test_invalid_file_handle"; |
| |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| handle1 = handle + 1; |
| |
| // write to invalid file handle |
| uint32_t val = 0xDEDBEEF; |
| rc = storage_write(handle1, 0, &val, sizeof(val), STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // read from invalid handle |
| rc = storage_read(handle1, 0, &val, sizeof(val)); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // set size |
| rc = storage_set_file_size(handle1, 0, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // get size |
| storage_off_t fsize = (storage_off_t)(-1); |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // close (there is no way to check errors here) |
| storage_close_file(handle1); |
| |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, ClosedFileHnadle) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| const char *fname1 = "test_invalid_file_handle1"; |
| const char *fname2 = "test_invalid_file_handle2"; |
| |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // close first file handle |
| storage_close_file(handle1); |
| |
| // write to invalid file handle |
| uint32_t val = 0xDEDBEEF; |
| rc = storage_write(handle1, 0, &val, sizeof(val), STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // read from invalid handle |
| rc = storage_read(handle1, 0, &val, sizeof(val)); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // set size |
| rc = storage_set_file_size(handle1, 0, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // get size |
| storage_off_t fsize = (storage_off_t)(-1); |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // close (there is no way to check errors here) |
| storage_close_file(handle1); |
| |
| // clean up |
| storage_close_file(handle2); |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_delete_file(session_, fname2, STORAGE_OP_COMPLETE); |
| } |
| |
| // Transactions |
| |
| TEST_P(StorageServiceTest, TransactDiscardInactive) { |
| int rc; |
| |
| // discard current transaction (there should not be any) |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // try it again |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| } |
| |
| TEST_P(StorageServiceTest, TransactCommitInactive) { |
| int rc; |
| |
| // try to commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // try it again |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardWrite) { |
| |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_write"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // write (without commit) |
| WritePattern(handle, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // cleanup |
| storage_close_file( handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactDiscardWriteAppend) { |
| |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_write_append"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data with commit |
| WritePattern(handle, 0, exp_len/2, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write data without commit |
| WritePattern(handle, exp_len/2, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size (should be exp_len) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // discard transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size, it should be exp_len/2 |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| // check file data |
| ReadPatternEOF(handle, 0, blk, exp_len/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardWriteRead) { |
| |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_write_read"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // Fill with zeroes (with commit) |
| for (uint i = 0; i < 32; i++) { |
| WriteZeroChunk(handle, i * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| } |
| |
| // check that test chunk is filled with zeroes |
| ReadChunk(handle, blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write test pattern (without commit) |
| WritePattern(handle, blk, blk, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back an check pattern |
| ReadChunk(handle, blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // read same chunk back (should be filled with zeros) |
| ReadChunk(handle, blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardWriteMany) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| size_t exp_len1 = 32 * 1024; |
| size_t exp_len2 = 31 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname1 = "test_transact_discard_write_file1"; |
| const char *fname2 = "test_transact_discard_write_file2"; |
| |
| // open create truncate (with commit) |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate (with commit) |
| rc = storage_open_file(session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // file1: fill file with pattern (without commit) |
| WritePattern(handle1, 0, exp_len1, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // file2: fill file with pattern (without commit) |
| WritePattern(handle2, 0, exp_len2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size, it should be exp_len1 |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len1, fsize); |
| |
| // check file size, it should be exp_len2 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len2, fsize); |
| |
| // commit transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size, it should be exp_len1 |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // check file size, it should be exp_len2 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // check data |
| ReadPatternEOF(handle1, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle2, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_close_file(handle2); |
| storage_delete_file(session_, fname2, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardTruncate) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_truncate"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // open truncate file (without commit) |
| rc = storage_open_file(session_, &handle, fname, STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be an oruginal size) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardSetSize) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_set_size"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // set file size to half of original (no commit) |
| rc = storage_set_file_size(handle, (storage_off_t)exp_len/2, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| // set file size to 1/3 of original (no commit) |
| rc = storage_set_file_size(handle, (storage_off_t)exp_len/3, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/3, fsize); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be an original size) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardDelete) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_delete"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // delete file (without commit) |
| rc = storage_delete_file(session_, fname, 0); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it (should fail) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be an original size) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactDiscardDelete2) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_discard_delete"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // delete file (without commit) |
| rc = storage_delete_file(session_, fname, 0); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle); |
| |
| // try to open it (should fail) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be an original size) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactDiscardCreate) { |
| int rc; |
| file_handle_t handle; |
| const char *fname = "test_transact_discard_create_excl"; |
| |
| // delete test file just in case |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| |
| // create file (without commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| 0); |
| ASSERT_EQ(0, rc); |
| |
| // abort current transaction |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactCommitWrites) { |
| |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_commit_writes"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open the same file in aux session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size, it should be 0 |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // write data in primary session (without commit) |
| WritePattern(handle, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write more data in primary session (without commit) |
| WritePattern(handle, exp_len/2, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size in aux session, it should still be 0 |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check file size of aux session, should fail |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // abort transaction in aux session to recover |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check file size in aux session, it should be exp_len |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // check file size in primary session, it should be exp_len |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // check data in primary session |
| ReadPatternEOF(handle, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check data in aux session |
| ReadPatternEOF(handle_aux, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactCommitWrites2) { |
| |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_commit_writes2"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open the same file in separate session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // discard transaction in aux_session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // Fill with zeroes (with commit) |
| for (uint i = 0; i < 8; i++) { |
| WriteZeroChunk(handle, i * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| } |
| |
| // check that test chunks are filled with zeroes |
| ReadChunk(handle, blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadChunk(handle, 2 * blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write test pattern (without commit) |
| WritePattern(handle, blk, blk, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // write test pattern (without commit) |
| WritePattern(handle, 2 * blk, blk, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back and check pattern |
| ReadChunk(handle, blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadChunk(handle, 2 * blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // In aux session it still should be empty |
| ReadChunk(handle_aux, blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadChunk(handle_aux, 2 * blk, blk, blk, 0, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // read same chunks back in primary session |
| ReadChunk(handle, blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadChunk(handle, 2 * blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read same chunks back in aux session (should fail) |
| uint32_t val; |
| rc = storage_read(handle_aux, blk, &val, sizeof(val)); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_read(handle_aux, 2 * blk, &val, sizeof(val)); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // abort transaction in aux session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // read same chunk again in aux session |
| ReadChunk(handle_aux, blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadChunk(handle_aux, 2 * blk, blk, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactCommitSetSize) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_commit_set_size"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open the same file in separate session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // same in aux session |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // set file size to half of original (no commit) |
| rc = storage_set_file_size(handle, (storage_off_t)exp_len/2, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // set file size to 1/3 of original (no commit) |
| rc = storage_set_file_size(handle, (storage_off_t)exp_len/3, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/3, fsize); |
| |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be 1/3 of an original size) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/3, fsize); |
| |
| // check file size from aux session |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // abort transaction in aux_session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check again |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/3, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactCommitDelete) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| const char *fname = "test_transact_commit_delete"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // open the same file in separate session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle_aux); |
| |
| // delete file (without commit) |
| rc = storage_delete_file(session_, fname, 0); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it (should fail) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // open the same file in separate session (should be fine) |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| storage_close_file(handle_aux); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it in primary session (still fails) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // open the same file in aux session (should also fail) |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactCommitTruncate) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_commit_truncate"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // check from different session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // open truncate file (without commit) |
| rc = storage_open_file(session_, &handle, fname, STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check file size (should be 0) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // check file size in aux session (should be -EBUSY) |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // abort transaction in aux session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // check again |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactCommitCreate) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_commit_create"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // delete test file just in case |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| |
| // check from aux session |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // create file (without commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file size |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // close file |
| storage_close_file(handle); |
| |
| // check from aux session (should fail) |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check open from normal session |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // check open from aux session (should succeed) |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactCommitCreateMany) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| file_handle_t handle1_aux; |
| file_handle_t handle2_aux; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname1 = "test_transact_commit_create1"; |
| const char *fname2 = "test_transact_commit_create2"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // delete test file just in case |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_delete_file(session_, fname2, STORAGE_OP_COMPLETE); |
| |
| // create file (without commit) |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| 0); |
| ASSERT_EQ(0, rc); |
| |
| // create file (without commit) |
| rc = storage_open_file(session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| 0); |
| ASSERT_EQ(0, rc); |
| |
| // check file sizes |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // close files |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| // open files from aux session |
| rc = storage_open_file(aux_session_, &handle1_aux, fname1, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| rc = storage_open_file(aux_session_, &handle2_aux, fname2, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // open from primary session |
| rc = storage_open_file(session_, &handle1, fname1, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(session_, &handle2, fname2, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // open from aux session |
| rc = storage_open_file(aux_session_, &handle1_aux, fname1, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(aux_session_, &handle2_aux, fname2, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle1_aux); |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_close_file(handle2); |
| storage_close_file(handle2_aux); |
| storage_delete_file(session_, fname2, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactCommitWriteMany) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| file_handle_t handle1_aux; |
| file_handle_t handle2_aux; |
| size_t blk = 2048; |
| size_t exp_len1 = 32 * 1024; |
| size_t exp_len2 = 31 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname1 = "test_transact_commit_write_file1"; |
| const char *fname2 = "test_transact_commit_write_file2"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate (with commit) |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate (with commit) |
| rc = storage_open_file(session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // open same files from aux session |
| rc = storage_open_file(aux_session_, &handle1_aux, fname1, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(aux_session_, &handle2_aux, fname2, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // file1: fill file with pattern (without commit) |
| WritePattern(handle1, 0, exp_len1, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // file2: fill file with pattern (without commit) |
| WritePattern(handle2, 0, exp_len2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size, it should be exp_len1 |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len1, fsize); |
| |
| // check file size, it should be exp_len2 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len2, fsize); |
| |
| // check file sizes from aux session (should be 0) |
| rc = storage_get_file_size(handle1_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| rc = storage_get_file_size(handle2_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // commit transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check file size, it should be exp_len1 |
| rc = storage_get_file_size(handle1, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len1, fsize); |
| |
| // check file size, it should be exp_len2 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len2, fsize); |
| |
| // check from aux session (should be -EBUSY) |
| rc = storage_get_file_size(handle1_aux, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // abort transaction in aux session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // and check again |
| rc = storage_get_file_size(handle1_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len1, fsize); |
| |
| rc = storage_get_file_size(handle2_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len2, fsize); |
| |
| // check data |
| ReadPatternEOF(handle1, 0, blk, exp_len1); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle2, 0, blk, exp_len2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle1_aux, 0, blk, exp_len1); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| ReadPatternEOF(handle2_aux, 0, blk, exp_len2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle1_aux); |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_close_file(handle2); |
| storage_close_file(handle2_aux); |
| storage_delete_file(session_, fname2, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactCommitDeleteCreate) { |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle_aux; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_delete_create"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, exp_len, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // delete file (without commit) |
| rc = storage_delete_file(session_, fname, 0); |
| ASSERT_EQ(0, rc); |
| |
| // try to open it (should fail) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // try to open it in aux session (should succeed) |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // create file with the same name (no commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_CREATE_EXCLUSIVE, |
| 0); |
| ASSERT_EQ(0, rc); |
| |
| // write half of data (with commit) |
| WritePattern(handle, 0, exp_len/2, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check file size (should be half) |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| // commit transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check data from primary session |
| ReadPatternEOF(handle, 0, blk, exp_len/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // check from aux session (should fail) |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // abort trunsaction in aux session |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // and try again (should still fail) |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // close file and reopen it again |
| storage_close_file(handle_aux); |
| rc = storage_open_file(aux_session_, &handle_aux, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // try it again (should succeed) |
| rc = storage_get_file_size(handle_aux, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| // check data |
| ReadPatternEOF(handle_aux, 0, blk, exp_len/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_close_file(handle_aux); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, TransactRewriteExistingTruncate) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| const char *fname = "test_transact_rewrite_existing_truncate"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // up |
| for (uint i = 1; i < 32; i++) { |
| // open truncate (no commit) |
| rc = storage_open_file(session_, &handle, fname, STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, i * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close |
| storage_close_file(handle); |
| } |
| |
| // down |
| for (uint i = 1; i < 32; i++) { |
| // open truncate (no commit) |
| rc = storage_open_file(session_, &handle, fname, STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, (32 - i) * blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close |
| storage_close_file(handle); |
| } |
| |
| // cleanup |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactRewriteExistingSetSize) { |
| int rc; |
| file_handle_t handle; |
| size_t blk = 2048; |
| const char *fname = "test_transact_rewrite_existing_set_size"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // close it |
| storage_close_file(handle); |
| |
| // up |
| for (uint i = 1; i < 32; i++) { |
| // open truncate (no commit) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, i * blk, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // update size (with commit) |
| rc = storage_set_file_size(handle, i * blk, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // close |
| storage_close_file(handle); |
| } |
| |
| // down |
| for (uint i = 1; i < 32; i++) { |
| // open trancate (no commit) |
| rc = storage_open_file(session_, &handle, fname, 0, 0); |
| ASSERT_EQ(0, rc); |
| |
| // write data (with commit) |
| WritePattern(handle, 0, (32 - i) * blk, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // update size (with commit) |
| rc = storage_set_file_size(handle, (32 - i) * blk, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // close |
| storage_close_file(handle); |
| } |
| |
| // cleanup |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, TransactResumeAfterNonFatalError) { |
| |
| int rc; |
| file_handle_t handle; |
| file_handle_t handle1; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_resume_writes"; |
| |
| // open create truncate file (with commit) |
| rc = storage_open_file(session_, &handle, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // write (without commit) |
| WritePattern(handle, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // issue some commands that should fail with non-fatal errors |
| |
| // write past end of file |
| uint32_t val = 0xDEDBEEF; |
| rc = storage_write(handle, exp_len/2 + 1, &val, sizeof(val), 0); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // read past end of file |
| rc = storage_read(handle, exp_len/2 + 1, &val, sizeof(val)); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // try to extend file past end of file |
| rc = storage_set_file_size(handle, exp_len/2 + 1, 0); |
| ASSERT_EQ(-EINVAL, rc); |
| |
| // open non existing file |
| rc = storage_open_file(session_, &handle1, "foo", |
| STORAGE_FILE_OPEN_TRUNCATE, STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // delete non-existing file |
| rc = storage_delete_file(session_, "foo", STORAGE_OP_COMPLETE); |
| ASSERT_EQ(-ENOENT, rc); |
| |
| // then resume writinga (without commit) |
| WritePattern(handle, exp_len/2, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // commit current transaction |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // check file size, it should be exp_len |
| rc = storage_get_file_size(handle, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // check data |
| ReadPatternEOF(handle, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle); |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| // Transaction Collisions |
| |
| TEST_P(StorageServiceTest, Transact2_WriteNC) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| const char *fname1 = "test_transact_f1"; |
| const char *fname2 = "test_transact_f2"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(aux_session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // session 1 |
| WritePattern(handle1, 0, blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back |
| ReadPatternEOF(handle1, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // session 2 |
| WritePattern(handle2, 0, blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back |
| ReadPatternEOF(handle2, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname1, STORAGE_OP_COMPLETE); |
| storage_delete_file(aux_session_, fname2, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, Transact2_DeleteNC) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| const char *fname1 = "test_transact_delete_f1"; |
| const char *fname2 = "test_transact_delete_f2"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(session_, &handle1, fname1, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_open_file(aux_session_, &handle2, fname2, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // session 1 |
| WritePattern(handle1, 0, blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back |
| ReadPatternEOF(handle1, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // session 2 |
| WritePattern(handle2, 0, blk, blk, true); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // read it back |
| ReadPatternEOF(handle2, 0, blk, blk); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // close files and delete them |
| storage_close_file(handle1); |
| storage_delete_file(session_, fname1, 0); |
| |
| storage_close_file(handle2); |
| storage_delete_file(aux_session_, fname2, 0); |
| |
| // commit |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| rc = storage_end_transaction(aux_session_, true); |
| ASSERT_EQ(0, rc); |
| } |
| |
| |
| TEST_P(StorageServiceTest, Transact2_Write_Read) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_writeRead"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // S1: open create truncate file |
| rc = storage_open_file(session_, &handle1, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S2: open the same file |
| rc = storage_open_file(aux_session_, &handle2, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S1: write (no commit) |
| WritePattern(handle1, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: read it back |
| ReadPatternEOF(handle1, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S2: check file size, it should be 0 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // S2: read it back (should no data) |
| ReadPatternEOF(handle2, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: commit |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // S2: check file size, it should fail |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // S2: abort transaction |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // S2: check file size again, it should be exp_len |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // S2: read it again (should be exp_len) |
| ReadPatternEOF(handle2, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, Transact2_Write_Write_Commit_Commit) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| file_handle_t handle3; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_write_write_commit_commit"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // S1: open create truncate file |
| rc = storage_open_file(session_, &handle1, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S2: open the same file |
| rc = storage_open_file(aux_session_, &handle2, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S1: write (no commit) |
| WritePattern(handle1, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S2: write (no commit) |
| WritePattern(handle2, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: commit |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // S2: read/write/get/set size/delete (all should fail) |
| uint32_t val = 0; |
| rc = storage_read(handle2, 0, &val, sizeof(val)); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_write(handle2, 0, &val, sizeof(val), 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_set_file_size(handle2, fsize, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_delete_file(aux_session_, fname, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_open_file(aux_session_, &handle3, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // S2: commit (should fail, and failed state should be cleared) |
| rc = storage_end_transaction(aux_session_, true); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // S2: check file size, it should be exp_len |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // S2: read it again (should be exp_len) |
| ReadPatternEOF(handle2, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, Transact2_Write_Write_Commit_Discard) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| file_handle_t handle3; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_write_write_commit_discard"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // S1: open create truncate file |
| rc = storage_open_file(session_, &handle1, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S2: open the same file |
| rc = storage_open_file(aux_session_, &handle2, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S1: write (no commit) |
| WritePattern(handle1, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S2: write (no commit) |
| WritePattern(handle2, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: commit |
| rc = storage_end_transaction(session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // S2: read/write/get/set size/delete (all should fail) |
| uint32_t val = 0; |
| rc = storage_read(handle2, 0, &val, sizeof(val)); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_write(handle2, 0, &val, sizeof(val), 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_set_file_size(handle2, fsize, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_delete_file(aux_session_, fname, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| rc = storage_open_file(aux_session_, &handle3, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, 0); |
| ASSERT_EQ(-EBUSY, rc); |
| |
| // S2: discard (should fail, and failed state should be cleared) |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // S2: check file size, it should be exp_len |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len, fsize); |
| |
| // S2: read it again (should be exp_len) |
| ReadPatternEOF(handle2, 0, blk, exp_len); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| TEST_P(StorageServiceTest, Transact2_Write_Write_Discard_Commit) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_write_write_discard_commit"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // S1: open create truncate file |
| rc = storage_open_file(session_, &handle1, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S2: open the same file |
| rc = storage_open_file(aux_session_, &handle2, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S1: write (no commit) |
| WritePattern(handle1, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S2: write (no commit) |
| WritePattern(handle2, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: discard |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // S2: commit (should succeed) |
| rc = storage_end_transaction(aux_session_, true); |
| ASSERT_EQ(0, rc); |
| |
| // S2: check file size, it should be exp_len |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)exp_len/2, fsize); |
| |
| // S2: read it again (should be exp_len) |
| ReadPatternEOF(handle2, 0, blk, exp_len/2); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
| |
| TEST_P(StorageServiceTest, Transact2_Write_Write_Discard_Discard) { |
| int rc; |
| file_handle_t handle1; |
| file_handle_t handle2; |
| size_t blk = 2048; |
| size_t exp_len = 32 * 1024; |
| storage_off_t fsize = (storage_off_t)(-1); |
| const char *fname = "test_transact_write_write_discard_Discard"; |
| |
| // open second session |
| rc = storage_open_session(TRUSTY_DEVICE_NAME, &aux_session_, port_); |
| ASSERT_EQ(0, rc); |
| |
| // S1: open create truncate file |
| rc = storage_open_file(session_, &handle1, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S2: open the same file |
| rc = storage_open_file(aux_session_, &handle2, fname, |
| STORAGE_FILE_OPEN_CREATE | STORAGE_FILE_OPEN_TRUNCATE, |
| STORAGE_OP_COMPLETE); |
| ASSERT_EQ(0, rc); |
| |
| // S1: write (no commit) |
| WritePattern(handle1, 0, exp_len, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S2: write (no commit) |
| WritePattern(handle2, 0, exp_len/2, blk, false); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // S1: discard |
| rc = storage_end_transaction(session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // S2: discard |
| rc = storage_end_transaction(aux_session_, false); |
| ASSERT_EQ(0, rc); |
| |
| // S2: check file size, it should be 0 |
| rc = storage_get_file_size(handle2, &fsize); |
| ASSERT_EQ(0, rc); |
| ASSERT_EQ((storage_off_t)0, fsize); |
| |
| // S2: read it again (should be 0) |
| ReadPatternEOF(handle2, 0, blk, 0); |
| ASSERT_FALSE(HasFatalFailure()); |
| |
| // cleanup |
| storage_close_file(handle1); |
| storage_close_file(handle2); |
| |
| storage_delete_file(session_, fname, STORAGE_OP_COMPLETE); |
| } |
| |
