• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/fstools/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 #ifndef GLOB_ONLYDIR
 34 #define GLOB_ONLYDIR 0x100
 35 #endif
 36 
 37 #define SWITCH_JFFS2 "/tmp/.switch_jffs2"
 38 
 39 static bool keep_sysupgrade;
 40 
 41 static int
 42 handle_rmdir(const char *dir)
 43 {
 44         struct dirent *dt;
 45         struct stat st;
 46         DIR *d;
 47         int fd;
 48 
 49         d = opendir(dir);
 50         if (!d)
 51                 return -1;
 52 
 53         fd = dirfd(d);
 54 
 55         while ((dt = readdir(d)) != NULL) {
 56                 if (fstatat(fd, dt->d_name, &st, AT_SYMLINK_NOFOLLOW) || S_ISDIR(st.st_mode))
 57                         continue;
 58 
 59                 if (keep_sysupgrade && !strcmp(dt->d_name, "sysupgrade.tgz"))
 60                         continue;
 61 
 62                 unlinkat(fd, dt->d_name, 0);
 63         }
 64 
 65         closedir(d);
 66         rmdir(dir);
 67 
 68         return 0;
 69 }
 70 
 71 void
 72 foreachdir(const char *dir, int (*cb)(const char*))
 73 {
 74         static char *globdir = NULL;
 75         static size_t globdirlen = 0;
 76         struct stat s = { 0 };
 77         size_t dirlen = strlen(dir);
 78         glob_t gl;
 79         int j;
 80 
 81         if (dirlen + sizeof("/*") > globdirlen) {
 82                 /* Alloc extra 256 B to avoid too many reallocs */
 83                 size_t len = dirlen + sizeof("/*") + 256;
 84                 char *tmp;
 85 
 86                 tmp = realloc(globdir, len);
 87                 if (!tmp)
 88                         return;
 89                 globdir = tmp;
 90                 globdirlen = len;
 91         }
 92 
 93         sprintf(globdir, "%s/*", dir);
 94 
 95         /* Include GLOB_MARK as callbacks expect a trailing slash */
 96         if (!glob(globdir, GLOB_NOESCAPE | GLOB_MARK | GLOB_ONLYDIR, NULL, &gl))
 97                 for (j = 0; j < gl.gl_pathc; j++) {
 98                         char *dir = gl.gl_pathv[j];
 99                         int len = strlen(gl.gl_pathv[j]);
100                         int err;
101 
102                         /* Quick way of skipping files */
103                         if (dir[len - 1] != '/')
104                                 continue;
105 
106                         /* lstat needs path without a trailing slash */
107                         if (len > 1)
108                                 dir[len - 1] = '\0';
109                         err = lstat(gl.gl_pathv[j], &s);
110                         if (len > 1)
111                                 dir[len - 1] = '/';
112 
113                         if (!err && !S_ISLNK(s.st_mode))
114                                 foreachdir(gl.gl_pathv[j], cb);
115         }
116         cb(dir);
117 }
118 
119 static void foreach_mount(int (*cb)(const char *, const char *))
120 {
121         FILE *fp = fopen("/proc/mounts", "r");
122         static char line[256];
123 
124         if (!fp)
125                 return;
126 
127         while (fgets(line, sizeof(line), fp)) {
128                 char device[32], mount_point[32];
129 
130                 if (sscanf(line, "%31s %31s %*s %*s %*u %*u", device, mount_point) == 2)
131                         cb(device, mount_point);
132         }
133 
134         fclose(fp);
135 }
136 
137 void
138 overlay_delete(const char *dir, bool _keep_sysupgrade)
139 {
140         keep_sysupgrade = _keep_sysupgrade;
141         foreachdir(dir, handle_rmdir);
142 }
143 
144 static int
145 overlay_mount(struct volume *v, char *fs)
146 {
147         if (mkdir("/tmp/overlay", 0755)) {
148                 ULOG_ERR("failed to mkdir /tmp/overlay: %m\n");
149                 return -1;
150         }
151 
152         if (mount(v->blk, "/tmp/overlay", fs, MS_NOATIME, NULL)) {
153                 ULOG_ERR("failed to mount -t %s %s /tmp/overlay: %m\n", fs, v->blk);
154                 return -1;
155         }
156 
157         return 0;
158 }
159 
160 /**
161  * move_mount - move mount point to the new root
162  */
163 static int move_mount(const char *device, const char *mount_point)
164 {
165         static const char *prefix = "/tmp/root/";
166 
167         if (strncmp(mount_point, prefix, strlen(prefix)))
168                 return 0;
169 
170         return mount_move(prefix, "/", mount_point + strlen(prefix));
171 }
172 
173 static int
174 switch2jffs(struct volume *v)
175 {
176         struct stat s;
177         int ret;
178 
179         if (!stat(SWITCH_JFFS2, &s)) {
180                 ULOG_ERR("jffs2 switch already running\n");
181                 return -1;
182         }
183 
184         creat("/tmp/.switch_jffs2", 0600);
185         ret = mount(v->blk, "/rom/overlay", "jffs2", MS_NOATIME, NULL);
186         unlink("/tmp/.switch_jffs2");
187         if (ret) {
188                 ULOG_ERR("failed - mount -t jffs2 %s /rom/overlay: %m\n", v->blk);
189                 return -1;
190         }
191 
192         if (mount("none", "/", NULL, MS_NOATIME | MS_REMOUNT, 0)) {
193                 ULOG_ERR("failed - mount -o remount,ro none: %m\n");
194                 return -1;
195         }
196 
197         if (system("cp -a /tmp/root/* /rom/overlay")) {
198                 ULOG_ERR("failed - cp -a /tmp/root/* /rom/overlay: %m\n");
199                 return -1;
200         }
201 
202         if (pivot("/rom", "/mnt")) {
203                 ULOG_ERR("failed - pivot /rom /mnt: %m\n");
204                 return -1;
205         }
206 
207         if (mount_move("/mnt", "/tmp/root", "")) {
208                 ULOG_ERR("failed - mount -o move /mnt /tmp/root %m\n");
209                 return -1;
210         }
211 
212         ret = fopivot("/overlay", "/rom");
213 
214         /*
215          * Besides copying overlay data from "tmpfs" to "jffs2" we should also
216          * move mount points that user could create during JFFS2 formatting.
217          * This has to happen after fopivot call because:
218          * 1) It's trivial to find mount points to move then (/tmp/root/...).
219          * 2) We can't do that earlier using /rom/overlay/upper/ as overlay(fs)
220          *    doesn't support mounts. Mounting to upper dir don't make overlay
221          *    /propagate/ files to the target dir.
222          */
223         foreach_mount(move_mount);
224 
225         return ret;
226 }
227 
228 int
229 handle_whiteout(const char *dir)
230 {
231         struct stat s;
232         char link[256];
233         ssize_t sz;
234         struct dirent **namelist;
235         int n;
236 
237         n = scandir(dir, &namelist, NULL, NULL);
238 
239         if (n < 1)
240                 return -1;
241 
242         while (n--) {
243                 char file[256];
244 
245                 snprintf(file, sizeof(file), "%s%s", dir, namelist[n]->d_name);
246                 if (!lstat(file, &s) && S_ISLNK(s.st_mode)) {
247                         sz = readlink(file, link, sizeof(link) - 1);
248                         if (sz > 0) {
249                                 char *orig;
250 
251                                 link[sz] = '\0';
252                                 orig = strstr(&file[1], "/");
253                                 if (orig && !strcmp(link, "(overlay-whiteout)"))
254                                         unlink(orig);
255                         }
256                 }
257                 free(namelist[n]);
258         }
259         free(namelist);
260 
261         return 0;
262 }
263 
264 static char *overlay_fs_name(int type)
265 {
266         switch (type) {
267                 case FS_EXT4:
268                         return "ext4";
269                 case FS_F2FS:
270                         return "f2fs";
271                 case FS_UBIFS:
272                         return "ubifs";
273                 case FS_JFFS2:
274                 default:
275                         return "jffs2";
276         }
277 }
278 
279 int
280 jffs2_switch(struct volume *v)
281 {
282         char *mp, *fs_name;
283         int type;
284 
285         if (find_overlay_mount("overlayfs:/tmp/root"))
286                 return -1;
287 
288         if (find_filesystem("overlay")) {
289                 ULOG_ERR("overlayfs not supported by kernel\n");
290                 return -1;
291         }
292 
293         volume_init(v);
294         mp = find_mount_point(v->blk, 0);
295         if (mp) {
296                 ULOG_ERR("rootfs_data:%s is already mounted as %s\n", v->blk, mp);
297                 return -1;
298         }
299 
300         type = volume_identify(v);
301         fs_name = overlay_fs_name(type);
302 
303         switch (type) {
304         case FS_NONE:
305                 ULOG_ERR("no jffs2 marker found\n");
306                 /* fall through */
307 
308         case FS_DEADCODE:
309                 if (switch2jffs(v))
310                         return -1;
311 
312                 ULOG_INFO("performing overlay whiteout\n");
313                 umount2("/tmp/root", MNT_DETACH);
314                 foreachdir("/overlay/", handle_whiteout);
315 
316                 /* try hard to be in sync */
317                 ULOG_INFO("syncronizing overlay\n");
318                 if (system("cp -a /tmp/root/upper/* / 2>/dev/null"))
319                         ULOG_ERR("failed to sync jffs2 overlay\n");
320                 break;
321 
322         case FS_EXT4:
323         case FS_F2FS:
324         case FS_UBIFS:
325                 if (overlay_mount(v, fs_name))
326                         return -1;
327                 if (mount_move("/tmp", "", "/overlay") || fopivot("/overlay", "/rom")) {
328                         ULOG_ERR("switching to %s failed\n", fs_name);
329                         return -1;
330                 }
331                 break;
332         }
333 
334         sync();
335         fs_state_set("/overlay", FS_STATE_READY);
336         return 0;
337 }
338 
339 static int overlay_mount_fs(struct volume *v)
340 {
341         char *fstype = overlay_fs_name(volume_identify(v));
342 
343         if (mkdir("/tmp/overlay", 0755)) {
344                 ULOG_ERR("failed to mkdir /tmp/overlay: %m\n");
345                 return -1;
346         }
347 
348         if (mount(v->blk, "/tmp/overlay", fstype,
349 #ifdef OVL_MOUNT_FULL_ACCESS_TIME
350                 MS_RELATIME,
351 #else
352                 MS_NOATIME,
353 #endif
354 #ifdef OVL_MOUNT_COMPRESS_ZLIB
355                 "compr=zlib"
356 #else
357                 NULL
358 #endif
359                 )) {
360                 ULOG_ERR("failed to mount -t %s %s /tmp/overlay: %m\n",
361                          fstype, v->blk);
362                 return -1;
363         }
364 
365         return 0;
366 }
367 
368 enum fs_state fs_state_get(const char *dir)
369 {
370         char *path;
371         char valstr[16];
372         uint32_t val;
373         ssize_t len;
374 
375         path = alloca(strlen(dir) + 1 + sizeof("/.fs_state"));
376         sprintf(path, "%s/.fs_state", dir);
377         len = readlink(path, valstr, sizeof(valstr) - 1);
378         if (len < 0)
379                 return FS_STATE_UNKNOWN;
380 
381         valstr[len] = 0;
382         val = atoi(valstr);
383 
384         if (val > __FS_STATE_LAST)
385                 return FS_STATE_UNKNOWN;
386 
387         return val;
388 }
389 
390 
391 int fs_state_set(const char *dir, enum fs_state state)
392 {
393         char valstr[16];
394         char *path;
395 
396         if (fs_state_get(dir) == state)
397                 return 0;
398 
399         path = alloca(strlen(dir) + 1 + sizeof("/.fs_state"));
400         sprintf(path, "%s/.fs_state", dir);
401         unlink(path);
402         snprintf(valstr, sizeof(valstr), "%d", state);
403 
404         return symlink(valstr, path);
405 }
406 
407 
408 int mount_overlay(struct volume *v)
409 {
410         char *mp, *fs_name;
411 
412         if (!v)
413                 return -1;
414 
415         mp = find_mount_point(v->blk, 0);
416         if (mp) {
417                 ULOG_ERR("rootfs_data:%s is already mounted as %s\n", v->blk, mp);
418                 return -1;
419         }
420 
421         overlay_mount_fs(v);
422 
423         extroot_prefix = "/tmp/overlay";
424         if (!mount_extroot()) {
425                 ULOG_INFO("switched to extroot\n");
426                 return 0;
427         }
428 
429         switch(fs_state_get("/tmp/overlay")) {
430         case FS_STATE_UNKNOWN:
431                 fs_state_set("/tmp/overlay", FS_STATE_PENDING);
432                 if (fs_state_get("/tmp/overlay") != FS_STATE_PENDING) {
433                         ULOG_ERR("unable to set filesystem state\n");
434                         break;
435                 }
436         case FS_STATE_PENDING:
437                 ULOG_INFO("overlay filesystem has not been fully initialized yet\n");
438                 overlay_delete("/tmp/overlay", true);
439                 break;
440         case FS_STATE_READY:
441                 break;
442         }
443 
444         fs_name = overlay_fs_name(volume_identify(v));
445         ULOG_INFO("switching to %s overlay\n", fs_name);
446         if (mount_move("/tmp", "", "/overlay") || fopivot("/overlay", "/rom")) {
447                 ULOG_ERR("switching to %s failed - fallback to ramoverlay\n", fs_name);
448                 return ramoverlay();
449         }
450 
451         return -1;
452 }
453 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt