ed0f30471614964ee603dd22674f08d4dd472792
[project/fstools.git] / libfstools / overlay.c
1 /*
2  * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License version 2.1
6  * as published by the Free Software Foundation
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  */
13
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include <sys/mount.h>
17
18 #include <asm/byteorder.h>
19
20 #include <errno.h>
21 #include <string.h>
22 #include <stdio.h>
23 #include <unistd.h>
24 #include <stdlib.h>
25 #include <glob.h>
26 #include <errno.h>
27 #include <dirent.h>
28 #include <fcntl.h>
29
30 #include "libfstools.h"
31 #include "volume.h"
32
33 #define SWITCH_JFFS2 "/tmp/.switch_jffs2"
34
35 static bool keep_sysupgrade;
36
37 static int
38 handle_rmdir(const char *dir)
39 {
40         struct dirent *dt;
41         struct stat st;
42         DIR *d;
43         int fd;
44
45         d = opendir(dir);
46         if (!d)
47                 return -1;
48
49         fd = dirfd(d);
50
51         while ((dt = readdir(d)) != NULL) {
52                 if (fstatat(fd, dt->d_name, &st, AT_SYMLINK_NOFOLLOW) || S_ISDIR(st.st_mode))
53                         continue;
54
55                 if (keep_sysupgrade && !strcmp(dt->d_name, "sysupgrade.tgz"))
56                         continue;
57
58                 unlinkat(fd, dt->d_name, 0);
59         }
60
61         closedir(d);
62         rmdir(dir);
63
64         return 0;
65 }
66
67 void
68 foreachdir(const char *dir, int (*cb)(const char*))
69 {
70         struct stat s = { 0 };
71         char globdir[256];
72         glob_t gl;
73         int j;
74
75         if (dir[strlen(dir) - 1] == '/')
76                 snprintf(globdir, 256, "%s*", dir);
77         else
78                 snprintf(globdir, 256, "%s/*", dir); /**/
79
80         if (!glob(globdir, GLOB_NOESCAPE | GLOB_MARK | GLOB_ONLYDIR, NULL, &gl))
81                 for (j = 0; j < gl.gl_pathc; j++) {
82                         char *dir = gl.gl_pathv[j];
83                         int len = strlen(gl.gl_pathv[j]);
84
85                         if (len > 1 && dir[len - 1] == '/')
86                                 dir[len - 1] = '\0';
87
88                         if (!lstat(gl.gl_pathv[j], &s) && !S_ISLNK(s.st_mode))
89                                 foreachdir(gl.gl_pathv[j], cb);
90         }
91         cb(dir);
92 }
93
94 void
95 overlay_delete(const char *dir, bool _keep_sysupgrade)
96 {
97         keep_sysupgrade = _keep_sysupgrade;
98         foreachdir(dir, handle_rmdir);
99 }
100
101 static int
102 overlay_mount(struct volume *v, char *fs)
103 {
104         if (mkdir("/tmp/overlay", 0755)) {
105                 ULOG_ERR("failed to mkdir /tmp/overlay: %s\n", strerror(errno));
106                 return -1;
107         }
108
109         if (mount(v->blk, "/tmp/overlay", fs, MS_NOATIME, NULL)) {
110                 ULOG_ERR("failed to mount -t %s %s /tmp/overlay: %s\n", fs, v->blk, strerror(errno));
111                 return -1;
112         }
113
114         return 0;
115 }
116
117 static int
118 switch2jffs(struct volume *v)
119 {
120         struct stat s;
121         int ret;
122
123         if (!stat(SWITCH_JFFS2, &s)) {
124                 ULOG_ERR("jffs2 switch already running\n");
125                 return -1;
126         }
127
128         creat("/tmp/.switch_jffs2", 0600);
129         ret = mount(v->blk, "/rom/overlay", "jffs2", MS_NOATIME, NULL);
130         unlink("/tmp/.switch_jffs2");
131         if (ret) {
132                 ULOG_ERR("failed - mount -t jffs2 %s /rom/overlay: %s\n", v->blk, strerror(errno));
133                 return -1;
134         }
135
136         if (mount("none", "/", NULL, MS_NOATIME | MS_REMOUNT, 0)) {
137                 ULOG_ERR("failed - mount -o remount,ro none: %s\n", strerror(errno));
138                 return -1;
139         }
140
141         if (system("cp -a /tmp/root/* /rom/overlay")) {
142                 ULOG_ERR("failed - cp -a /tmp/root/* /rom/overlay: %s\n", strerror(errno));
143                 return -1;
144         }
145
146         if (pivot("/rom", "/mnt")) {
147                 ULOG_ERR("failed - pivot /rom /mnt: %s\n", strerror(errno));
148                 return -1;
149         }
150
151         if (mount_move("/mnt", "/tmp/root", "")) {
152                 ULOG_ERR("failed - mount -o move /mnt /tmp/root %s\n", strerror(errno));
153                 return -1;
154         }
155
156         return fopivot("/overlay", "/rom");
157 }
158
159 int
160 handle_whiteout(const char *dir)
161 {
162         struct stat s;
163         char link[256];
164         ssize_t sz;
165         struct dirent **namelist;
166         int n;
167
168         n = scandir(dir, &namelist, NULL, NULL);
169
170         if (n < 1)
171                 return -1;
172
173         while (n--) {
174                 char file[256];
175
176                 snprintf(file, sizeof(file), "%s%s", dir, namelist[n]->d_name);
177                 if (!lstat(file, &s) && S_ISLNK(s.st_mode)) {
178                         sz = readlink(file, link, sizeof(link) - 1);
179                         if (sz > 0) {
180                                 char *orig;
181
182                                 link[sz] = '\0';
183                                 orig = strstr(&file[1], "/");
184                                 if (orig && !strcmp(link, "(overlay-whiteout)"))
185                                         unlink(orig);
186                         }
187                 }
188                 free(namelist[n]);
189         }
190         free(namelist);
191
192         return 0;
193 }
194
195 static char *overlay_fs_name(int type)
196 {
197         switch (type) {
198                 case FS_EXT4:
199                         return "ext4";
200                 case FS_F2FS:
201                         return "f2fs";
202                 case FS_UBIFS:
203                         return "ubifs";
204                 case FS_JFFS2:
205                 default:
206                         return "jffs2";
207         }
208 }
209
210 int
211 jffs2_switch(struct volume *v)
212 {
213         char *mp;
214         int type;
215
216         if (find_overlay_mount("overlayfs:/tmp/root"))
217                 return -1;
218
219         if (find_filesystem("overlay")) {
220                 ULOG_ERR("overlayfs not supported by kernel\n");
221                 return -1;
222         }
223
224         volume_init(v);
225         mp = find_mount_point(v->blk, 0);
226         if (mp) {
227                 ULOG_ERR("rootfs_data:%s is already mounted as %s\n", v->blk, mp);
228                 return -1;
229         }
230
231         type = volume_identify(v);
232         switch (type) {
233         case FS_NONE:
234                 ULOG_ERR("no jffs2 marker found\n");
235                 /* fall through */
236
237         case FS_DEADCODE:
238                 if (switch2jffs(v))
239                         return -1;
240
241                 ULOG_INFO("performing overlay whiteout\n");
242                 umount2("/tmp/root", MNT_DETACH);
243                 foreachdir("/overlay/", handle_whiteout);
244                 break;
245
246         case FS_EXT4:
247         case FS_F2FS:
248         case FS_UBIFS:
249                 if (overlay_mount(v, overlay_fs_name(type)))
250                         return -1;
251                 if (mount_move("/tmp", "", "/overlay") || fopivot("/overlay", "/rom")) {
252                         ULOG_ERR("switching to jffs2 failed\n");
253                         return -1;
254                 }
255                 break;
256         }
257
258         sync();
259         fs_state_set("/overlay", FS_STATE_READY);
260         return 0;
261 }
262
263 static int overlay_mount_fs(struct volume *v)
264 {
265         char *fstype = overlay_fs_name(volume_identify(v));
266
267         if (mkdir("/tmp/overlay", 0755)) {
268                 ULOG_ERR("failed to mkdir /tmp/overlay: %s\n", strerror(errno));
269                 return -1;
270         }
271
272         if (mount(v->blk, "/tmp/overlay", fstype, MS_NOATIME, NULL)) {
273                 ULOG_ERR("failed to mount -t %s %s /tmp/overlay: %s\n",
274                          fstype, v->blk, strerror(errno));
275                 return -1;
276         }
277
278         return 0;
279 }
280
281 enum fs_state fs_state_get(const char *dir)
282 {
283         char *path;
284         char valstr[16];
285         uint32_t val;
286         ssize_t len;
287
288         path = alloca(strlen(dir) + 1 + sizeof("/.fs_state"));
289         sprintf(path, "%s/.fs_state", dir);
290         len = readlink(path, valstr, sizeof(valstr) - 1);
291         if (len < 0)
292                 return FS_STATE_UNKNOWN;
293
294         valstr[len] = 0;
295         val = atoi(valstr);
296
297         if (val > __FS_STATE_LAST)
298                 return FS_STATE_UNKNOWN;
299
300         return val;
301 }
302
303
304 int fs_state_set(const char *dir, enum fs_state state)
305 {
306         char valstr[16];
307         char *path;
308
309         if (fs_state_get(dir) == state)
310                 return 0;
311
312         path = alloca(strlen(dir) + 1 + sizeof("/.fs_state"));
313         sprintf(path, "%s/.fs_state", dir);
314         unlink(path);
315         snprintf(valstr, sizeof(valstr), "%d", state);
316
317         return symlink(valstr, path);
318 }
319
320
321 int mount_overlay(struct volume *v)
322 {
323         char *mp;
324
325         if (!v)
326                 return -1;
327
328         mp = find_mount_point(v->blk, 0);
329         if (mp) {
330                 ULOG_ERR("rootfs_data:%s is already mounted as %s\n", v->blk, mp);
331                 return -1;
332         }
333
334         overlay_mount_fs(v);
335
336         extroot_prefix = "/tmp/overlay";
337         if (!mount_extroot()) {
338                 ULOG_INFO("switched to extroot\n");
339                 return 0;
340         }
341
342         switch(fs_state_get("/tmp/overlay")) {
343         case FS_STATE_UNKNOWN:
344                 fs_state_set("/tmp/overlay", FS_STATE_PENDING);
345                 if (fs_state_get("/tmp/overlay") != FS_STATE_PENDING) {
346                         ULOG_ERR("unable to set filesystem state\n");
347                         break;
348                 }
349         case FS_STATE_PENDING:
350                 ULOG_INFO("overlay filesystem has not been fully initialized yet\n");
351                 overlay_delete("/tmp/overlay", true);
352                 break;
353         case FS_STATE_READY:
354                 break;
355         }
356
357         ULOG_INFO("switching to jffs2 overlay\n");
358         if (mount_move("/tmp", "", "/overlay") || fopivot("/overlay", "/rom")) {
359                 ULOG_ERR("switching to jffs2 failed - fallback to ramoverlay\n");
360                 return ramoverlay();
361         }
362
363         return -1;
364 }