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