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 
load_volume_table()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 
volume_for_path(const char * path)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.
ensure_path_mounted_at(const char * path,const char * 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 
ensure_path_mounted(const char * path)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 
ensure_path_unmounted(const char * path)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 
exec_cmd(const char * path,char * const argv[])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 
format_volume(const char * volume,const char * directory)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 
format_volume(const char * volume)276 int format_volume(const char* volume) {
277     return format_volume(volume, NULL);
278 }
279 
setup_install_mounts()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