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 <errno.h> 18 #include <stdlib.h> 19 #include <sys/mount.h> 20 #include <sys/stat.h> 21 #include <sys/types.h> 22 #include <sys/wait.h> 23 #include <unistd.h> 24 #include <ctype.h> 25 #include <fcntl.h> 26 27 #include <fs_mgr.h> 28 #include "mtdutils/mtdutils.h" 29 #include "mtdutils/mounts.h" 30 #include "roots.h" 31 #include "common.h" 32 #include "make_ext4fs.h" 33 #include "wipe.h" 34 #include "cryptfs.h" 35 36 static struct fstab *fstab = NULL; 37 38 extern struct selabel_handle *sehandle; 39 40 void load_volume_table() 41 { 42 int i; 43 int ret; 44 45 fstab = fs_mgr_read_fstab("/etc/recovery.fstab"); 46 if (!fstab) { 47 LOGE("failed to read /etc/recovery.fstab\n"); 48 return; 49 } 50 51 ret = fs_mgr_add_entry(fstab, "/tmp", "ramdisk", "ramdisk"); 52 if (ret < 0 ) { 53 LOGE("failed to add /tmp entry to fstab\n"); 54 fs_mgr_free_fstab(fstab); 55 fstab = NULL; 56 return; 57 } 58 59 printf("recovery filesystem table\n"); 60 printf("=========================\n"); 61 for (i = 0; i < fstab->num_entries; ++i) { 62 Volume* v = &fstab->recs[i]; 63 printf(" %d %s %s %s %lld\n", i, v->mount_point, v->fs_type, 64 v->blk_device, v->length); 65 } 66 printf("\n"); 67 } 68 69 Volume* volume_for_path(const char* path) { 70 return fs_mgr_get_entry_for_mount_point(fstab, path); 71 } 72 73 // Mount the volume specified by path at the given mount_point. 74 int ensure_path_mounted_at(const char* path, const char* mount_point) { 75 Volume* v = volume_for_path(path); 76 if (v == NULL) { 77 LOGE("unknown volume for path [%s]\n", path); 78 return -1; 79 } 80 if (strcmp(v->fs_type, "ramdisk") == 0) { 81 // the ramdisk is always mounted. 82 return 0; 83 } 84 85 int result; 86 result = scan_mounted_volumes(); 87 if (result < 0) { 88 LOGE("failed to scan mounted volumes\n"); 89 return -1; 90 } 91 92 if (!mount_point) { 93 mount_point = v->mount_point; 94 } 95 96 const MountedVolume* mv = 97 find_mounted_volume_by_mount_point(mount_point); 98 if (mv) { 99 // volume is already mounted 100 return 0; 101 } 102 103 mkdir(mount_point, 0755); // in case it doesn't already exist 104 105 if (strcmp(v->fs_type, "yaffs2") == 0) { 106 // mount an MTD partition as a YAFFS2 filesystem. 107 mtd_scan_partitions(); 108 const MtdPartition* partition; 109 partition = mtd_find_partition_by_name(v->blk_device); 110 if (partition == NULL) { 111 LOGE("failed to find \"%s\" partition to mount at \"%s\"\n", 112 v->blk_device, mount_point); 113 return -1; 114 } 115 return mtd_mount_partition(partition, mount_point, v->fs_type, 0); 116 } else if (strcmp(v->fs_type, "ext4") == 0 || 117 strcmp(v->fs_type, "squashfs") == 0 || 118 strcmp(v->fs_type, "vfat") == 0) { 119 result = mount(v->blk_device, mount_point, v->fs_type, 120 v->flags, v->fs_options); 121 if (result == 0) return 0; 122 123 LOGE("failed to mount %s (%s)\n", mount_point, strerror(errno)); 124 return -1; 125 } 126 127 LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, mount_point); 128 return -1; 129 } 130 131 int ensure_path_mounted(const char* path) { 132 // Mount at the default mount point. 133 return ensure_path_mounted_at(path, nullptr); 134 } 135 136 int ensure_path_unmounted(const char* path) { 137 Volume* v = volume_for_path(path); 138 if (v == NULL) { 139 LOGE("unknown volume for path [%s]\n", path); 140 return -1; 141 } 142 if (strcmp(v->fs_type, "ramdisk") == 0) { 143 // the ramdisk is always mounted; you can't unmount it. 144 return -1; 145 } 146 147 int result; 148 result = scan_mounted_volumes(); 149 if (result < 0) { 150 LOGE("failed to scan mounted volumes\n"); 151 return -1; 152 } 153 154 const MountedVolume* mv = 155 find_mounted_volume_by_mount_point(v->mount_point); 156 if (mv == NULL) { 157 // volume is already unmounted 158 return 0; 159 } 160 161 return unmount_mounted_volume(mv); 162 } 163 164 static int exec_cmd(const char* path, char* const argv[]) { 165 int status; 166 pid_t child; 167 if ((child = vfork()) == 0) { 168 execv(path, argv); 169 _exit(-1); 170 } 171 waitpid(child, &status, 0); 172 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { 173 LOGE("%s failed with status %d\n", path, WEXITSTATUS(status)); 174 } 175 return WEXITSTATUS(status); 176 } 177 178 int format_volume(const char* volume, const char* directory) { 179 Volume* v = volume_for_path(volume); 180 if (v == NULL) { 181 LOGE("unknown volume \"%s\"\n", volume); 182 return -1; 183 } 184 if (strcmp(v->fs_type, "ramdisk") == 0) { 185 // you can't format the ramdisk. 186 LOGE("can't format_volume \"%s\"", volume); 187 return -1; 188 } 189 if (strcmp(v->mount_point, volume) != 0) { 190 LOGE("can't give path \"%s\" to format_volume\n", volume); 191 return -1; 192 } 193 194 if (ensure_path_unmounted(volume) != 0) { 195 LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point); 196 return -1; 197 } 198 199 if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) { 200 mtd_scan_partitions(); 201 const MtdPartition* partition = mtd_find_partition_by_name(v->blk_device); 202 if (partition == NULL) { 203 LOGE("format_volume: no MTD partition \"%s\"\n", v->blk_device); 204 return -1; 205 } 206 207 MtdWriteContext *write = mtd_write_partition(partition); 208 if (write == NULL) { 209 LOGW("format_volume: can't open MTD \"%s\"\n", v->blk_device); 210 return -1; 211 } else if (mtd_erase_blocks(write, -1) == (off_t) -1) { 212 LOGW("format_volume: can't erase MTD \"%s\"\n", v->blk_device); 213 mtd_write_close(write); 214 return -1; 215 } else if (mtd_write_close(write)) { 216 LOGW("format_volume: can't close MTD \"%s\"\n", v->blk_device); 217 return -1; 218 } 219 return 0; 220 } 221 222 if (strcmp(v->fs_type, "ext4") == 0 || strcmp(v->fs_type, "f2fs") == 0) { 223 // if there's a key_loc that looks like a path, it should be a 224 // block device for storing encryption metadata. wipe it too. 225 if (v->key_loc != NULL && v->key_loc[0] == '/') { 226 LOGI("wiping %s\n", v->key_loc); 227 int fd = open(v->key_loc, O_WRONLY | O_CREAT, 0644); 228 if (fd < 0) { 229 LOGE("format_volume: failed to open %s\n", v->key_loc); 230 return -1; 231 } 232 wipe_block_device(fd, get_file_size(fd)); 233 close(fd); 234 } 235 236 ssize_t length = 0; 237 if (v->length != 0) { 238 length = v->length; 239 } else if (v->key_loc != NULL && strcmp(v->key_loc, "footer") == 0) { 240 length = -CRYPT_FOOTER_OFFSET; 241 } 242 int result; 243 if (strcmp(v->fs_type, "ext4") == 0) { 244 result = make_ext4fs_directory(v->blk_device, length, volume, sehandle, directory); 245 } else { /* Has to be f2fs because we checked earlier. */ 246 if (v->key_loc != NULL && strcmp(v->key_loc, "footer") == 0 && length < 0) { 247 LOGE("format_volume: crypt footer + negative length (%zd) not supported on %s\n", length, v->fs_type); 248 return -1; 249 } 250 if (length < 0) { 251 LOGE("format_volume: negative length (%zd) not supported on %s\n", length, v->fs_type); 252 return -1; 253 } 254 char *num_sectors; 255 if (asprintf(&num_sectors, "%zd", length / 512) <= 0) { 256 LOGE("format_volume: failed to create %s command for %s\n", v->fs_type, v->blk_device); 257 return -1; 258 } 259 const char *f2fs_path = "/sbin/mkfs.f2fs"; 260 const char* const f2fs_argv[] = {"mkfs.f2fs", "-t", "-d1", v->blk_device, num_sectors, NULL}; 261 262 result = exec_cmd(f2fs_path, (char* const*)f2fs_argv); 263 free(num_sectors); 264 } 265 if (result != 0) { 266 LOGE("format_volume: make %s failed on %s with %d(%s)\n", v->fs_type, v->blk_device, result, strerror(errno)); 267 return -1; 268 } 269 return 0; 270 } 271 272 LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type); 273 return -1; 274 } 275 276 int format_volume(const char* volume) { 277 return format_volume(volume, NULL); 278 } 279 280 int setup_install_mounts() { 281 if (fstab == NULL) { 282 LOGE("can't set up install mounts: no fstab loaded\n"); 283 return -1; 284 } 285 for (int i = 0; i < fstab->num_entries; ++i) { 286 Volume* v = fstab->recs + i; 287 288 if (strcmp(v->mount_point, "/tmp") == 0 || 289 strcmp(v->mount_point, "/cache") == 0) { 290 if (ensure_path_mounted(v->mount_point) != 0) { 291 LOGE("failed to mount %s\n", v->mount_point); 292 return -1; 293 } 294 295 } else { 296 if (ensure_path_unmounted(v->mount_point) != 0) { 297 LOGE("failed to unmount %s\n", v->mount_point); 298 return -1; 299 } 300 } 301 } 302 return 0; 303 } 304
