openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

fs_mgr: test parsing all mount and fs mgr options 

Test: these new unit tests
Change-Id: Ibdecf0c97b313dc157b982340ca022b617757383
This commit is contained in:
Tom Cherry 2019-01-25 15:25:15 -08:00
parent 151a17f015
commit eb6da459a0
2 changed files with 678 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs_mgr/tests/data/fstab.example
View File

@ -9,3 +9,7 @@
/dev/block/bootdevice/by-name/modem /vendor/firmware_mnt vfat ro,shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,context=u:object_r:firmware_file:s0 wait,slotselect
/devices/platform/soc/a600000.ssusb/a600000.dwc3* auto vfat defaults voldmanaged=usb:auto
/dev/block/zram0 none swap defaults zramsize=1073741824,max_comp_streams=8
/dev/block/zram0 none2 swap nodiratime,remount,bind zramsize=1073741824,max_comp_streams=8
/dev/block/zram0 none3 swap unbindable,private,slave zramsize=1073741824,max_comp_streams=8
/dev/block/zram0 none4 swap noexec,shared,rec zramsize=1073741824,max_comp_streams=8
/dev/block/zram0 none5 swap rw zramsize=1073741824,max_comp_streams=8

675
fs_mgr/tests/fs_mgr_test.cpp
View File

@ -201,34 +201,448 @@ TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) {
EXPECT_EQ(i, fstab.size());
}
TEST(fs_mgr, ReadFstabFromFile_FsOptions) {
TEST(fs_mgr, ReadFstabFromFile_MountOptions) {
Fstab fstab;
std::string fstab_file = android::base::GetExecutableDirectory() + "/data/fstab.example";
EXPECT_TRUE(ReadFstabFromFile(fstab_file, &fstab));
EXPECT_EQ("/", fstab[0].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[0].flags);
EXPECT_EQ("barrier=1", fstab[0].fs_options);
EXPECT_EQ("/metadata", fstab[1].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[1].flags);
EXPECT_EQ("discard", fstab[1].fs_options);
EXPECT_EQ("/data", fstab[2].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[2].flags);
EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", fstab[2].fs_options);
EXPECT_EQ("/misc", fstab[3].mount_point);
EXPECT_EQ(0U, fstab[3].flags);
EXPECT_EQ("", fstab[3].fs_options);
EXPECT_EQ("/vendor/firmware_mnt", fstab[4].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[4].flags);
EXPECT_EQ(
"shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,"
"context=u:object_r:firmware_file:s0",
fstab[4].fs_options);
EXPECT_EQ("auto", fstab[5].mount_point);
EXPECT_EQ(0U, fstab[5].flags);
EXPECT_EQ("", fstab[5].fs_options);
EXPECT_EQ("none", fstab[6].mount_point);
EXPECT_EQ(0U, fstab[6].flags);
EXPECT_EQ("", fstab[6].fs_options);
EXPECT_EQ("none2", fstab[7].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), fstab[7].flags);
EXPECT_EQ("", fstab[7].fs_options);
EXPECT_EQ("none3", fstab[8].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), fstab[8].flags);
EXPECT_EQ("", fstab[8].fs_options);
EXPECT_EQ("none4", fstab[9].mount_point);
EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), fstab[9].flags);
EXPECT_EQ("", fstab[9].fs_options);
EXPECT_EQ("none5", fstab[10].mount_point);
EXPECT_EQ(0U, fstab[10].flags); // rw is the same as defaults
EXPECT_EQ("", fstab[10].fs_options);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrFlags) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults wait,check,nonremovable,recoveryonly,verifyatboot,verify
source none1 swap defaults avb,noemulatedsd,notrim,formattable,slotselect,nofail
source none2 swap defaults first_stage_mount,latemount,quota,logical,slotselect_other
source none3 swap defaults checkpoint=block
source none4 swap defaults checkpoint=fs
source none5 swap defaults defaults
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(6U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.wait = true;
flags.check = true;
flags.nonremovable = true;
flags.recovery_only = true;
flags.verify_at_boot = true;
flags.verify = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
entry++;
EXPECT_EQ("none1", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.avb = true;
flags.no_emulated_sd = true;
flags.no_trim = true;
flags.formattable = true;
flags.slot_select = true;
flags.no_fail = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
entry++;
EXPECT_EQ("none2", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.first_stage_mount = true;
flags.late_mount = true;
flags.quota = true;
flags.logical = true;
flags.slot_select_other = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
entry++;
EXPECT_EQ("none3", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.checkpoint_blk = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
entry++;
EXPECT_EQ("none4", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.checkpoint_fs = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
entry++;
EXPECT_EQ("none5", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_AllBad) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults encryptable,forceencrypt,fileencryption,forcefdeorfbe,keydirectory,length,swapprio,zramsize,max_comp_streams,reservedsize,eraseblk,logicalblk,sysfs_path,zram_loopback_path,zram_loopback_size,zram_backing_dev_path
source none1 swap defaults encryptable=,forceencrypt=,fileencryption=,keydirectory=,length=,swapprio=,zramsize=,max_comp_streams=,verify=,avb=,reservedsize=,eraseblk=,logicalblk=,sysfs_path=,zram_loopback_path=,zram_loopback_size=,zram_backing_dev_path=
source none2 swap defaults forcefdeorfbe=
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(3U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
EXPECT_EQ("", entry->key_loc);
EXPECT_EQ("", entry->key_dir);
EXPECT_EQ("", entry->verity_loc);
EXPECT_EQ(0, entry->length);
EXPECT_EQ("", entry->label);
EXPECT_EQ(-1, entry->partnum);
EXPECT_EQ(-1, entry->swap_prio);
EXPECT_EQ(0, entry->max_comp_streams);
EXPECT_EQ(0, entry->zram_size);
EXPECT_EQ(0, entry->reserved_size);
EXPECT_EQ("", entry->file_contents_mode);
EXPECT_EQ("", entry->file_names_mode);
EXPECT_EQ(0, entry->erase_blk_size);
EXPECT_EQ(0, entry->logical_blk_size);
EXPECT_EQ("", entry->sysfs_path);
EXPECT_EQ("", entry->zram_loopback_path);
EXPECT_EQ(512U * 1024U * 1024U, entry->zram_loopback_size);
EXPECT_EQ("", entry->zram_backing_dev_path);
entry++;
EXPECT_EQ("none1", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.crypt = true;
flags.force_crypt = true;
flags.file_encryption = true;
flags.key_directory = true;
flags.length = true;
flags.swap_prio = true;
flags.zram_size = true;
flags.max_comp_streams = true;
flags.verify = true;
flags.avb = true;
flags.reserved_size = true;
flags.erase_blk_size = true;
flags.logical_blk_size = true;
flags.sysfs = true;
flags.zram_loopback_path = true;
flags.zram_loopback_size = true;
flags.zram_backing_dev_path = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
EXPECT_EQ("", entry->key_loc);
EXPECT_EQ("", entry->key_dir);
EXPECT_EQ("", entry->verity_loc);
EXPECT_EQ(0, entry->length);
EXPECT_EQ("", entry->label);
EXPECT_EQ(-1, entry->partnum);
EXPECT_EQ(-1, entry->swap_prio);
EXPECT_EQ(0, entry->max_comp_streams);
EXPECT_EQ(0, entry->zram_size);
EXPECT_EQ(0, entry->reserved_size);
EXPECT_EQ("", entry->file_contents_mode);
EXPECT_EQ("", entry->file_names_mode);
EXPECT_EQ(0, entry->erase_blk_size);
EXPECT_EQ(0, entry->logical_blk_size);
EXPECT_EQ("", entry->sysfs_path);
EXPECT_EQ("", entry->zram_loopback_path);
EXPECT_EQ(512U * 1024U * 1024U, entry->zram_loopback_size);
EXPECT_EQ("", entry->zram_backing_dev_path);
entry++;
// forcefdeorfbe sets file_contents_mode and file_names_mode by default, so test it separately.
EXPECT_EQ("none2", entry->mount_point);
{
FstabEntry::FsMgrFlags flags = {0};
flags.force_fde_or_fbe = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
}
EXPECT_EQ("aes-256-xts", entry->file_contents_mode);
EXPECT_EQ("aes-256-cts", entry->file_names_mode);
EXPECT_EQ("", entry->key_loc);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Encryptable) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults encryptable=/dir/key
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.crypt = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("/dir/key", entry->key_loc);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_VoldManaged) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults voldmanaged=:
source none1 swap defaults voldmanaged=sdcard
source none2 swap defaults voldmanaged=sdcard:3
source none3 swap defaults voldmanaged=sdcard:auto
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(4U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.vold_managed = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_TRUE(entry->label.empty());
EXPECT_EQ(-1, entry->partnum);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_TRUE(entry->label.empty());
EXPECT_EQ(-1, entry->partnum);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("sdcard", entry->label);
EXPECT_EQ(3, entry->partnum);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("sdcard", entry->label);
EXPECT_EQ(-1, entry->partnum);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Length) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults length=blah
source none1 swap defaults length=123456
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(2U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.length = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->length);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(123456, entry->length);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Swapprio) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults swapprio=blah
source none1 swap defaults swapprio=123456
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(2U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.swap_prio = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(-1, entry->swap_prio);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(123456, entry->swap_prio);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ZramSize) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults zramsize=blah
source none1 swap defaults zramsize=123456
source none2 swap defaults zramsize=blah%
source none3 swap defaults zramsize=5%
source none4 swap defaults zramsize=105%
source none5 swap defaults zramsize=%
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(6U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.zram_size = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->zram_size);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(123456, entry->zram_size);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->zram_size);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_NE(0, entry->zram_size);
entry++;
EXPECT_EQ("none4", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->zram_size);
entry++;
EXPECT_EQ("none5", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->zram_size);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Verify) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults verify=/dir/key
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
FstabEntry::FsMgrFlags flags = {0};
flags.verify = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("/dir/key", entry->verity_loc);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ForceEncrypt) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults forceencrypt=/dir/key
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
FstabEntry::FsMgrFlags flags = {0};
flags.force_crypt = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("/dir/key", entry->key_loc);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ForceFdeOrFbe) {
@ -348,3 +762,262 @@ source none10 swap defaults fileencryption=ice:adiantum:
EXPECT_EQ("", entry->file_contents_mode);
EXPECT_EQ("", entry->file_names_mode);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_MaxCompStreams) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults max_comp_streams=blah
source none1 swap defaults max_comp_streams=123456
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(2U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.max_comp_streams = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->max_comp_streams);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(123456, entry->max_comp_streams);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ReservedSize) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults reservedsize=blah
source none1 swap defaults reservedsize=2
source none2 swap defaults reservedsize=1K
source none3 swap defaults reservedsize=2m
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(4U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.reserved_size = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->reserved_size);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(2, entry->reserved_size);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(1024, entry->reserved_size);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(2 * 1024 * 1024, entry->reserved_size);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_EraseBlk) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults eraseblk=blah
source none1 swap defaults eraseblk=4000
source none2 swap defaults eraseblk=5000
source none3 swap defaults eraseblk=8192
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(4U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.erase_blk_size = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->erase_blk_size);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->erase_blk_size);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->erase_blk_size);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(8192, entry->erase_blk_size);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Logicalblk) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults logicalblk=blah
source none1 swap defaults logicalblk=4000
source none2 swap defaults logicalblk=5000
source none3 swap defaults logicalblk=8192
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(4U, fstab.size());
FstabEntry::FsMgrFlags flags = {0};
flags.logical_blk_size = true;
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->logical_blk_size);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->logical_blk_size);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(0, entry->logical_blk_size);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ(8192, entry->logical_blk_size);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Avb) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults avb=vbmeta_partition
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
FstabEntry::FsMgrFlags flags = {0};
flags.avb = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("vbmeta_partition", entry->vbmeta_partition);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_KeyDirectory) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults keydirectory=/dir/key
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
FstabEntry::FsMgrFlags flags = {0};
flags.key_directory = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("/dir/key", entry->key_dir);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_SysfsPath) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults sysfs_path=/sys/device
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(1U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
FstabEntry::FsMgrFlags flags = {0};
flags.sysfs = true;
EXPECT_EQ(flags.val, entry->fs_mgr_flags.val);
EXPECT_EQ("/sys/device", entry->sysfs_path);
}
TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Zram) {
TemporaryFile tf;
ASSERT_TRUE(tf.fd != -1);
std::string fstab_contents = R"fs(
source none0 swap defaults zram_loopback_path=/dev/path
source none1 swap defaults zram_loopback_size=blah
source none2 swap defaults zram_loopback_size=2
source none3 swap defaults zram_loopback_size=1K
source none4 swap defaults zram_loopback_size=2m
source none5 swap defaults zram_backing_dev_path=/dev/path2
)fs";
ASSERT_TRUE(android::base::WriteStringToFd(fstab_contents, tf.fd));
Fstab fstab;
EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
ASSERT_EQ(6U, fstab.size());
auto entry = fstab.begin();
EXPECT_EQ("none0", entry->mount_point);
EXPECT_EQ("/dev/path", entry->zram_loopback_path);
entry++;
EXPECT_EQ("none1", entry->mount_point);
EXPECT_EQ(512U * 1024U * 1024U, entry->zram_loopback_size);
entry++;
EXPECT_EQ("none2", entry->mount_point);
EXPECT_EQ(2U, entry->zram_loopback_size);
entry++;
EXPECT_EQ("none3", entry->mount_point);
EXPECT_EQ(1024U, entry->zram_loopback_size);
entry++;
EXPECT_EQ("none4", entry->mount_point);
EXPECT_EQ(2U * 1024U * 1024U, entry->zram_loopback_size);
entry++;
EXPECT_EQ("none5", entry->mount_point);
EXPECT_EQ("/dev/path2", entry->zram_backing_dev_path);
}