1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <linux/fs.h>
18 #include <mntent.h>
19
20 #include <algorithm>
21 #include <iterator>
22 #include <set>
23 #include <string>
24 #include <utility>
25 #include <vector>
26
27 #include <android-base/file.h>
28 #include <android-base/properties.h>
29 #include <android-base/strings.h>
30 #include <fs_mgr.h>
31 #include <fstab/fstab.h>
32 #include <gtest/gtest.h>
33
34 #include "../fs_mgr_priv_boot_config.h"
35
36 using namespace android::fs_mgr;
37
38 namespace {
39
40 const std::string cmdline =
41 "rcupdate.rcu_expedited=1 rootwait ro "
42 "init=/init androidboot.bootdevice=1d84000.ufshc "
43 "androidboot.baseband=sdy androidboot.keymaster=1 skip_initramfs "
44 "androidboot.serialno=BLAHBLAHBLAH androidboot.slot_suffix=_a "
45 "androidboot.hardware.platform=sdw813 androidboot.hardware=foo "
46 "androidboot.revision=EVT1.0 androidboot.bootloader=burp-0.1-7521 "
47 "androidboot.hardware.sku=mary androidboot.hardware.radio.subtype=0 "
48 "androidboot.dtbo_idx=2 androidboot.mode=normal "
49 "androidboot.hardware.ddr=1GB,combuchi,LPDDR4X "
50 "androidboot.ddr_info=combuchiandroidboot.ddr_size=2GB "
51 "androidboot.hardware.ufs=2GB,combushi "
52 "androidboot.boottime=0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123 "
53 "androidboot.ramdump=disabled "
54 "dm=\"1 vroot none ro 1,0 10416 verity 1 624684 fec_start 624684\" "
55 "root=/dev/dm-0 "
56 "androidboot.vbmeta.device=PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb "
57 "androidboot.vbmeta.avb_version=\"1.1\" "
58 "androidboot.vbmeta.device_state=unlocked "
59 "androidboot.vbmeta.hash_alg=sha256 androidboot.vbmeta.size=5248 "
60 "androidboot.vbmeta.digest="
61 "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860 "
62 "androidboot.vbmeta.invalidate_on_error=yes "
63 "androidboot.veritymode=enforcing androidboot.verifiedbootstate=orange "
64 "androidboot.space=\"sha256 5248 androidboot.nospace=nope\" "
65 "printk.devkmsg=on msm_rtb.filter=0x237 ehci-hcd.park=3 "
66 "\"string =\"\"string '\" "
67 "service_locator.enable=1 firmware_class.path=/vendor/firmware "
68 "cgroup.memory=nokmem lpm_levels.sleep_disabled=1 "
69 "buildvariant=userdebug console=null "
70 "terminator=\"truncated";
71
72 const std::vector<std::pair<std::string, std::string>> result_space = {
73 {"rcupdate.rcu_expedited", "1"},
74 {"rootwait", ""},
75 {"ro", ""},
76 {"init", "/init"},
77 {"androidboot.bootdevice", "1d84000.ufshc"},
78 {"androidboot.baseband", "sdy"},
79 {"androidboot.keymaster", "1"},
80 {"skip_initramfs", ""},
81 {"androidboot.serialno", "BLAHBLAHBLAH"},
82 {"androidboot.slot_suffix", "_a"},
83 {"androidboot.hardware.platform", "sdw813"},
84 {"androidboot.hardware", "foo"},
85 {"androidboot.revision", "EVT1.0"},
86 {"androidboot.bootloader", "burp-0.1-7521"},
87 {"androidboot.hardware.sku", "mary"},
88 {"androidboot.hardware.radio.subtype", "0"},
89 {"androidboot.dtbo_idx", "2"},
90 {"androidboot.mode", "normal"},
91 {"androidboot.hardware.ddr", "1GB,combuchi,LPDDR4X"},
92 {"androidboot.ddr_info", "combuchiandroidboot.ddr_size=2GB"},
93 {"androidboot.hardware.ufs", "2GB,combushi"},
94 {"androidboot.boottime", "0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123"},
95 {"androidboot.ramdump", "disabled"},
96 {"dm", "1 vroot none ro 1,0 10416 verity 1 624684 fec_start 624684"},
97 {"root", "/dev/dm-0"},
98 {"androidboot.vbmeta.device", "PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb"},
99 {"androidboot.vbmeta.avb_version", "1.1"},
100 {"androidboot.vbmeta.device_state", "unlocked"},
101 {"androidboot.vbmeta.hash_alg", "sha256"},
102 {"androidboot.vbmeta.size", "5248"},
103 {"androidboot.vbmeta.digest",
104 "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860"},
105 {"androidboot.vbmeta.invalidate_on_error", "yes"},
106 {"androidboot.veritymode", "enforcing"},
107 {"androidboot.verifiedbootstate", "orange"},
108 {"androidboot.space", "sha256 5248 androidboot.nospace=nope"},
109 {"printk.devkmsg", "on"},
110 {"msm_rtb.filter", "0x237"},
111 {"ehci-hcd.park", "3"},
112 {"string ", "string '"},
113 {"service_locator.enable", "1"},
114 {"firmware_class.path", "/vendor/firmware"},
115 {"cgroup.memory", "nokmem"},
116 {"lpm_levels.sleep_disabled", "1"},
117 {"buildvariant", "userdebug"},
118 {"console", "null"},
119 {"terminator", "truncated"},
120 };
121
122 const std::string bootconfig =
123 "androidboot.bootdevice = \"1d84000.ufshc\"\n"
124 "androidboot.boot_devices = \"dev1\", \"dev2,withcomma\", \"dev3\"\n"
125 "androidboot.baseband = \"sdy\"\n"
126 "androidboot.keymaster = \"1\"\n"
127 "androidboot.serialno = \"BLAHBLAHBLAH\"\n"
128 "androidboot.slot_suffix = \"_a\"\n"
129 "androidboot.hardware.platform = \"sdw813\"\n"
130 "androidboot.hardware = \"foo\"\n"
131 "androidboot.revision = \"EVT1.0\"\n"
132 "androidboot.bootloader = \"burp-0.1-7521\"\n"
133 "androidboot.hardware.sku = \"mary\"\n"
134 "androidboot.hardware.radio.subtype = \"0\"\n"
135 "androidboot.dtbo_idx = \"2\"\n"
136 "androidboot.mode = \"normal\"\n"
137 "androidboot.hardware.ddr = \"1GB,combuchi,LPDDR4X\"\n"
138 "androidboot.ddr_info = \"combuchiandroidboot.ddr_size=2GB\"\n"
139 "androidboot.hardware.ufs = \"2GB,combushi\"\n"
140 "androidboot.boottime = \"0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123\"\n"
141 "androidboot.ramdump = \"disabled\"\n"
142 "androidboot.vbmeta.device = \"PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb\"\n"
143 "androidboot.vbmeta.avb_version = \"1.1\"\n"
144 "androidboot.vbmeta.device_state = \"unlocked\"\n"
145 "androidboot.vbmeta.hash_alg = \"sha256\"\n"
146 "androidboot.vbmeta.size = \"5248\"\n"
147 "androidboot.vbmeta.digest = \""
148 "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860\"\n"
149 "androidboot.vbmeta.invalidate_on_error = \"yes\"\n"
150 "androidboot.veritymode = \"enforcing\"\n"
151 "androidboot.verifiedbootstate = \"orange\"\n"
152 "androidboot.space = \"sha256 5248 androidboot.nospace = nope\"\n";
153
154 const std::vector<std::pair<std::string, std::string>> bootconfig_result_space = {
155 {"androidboot.bootdevice", "1d84000.ufshc"},
156 {"androidboot.boot_devices", "dev1, dev2,withcomma, dev3"},
157 {"androidboot.baseband", "sdy"},
158 {"androidboot.keymaster", "1"},
159 {"androidboot.serialno", "BLAHBLAHBLAH"},
160 {"androidboot.slot_suffix", "_a"},
161 {"androidboot.hardware.platform", "sdw813"},
162 {"androidboot.hardware", "foo"},
163 {"androidboot.revision", "EVT1.0"},
164 {"androidboot.bootloader", "burp-0.1-7521"},
165 {"androidboot.hardware.sku", "mary"},
166 {"androidboot.hardware.radio.subtype", "0"},
167 {"androidboot.dtbo_idx", "2"},
168 {"androidboot.mode", "normal"},
169 {"androidboot.hardware.ddr", "1GB,combuchi,LPDDR4X"},
170 {"androidboot.ddr_info", "combuchiandroidboot.ddr_size=2GB"},
171 {"androidboot.hardware.ufs", "2GB,combushi"},
172 {"androidboot.boottime", "0BLE:58,1BLL:22,1BLE:571,2BLL:105,ODT:0,AVB:123"},
173 {"androidboot.ramdump", "disabled"},
174 {"androidboot.vbmeta.device", "PARTUUID=aa08f1a4-c7c9-402e-9a66-9707cafa9ceb"},
175 {"androidboot.vbmeta.avb_version", "1.1"},
176 {"androidboot.vbmeta.device_state", "unlocked"},
177 {"androidboot.vbmeta.hash_alg", "sha256"},
178 {"androidboot.vbmeta.size", "5248"},
179 {"androidboot.vbmeta.digest",
180 "ac13147e959861c20f2a6da97d25fe79e60e902c022a371c5c039d31e7c68860"},
181 {"androidboot.vbmeta.invalidate_on_error", "yes"},
182 {"androidboot.veritymode", "enforcing"},
183 {"androidboot.verifiedbootstate", "orange"},
184 {"androidboot.space", "sha256 5248 androidboot.nospace = nope"},
185 };
186
CompareFlags(FstabEntry::FsMgrFlags & lhs,FstabEntry::FsMgrFlags & rhs)187 bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {
188 // clang-format off
189 return lhs.wait == rhs.wait &&
190 lhs.check == rhs.check &&
191 lhs.crypt == rhs.crypt &&
192 lhs.nonremovable == rhs.nonremovable &&
193 lhs.vold_managed == rhs.vold_managed &&
194 lhs.recovery_only == rhs.recovery_only &&
195 lhs.no_emulated_sd == rhs.no_emulated_sd &&
196 lhs.no_trim == rhs.no_trim &&
197 lhs.file_encryption == rhs.file_encryption &&
198 lhs.formattable == rhs.formattable &&
199 lhs.slot_select == rhs.slot_select &&
200 lhs.late_mount == rhs.late_mount &&
201 lhs.no_fail == rhs.no_fail &&
202 lhs.quota == rhs.quota &&
203 lhs.avb == rhs.avb &&
204 lhs.logical == rhs.logical &&
205 lhs.checkpoint_blk == rhs.checkpoint_blk &&
206 lhs.checkpoint_fs == rhs.checkpoint_fs &&
207 lhs.first_stage_mount == rhs.first_stage_mount &&
208 lhs.slot_select_other == rhs.slot_select_other &&
209 lhs.fs_verity == rhs.fs_verity;
210 // clang-format on
211 }
212
213 } // namespace
214
TEST(fs_mgr,fs_mgr_parse_cmdline)215 TEST(fs_mgr, fs_mgr_parse_cmdline) {
216 EXPECT_EQ(result_space, fs_mgr_parse_cmdline(cmdline));
217 }
218
TEST(fs_mgr,fs_mgr_get_boot_config_from_kernel_cmdline)219 TEST(fs_mgr, fs_mgr_get_boot_config_from_kernel_cmdline) {
220 std::string content;
221 for (const auto& entry : result_space) {
222 static constexpr char androidboot[] = "androidboot.";
223 if (!android::base::StartsWith(entry.first, androidboot)) continue;
224 auto key = entry.first.substr(strlen(androidboot));
225 EXPECT_TRUE(fs_mgr_get_boot_config_from_kernel(cmdline, key, &content)) << " for " << key;
226 EXPECT_EQ(entry.second, content);
227 }
228 EXPECT_FALSE(fs_mgr_get_boot_config_from_kernel(cmdline, "vbmeta.avb_versio", &content));
229 EXPECT_TRUE(content.empty()) << content;
230 EXPECT_FALSE(fs_mgr_get_boot_config_from_kernel(cmdline, "nospace", &content));
231 EXPECT_TRUE(content.empty()) << content;
232 }
233
TEST(fs_mgr,fs_mgr_parse_bootconfig)234 TEST(fs_mgr, fs_mgr_parse_bootconfig) {
235 EXPECT_EQ(bootconfig_result_space, fs_mgr_parse_proc_bootconfig(bootconfig));
236 }
237
TEST(fs_mgr,fs_mgr_get_boot_config_from_bootconfig)238 TEST(fs_mgr, fs_mgr_get_boot_config_from_bootconfig) {
239 std::string content;
240 for (const auto& entry : bootconfig_result_space) {
241 static constexpr char androidboot[] = "androidboot.";
242 if (!android::base::StartsWith(entry.first, androidboot)) continue;
243 auto key = entry.first.substr(strlen(androidboot));
244 EXPECT_TRUE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, key, &content))
245 << " for " << key;
246 EXPECT_EQ(entry.second, content);
247 }
248
249 EXPECT_FALSE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, "vbmeta.avb_versio", &content));
250 EXPECT_TRUE(content.empty()) << content;
251 EXPECT_FALSE(fs_mgr_get_boot_config_from_bootconfig(bootconfig, "nospace", &content));
252 EXPECT_TRUE(content.empty()) << content;
253 }
254
TEST(fs_mgr,fs_mgr_read_fstab_file_proc_mounts)255 TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) {
256 Fstab fstab;
257 ASSERT_TRUE(ReadFstabFromFile("/proc/mounts", &fstab));
258
259 std::unique_ptr<std::FILE, int (*)(std::FILE*)> mounts(setmntent("/proc/mounts", "re"),
260 endmntent);
261 ASSERT_NE(mounts, nullptr);
262
263 mntent* mentry;
264 size_t i = 0;
265 while ((mentry = getmntent(mounts.get())) != nullptr) {
266 ASSERT_LT(i, fstab.size());
267 auto& entry = fstab[i];
268
269 EXPECT_EQ(mentry->mnt_fsname, entry.blk_device);
270 EXPECT_EQ(mentry->mnt_dir, entry.mount_point);
271 EXPECT_EQ(mentry->mnt_type, entry.fs_type);
272
273 std::set<std::string> mnt_opts;
274 for (auto& s : android::base::Split(mentry->mnt_opts, ",")) {
275 mnt_opts.emplace(s);
276 }
277 std::set<std::string> fs_options;
278 if (!entry.fs_options.empty()) {
279 for (auto& s : android::base::Split(entry.fs_options, ",")) {
280 fs_options.emplace(s);
281 }
282 }
283 // matches private content in fs_mgr_fstab.c
284 static struct flag_list {
285 const char* name;
286 unsigned int flag;
287 } mount_flags[] = {
288 {"noatime", MS_NOATIME},
289 {"noexec", MS_NOEXEC},
290 {"nosuid", MS_NOSUID},
291 {"nodev", MS_NODEV},
292 {"nodiratime", MS_NODIRATIME},
293 {"ro", MS_RDONLY},
294 {"rw", 0},
295 {"sync", MS_SYNCHRONOUS},
296 {"remount", MS_REMOUNT},
297 {"bind", MS_BIND},
298 {"rec", MS_REC},
299 {"unbindable", MS_UNBINDABLE},
300 {"private", MS_PRIVATE},
301 {"slave", MS_SLAVE},
302 {"shared", MS_SHARED},
303 {"defaults", 0},
304 {0, 0},
305 };
306 for (auto f = 0; mount_flags[f].name; ++f) {
307 if (mount_flags[f].flag & entry.flags) {
308 fs_options.emplace(mount_flags[f].name);
309 }
310 }
311 if (!(entry.flags & MS_RDONLY)) {
312 fs_options.emplace("rw");
313 }
314 EXPECT_EQ(mnt_opts, fs_options) << "At line " << i;
315 ++i;
316 }
317 EXPECT_EQ(i, fstab.size());
318 }
319
TEST(fs_mgr,ReadFstabFromFile_MountOptions)320 TEST(fs_mgr, ReadFstabFromFile_MountOptions) {
321 TemporaryFile tf;
322 ASSERT_TRUE(tf.fd != -1);
323 std::string fstab_contents = R"fs(
324 source / ext4 ro,barrier=1 wait,avb
325 source /metadata ext4 noatime,nosuid,nodev,discard wait,formattable
326
327 source /data f2fs noatime,nosuid,nodev,discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier latemount,wait,check,fileencryption=ice,keydirectory=/metadata/vold/metadata_encryption,quota,formattable,sysfs_path=/sys/devices/platform/soc/1d84000.ufshc,reservedsize=128M
328
329 source /misc emmc defaults defaults
330
331 source /vendor/firmware_mnt vfat ro,shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,context=u:object_r:firmware_file:s0 wait
332
333 source auto vfat defaults voldmanaged=usb:auto
334 source none swap defaults zramsize=1073741824,max_comp_streams=8
335 source none2 swap nodiratime,remount,bind zramsize=1073741824,max_comp_streams=8
336 source none3 swap unbindable,private,slave zramsize=1073741824,max_comp_streams=8
337 source none4 swap noexec,shared,rec zramsize=1073741824,max_comp_streams=8
338 source none5 swap rw zramsize=1073741824,max_comp_streams=8
339 )fs";
340 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
341
342 Fstab fstab;
343 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
344 ASSERT_LE(11U, fstab.size());
345
346 FstabEntry* entry = GetEntryForMountPoint(&fstab, "/");
347 ASSERT_NE(nullptr, entry);
348 EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);
349 EXPECT_EQ("barrier=1", entry->fs_options);
350
351 entry = GetEntryForMountPoint(&fstab, "/metadata");
352 ASSERT_NE(nullptr, entry);
353 EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);
354 EXPECT_EQ("discard", entry->fs_options);
355
356 entry = GetEntryForMountPoint(&fstab, "/data");
357 ASSERT_NE(nullptr, entry);
358 EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);
359 EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", entry->fs_options);
360
361 entry = GetEntryForMountPoint(&fstab, "/misc");
362 ASSERT_NE(nullptr, entry);
363 EXPECT_EQ(0U, entry->flags);
364 EXPECT_EQ("", entry->fs_options);
365
366 entry = GetEntryForMountPoint(&fstab, "/vendor/firmware_mnt");
367 ASSERT_NE(nullptr, entry);
368 EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);
369 EXPECT_EQ(
370 "shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,"
371 "context=u:object_r:firmware_file:s0",
372 entry->fs_options);
373
374 entry = GetEntryForMountPoint(&fstab, "auto");
375 ASSERT_NE(nullptr, entry);
376 EXPECT_EQ(0U, entry->flags);
377 EXPECT_EQ("", entry->fs_options);
378
379 entry = GetEntryForMountPoint(&fstab, "none");
380 ASSERT_NE(nullptr, entry);
381 EXPECT_EQ(0U, entry->flags);
382 EXPECT_EQ("", entry->fs_options);
383
384 entry = GetEntryForMountPoint(&fstab, "none2");
385 ASSERT_NE(nullptr, entry);
386 EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), entry->flags);
387 EXPECT_EQ("", entry->fs_options);
388
389 entry = GetEntryForMountPoint(&fstab, "none3");
390 ASSERT_NE(nullptr, entry);
391 EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), entry->flags);
392 EXPECT_EQ("", entry->fs_options);
393
394 entry = GetEntryForMountPoint(&fstab, "none4");
395 ASSERT_NE(nullptr, entry);
396 EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), entry->flags);
397 EXPECT_EQ("", entry->fs_options);
398
399 entry = GetEntryForMountPoint(&fstab, "none5");
400 ASSERT_NE(nullptr, entry);
401 // rw is the default.
402 EXPECT_EQ(0U, entry->flags);
403 EXPECT_EQ("", entry->fs_options);
404 }
405
TEST(fs_mgr,ReadFstabFromFile_FsMgrFlags)406 TEST(fs_mgr, ReadFstabFromFile_FsMgrFlags) {
407 TemporaryFile tf;
408 ASSERT_TRUE(tf.fd != -1);
409 std::string fstab_contents = R"fs(
410 source none0 swap defaults wait,check,nonremovable,recoveryonly
411 source none1 swap defaults avb,noemulatedsd,notrim,formattable,nofail
412 source none2 swap defaults first_stage_mount,latemount,quota,logical
413 source none3 swap defaults checkpoint=block
414 source none4 swap defaults checkpoint=fs
415 source none5 swap defaults defaults
416 )fs";
417 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
418
419 Fstab fstab;
420 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
421 ASSERT_LE(6U, fstab.size());
422
423 FstabEntry* entry = GetEntryForMountPoint(&fstab, "none0");
424 ASSERT_NE(nullptr, entry);
425 {
426 FstabEntry::FsMgrFlags flags = {};
427 flags.wait = true;
428 flags.check = true;
429 flags.nonremovable = true;
430 flags.recovery_only = true;
431 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
432 }
433
434 entry = GetEntryForMountPoint(&fstab, "none1");
435 ASSERT_NE(nullptr, entry);
436 {
437 FstabEntry::FsMgrFlags flags = {};
438 flags.avb = true;
439 flags.no_emulated_sd = true;
440 flags.no_trim = true;
441 flags.formattable = true;
442 flags.no_fail = true;
443 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
444 }
445
446 entry = GetEntryForMountPoint(&fstab, "none2");
447 ASSERT_NE(nullptr, entry);
448 {
449 FstabEntry::FsMgrFlags flags = {};
450 flags.first_stage_mount = true;
451 flags.late_mount = true;
452 flags.quota = true;
453 flags.logical = true;
454 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
455 }
456
457 entry = GetEntryForMountPoint(&fstab, "none3");
458 ASSERT_NE(nullptr, entry);
459 {
460 FstabEntry::FsMgrFlags flags = {};
461 flags.checkpoint_blk = true;
462 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
463 }
464
465 entry = GetEntryForMountPoint(&fstab, "none4");
466 ASSERT_NE(nullptr, entry);
467 {
468 FstabEntry::FsMgrFlags flags = {};
469 flags.checkpoint_fs = true;
470 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
471 }
472
473 entry = GetEntryForMountPoint(&fstab, "none5");
474 ASSERT_NE(nullptr, entry);
475 {
476 FstabEntry::FsMgrFlags flags = {};
477 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
478 }
479 }
480
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_AllBad)481 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_AllBad) {
482 TemporaryFile tf;
483 ASSERT_TRUE(tf.fd != -1);
484 std::string fstab_contents = R"fs(
485 source none0 swap defaults fileencryption,keydirectory,length,swapprio,zramsize,max_comp_streams,reservedsize,eraseblk,logicalblk,sysfs_path,zram_backingdev_size
486
487 source none1 swap defaults fileencryption=,keydirectory=,length=,swapprio=,zramsize=,max_comp_streams=,avb=,reservedsize=,eraseblk=,logicalblk=,sysfs_path=,zram_backingdev_size=
488
489 )fs";
490 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
491
492 Fstab fstab;
493 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
494 ASSERT_LE(2U, fstab.size());
495
496 auto entry = fstab.begin();
497 EXPECT_EQ("none0", entry->mount_point);
498 {
499 FstabEntry::FsMgrFlags flags = {};
500 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
501 }
502 EXPECT_EQ("", entry->metadata_key_dir);
503 EXPECT_EQ(0, entry->length);
504 EXPECT_EQ("", entry->label);
505 EXPECT_EQ(-1, entry->partnum);
506 EXPECT_EQ(-1, entry->swap_prio);
507 EXPECT_EQ(0, entry->max_comp_streams);
508 EXPECT_EQ(0, entry->zram_size);
509 EXPECT_EQ(0, entry->reserved_size);
510 EXPECT_EQ("", entry->encryption_options);
511 EXPECT_EQ(0, entry->erase_blk_size);
512 EXPECT_EQ(0, entry->logical_blk_size);
513 EXPECT_EQ("", entry->sysfs_path);
514 EXPECT_EQ(0U, entry->zram_backingdev_size);
515 entry++;
516
517 EXPECT_EQ("none1", entry->mount_point);
518 {
519 FstabEntry::FsMgrFlags flags = {};
520 flags.file_encryption = true;
521 flags.avb = true;
522 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
523 }
524 EXPECT_EQ("", entry->metadata_key_dir);
525 EXPECT_EQ(0, entry->length);
526 EXPECT_EQ("", entry->label);
527 EXPECT_EQ(-1, entry->partnum);
528 EXPECT_EQ(-1, entry->swap_prio);
529 EXPECT_EQ(0, entry->max_comp_streams);
530 EXPECT_EQ(0, entry->zram_size);
531 EXPECT_EQ(0, entry->reserved_size);
532 EXPECT_EQ("", entry->encryption_options);
533 EXPECT_EQ(0, entry->erase_blk_size);
534 EXPECT_EQ(0, entry->logical_blk_size);
535 EXPECT_EQ("", entry->sysfs_path);
536 EXPECT_EQ(0U, entry->zram_backingdev_size);
537 }
538
539 // FDE is no longer supported, so an fstab with FDE enabled should be rejected.
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_FDE)540 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_FDE) {
541 TemporaryFile tf;
542 ASSERT_TRUE(tf.fd != -1);
543 std::string fstab_contents = R"fs(
544 source /data ext4 noatime forceencrypt=footer
545 )fs";
546 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
547
548 Fstab fstab;
549 EXPECT_FALSE(ReadFstabFromFile(tf.path, &fstab));
550 }
551
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_AdoptableStorage)552 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_AdoptableStorage) {
553 TemporaryFile tf;
554 ASSERT_TRUE(tf.fd != -1);
555 std::string fstab_contents = R"fs(
556 source none0 swap defaults encryptable=userdata,voldmanaged=sdcard:auto
557 )fs";
558 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
559
560 Fstab fstab;
561 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
562 ASSERT_LE(1U, fstab.size());
563
564 FstabEntry::FsMgrFlags flags = {};
565 flags.crypt = true;
566 flags.vold_managed = true;
567
568 auto entry = fstab.begin();
569 EXPECT_EQ("none0", entry->mount_point);
570 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
571 }
572
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_VoldManaged)573 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_VoldManaged) {
574 TemporaryFile tf;
575 ASSERT_TRUE(tf.fd != -1);
576 std::string fstab_contents = R"fs(
577 source none0 swap defaults voldmanaged=:
578 source none1 swap defaults voldmanaged=sdcard
579 source none2 swap defaults voldmanaged=sdcard:3
580 source none3 swap defaults voldmanaged=sdcard:auto
581 )fs";
582 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
583
584 Fstab fstab;
585 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
586 ASSERT_LE(4U, fstab.size());
587
588 FstabEntry::FsMgrFlags flags = {};
589 flags.vold_managed = true;
590
591 auto entry = fstab.begin();
592 EXPECT_EQ("none0", entry->mount_point);
593 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
594 EXPECT_TRUE(entry->label.empty());
595 EXPECT_EQ(-1, entry->partnum);
596 entry++;
597
598 EXPECT_EQ("none1", entry->mount_point);
599 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
600 EXPECT_TRUE(entry->label.empty());
601 EXPECT_EQ(-1, entry->partnum);
602 entry++;
603
604 EXPECT_EQ("none2", entry->mount_point);
605 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
606 EXPECT_EQ("sdcard", entry->label);
607 EXPECT_EQ(3, entry->partnum);
608 entry++;
609
610 EXPECT_EQ("none3", entry->mount_point);
611 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
612 EXPECT_EQ("sdcard", entry->label);
613 EXPECT_EQ(-1, entry->partnum);
614 }
615
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Length)616 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Length) {
617 TemporaryFile tf;
618 ASSERT_TRUE(tf.fd != -1);
619 std::string fstab_contents = R"fs(
620 source none0 swap defaults length=blah
621 source none1 swap defaults length=123456
622 )fs";
623 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
624
625 Fstab fstab;
626 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
627 ASSERT_LE(2U, fstab.size());
628
629 FstabEntry::FsMgrFlags flags = {};
630
631 auto entry = fstab.begin();
632 EXPECT_EQ("none0", entry->mount_point);
633 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
634 EXPECT_EQ(0, entry->length);
635 entry++;
636
637 EXPECT_EQ("none1", entry->mount_point);
638 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
639 EXPECT_EQ(123456, entry->length);
640 }
641
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Swapprio)642 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Swapprio) {
643 TemporaryFile tf;
644 ASSERT_TRUE(tf.fd != -1);
645 std::string fstab_contents = R"fs(
646 source none0 swap defaults swapprio=blah
647 source none1 swap defaults swapprio=123456
648 )fs";
649 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
650
651 Fstab fstab;
652 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
653 ASSERT_LE(2U, fstab.size());
654
655 FstabEntry::FsMgrFlags flags = {};
656
657 auto entry = fstab.begin();
658 EXPECT_EQ("none0", entry->mount_point);
659 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
660 EXPECT_EQ(-1, entry->swap_prio);
661 entry++;
662
663 EXPECT_EQ("none1", entry->mount_point);
664 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
665 EXPECT_EQ(123456, entry->swap_prio);
666 }
667
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_ZramSize)668 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ZramSize) {
669 TemporaryFile tf;
670 ASSERT_TRUE(tf.fd != -1);
671 std::string fstab_contents = R"fs(
672 source none0 swap defaults zramsize=blah
673 source none1 swap defaults zramsize=123456
674 source none2 swap defaults zramsize=blah%
675 source none3 swap defaults zramsize=5%
676 source none4 swap defaults zramsize=105%
677 source none5 swap defaults zramsize=%
678 )fs";
679 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
680
681 Fstab fstab;
682 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
683 ASSERT_LE(6U, fstab.size());
684
685 FstabEntry::FsMgrFlags flags = {};
686
687 auto entry = fstab.begin();
688 EXPECT_EQ("none0", entry->mount_point);
689 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
690 EXPECT_EQ(0, entry->zram_size);
691 entry++;
692
693 EXPECT_EQ("none1", entry->mount_point);
694 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
695 EXPECT_EQ(123456, entry->zram_size);
696 entry++;
697
698 EXPECT_EQ("none2", entry->mount_point);
699 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
700 EXPECT_EQ(0, entry->zram_size);
701 entry++;
702
703 EXPECT_EQ("none3", entry->mount_point);
704 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
705 EXPECT_NE(0, entry->zram_size);
706 entry++;
707
708 EXPECT_EQ("none4", entry->mount_point);
709 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
710 EXPECT_EQ(0, entry->zram_size);
711 entry++;
712
713 EXPECT_EQ("none5", entry->mount_point);
714 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
715 EXPECT_EQ(0, entry->zram_size);
716 }
717
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_FileEncryption)718 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_FileEncryption) {
719 TemporaryFile tf;
720 ASSERT_TRUE(tf.fd != -1);
721 std::string fstab_contents = R"fs(
722 source none0 swap defaults fileencryption=aes-256-xts:aes-256-cts:v1
723 )fs";
724
725 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
726
727 Fstab fstab;
728 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
729 ASSERT_LE(1U, fstab.size());
730
731 FstabEntry::FsMgrFlags flags = {};
732 flags.file_encryption = true;
733
734 auto entry = fstab.begin();
735 EXPECT_EQ("none0", entry->mount_point);
736 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
737 EXPECT_EQ("aes-256-xts:aes-256-cts:v1", entry->encryption_options);
738 }
739
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_MaxCompStreams)740 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_MaxCompStreams) {
741 TemporaryFile tf;
742 ASSERT_TRUE(tf.fd != -1);
743 std::string fstab_contents = R"fs(
744 source none0 swap defaults max_comp_streams=blah
745 source none1 swap defaults max_comp_streams=123456
746 )fs";
747 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
748
749 Fstab fstab;
750 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
751 ASSERT_LE(2U, fstab.size());
752
753 FstabEntry::FsMgrFlags flags = {};
754
755 auto entry = fstab.begin();
756 EXPECT_EQ("none0", entry->mount_point);
757 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
758 EXPECT_EQ(0, entry->max_comp_streams);
759 entry++;
760
761 EXPECT_EQ("none1", entry->mount_point);
762 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
763 EXPECT_EQ(123456, entry->max_comp_streams);
764 }
765
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_ReservedSize)766 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_ReservedSize) {
767 TemporaryFile tf;
768 ASSERT_TRUE(tf.fd != -1);
769 std::string fstab_contents = R"fs(
770 source none0 swap defaults reservedsize=blah
771 source none1 swap defaults reservedsize=2
772 source none2 swap defaults reservedsize=1K
773 source none3 swap defaults reservedsize=2m
774 )fs";
775 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
776
777 Fstab fstab;
778 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
779 ASSERT_LE(4U, fstab.size());
780
781 FstabEntry::FsMgrFlags flags = {};
782
783 auto entry = fstab.begin();
784 EXPECT_EQ("none0", entry->mount_point);
785 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
786 EXPECT_EQ(0, entry->reserved_size);
787 entry++;
788
789 EXPECT_EQ("none1", entry->mount_point);
790 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
791 EXPECT_EQ(2, entry->reserved_size);
792 entry++;
793
794 EXPECT_EQ("none2", entry->mount_point);
795 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
796 EXPECT_EQ(1024, entry->reserved_size);
797 entry++;
798
799 EXPECT_EQ("none3", entry->mount_point);
800 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
801 EXPECT_EQ(2 * 1024 * 1024, entry->reserved_size);
802 }
803
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_EraseBlk)804 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_EraseBlk) {
805 TemporaryFile tf;
806 ASSERT_TRUE(tf.fd != -1);
807 std::string fstab_contents = R"fs(
808 source none0 swap defaults eraseblk=blah
809 source none1 swap defaults eraseblk=4000
810 source none2 swap defaults eraseblk=5000
811 source none3 swap defaults eraseblk=8192
812 )fs";
813 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
814
815 Fstab fstab;
816 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
817 ASSERT_LE(4U, fstab.size());
818
819 FstabEntry::FsMgrFlags flags = {};
820
821 auto entry = fstab.begin();
822 EXPECT_EQ("none0", entry->mount_point);
823 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
824 EXPECT_EQ(0, entry->erase_blk_size);
825 entry++;
826
827 EXPECT_EQ("none1", entry->mount_point);
828 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
829 EXPECT_EQ(0, entry->erase_blk_size);
830 entry++;
831
832 EXPECT_EQ("none2", entry->mount_point);
833 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
834 EXPECT_EQ(0, entry->erase_blk_size);
835 entry++;
836
837 EXPECT_EQ("none3", entry->mount_point);
838 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
839 EXPECT_EQ(8192, entry->erase_blk_size);
840 }
841
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Logicalblk)842 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Logicalblk) {
843 TemporaryFile tf;
844 ASSERT_TRUE(tf.fd != -1);
845 std::string fstab_contents = R"fs(
846 source none0 swap defaults logicalblk=blah
847 source none1 swap defaults logicalblk=4000
848 source none2 swap defaults logicalblk=5000
849 source none3 swap defaults logicalblk=8192
850 )fs";
851 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
852
853 Fstab fstab;
854 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
855 ASSERT_LE(4U, fstab.size());
856
857 FstabEntry::FsMgrFlags flags = {};
858
859 auto entry = fstab.begin();
860 EXPECT_EQ("none0", entry->mount_point);
861 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
862 EXPECT_EQ(0, entry->logical_blk_size);
863 entry++;
864
865 EXPECT_EQ("none1", entry->mount_point);
866 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
867 EXPECT_EQ(0, entry->logical_blk_size);
868 entry++;
869
870 EXPECT_EQ("none2", entry->mount_point);
871 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
872 EXPECT_EQ(0, entry->logical_blk_size);
873 entry++;
874
875 EXPECT_EQ("none3", entry->mount_point);
876 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
877 EXPECT_EQ(8192, entry->logical_blk_size);
878 }
879
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Avb)880 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Avb) {
881 TemporaryFile tf;
882 ASSERT_TRUE(tf.fd != -1);
883 std::string fstab_contents = R"fs(
884 source none0 swap defaults avb=vbmeta_partition
885 source none1 swap defaults avb_keys=/path/to/test.avbpubkey
886 )fs";
887
888 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
889
890 Fstab fstab;
891 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
892 ASSERT_LE(2U, fstab.size());
893
894 auto entry = fstab.begin();
895 EXPECT_EQ("none0", entry->mount_point);
896
897 FstabEntry::FsMgrFlags flags = {};
898 flags.avb = true;
899 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
900
901 EXPECT_EQ("vbmeta_partition", entry->vbmeta_partition);
902 entry++;
903
904 EXPECT_EQ("none1", entry->mount_point);
905 FstabEntry::FsMgrFlags empty_flags = {}; // no flags should be set for avb_keys.
906 EXPECT_TRUE(CompareFlags(empty_flags, entry->fs_mgr_flags));
907 EXPECT_EQ("/path/to/test.avbpubkey", entry->avb_keys);
908 }
909
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_KeyDirectory)910 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_KeyDirectory) {
911 TemporaryFile tf;
912 ASSERT_TRUE(tf.fd != -1);
913 std::string fstab_contents = R"fs(
914 source none0 swap defaults keydirectory=/dir/key
915 )fs";
916
917 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
918
919 Fstab fstab;
920 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
921 ASSERT_LE(1U, fstab.size());
922
923 auto entry = fstab.begin();
924 EXPECT_EQ("none0", entry->mount_point);
925
926 FstabEntry::FsMgrFlags flags = {};
927 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
928
929 EXPECT_EQ("/dir/key", entry->metadata_key_dir);
930 }
931
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_MetadataEncryption)932 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_MetadataEncryption) {
933 TemporaryFile tf;
934 ASSERT_TRUE(tf.fd != -1);
935 std::string fstab_contents = R"fs(
936 source none0 swap defaults keydirectory=/dir/key,metadata_encryption=adiantum
937 )fs";
938
939 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
940
941 Fstab fstab;
942 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
943 ASSERT_LE(1U, fstab.size());
944
945 auto entry = fstab.begin();
946 EXPECT_EQ("adiantum", entry->metadata_encryption_options);
947 }
948
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_MetadataEncryption_WrappedKey)949 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_MetadataEncryption_WrappedKey) {
950 TemporaryFile tf;
951 ASSERT_TRUE(tf.fd != -1);
952 std::string fstab_contents = R"fs(
953 source none0 swap defaults keydirectory=/dir/key,metadata_encryption=aes-256-xts:wrappedkey_v0
954 )fs";
955
956 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
957
958 Fstab fstab;
959 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
960 ASSERT_LE(1U, fstab.size());
961
962 auto entry = fstab.begin();
963 EXPECT_EQ("aes-256-xts:wrappedkey_v0", entry->metadata_encryption_options);
964 auto parts = android::base::Split(entry->metadata_encryption_options, ":");
965 EXPECT_EQ(2U, parts.size());
966 EXPECT_EQ("aes-256-xts", parts[0]);
967 EXPECT_EQ("wrappedkey_v0", parts[1]);
968 }
969
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_SysfsPath)970 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_SysfsPath) {
971 TemporaryFile tf;
972 ASSERT_TRUE(tf.fd != -1);
973 std::string fstab_contents = R"fs(
974 source none0 swap defaults sysfs_path=/sys/device
975 )fs";
976
977 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
978
979 Fstab fstab;
980 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
981 ASSERT_LE(1U, fstab.size());
982
983 auto entry = fstab.begin();
984 EXPECT_EQ("none0", entry->mount_point);
985
986 FstabEntry::FsMgrFlags flags = {};
987 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
988
989 EXPECT_EQ("/sys/device", entry->sysfs_path);
990 }
991
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Zram)992 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Zram) {
993 TemporaryFile tf;
994 ASSERT_TRUE(tf.fd != -1);
995 std::string fstab_contents = R"fs(
996 source none1 swap defaults zram_backingdev_size=blah
997 source none2 swap defaults zram_backingdev_size=2
998 source none3 swap defaults zram_backingdev_size=1K
999 source none4 swap defaults zram_backingdev_size=2m
1000
1001 )fs";
1002
1003 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
1004
1005 Fstab fstab;
1006 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
1007 ASSERT_LE(4U, fstab.size());
1008
1009 auto entry = fstab.begin();
1010
1011 EXPECT_EQ("none1", entry->mount_point);
1012 EXPECT_EQ(0U, entry->zram_backingdev_size);
1013 entry++;
1014
1015 EXPECT_EQ("none2", entry->mount_point);
1016 EXPECT_EQ(2U, entry->zram_backingdev_size);
1017 entry++;
1018
1019 EXPECT_EQ("none3", entry->mount_point);
1020 EXPECT_EQ(1024U, entry->zram_backingdev_size);
1021 entry++;
1022
1023 EXPECT_EQ("none4", entry->mount_point);
1024 EXPECT_EQ(2U * 1024U * 1024U, entry->zram_backingdev_size);
1025 entry++;
1026 }
1027
TEST(fs_mgr,DefaultFstabContainsUserdata)1028 TEST(fs_mgr, DefaultFstabContainsUserdata) {
1029 Fstab fstab;
1030 ASSERT_TRUE(ReadDefaultFstab(&fstab)) << "Failed to read default fstab";
1031 ASSERT_NE(nullptr, GetEntryForMountPoint(&fstab, "/data"))
1032 << "Default fstab doesn't contain /data entry";
1033 }
1034
TEST(fs_mgr,UserdataMountedFromDefaultFstab)1035 TEST(fs_mgr, UserdataMountedFromDefaultFstab) {
1036 if (getuid() != 0) {
1037 GTEST_SKIP() << "Must be run as root.";
1038 return;
1039 }
1040 Fstab fstab;
1041 ASSERT_TRUE(ReadDefaultFstab(&fstab)) << "Failed to read default fstab";
1042 Fstab proc_mounts;
1043 ASSERT_TRUE(ReadFstabFromFile("/proc/mounts", &proc_mounts)) << "Failed to read /proc/mounts";
1044 auto mounted_entry = GetEntryForMountPoint(&proc_mounts, "/data");
1045 ASSERT_NE(mounted_entry, nullptr) << "/data is not mounted";
1046 std::string block_device;
1047 ASSERT_TRUE(android::base::Realpath(mounted_entry->blk_device, &block_device));
1048 ASSERT_NE(nullptr, fs_mgr_get_mounted_entry_for_userdata(&fstab, block_device))
1049 << "/data wasn't mounted from default fstab";
1050 }
1051
TEST(fs_mgr,ReadFstabFromFile_FsMgrOptions_Readahead_Size_KB)1052 TEST(fs_mgr, ReadFstabFromFile_FsMgrOptions_Readahead_Size_KB) {
1053 TemporaryFile tf;
1054 ASSERT_TRUE(tf.fd != -1);
1055 std::string fstab_contents = R"fs(
1056 source none0 swap defaults readahead_size_kb=blah
1057 source none1 swap defaults readahead_size_kb=128
1058 source none2 swap defaults readahead_size_kb=5%
1059 source none3 swap defaults readahead_size_kb=5kb
1060 source none4 swap defaults readahead_size_kb=16385
1061 source none5 swap defaults readahead_size_kb=-128
1062 source none6 swap defaults readahead_size_kb=0
1063 )fs";
1064 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
1065
1066 Fstab fstab;
1067 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
1068 ASSERT_LE(7U, fstab.size());
1069
1070 FstabEntry::FsMgrFlags flags = {};
1071
1072 auto entry = fstab.begin();
1073 EXPECT_EQ("none0", entry->mount_point);
1074 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1075 EXPECT_EQ(-1, entry->readahead_size_kb);
1076 entry++;
1077
1078 EXPECT_EQ("none1", entry->mount_point);
1079 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1080 EXPECT_EQ(128, entry->readahead_size_kb);
1081 entry++;
1082
1083 EXPECT_EQ("none2", entry->mount_point);
1084 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1085 EXPECT_EQ(-1, entry->readahead_size_kb);
1086 entry++;
1087
1088 EXPECT_EQ("none3", entry->mount_point);
1089 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1090 EXPECT_EQ(-1, entry->readahead_size_kb);
1091 entry++;
1092
1093 EXPECT_EQ("none4", entry->mount_point);
1094 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1095 EXPECT_EQ(-1, entry->readahead_size_kb);
1096 entry++;
1097
1098 EXPECT_EQ("none5", entry->mount_point);
1099 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1100 EXPECT_EQ(-1, entry->readahead_size_kb);
1101 entry++;
1102
1103 EXPECT_EQ("none6", entry->mount_point);
1104 EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));
1105 EXPECT_EQ(0, entry->readahead_size_kb);
1106 }
1107
TEST(fs_mgr,TransformFstabForDsu)1108 TEST(fs_mgr, TransformFstabForDsu) {
1109 TemporaryFile tf;
1110 ASSERT_TRUE(tf.fd != -1);
1111 std::string fstab_contents = R"fs(
1112 data /data f2fs noatime wait,latemount
1113 system /system erofs ro wait,logical,first_stage_mount
1114 system /system ext4 ro wait,logical,first_stage_mount
1115 vendor /vendor ext4 ro wait,logical,first_stage_mount
1116 )fs";
1117
1118 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
1119
1120 // If GSI is installed, ReadFstabFromFile() would have called TransformFstabForDsu() implicitly.
1121 // In other words, TransformFstabForDsu() would be called two times if running CTS-on-GSI,
1122 // which implies TransformFstabForDsu() should be idempotent.
1123 Fstab fstab;
1124 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
1125 TransformFstabForDsu(&fstab, "dsu", {"system_gsi", "userdata_gsi"});
1126 ASSERT_EQ(4U, fstab.size());
1127
1128 auto entry = fstab.begin();
1129
1130 EXPECT_EQ("/data", entry->mount_point);
1131 EXPECT_EQ("userdata_gsi", entry->blk_device);
1132 entry++;
1133
1134 EXPECT_EQ("/system", entry->mount_point);
1135 EXPECT_EQ("system_gsi", entry->blk_device);
1136 EXPECT_EQ("erofs", entry->fs_type);
1137 entry++;
1138
1139 EXPECT_EQ("/system", entry->mount_point);
1140 EXPECT_EQ("system_gsi", entry->blk_device);
1141 EXPECT_EQ("ext4", entry->fs_type);
1142 entry++;
1143
1144 EXPECT_EQ("/vendor", entry->mount_point);
1145 EXPECT_EQ("vendor", entry->blk_device);
1146 entry++;
1147 }
1148
TEST(fs_mgr,TransformFstabForDsu_synthesisExt4Entry)1149 TEST(fs_mgr, TransformFstabForDsu_synthesisExt4Entry) {
1150 TemporaryFile tf;
1151 ASSERT_TRUE(tf.fd != -1);
1152 std::string fstab_contents = R"fs(
1153 system /system erofs ro wait,logical,first_stage_mount
1154 vendor /vendor ext4 ro wait,logical,first_stage_mount
1155 data /data f2fs noatime wait,latemount
1156 )fs";
1157
1158 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
1159
1160 Fstab fstab;
1161 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
1162 TransformFstabForDsu(&fstab, "dsu", {"system_gsi", "userdata_gsi"});
1163 ASSERT_EQ(4U, fstab.size());
1164
1165 auto entry = fstab.begin();
1166
1167 EXPECT_EQ("/system", entry->mount_point);
1168 EXPECT_EQ("system_gsi", entry->blk_device);
1169 EXPECT_EQ("erofs", entry->fs_type);
1170 entry++;
1171
1172 EXPECT_EQ("/system", entry->mount_point);
1173 EXPECT_EQ("system_gsi", entry->blk_device);
1174 EXPECT_EQ("ext4", entry->fs_type);
1175 entry++;
1176
1177 EXPECT_EQ("/vendor", entry->mount_point);
1178 EXPECT_EQ("vendor", entry->blk_device);
1179 entry++;
1180
1181 EXPECT_EQ("/data", entry->mount_point);
1182 EXPECT_EQ("userdata_gsi", entry->blk_device);
1183 entry++;
1184 }
1185
TEST(fs_mgr,TransformFstabForDsu_synthesisAllMissingEntries)1186 TEST(fs_mgr, TransformFstabForDsu_synthesisAllMissingEntries) {
1187 TemporaryFile tf;
1188 ASSERT_TRUE(tf.fd != -1);
1189 std::string fstab_contents = R"fs(
1190 data /data f2fs noatime wait,latemount
1191 vendor /vendor ext4 ro wait,logical,first_stage_mount
1192 )fs";
1193
1194 ASSERT_TRUE(android::base::WriteStringToFile(fstab_contents, tf.path));
1195
1196 Fstab fstab;
1197 EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));
1198 TransformFstabForDsu(&fstab, "dsu", {"system_gsi", "userdata_gsi"});
1199 ASSERT_EQ(4U, fstab.size());
1200
1201 auto entry = fstab.begin();
1202
1203 EXPECT_EQ("/data", entry->mount_point);
1204 EXPECT_EQ("userdata_gsi", entry->blk_device);
1205 entry++;
1206
1207 EXPECT_EQ("/vendor", entry->mount_point);
1208 EXPECT_EQ("vendor", entry->blk_device);
1209 entry++;
1210
1211 EXPECT_EQ("/system", entry->mount_point);
1212 EXPECT_EQ("system_gsi", entry->blk_device);
1213 EXPECT_EQ("ext4", entry->fs_type);
1214 entry++;
1215
1216 EXPECT_EQ("/system", entry->mount_point);
1217 EXPECT_EQ("system_gsi", entry->blk_device);
1218 EXPECT_EQ("erofs", entry->fs_type);
1219 entry++;
1220 }
1221