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