Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux-3.10.git] / init / do_mounts.c
1 #include <linux/module.h>
2 #include <linux/sched.h>
3 #include <linux/ctype.h>
4 #include <linux/fd.h>
5 #include <linux/tty.h>
6 #include <linux/suspend.h>
7 #include <linux/root_dev.h>
8 #include <linux/security.h>
9 #include <linux/delay.h>
10 #include <linux/genhd.h>
11 #include <linux/mount.h>
12 #include <linux/device.h>
13 #include <linux/init.h>
14
15 #include <linux/nfs_fs.h>
16 #include <linux/nfs_fs_sb.h>
17 #include <linux/nfs_mount.h>
18
19 #include "do_mounts.h"
20
21 extern int get_filesystem_list(char * buf);
22
23 int __initdata rd_doload;       /* 1 = load RAM disk, 0 = don't load */
24
25 int root_mountflags = MS_RDONLY | MS_SILENT;
26 char * __initdata root_device_name;
27 static char __initdata saved_root_name[64];
28 static int __initdata root_wait;
29
30 dev_t ROOT_DEV;
31
32 static int __init load_ramdisk(char *str)
33 {
34         rd_doload = simple_strtol(str,NULL,0) & 3;
35         return 1;
36 }
37 __setup("load_ramdisk=", load_ramdisk);
38
39 static int __init readonly(char *str)
40 {
41         if (*str)
42                 return 0;
43         root_mountflags |= MS_RDONLY;
44         return 1;
45 }
46
47 static int __init readwrite(char *str)
48 {
49         if (*str)
50                 return 0;
51         root_mountflags &= ~MS_RDONLY;
52         return 1;
53 }
54
55 __setup("ro", readonly);
56 __setup("rw", readwrite);
57
58 /*
59  *      Convert a name into device number.  We accept the following variants:
60  *
61  *      1) device number in hexadecimal represents itself
62  *      2) /dev/nfs represents Root_NFS (0xff)
63  *      3) /dev/<disk_name> represents the device number of disk
64  *      4) /dev/<disk_name><decimal> represents the device number
65  *         of partition - device number of disk plus the partition number
66  *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
67  *         used when disk name of partitioned disk ends on a digit.
68  *
69  *      If name doesn't have fall into the categories above, we return (0,0).
70  *      block_class is used to check if something is a disk name. If the disk
71  *      name contains slashes, the device name has them replaced with
72  *      bangs.
73  */
74
75 dev_t name_to_dev_t(char *name)
76 {
77         char s[32];
78         char *p;
79         dev_t res = 0;
80
81         if (strncmp(name, "/dev/", 5) != 0) {
82                 unsigned maj, min;
83
84                 if (sscanf(name, "%u:%u", &maj, &min) == 2) {
85                         res = MKDEV(maj, min);
86                         if (maj != MAJOR(res) || min != MINOR(res))
87                                 goto fail;
88                 } else {
89                         res = new_decode_dev(simple_strtoul(name, &p, 16));
90                         if (*p)
91                                 goto fail;
92                 }
93                 goto done;
94         }
95
96         name += 5;
97         res = Root_NFS;
98         if (strcmp(name, "nfs") == 0)
99                 goto done;
100         res = Root_RAM0;
101         if (strcmp(name, "ram") == 0)
102                 goto done;
103
104         if (strlen(name) > 31)
105                 goto fail;
106         strcpy(s, name);
107         for (p = s; *p; p++)
108                 if (*p == '/')
109                         *p = '!';
110         res = blk_lookup_devt(s);
111         if (res)
112                 goto done;
113
114 fail:
115         return 0;
116 done:
117         return res;
118 }
119
120 static int __init root_dev_setup(char *line)
121 {
122         strlcpy(saved_root_name, line, sizeof(saved_root_name));
123         return 1;
124 }
125
126 __setup("root=", root_dev_setup);
127
128 static int __init rootwait_setup(char *str)
129 {
130         if (*str)
131                 return 0;
132         root_wait = 1;
133         return 1;
134 }
135
136 __setup("rootwait", rootwait_setup);
137
138 static char * __initdata root_mount_data;
139 static int __init root_data_setup(char *str)
140 {
141         root_mount_data = str;
142         return 1;
143 }
144
145 static char * __initdata root_fs_names;
146 static int __init fs_names_setup(char *str)
147 {
148         root_fs_names = str;
149         return 1;
150 }
151
152 static unsigned int __initdata root_delay;
153 static int __init root_delay_setup(char *str)
154 {
155         root_delay = simple_strtoul(str, NULL, 0);
156         return 1;
157 }
158
159 __setup("rootflags=", root_data_setup);
160 __setup("rootfstype=", fs_names_setup);
161 __setup("rootdelay=", root_delay_setup);
162
163 static void __init get_fs_names(char *page)
164 {
165         char *s = page;
166
167         if (root_fs_names) {
168                 strcpy(page, root_fs_names);
169                 while (*s++) {
170                         if (s[-1] == ',')
171                                 s[-1] = '\0';
172                 }
173         } else {
174                 int len = get_filesystem_list(page);
175                 char *p, *next;
176
177                 page[len] = '\0';
178                 for (p = page-1; p; p = next) {
179                         next = strchr(++p, '\n');
180                         if (*p++ != '\t')
181                                 continue;
182                         while ((*s++ = *p++) != '\n')
183                                 ;
184                         s[-1] = '\0';
185                 }
186         }
187         *s = '\0';
188 }
189
190 static int __init do_mount_root(char *name, char *fs, int flags, void *data)
191 {
192         int err = sys_mount(name, "/root", fs, flags, data);
193         if (err)
194                 return err;
195
196         sys_chdir("/root");
197         ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev;
198         printk("VFS: Mounted root (%s filesystem)%s.\n",
199                current->fs->pwdmnt->mnt_sb->s_type->name,
200                current->fs->pwdmnt->mnt_sb->s_flags & MS_RDONLY ? 
201                " readonly" : "");
202         return 0;
203 }
204
205 void __init mount_block_root(char *name, int flags)
206 {
207         char *fs_names = __getname();
208         char *p;
209 #ifdef CONFIG_BLOCK
210         char b[BDEVNAME_SIZE];
211 #else
212         const char *b = name;
213 #endif
214
215         get_fs_names(fs_names);
216 retry:
217         for (p = fs_names; *p; p += strlen(p)+1) {
218                 int err = do_mount_root(name, p, flags, root_mount_data);
219                 switch (err) {
220                         case 0:
221                                 goto out;
222                         case -EACCES:
223                                 flags |= MS_RDONLY;
224                                 goto retry;
225                         case -EINVAL:
226                                 continue;
227                 }
228                 /*
229                  * Allow the user to distinguish between failed sys_open
230                  * and bad superblock on root device.
231                  * and give them a list of the available devices
232                  */
233 #ifdef CONFIG_BLOCK
234                 __bdevname(ROOT_DEV, b);
235 #endif
236                 printk("VFS: Cannot open root device \"%s\" or %s\n",
237                                 root_device_name, b);
238                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
239
240                 printk_all_partitions();
241                 panic("VFS: Unable to mount root fs on %s", b);
242         }
243
244         printk("List of all partitions:\n");
245         printk_all_partitions();
246         printk("No filesystem could mount root, tried: ");
247         for (p = fs_names; *p; p += strlen(p)+1)
248                 printk(" %s", p);
249         printk("\n");
250 #ifdef CONFIG_BLOCK
251         __bdevname(ROOT_DEV, b);
252 #endif
253         panic("VFS: Unable to mount root fs on %s", b);
254 out:
255         putname(fs_names);
256 }
257  
258 #ifdef CONFIG_ROOT_NFS
259 static int __init mount_nfs_root(void)
260 {
261         void *data = nfs_root_data();
262
263         create_dev("/dev/root", ROOT_DEV);
264         if (data &&
265             do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0)
266                 return 1;
267         return 0;
268 }
269 #endif
270
271 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
272 void __init change_floppy(char *fmt, ...)
273 {
274         struct termios termios;
275         char buf[80];
276         char c;
277         int fd;
278         va_list args;
279         va_start(args, fmt);
280         vsprintf(buf, fmt, args);
281         va_end(args);
282         fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
283         if (fd >= 0) {
284                 sys_ioctl(fd, FDEJECT, 0);
285                 sys_close(fd);
286         }
287         printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
288         fd = sys_open("/dev/console", O_RDWR, 0);
289         if (fd >= 0) {
290                 sys_ioctl(fd, TCGETS, (long)&termios);
291                 termios.c_lflag &= ~ICANON;
292                 sys_ioctl(fd, TCSETSF, (long)&termios);
293                 sys_read(fd, &c, 1);
294                 termios.c_lflag |= ICANON;
295                 sys_ioctl(fd, TCSETSF, (long)&termios);
296                 sys_close(fd);
297         }
298 }
299 #endif
300
301 void __init mount_root(void)
302 {
303 #ifdef CONFIG_ROOT_NFS
304         if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) {
305                 if (mount_nfs_root())
306                         return;
307
308                 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
309                 ROOT_DEV = Root_FD0;
310         }
311 #endif
312 #ifdef CONFIG_BLK_DEV_FD
313         if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
314                 /* rd_doload is 2 for a dual initrd/ramload setup */
315                 if (rd_doload==2) {
316                         if (rd_load_disk(1)) {
317                                 ROOT_DEV = Root_RAM1;
318                                 root_device_name = NULL;
319                         }
320                 } else
321                         change_floppy("root floppy");
322         }
323 #endif
324 #ifdef CONFIG_BLOCK
325         create_dev("/dev/root", ROOT_DEV);
326         mount_block_root("/dev/root", root_mountflags);
327 #endif
328 }
329
330 /*
331  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
332  */
333 void __init prepare_namespace(void)
334 {
335         int is_floppy;
336
337         if (root_delay) {
338                 printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
339                        root_delay);
340                 ssleep(root_delay);
341         }
342
343         /* wait for the known devices to complete their probing */
344         while (driver_probe_done() != 0)
345                 msleep(100);
346
347         md_run_setup();
348
349         if (saved_root_name[0]) {
350                 root_device_name = saved_root_name;
351                 if (!strncmp(root_device_name, "mtd", 3)) {
352                         mount_block_root(root_device_name, root_mountflags);
353                         goto out;
354                 }
355                 ROOT_DEV = name_to_dev_t(root_device_name);
356                 if (strncmp(root_device_name, "/dev/", 5) == 0)
357                         root_device_name += 5;
358         }
359
360         if (initrd_load())
361                 goto out;
362
363         /* wait for any asynchronous scanning to complete */
364         if ((ROOT_DEV == 0) && root_wait) {
365                 printk(KERN_INFO "Waiting for root device %s...\n",
366                         saved_root_name);
367                 while (driver_probe_done() != 0 ||
368                         (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
369                         msleep(100);
370         }
371
372         is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
373
374         if (is_floppy && rd_doload && rd_load_disk(0))
375                 ROOT_DEV = Root_RAM0;
376
377         mount_root();
378 out:
379         sys_mount(".", "/", NULL, MS_MOVE, NULL);
380         sys_chroot(".");
381 }
382