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