sys-utils/switch_root.c

   1 /*
   2  * switchroot.c - switch to new root directory and start init.
   3  *
   4  * Copyright 2002-2009 Red Hat, Inc.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  * Authors:
  20  *      Peter Jones <pjones@redhat.com>
  21  *      Jeremy Katz <katzj@redhat.com>
  22  */
  23 #include <sys/mount.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <sys/statfs.h>
  27 #include <sys/param.h>
  28 #include <fcntl.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <ctype.h>
  35 #include <dirent.h>
  36 #include <getopt.h>
  37
  38 #include "c.h"
  39 #include "nls.h"
  40 #include "closestream.h"
  41 #include "statfs_magic.h"
  42
  43 #ifndef MS_MOVE
  44 #define MS_MOVE 8192
  45 #endif
  46
  47 #ifndef MNT_DETACH
  48 #define MNT_DETACH       0x00000002     /* Just detach from the tree */
  49 #endif
  50
  51 /* remove all files/directories below dirName -- don't cross mountpoints */
  52 static int recursiveRemove(int fd)
  53 {
  54         struct stat rb;
  55         DIR *dir;
  56         int rc = -1;
  57         int dfd;
  58
  59         if (!(dir = fdopendir(fd))) {
  60                 warn(_("failed to open directory"));
  61                 goto done;
  62         }
  63
  64         /* fdopendir() precludes us from continuing to use the input fd */
  65         dfd = dirfd(dir);
  66
  67         if (fstat(dfd, &rb)) {
  68                 warn(_("stat failed"));
  69                 goto done;
  70         }
  71
  72         while(1) {
  73                 struct dirent *d;
  74                 int isdir = 0;
  75
  76                 errno = 0;
  77                 if (!(d = readdir(dir))) {
  78                         if (errno) {
  79                                 warn(_("failed to read directory"));
  80                                 goto done;
  81                         }
  82                         break;  /* end of directory */
  83                 }
  84
  85                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
  86                         continue;
  87 #ifdef _DIRENT_HAVE_D_TYPE
  88                 if (d->d_type == DT_DIR || d->d_type == DT_UNKNOWN)
  89 #endif
  90                 {
  91                         struct stat sb;
  92
  93                         if (fstatat(dfd, d->d_name, &sb, AT_SYMLINK_NOFOLLOW)) {
  94                                 warn(_("stat of %s failed"), d->d_name);
  95                                 continue;
  96                         }
  97
  98                         /* skip if device is not the same */
  99                         if (sb.st_dev != rb.st_dev)
 100                                 continue;
 101
 102                         /* remove subdirectories */
 103                         if (S_ISDIR(sb.st_mode)) {
 104                                 int cfd;
 105
 106                                 cfd = openat(dfd, d->d_name, O_RDONLY);
 107                                 if (cfd >= 0) {
 108                                         recursiveRemove(cfd);
 109                                         close(cfd);
 110                                 }
 111                                 isdir = 1;
 112                         }
 113                 }
 114
 115                 if (unlinkat(dfd, d->d_name, isdir ? AT_REMOVEDIR : 0))
 116                         warn(_("failed to unlink %s"), d->d_name);
 117         }
 118
 119         rc = 0; /* success */
 120
 121 done:
 122         if (dir)
 123                 closedir(dir);
 124         return rc;
 125 }
 126
 127 static int switchroot(const char *newroot)
 128 {
 129         /*  Don't try to unmount the old "/", there's no way to do it. */
 130         const char *umounts[] = { "/dev", "/proc", "/sys", "/run", NULL };
 131         int i;
 132         int cfd;
 133         pid_t pid;
 134         struct stat newroot_stat, sb;
 135
 136         if (stat(newroot, &newroot_stat) != 0) {
 137                 warn(_("stat of %s failed"), newroot);
 138                 return -1;
 139         }
 140
 141         for (i = 0; umounts[i] != NULL; i++) {
 142                 char newmount[PATH_MAX];
 143
 144                 snprintf(newmount, sizeof(newmount), "%s%s", newroot, umounts[i]);
 145
 146                 if ((stat(newmount, &sb) != 0) || (sb.st_dev != newroot_stat.st_dev)) {
 147                         /* mount point seems to be mounted already or stat failed */
 148                         umount2(umounts[i], MNT_DETACH);
 149                         continue;
 150                 }
 151
 152                 if (mount(umounts[i], newmount, NULL, MS_MOVE, NULL) < 0) {
 153                         warn(_("failed to mount moving %s to %s"),
 154                                 umounts[i], newmount);
 155                         warnx(_("forcing unmount of %s"), umounts[i]);
 156                         umount2(umounts[i], MNT_FORCE);
 157                 }
 158         }
 159
 160         if (chdir(newroot)) {
 161                 warn(_("failed to change directory to %s"), newroot);
 162                 return -1;
 163         }
 164
 165         cfd = open("/", O_RDONLY);
 166         if (cfd < 0) {
 167                 warn(_("cannot open %s"), "/");
 168                 return -1;
 169         }
 170
 171         if (mount(newroot, "/", NULL, MS_MOVE, NULL) < 0) {
 172                 close(cfd);
 173                 warn(_("failed to mount moving %s to /"), newroot);
 174                 return -1;
 175         }
 176
 177         if (chroot(".")) {
 178                 close(cfd);
 179                 warn(_("failed to change root"));
 180                 return -1;
 181         }
 182
 183         pid = fork();
 184         if (pid <= 0) {
 185                 struct statfs stfs;
 186
 187                 if (fstatfs(cfd, &stfs) == 0 &&
 188                     (F_TYPE_EQUAL(stfs.f_type, STATFS_RAMFS_MAGIC) ||
 189                      F_TYPE_EQUAL(stfs.f_type, STATFS_TMPFS_MAGIC)))
 190                         recursiveRemove(cfd);
 191                 else
 192                         warn(_("old root filesystem is not an initramfs"));
 193                 if (pid == 0)
 194                         exit(EXIT_SUCCESS);
 195         }
 196
 197         close(cfd);
 198         return 0;
 199 }
 200
 201 static void __attribute__((__noreturn__)) usage(void)
 202 {
 203         FILE *output = stdout;
 204         fputs(USAGE_HEADER, output);
 205         fprintf(output, _(" %s [options] <newrootdir> <init> <args to init>\n"),
 206                 program_invocation_short_name);
 207
 208         fputs(USAGE_SEPARATOR, output);
 209         fputs(_("Switch to another filesystem as the root of the mount tree.\n"), output);
 210
 211         fputs(USAGE_OPTIONS, output);
 212         printf(USAGE_HELP_OPTIONS(16));
 213         printf(USAGE_MAN_TAIL("switch_root(8)"));
 214
 215         exit(EXIT_SUCCESS);
 216 }
 217
 218 int main(int argc, char *argv[])
 219 {
 220         char *newroot, *init, **initargs;
 221         int c;
 222         static const struct option longopts[] = {
 223                 {"version", no_argument, NULL, 'V'},
 224                 {"help", no_argument, NULL, 'h'},
 225                 {NULL, 0, NULL, 0}
 226         };
 227
 228         atexit(close_stdout);
 229
 230         while ((c = getopt_long(argc, argv, "+Vh", longopts, NULL)) != -1)
 231                 switch (c) {
 232                 case 'V':
 233                         printf(UTIL_LINUX_VERSION);
 234                         return EXIT_SUCCESS;
 235                 case 'h':
 236                         usage();
 237                 default:
 238                         errtryhelp(EXIT_FAILURE);
 239                 }
 240         if (argc < 3) {
 241                 warnx(_("not enough arguments"));
 242                 errtryhelp(EXIT_FAILURE);
 243         }
 244
 245         newroot = argv[1];
 246         init = argv[2];
 247         initargs = &argv[2];
 248
 249         if (!*newroot || !*init) {
 250                 warnx(_("bad usage"));
 251                 errtryhelp(EXIT_FAILURE);
 252         }
 253
 254         if (switchroot(newroot))
 255                 errx(EXIT_FAILURE, _("failed. Sorry."));
 256
 257         if (access(init, X_OK))
 258                 warn(_("cannot access %s"), init);
 259
 260         execv(init, initargs);
 261         errexec(init);
 262 }
 263