rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/system/incremental_delivery/incfs/tests/util/map_ptr_test.cpp

329 lines
8.8 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) 2020 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 <android-base/file.h>
#include <sys/select.h>
#include <setjmp.h>
#include <unistd.h>
#include "IncFsTestBase.h"
#include "util/map_ptr.h"
using namespace android::incfs;
using namespace std::literals;
constexpr int FILE_PAGES = 5U;
constexpr int FILE_SIZE = INCFS_DATA_FILE_BLOCK_SIZE * FILE_PAGES;
constexpr int FILE_MISSING_PAGE = 3U;
class MapPtrTest : public IncFsTestBase {
protected:
virtual void SetUp() override {
IncFsTestBase::SetUp();
const auto id = fileId(1);
ASSERT_TRUE(control_.logs() >= 0);
ASSERT_EQ(0, makeFile(control_, mountPath(test_file_name_), 0555, id, {.size = FILE_SIZE}));
auto fd = openForSpecialOps(control_, fileId(1));
ASSERT_GE(fd.get(), 0);
// Generate the file data.
std::vector<uint32_t> data(FILE_SIZE);
for (int i = 0; i < FILE_SIZE; i++) {
data[i] = i;
}
// Write the file, but leave one page missing.
for (int p = 0; p < FILE_PAGES; p++) {
if (p == FILE_MISSING_PAGE) {
continue;
}
auto block = DataBlock{
.fileFd = fd.get(),
.pageIndex = p,
.compression = INCFS_COMPRESSION_KIND_NONE,
.dataSize = (uint32_t)INCFS_DATA_FILE_BLOCK_SIZE,
.data = reinterpret_cast<const char *>(data.data()) +
INCFS_DATA_FILE_BLOCK_SIZE * p,
};
ASSERT_EQ(1, writeBlocks({&block, 1}));
}
mount_path_ = mountPath(test_file_name_);
}
android::base::unique_fd GetFd() {
return android::base::unique_fd(open(mount_path_.c_str(), O_RDONLY | O_CLOEXEC | O_BINARY));
}
int32_t getReadTimeout() override { return 1; }
std::unique_ptr<IncFsFileMap> GetFileMap(int fd, off64_t offset, size_t length) {
auto map = std::make_unique<IncFsFileMap>();
return map->Create(fd, offset, length, nullptr) ? std::move(map) : nullptr;
}
private:
std::string mount_path_;
};
struct TwoValues {
uint32_t first;
uint32_t second;
};
TEST_F(MapPtrTest, ReadAtStart) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(0U, p1.value());
auto p2 = map->data<TwoValues>();
ASSERT_TRUE(p2);
ASSERT_EQ(0U, p2->first);
ASSERT_EQ(1U, p2->second);
}
TEST_F(MapPtrTest, ReadNull) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(0U, p1.value());
p1 = nullptr;
ASSERT_FALSE(p1);
p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(0U, p1.value());
}
TEST_F(MapPtrTest, ReadAtStartWithOffset) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), sizeof(uint32_t) * 4U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(4U, p1.value());
auto p2 = map->data<TwoValues>();
ASSERT_TRUE(p2);
ASSERT_EQ(4U, p2->first);
ASSERT_EQ(5U, p2->second);
}
TEST_F(MapPtrTest, PointerArithmetic) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>() + 11U;
ASSERT_TRUE(p1);
ASSERT_EQ(11U, p1.value());
auto p2 = p1 - 5U;
ASSERT_TRUE(p2);
ASSERT_EQ(6U, p2.value());
auto dis = p1 - p2;
ASSERT_EQ((ptrdiff_t)5U, dis);
}
TEST_F(MapPtrTest, PointerIncrement) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(0U, p1.value());
auto p2 = p1++;
ASSERT_TRUE(p1);
ASSERT_TRUE(p2);
ASSERT_EQ(1U, p1.value());
ASSERT_EQ(0U, p2.value());
auto p3 = ++p2;
ASSERT_TRUE(p2);
ASSERT_TRUE(p3);
ASSERT_EQ(1U, p2.value());
ASSERT_EQ(1U, p3.value());
}
TEST_F(MapPtrTest, PointerComparison) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data<uint32_t>();
ASSERT_TRUE(p1);
ASSERT_EQ(0U, p1.value());
auto p2 = p1;
ASSERT_TRUE(p1 == p2);
ASSERT_TRUE(p1 < p2 + 1U);
ASSERT_TRUE(p2 != p2 + 1U);
}
TEST_F(MapPtrTest, PointerConvert) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = (map->data<uint32_t>() + 11U).convert<TwoValues>();
ASSERT_TRUE(p1);
ASSERT_EQ(11U, p1->first);
ASSERT_EQ(12U, p1->second);
}
TEST_F(MapPtrTest, PointerOffset) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto p1 = map->data().offset(11U * sizeof(uint32_t)).convert<TwoValues>();
ASSERT_TRUE(p1);
ASSERT_EQ(11U, p1->first);
ASSERT_EQ(12U, p1->second);
}
TEST_F(MapPtrTest, Iterator) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto it = map->data<uint32_t>().iterator();
ASSERT_TRUE(*it);
ASSERT_EQ(0U, (*it).value());
auto it2 = it;
ASSERT_EQ(it, it2);
auto it3 = it++;
ASSERT_TRUE(*it3);
ASSERT_EQ(0U, (*it3).value());
ASSERT_NE(it, it2);
ASSERT_EQ(1, it - it2);
ASSERT_EQ(-1, it2 - it);
auto it4 = ++it;
ASSERT_TRUE(*it4);
ASSERT_EQ(2U, (*it4).value());
it += 10;
ASSERT_EQ(12U, (*it).value());
}
static jmp_buf buf;
void sigbus_handler(int sig) {
if (sig == SIGBUS) {
siglongjmp(buf, 1);
} else {
FAIL();
}
}
#define ASSERT_SIGBUS(test) \
do { \
signal(SIGBUS, &sigbus_handler); \
if (sigsetjmp(buf, 1) == 0) { \
ASSERT_EQ(0U, (test)); \
FAIL() << "No signal raised"; \
} \
} while (0)
TEST_F(MapPtrTest, VerifyMissingPageFails) {
for (uint32_t off :
std::vector<uint32_t>{0U, INCFS_DATA_FILE_BLOCK_SIZE / 2 - 1,
INCFS_DATA_FILE_BLOCK_SIZE / 2 + 1, INCFS_DATA_FILE_BLOCK_SIZE,
INCFS_DATA_FILE_BLOCK_SIZE * 3 / 2 - 1,
INCFS_DATA_FILE_BLOCK_SIZE * 3 / 2 + 1}) {
auto fd = GetFd();
auto map = GetFileMap(fd.get(), off /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
auto missing_page_start = INCFS_DATA_FILE_BLOCK_SIZE * FILE_MISSING_PAGE;
auto p1 = map->data().offset(missing_page_start - off).convert<uint32_t>();
ASSERT_FALSE(p1);
ASSERT_SIGBUS(p1.value());
const auto p2 = p1;
ASSERT_FALSE(p2);
ASSERT_SIGBUS(p2.value());
const auto p3 = p2 - 1U;
ASSERT_TRUE(p3);
ASSERT_EQ(3071U, p3.value());
auto p4 = p3;
ASSERT_TRUE(p4);
ASSERT_EQ(3071U, p4.value());
ASSERT_FALSE(p4 + 1U);
ASSERT_SIGBUS((p4 + 1U).value());
auto p5 = p4++;
ASSERT_TRUE(p5);
ASSERT_EQ(3071U, p5.value());
ASSERT_FALSE(p4);
ASSERT_SIGBUS(p4.value());
auto p6 = p3;
ASSERT_TRUE(p6);
ASSERT_EQ(3071U, p6.value());
auto p7 = ++p6;
ASSERT_FALSE(p7);
ASSERT_SIGBUS(p7.value());
ASSERT_FALSE(p6);
ASSERT_SIGBUS(p6.value());
auto missing_page_end = INCFS_DATA_FILE_BLOCK_SIZE * (FILE_MISSING_PAGE + 1);
auto p8 = map->data().offset(missing_page_end - off).convert<uint32_t>();
ASSERT_TRUE(p8);
ASSERT_EQ(4096U, p8.value());
ASSERT_FALSE(p8 - 1U);
ASSERT_SIGBUS((p8 - 1U).value());
}
}
TEST_F(MapPtrTest, GetDataAfterClose) {
std::unique_ptr<IncFsFileMap> map;
{
auto fd = GetFd();
map = GetFileMap(fd.get(), 0U /* offset */, FILE_SIZE);
ASSERT_NE(nullptr, map);
}
auto missing_page_start = INCFS_DATA_FILE_BLOCK_SIZE * FILE_MISSING_PAGE;
auto p1 = map->data().offset(missing_page_start).convert<uint32_t>();
ASSERT_FALSE(p1);
ASSERT_SIGBUS(p1.value());
}
Reference in New Issue View Git Blame Copy Permalink