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