1 /*
2 * Copyright (C) 2007 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 "recovery_utils/roots.h"
18
19 #include <fcntl.h>
20 #include <stdint.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <sys/wait.h>
26 #include <unistd.h>
27
28 #include <iostream>
29 #include <string>
30 #include <vector>
31
32 #include <android-base/logging.h>
33 #include <android-base/properties.h>
34 #include <android-base/stringprintf.h>
35 #include <android-base/unique_fd.h>
36 #include <ext4_utils/ext4_utils.h>
37 #include <ext4_utils/wipe.h>
38 #include <fs_mgr.h>
39 #include <fs_mgr/roots.h>
40
41 #include "otautil/sysutil.h"
42
43 using android::fs_mgr::Fstab;
44 using android::fs_mgr::FstabEntry;
45 using android::fs_mgr::ReadDefaultFstab;
46
47 static Fstab fstab;
48
49 constexpr const char* CACHE_ROOT = "/cache";
50
load_volume_table()51 void load_volume_table() {
52 if (!ReadDefaultFstab(&fstab)) {
53 LOG(ERROR) << "Failed to read default fstab";
54 return;
55 }
56
57 fstab.emplace_back(FstabEntry{
58 .blk_device = "ramdisk",
59 .mount_point = "/tmp",
60 .fs_type = "ramdisk",
61 .length = 0,
62 });
63
64 std::cout << "recovery filesystem table" << std::endl << "=========================" << std::endl;
65 for (size_t i = 0; i < fstab.size(); ++i) {
66 const auto& entry = fstab[i];
67 std::cout << " " << i << " " << entry.mount_point << " "
68 << " " << entry.fs_type << " " << entry.blk_device << " " << entry.length
69 << std::endl;
70 }
71 std::cout << std::endl;
72 }
73
volume_for_mount_point(const std::string & mount_point)74 Volume* volume_for_mount_point(const std::string& mount_point) {
75 return android::fs_mgr::GetEntryForMountPoint(&fstab, mount_point);
76 }
77
78 // Mount the volume specified by path at the given mount_point.
ensure_path_mounted_at(const std::string & path,const std::string & mount_point)79 int ensure_path_mounted_at(const std::string& path, const std::string& mount_point) {
80 return android::fs_mgr::EnsurePathMounted(&fstab, path, mount_point) ? 0 : -1;
81 }
82
ensure_path_mounted(const std::string & path)83 int ensure_path_mounted(const std::string& path) {
84 // Mount at the default mount point.
85 return android::fs_mgr::EnsurePathMounted(&fstab, path) ? 0 : -1;
86 }
87
ensure_path_unmounted(const std::string & path)88 int ensure_path_unmounted(const std::string& path) {
89 return android::fs_mgr::EnsurePathUnmounted(&fstab, path) ? 0 : -1;
90 }
91
exec_cmd(const std::vector<std::string> & args)92 static int exec_cmd(const std::vector<std::string>& args) {
93 CHECK(!args.empty());
94 auto argv = StringVectorToNullTerminatedArray(args);
95
96 pid_t child;
97 if ((child = fork()) == 0) {
98 execv(argv[0], argv.data());
99 _exit(EXIT_FAILURE);
100 }
101
102 int status;
103 waitpid(child, &status, 0);
104 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
105 LOG(ERROR) << args[0] << " failed with status " << WEXITSTATUS(status);
106 }
107 return WEXITSTATUS(status);
108 }
109
get_file_size(int fd,uint64_t reserve_len)110 static int64_t get_file_size(int fd, uint64_t reserve_len) {
111 struct stat buf;
112 int ret = fstat(fd, &buf);
113 if (ret) return 0;
114
115 int64_t computed_size;
116 if (S_ISREG(buf.st_mode)) {
117 computed_size = buf.st_size - reserve_len;
118 } else if (S_ISBLK(buf.st_mode)) {
119 uint64_t block_device_size = get_block_device_size(fd);
120 if (block_device_size < reserve_len ||
121 block_device_size > std::numeric_limits<int64_t>::max()) {
122 computed_size = 0;
123 } else {
124 computed_size = block_device_size - reserve_len;
125 }
126 } else {
127 computed_size = 0;
128 }
129
130 return computed_size;
131 }
132
format_volume(const std::string & volume,const std::string & directory)133 int format_volume(const std::string& volume, const std::string& directory) {
134 const FstabEntry* v = android::fs_mgr::GetEntryForPath(&fstab, volume);
135 if (v == nullptr) {
136 LOG(ERROR) << "unknown volume \"" << volume << "\"";
137 return -1;
138 }
139 if (v->fs_type == "ramdisk") {
140 LOG(ERROR) << "can't format_volume \"" << volume << "\"";
141 return -1;
142 }
143 if (v->mount_point != volume) {
144 LOG(ERROR) << "can't give path \"" << volume << "\" to format_volume";
145 return -1;
146 }
147 if (ensure_path_unmounted(volume) != 0) {
148 LOG(ERROR) << "format_volume: Failed to unmount \"" << v->mount_point << "\"";
149 return -1;
150 }
151 if (v->fs_type != "ext4" && v->fs_type != "f2fs") {
152 LOG(ERROR) << "format_volume: fs_type \"" << v->fs_type << "\" unsupported";
153 return -1;
154 }
155
156 bool needs_casefold = false;
157
158 if (volume == "/data") {
159 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
160 }
161
162 int64_t length = 0;
163 if (v->length > 0) {
164 length = v->length;
165 } else if (v->length < 0) {
166 android::base::unique_fd fd(open(v->blk_device.c_str(), O_RDONLY));
167 if (fd == -1) {
168 PLOG(ERROR) << "format_volume: failed to open " << v->blk_device;
169 return -1;
170 }
171 length = get_file_size(fd.get(), -v->length);
172 if (length <= 0) {
173 LOG(ERROR) << "get_file_size: invalid size " << length << " for " << v->blk_device;
174 return -1;
175 }
176 }
177
178 // If the raw disk will be used as a metadata encrypted device mapper target,
179 // next boot will do encrypt_in_place the raw disk which gives a subtle duration
180 // to get any failure in the process. In order to avoid it, let's simply wipe
181 // the raw disk if we don't reserve any space, which behaves exactly same as booting
182 // after "fastboot -w".
183 if (!v->metadata_key_dir.empty() && length == 0) {
184 android::base::unique_fd fd(open(v->blk_device.c_str(), O_RDWR));
185 if (fd == -1) {
186 PLOG(ERROR) << "format_volume: failed to open " << v->blk_device;
187 return -1;
188 }
189 int64_t device_size = get_file_size(fd.get(), 0);
190 if (device_size > 0 && !wipe_block_device(fd.get(), device_size)) {
191 LOG(INFO) << "format_volume: wipe metadata encrypted " << v->blk_device << " with size "
192 << device_size;
193 return 0;
194 }
195 }
196
197 if (v->fs_type == "ext4") {
198 static constexpr int kBlockSize = 4096;
199 std::vector<std::string> mke2fs_args = {
200 "/system/bin/mke2fs", "-F", "-t", "ext4", "-b", std::to_string(kBlockSize),
201 };
202
203 // Following is added for Project ID's quota as they require wider inodes.
204 // The Quotas themselves are enabled by tune2fs on boot.
205 mke2fs_args.push_back("-I");
206 mke2fs_args.push_back("512");
207
208 if (v->fs_mgr_flags.ext_meta_csum) {
209 mke2fs_args.push_back("-O");
210 mke2fs_args.push_back("metadata_csum");
211 mke2fs_args.push_back("-O");
212 mke2fs_args.push_back("64bit");
213 mke2fs_args.push_back("-O");
214 mke2fs_args.push_back("extent");
215 }
216
217 int raid_stride = v->logical_blk_size / kBlockSize;
218 int raid_stripe_width = v->erase_blk_size / kBlockSize;
219 // stride should be the max of 8KB and logical block size
220 if (v->logical_blk_size != 0 && v->logical_blk_size < 8192) {
221 raid_stride = 8192 / kBlockSize;
222 }
223 if (v->erase_blk_size != 0 && v->logical_blk_size != 0) {
224 mke2fs_args.push_back("-E");
225 mke2fs_args.push_back(
226 android::base::StringPrintf("stride=%d,stripe-width=%d", raid_stride, raid_stripe_width));
227 }
228 mke2fs_args.push_back(v->blk_device);
229 if (length != 0) {
230 mke2fs_args.push_back(std::to_string(length / kBlockSize));
231 }
232
233 int result = exec_cmd(mke2fs_args);
234 if (result == 0 && !directory.empty()) {
235 std::vector<std::string> e2fsdroid_args = {
236 "/system/bin/e2fsdroid", "-e", "-f", directory, "-a", volume, v->blk_device,
237 };
238 result = exec_cmd(e2fsdroid_args);
239 }
240
241 if (result != 0) {
242 PLOG(ERROR) << "format_volume: Failed to make ext4 on " << v->blk_device;
243 return -1;
244 }
245 return 0;
246 }
247
248 // Has to be f2fs because we checked earlier.
249 static constexpr int kSectorSize = 4096;
250 std::vector<std::string> make_f2fs_cmd = {
251 "/system/bin/make_f2fs",
252 "-g",
253 "android",
254 };
255
256 make_f2fs_cmd.push_back("-O");
257 make_f2fs_cmd.push_back("project_quota,extra_attr");
258
259 if (needs_casefold) {
260 make_f2fs_cmd.push_back("-O");
261 make_f2fs_cmd.push_back("casefold");
262 make_f2fs_cmd.push_back("-C");
263 make_f2fs_cmd.push_back("utf8");
264 }
265 if (v->fs_mgr_flags.fs_compress) {
266 make_f2fs_cmd.push_back("-O");
267 make_f2fs_cmd.push_back("compression");
268 make_f2fs_cmd.push_back("-O");
269 make_f2fs_cmd.push_back("extra_attr");
270 }
271 make_f2fs_cmd.push_back(v->blk_device);
272 if (length >= kSectorSize) {
273 make_f2fs_cmd.push_back(std::to_string(length / kSectorSize));
274 }
275
276 if (exec_cmd(make_f2fs_cmd) != 0) {
277 PLOG(ERROR) << "format_volume: Failed to make_f2fs on " << v->blk_device;
278 return -1;
279 }
280 if (!directory.empty()) {
281 std::vector<std::string> sload_f2fs_cmd = {
282 "/system/bin/sload_f2fs", "-f", directory, "-t", volume, v->blk_device,
283 };
284 if (exec_cmd(sload_f2fs_cmd) != 0) {
285 PLOG(ERROR) << "format_volume: Failed to sload_f2fs on " << v->blk_device;
286 return -1;
287 }
288 }
289 return 0;
290 }
291
format_volume(const std::string & volume)292 int format_volume(const std::string& volume) {
293 return format_volume(volume, "");
294 }
295
setup_install_mounts()296 int setup_install_mounts() {
297 if (fstab.empty()) {
298 LOG(ERROR) << "can't set up install mounts: no fstab loaded";
299 return -1;
300 }
301 for (const FstabEntry& entry : fstab) {
302 // We don't want to do anything with "/".
303 if (entry.mount_point == "/") {
304 continue;
305 }
306
307 if (entry.mount_point == "/tmp" || entry.mount_point == "/cache") {
308 if (ensure_path_mounted(entry.mount_point) != 0) {
309 LOG(ERROR) << "Failed to mount " << entry.mount_point;
310 return -1;
311 }
312 } else {
313 if (ensure_path_unmounted(entry.mount_point) != 0) {
314 LOG(ERROR) << "Failed to unmount " << entry.mount_point;
315 return -1;
316 }
317 }
318 }
319 return 0;
320 }
321
HasCache()322 bool HasCache() {
323 CHECK(!fstab.empty());
324 static bool has_cache = volume_for_mount_point(CACHE_ROOT) != nullptr;
325 return has_cache;
326 }
327