util-linux/switch_root.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Copyright 2005 Rob Landley <rob@landley.net>
   4  *
   5  * Switch from rootfs to another filesystem as the root of the mount tree.
   6  *
   7  * Licensed under GPLv2, see file LICENSE in this source tree.
   8  */
   9 //config:config SWITCH_ROOT
  10 //config:       bool "switch_root (5.2 kb)"
  11 //config:       default y
  12 //config:       select PLATFORM_LINUX
  13 //config:       help
  14 //config:       The switch_root utility is used from initramfs to select a new
  15 //config:       root device. Under initramfs, you have to use this instead of
  16 //config:       pivot_root. (Stop reading here if you don't care why.)
  17 //config:
  18 //config:       Booting with initramfs extracts a gzipped cpio archive into rootfs
  19 //config:       (which is a variant of ramfs/tmpfs). Because rootfs can't be moved
  20 //config:       or unmounted*, pivot_root will not work from initramfs. Instead,
  21 //config:       switch_root deletes everything out of rootfs (including itself),
  22 //config:       does a mount --move that overmounts rootfs with the new root, and
  23 //config:       then execs the specified init program.
  24 //config:
  25 //config:       * Because the Linux kernel uses rootfs internally as the starting
  26 //config:       and ending point for searching through the kernel's doubly linked
  27 //config:       list of active mount points. That's why.
  28 //config:
  29 // RUN_INIT config item is in klibc-utils
  30
  31 //applet:IF_SWITCH_ROOT(APPLET(switch_root, BB_DIR_SBIN, BB_SUID_DROP))
  32 //                      APPLET_ODDNAME:name      main         location     suid_type     help
  33 //applet:IF_RUN_INIT(   APPLET_ODDNAME(run-init, switch_root, BB_DIR_SBIN, BB_SUID_DROP, run_init))
  34
  35 //kbuild:lib-$(CONFIG_SWITCH_ROOT) += switch_root.o
  36 //kbuild:lib-$(CONFIG_RUN_INIT)    += switch_root.o
  37
  38 #include <sys/vfs.h>
  39 #include <sys/mount.h>
  40 #if ENABLE_RUN_INIT
  41 # include <sys/prctl.h>
  42 # include <linux/capability.h>
  43 // #include <sys/capability.h>
  44 // This header is in libcap, but the functions are in libc.
  45 // Comment in the header says this above capset/capget:
  46 /* system calls - look to libc for function to system call mapping */
  47 extern int capset(cap_user_header_t header, cap_user_data_t data);
  48 extern int capget(cap_user_header_t header, const cap_user_data_t data);
  49 // so for bbox, let's just repeat the declarations.
  50 // This way, libcap needs not be installed in build environment.
  51 #endif
  52
  53 #include "libbb.h"
  54
  55 // Make up for header deficiencies
  56 #ifndef RAMFS_MAGIC
  57 # define RAMFS_MAGIC ((unsigned)0x858458f6)
  58 #endif
  59 #ifndef TMPFS_MAGIC
  60 # define TMPFS_MAGIC ((unsigned)0x01021994)
  61 #endif
  62 #ifndef MS_MOVE
  63 # define MS_MOVE     8192
  64 #endif
  65
  66 // Recursively delete contents of rootfs
  67 static void delete_contents(const char *directory, dev_t rootdev)
  68 {
  69         DIR *dir;
  70         struct dirent *d;
  71         struct stat st;
  72
  73         // Don't descend into other filesystems
  74         if (lstat(directory, &st) || st.st_dev != rootdev)
  75                 return;
  76
  77         // Recursively delete the contents of directories
  78         if (S_ISDIR(st.st_mode)) {
  79                 dir = opendir(directory);
  80                 if (dir) {
  81                         while ((d = readdir(dir))) {
  82                                 char *newdir = d->d_name;
  83
  84                                 // Skip . and ..
  85                                 if (DOT_OR_DOTDOT(newdir))
  86                                         continue;
  87
  88                                 // Recurse to delete contents
  89                                 newdir = concat_path_file(directory, newdir);
  90                                 delete_contents(newdir, rootdev);
  91                                 free(newdir);
  92                         }
  93                         closedir(dir);
  94
  95                         // Directory should now be empty, zap it
  96                         rmdir(directory);
  97                 }
  98         } else {
  99                 // It wasn't a directory, zap it
 100                 unlink(directory);
 101         }
 102 }
 103
 104 #if ENABLE_RUN_INIT
 105 DEFINE_STRUCT_CAPS;
 106
 107 static void drop_capset(int cap_idx)
 108 {
 109         struct caps caps;
 110
 111         getcaps(&caps);
 112         caps.data[CAP_TO_INDEX(cap_idx)].inheritable &= ~CAP_TO_MASK(cap_idx);
 113         if (capset(&caps.header, caps.data) != 0)
 114                 bb_perror_msg_and_die("capset");
 115 }
 116
 117 static void drop_bounding_set(int cap_idx)
 118 {
 119         int ret;
 120
 121         ret = prctl(PR_CAPBSET_READ, cap_idx, 0, 0, 0);
 122         if (ret < 0)
 123                 bb_perror_msg_and_die("prctl: %s", "PR_CAPBSET_READ");
 124
 125         if (ret == 1) {
 126                 ret = prctl(PR_CAPBSET_DROP, cap_idx, 0, 0, 0);
 127                 if (ret != 0)
 128                         bb_perror_msg_and_die("prctl: %s", "PR_CAPBSET_DROP");
 129         }
 130 }
 131
 132 static void drop_usermodehelper(const char *filename, int cap_idx)
 133 {
 134         unsigned lo, hi;
 135         char buf[sizeof(int)*3 * 2 + 8];
 136         int fd;
 137         int ret;
 138
 139         ret = open_read_close(filename, buf, sizeof(buf) - 1);
 140         if (ret < 0)
 141                 return; /* assuming files do not exist */
 142
 143         buf[ret] = '\0';
 144         ret = sscanf(buf, "%u %u", &lo, &hi);
 145         if (ret != 2)
 146                 bb_perror_msg_and_die("can't parse file '%s'", filename);
 147
 148         if (cap_idx < 32)
 149                 lo &= ~(1 << cap_idx);
 150         else
 151                 hi &= ~(1 << (cap_idx - 32));
 152
 153         fd = xopen(filename, O_WRONLY);
 154         fdprintf(fd, "%u %u", lo, hi);
 155         close(fd);
 156 }
 157
 158 static void drop_capabilities(char *string)
 159 {
 160         char *cap;
 161
 162         cap = strtok(string, ",");
 163         while (cap) {
 164                 unsigned cap_idx;
 165
 166                 cap_idx = cap_name_to_number(cap);
 167                 drop_usermodehelper("/proc/sys/kernel/usermodehelper/bset", cap_idx);
 168                 drop_usermodehelper("/proc/sys/kernel/usermodehelper/inheritable", cap_idx);
 169                 drop_bounding_set(cap_idx);
 170                 drop_capset(cap_idx);
 171                 bb_error_msg("dropped capability: %s", cap);
 172                 cap = strtok(NULL, ",");
 173         }
 174 }
 175 #endif
 176
 177 int switch_root_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 178 int switch_root_main(int argc UNUSED_PARAM, char **argv)
 179 {
 180         char *newroot, *console = NULL;
 181         struct stat st;
 182         struct statfs stfs;
 183         unsigned dry_run = 0;
 184         dev_t rootdev;
 185
 186         // Parse args. '+': stop at first non-option
 187         if (ENABLE_SWITCH_ROOT && (!ENABLE_RUN_INIT || applet_name[0] == 's')) {
 188 //usage:#define switch_root_trivial_usage
 189 //usage:       "[-c CONSOLE_DEV] NEW_ROOT NEW_INIT [ARGS]"
 190 //usage:#define switch_root_full_usage "\n\n"
 191 //usage:       "Free initramfs and switch to another root fs:\n"
 192 //usage:       "chroot to NEW_ROOT, delete all in /, move NEW_ROOT to /,\n"
 193 //usage:       "execute NEW_INIT. PID must be 1. NEW_ROOT must be a mountpoint.\n"
 194 //usage:     "\n        -c DEV  Reopen stdio to DEV after switch"
 195                 getopt32(argv, "^+"
 196                         "c:"
 197                         "\0" "-2" /* minimum 2 args */,
 198                         &console
 199                 );
 200         } else {
 201 #if ENABLE_RUN_INIT
 202 //usage:#define run_init_trivial_usage
 203 //usage:       "[-d CAP,CAP...] [-n] [-c CONSOLE_DEV] NEW_ROOT NEW_INIT [ARGS]"
 204 //usage:#define run_init_full_usage "\n\n"
 205 //usage:       "Free initramfs and switch to another root fs:\n"
 206 //usage:       "chroot to NEW_ROOT, delete all in /, move NEW_ROOT to /,\n"
 207 //usage:       "execute NEW_INIT. PID must be 1. NEW_ROOT must be a mountpoint.\n"
 208 //usage:     "\n        -c DEV  Reopen stdio to DEV after switch"
 209 //usage:     "\n        -d CAPS Drop capabilities"
 210 //usage:     "\n        -n      Dry run"
 211                 char *cap_list = NULL;
 212                 dry_run = getopt32(argv, "^+"
 213                         "c:d:n"
 214                         "\0" "-2" /* minimum 2 args */,
 215                         &console,
 216                         &cap_list
 217                 );
 218                 dry_run >>= 2; // -n
 219                 if (cap_list)
 220                         drop_capabilities(cap_list);
 221 #endif
 222         }
 223         argv += optind;
 224         newroot = *argv++;
 225
 226         // Change to new root directory and verify it's a different fs
 227         xchdir(newroot);
 228         xstat("/", &st);
 229         rootdev = st.st_dev;
 230         xstat(".", &st);
 231         if (st.st_dev == rootdev) {
 232                 // Show usage, it says new root must be a mountpoint
 233                 bb_show_usage();
 234         }
 235         if (!dry_run && getpid() != 1) {
 236                 // Show usage, it says we must be PID 1
 237                 bb_show_usage();
 238         }
 239
 240         // Additional sanity checks: we're about to rm -rf /, so be REALLY SURE
 241         // we mean it. I could make this a CONFIG option, but I would get email
 242         // from all the people who WILL destroy their filesystems.
 243         if (stat("/init", &st) != 0 || !S_ISREG(st.st_mode)) {
 244                 bb_error_msg_and_die("'%s' is not a regular file", "/init");
 245         }
 246         statfs("/", &stfs); // this never fails
 247         if ((unsigned)stfs.f_type != RAMFS_MAGIC
 248          && (unsigned)stfs.f_type != TMPFS_MAGIC
 249         ) {
 250                 bb_error_msg_and_die("root filesystem is not ramfs/tmpfs");
 251         }
 252
 253         if (!dry_run) {
 254                 // Zap everything out of rootdev
 255                 delete_contents("/", rootdev);
 256
 257                 // Overmount / with newdir and chroot into it
 258                 if (mount(".", "/", NULL, MS_MOVE, NULL)) {
 259                         // For example, fails when newroot is not a mountpoint
 260                         bb_perror_msg_and_die("error moving root");
 261                 }
 262         }
 263         xchroot(".");
 264         // The chdir is needed to recalculate "." and ".." links
 265         /*xchdir("/"); - done in xchroot */
 266
 267         // If a new console specified, redirect stdin/stdout/stderr to it
 268         if (console) {
 269                 int fd = open_or_warn(console, O_RDWR);
 270                 if (fd >= 0) {
 271                         xmove_fd(fd, 0);
 272                         xdup2(0, 1);
 273                         xdup2(0, 2);
 274                 }
 275         }
 276
 277         if (dry_run) {
 278                 // Does NEW_INIT look like it can be executed?
 279                 //xstat(argv[0], &st);
 280                 //if (!S_ISREG(st.st_mode))
 281                 //      bb_perror_msg_and_die("'%s' is not a regular file", argv[0]);
 282                 if (access(argv[0], X_OK) == 0)
 283                         return 0;
 284         } else {
 285                 // Exec NEW_INIT
 286                 execv(argv[0], argv);
 287         }
 288         bb_perror_msg_and_die("can't execute '%s'", argv[0]);
 289 }
 290
 291 /*
 292 From: Rob Landley <rob@landley.net>
 293 Date: Tue, Jun 16, 2009 at 7:47 PM
 294 Subject: Re: switch_root...
 295
 296 ...
 297 ...
 298 ...
 299
 300 If you're _not_ running out of init_ramfs (if for example you're using initrd
 301 instead), you probably shouldn't use switch_root because it's the wrong tool.
 302
 303 Basically what the sucker does is something like the following shell script:
 304
 305  find / -xdev | xargs rm -rf
 306  cd "$1"
 307  shift
 308  mount --move . /
 309  exec chroot . "$@"
 310
 311 There are a couple reasons that won't work as a shell script:
 312
 313 1) If you delete the commands out of your $PATH, your shell scripts can't run
 314 more commands, but you can't start using dynamically linked _new_ commands
 315 until after you do the chroot because the path to the dynamic linker is wrong.
 316 So there's a step that needs to be sort of atomic but can't be as a shell
 317 script.  (You can work around this with static linking or very carefully laid
 318 out paths and sequencing, but it's brittle, ugly, and non-obvious.)
 319
 320 2) The "find | rm" bit will actually delete everything because the mount points
 321 still show up (even if their contents don't), and rm -rf will then happily zap
 322 that.  So the first line is an oversimplification of what you need to do _not_
 323 to descend into other filesystems and delete their contents.
 324
 325 The reason we do this is to free up memory, by the way.  Since initramfs is a
 326 ramfs, deleting its contents frees up the memory it uses.  (We leave it with
 327 one remaining dentry for the new mount point, but that's ok.)
 328
 329 Note that you cannot ever umount rootfs, for approximately the same reason you
 330 can't kill PID 1.  The kernel tracks mount points as a doubly linked list, and
 331 the pointer to the start/end of that list always points to an entry that's
 332 known to be there (rootfs), so it never has to worry about moving that pointer
 333 and it never has to worry about the list being empty.  (Back around 2.6.13
 334 there _was_ a bug that let you umount rootfs, and the system locked hard the
 335 instant you did so endlessly looping to find the end of the mount list and
 336 never stopping.  They fixed it.)
 337
 338 Oh, and the reason we mount --move _and_ do the chroot is due to the way "/"
 339 works.  Each process has two special symlinks, ".", and "/".  Each of them
 340 points to the dentry of a directory, and give you a location paths can start
 341 from.  (Historically ".." was also special, because you could enter a
 342 directory via a symlink so backing out to the directory you came from doesn't
 343 necessarily mean the one physically above where "." points to.  These days I
 344 think it's just handed off to the filesystem.)
 345
 346 Anyway, path resolution starts with "." or "/" (although the "./" at the start
 347 of the path may be implicit), meaning it's relative to one of those two
 348 directories.  Your current directory, and your current root directory.  The
 349 chdir() syscall changes where "." points to, and the chroot() syscall changes
 350 where "/" points to.  (Again, both are per-process which is why chroot only
 351 affects your current process and its child processes.)
 352
 353 Note that chroot() does _not_ change where "." points to, and back before they
 354 put crazy security checks into the kernel your current directory could be
 355 somewhere you could no longer access after the chroot.  (The command line
 356 chroot does a cd as well, the chroot _syscall_ is what I'm talking about.)
 357
 358 The reason mounting something new over / has no obvious effect is the same
 359 reason mounting something over your current directory has no obvious effect:
 360 the . and / links aren't recalculated after a mount, so they still point to
 361 the same dentry they did before, even if that dentry is no longer accessible
 362 by other means.  Note that "cd ." is a NOP, and "chroot /" is a nop; both look
 363 up the cached dentry and set it right back.  They don't re-parse any paths,
 364 because they're what all paths your process uses would be relative to.
 365
 366 That's why the careful sequencing above: we cd into the new mount point before
 367 we do the mount --move.  Moving the mount point would otherwise make it
 368 totally inaccessible to us because cd-ing to the old path wouldn't give it to
 369 us anymore, and cd "/" just gives us the cached dentry from when the process
 370 was created (in this case the old initramfs one).  But the "." symlink gives
 371 us the dentry of the filesystem we just moved, so we can then "chroot ." to
 372 copy that dentry to "/" and get the new filesystem.  If we _didn't_ save that
 373 dentry in "." we couldn't get it back after the mount --move.
 374
 375 (Yes, this is all screwy and I had to email questions to Linus Torvalds to get
 376 it straight myself.  I keep meaning to write up a "how mount actually works"
 377 document someday...)
 378 */