From eb6da459a08120790c9d268fcd6aea3576297d15 Mon Sep 17 00:00:00 2001 From: Tom Cherry Date: Fri, 25 Jan 2019 15:25:15 -0800 Subject: [PATCH] fs_mgr: test parsing all mount and fs mgr options Test: these new unit tests Change-Id: Ibdecf0c97b313dc157b982340ca022b617757383 --- fs_mgr/tests/data/fstab.example | 4 + fs_mgr/tests/fs_mgr_test.cpp | 675 +++++++++++++++++++++++++++++++- 2 files changed, 678 insertions(+), 1 deletion(-) diff --git a/fs_mgr/tests/data/fstab.example b/fs_mgr/tests/data/fstab.example index 1a3dfa11b..aebce32f6 100644 --- a/fs_mgr/tests/data/fstab.example +++ b/fs_mgr/tests/data/fstab.example @@ -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 diff --git a/fs_mgr/tests/fs_mgr_test.cpp b/fs_mgr/tests/fs_mgr_test.cpp index 9aa8efc09..e2b283ae1 100644 --- a/fs_mgr/tests/fs_mgr_test.cpp +++ b/fs_mgr/tests/fs_mgr_test.cpp @@ -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(MS_RDONLY), fstab[0].flags); EXPECT_EQ("barrier=1", fstab[0].fs_options); EXPECT_EQ("/metadata", fstab[1].mount_point); + EXPECT_EQ(static_cast(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(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(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(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(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(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); +}