1 /* vi: set sw=4 ts=4: */
2 /* Copyright 2005 Rob Landley <rob@landley.net>
4 * Switch from rootfs to another filesystem as the root of the mount tree.
6 * Licensed under GPLv2, see file LICENSE in this source tree.
9 //usage:#define switch_root_trivial_usage
10 //usage: "[-c /dev/console] NEW_ROOT NEW_INIT [ARGS]"
11 //usage:#define switch_root_full_usage "\n\n"
12 //usage: "Free initramfs and switch to another root fs:\n"
13 //usage: "chroot to NEW_ROOT, delete all in /, move NEW_ROOT to /,\n"
14 //usage: "execute NEW_INIT. PID must be 1. NEW_ROOT must be a mountpoint.\n"
16 //usage: "\n -c DEV Reopen stdio to DEV after switch"
19 #include <sys/mount.h>
21 // Make up for header deficiencies
23 # define RAMFS_MAGIC ((unsigned)0x858458f6)
26 # define TMPFS_MAGIC ((unsigned)0x01021994)
32 // Recursively delete contents of rootfs
33 static void delete_contents(const char *directory, dev_t rootdev)
39 // Don't descend into other filesystems
40 if (lstat(directory, &st) || st.st_dev != rootdev)
43 // Recursively delete the contents of directories
44 if (S_ISDIR(st.st_mode)) {
45 dir = opendir(directory);
47 while ((d = readdir(dir))) {
48 char *newdir = d->d_name;
51 if (DOT_OR_DOTDOT(newdir))
54 // Recurse to delete contents
55 newdir = concat_path_file(directory, newdir);
56 delete_contents(newdir, rootdev);
61 // Directory should now be empty, zap it
65 // It wasn't a directory, zap it
70 int switch_root_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
71 int switch_root_main(int argc UNUSED_PARAM, char **argv)
73 char *newroot, *console = NULL;
78 // Parse args (-c console)
79 opt_complementary = "-2"; // minimum 2 params
80 getopt32(argv, "+c:", &console); // '+': stop at first non-option
84 // Change to new root directory and verify it's a different fs
89 if (st.st_dev == rootdev || getpid() != 1) {
90 // Show usage, it says new root must be a mountpoint
91 // and we must be PID 1
95 // Additional sanity checks: we're about to rm -rf /, so be REALLY SURE
96 // we mean it. I could make this a CONFIG option, but I would get email
97 // from all the people who WILL destroy their filesystems.
98 if (stat("/init", &st) != 0 || !S_ISREG(st.st_mode)) {
99 bb_error_msg_and_die("/init is not a regular file");
101 statfs("/", &stfs); // this never fails
102 if ((unsigned)stfs.f_type != RAMFS_MAGIC
103 && (unsigned)stfs.f_type != TMPFS_MAGIC
105 bb_error_msg_and_die("root filesystem is not ramfs/tmpfs");
108 // Zap everything out of rootdev
109 delete_contents("/", rootdev);
111 // Overmount / with newdir and chroot into it
112 if (mount(".", "/", NULL, MS_MOVE, NULL)) {
113 // For example, fails when newroot is not a mountpoint
114 bb_perror_msg_and_die("error moving root");
117 // The chdir is needed to recalculate "." and ".." links
120 // If a new console specified, redirect stdin/stdout/stderr to it
123 xopen(console, O_RDWR);
129 execv(argv[0], argv);
130 bb_perror_msg_and_die("can't execute '%s'", argv[0]);
134 From: Rob Landley <rob@landley.net>
135 Date: Tue, Jun 16, 2009 at 7:47 PM
136 Subject: Re: switch_root...
142 If you're _not_ running out of init_ramfs (if for example you're using initrd
143 instead), you probably shouldn't use switch_root because it's the wrong tool.
145 Basically what the sucker does is something like the following shell script:
147 find / -xdev | xargs rm -rf
153 There are a couple reasons that won't work as a shell script:
155 1) If you delete the commands out of your $PATH, your shell scripts can't run
156 more commands, but you can't start using dynamically linked _new_ commands
157 until after you do the chroot because the path to the dynamic linker is wrong.
158 So there's a step that needs to be sort of atomic but can't be as a shell
159 script. (You can work around this with static linking or very carefully laid
160 out paths and sequencing, but it's brittle, ugly, and non-obvious.)
162 2) The "find | rm" bit will acually delete everything because the mount points
163 still show up (even if their contents don't), and rm -rf will then happily zap
164 that. So the first line is an oversimplification of what you need to do _not_
165 to descend into other filesystems and delete their contents.
167 The reason we do this is to free up memory, by the way. Since initramfs is a
168 ramfs, deleting its contents frees up the memory it uses. (We leave it with
169 one remaining dentry for the new mount point, but that's ok.)
171 Note that you cannot ever umount rootfs, for approximately the same reason you
172 can't kill PID 1. The kernel tracks mount points as a doubly linked list, and
173 the pointer to the start/end of that list always points to an entry that's
174 known to be there (rootfs), so it never has to worry about moving that pointer
175 and it never has to worry about the list being empty. (Back around 2.6.13
176 there _was_ a bug that let you umount rootfs, and the system locked hard the
177 instant you did so endlessly looping to find the end of the mount list and
178 never stopping. They fixed it.)
180 Oh, and the reason we mount --move _and_ do the chroot is due to the way "/"
181 works. Each process has two special symlinks, ".", and "/". Each of them
182 points to the dentry of a directory, and give you a location paths can start
183 from. (Historically ".." was also special, because you could enter a
184 directory via a symlink so backing out to the directory you came from doesn't
185 necessarily mean the one physically above where "." points to. These days I
186 think it's just handed off to the filesystem.)
188 Anyway, path resolution starts with "." or "/" (although the "./" at the start
189 of the path may be implicit), meaning it's relative to one of those two
190 directories. Your current directory, and your current root directory. The
191 chdir() syscall changes where "." points to, and the chroot() syscall changes
192 where "/" points to. (Again, both are per-process which is why chroot only
193 affects your current process and its child processes.)
195 Note that chroot() does _not_ change where "." points to, and back before they
196 put crazy security checks into the kernel your current directory could be
197 somewhere you could no longer access after the chroot. (The command line
198 chroot does a cd as well, the chroot _syscall_ is what I'm talking about.)
200 The reason mounting something new over / has no obvious effect is the same
201 reason mounting something over your current directory has no obvious effect:
202 the . and / links aren't recalculated after a mount, so they still point to
203 the same dentry they did before, even if that dentry is no longer accessible
204 by other means. Note that "cd ." is a NOP, and "chroot /" is a nop; both look
205 up the cached dentry and set it right back. They don't re-parse any paths,
206 because they're what all paths your process uses would be relative to.
208 That's why the careful sequencing above: we cd into the new mount point before
209 we do the mount --move. Moving the mount point would otherwise make it
210 totally inaccessible to is because cd-ing to the old path wouldn't give it to
211 us anymore, and cd "/" just gives us the cached dentry from when the process
212 was created (in this case the old initramfs one). But the "." symlink gives
213 us the dentry of the filesystem we just moved, so we can then "chroot ." to
214 copy that dentry to "/" and get the new filesystem. If we _didn't_ save that
215 dentry in "." we couldn't get it back after the mount --move.
217 (Yes, this is all screwy and I had to email questions to Linus Torvalds to get
218 it straight myself. I keep meaning to write up a "how mount actually works"