netdev: octeon: fix return value check in octeon_mgmt_init_phy()
[linux-3.10.git] / init / do_mounts.c
1 /*
2  * Many of the syscalls used in this file expect some of the arguments
3  * to be __user pointers not __kernel pointers.  To limit the sparse
4  * noise, turn off sparse checking for this file.
5  */
6 #ifdef __CHECKER__
7 #undef __CHECKER__
8 #warning "Sparse checking disabled for this file"
9 #endif
10
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/ctype.h>
14 #include <linux/fd.h>
15 #include <linux/tty.h>
16 #include <linux/suspend.h>
17 #include <linux/root_dev.h>
18 #include <linux/security.h>
19 #include <linux/delay.h>
20 #include <linux/genhd.h>
21 #include <linux/mount.h>
22 #include <linux/device.h>
23 #include <linux/init.h>
24 #include <linux/fs.h>
25 #include <linux/initrd.h>
26 #include <linux/async.h>
27 #include <linux/fs_struct.h>
28 #include <linux/slab.h>
29
30 #include <linux/nfs_fs.h>
31 #include <linux/nfs_fs_sb.h>
32 #include <linux/nfs_mount.h>
33
34 #include "do_mounts.h"
35
36 int __initdata rd_doload;       /* 1 = load RAM disk, 0 = don't load */
37
38 int root_mountflags = MS_RDONLY | MS_SILENT;
39 static char * __initdata root_device_name;
40 static char __initdata saved_root_name[64];
41 static int root_wait;
42
43 dev_t ROOT_DEV;
44
45 static int __init load_ramdisk(char *str)
46 {
47         rd_doload = simple_strtol(str,NULL,0) & 3;
48         return 1;
49 }
50 __setup("load_ramdisk=", load_ramdisk);
51
52 static int __init readonly(char *str)
53 {
54         if (*str)
55                 return 0;
56         root_mountflags |= MS_RDONLY;
57         return 1;
58 }
59
60 static int __init readwrite(char *str)
61 {
62         if (*str)
63                 return 0;
64         root_mountflags &= ~MS_RDONLY;
65         return 1;
66 }
67
68 __setup("ro", readonly);
69 __setup("rw", readwrite);
70
71 #ifdef CONFIG_BLOCK
72 /**
73  * match_dev_by_uuid - callback for finding a partition using its uuid
74  * @dev:        device passed in by the caller
75  * @data:       opaque pointer to a 36 byte char array with a UUID
76  *
77  * Returns 1 if the device matches, and 0 otherwise.
78  */
79 static int match_dev_by_uuid(struct device *dev, void *data)
80 {
81         u8 *uuid = data;
82         struct hd_struct *part = dev_to_part(dev);
83
84         if (!part->info)
85                 goto no_match;
86
87         if (memcmp(uuid, part->info->uuid, sizeof(part->info->uuid)))
88                         goto no_match;
89
90         return 1;
91 no_match:
92         return 0;
93 }
94
95
96 /**
97  * devt_from_partuuid - looks up the dev_t of a partition by its UUID
98  * @uuid:       min 36 byte char array containing a hex ascii UUID
99  *
100  * The function will return the first partition which contains a matching
101  * UUID value in its partition_meta_info struct.  This does not search
102  * by filesystem UUIDs.
103  *
104  * If @uuid is followed by a "/PARTNROFF=%d", then the number will be
105  * extracted and used as an offset from the partition identified by the UUID.
106  *
107  * Returns the matching dev_t on success or 0 on failure.
108  */
109 static dev_t devt_from_partuuid(char *uuid_str)
110 {
111         dev_t res = 0;
112         struct device *dev = NULL;
113         u8 uuid[16];
114         struct gendisk *disk;
115         struct hd_struct *part;
116         int offset = 0;
117
118         if (strlen(uuid_str) < 36)
119                 goto done;
120
121         /* Check for optional partition number offset attributes. */
122         if (uuid_str[36]) {
123                 char c = 0;
124                 /* Explicitly fail on poor PARTUUID syntax. */
125                 if (sscanf(&uuid_str[36],
126                            "/PARTNROFF=%d%c", &offset, &c) != 1) {
127                         printk(KERN_ERR "VFS: PARTUUID= is invalid.\n"
128                          "Expected PARTUUID=<valid-uuid-id>[/PARTNROFF=%%d]\n");
129                         if (root_wait)
130                                 printk(KERN_ERR
131                                      "Disabling rootwait; root= is invalid.\n");
132                         root_wait = 0;
133                         goto done;
134                 }
135         }
136
137         /* Pack the requested UUID in the expected format. */
138         part_pack_uuid(uuid_str, uuid);
139
140         dev = class_find_device(&block_class, NULL, uuid, &match_dev_by_uuid);
141         if (!dev)
142                 goto done;
143
144         res = dev->devt;
145
146         /* Attempt to find the partition by offset. */
147         if (!offset)
148                 goto no_offset;
149
150         res = 0;
151         disk = part_to_disk(dev_to_part(dev));
152         part = disk_get_part(disk, dev_to_part(dev)->partno + offset);
153         if (part) {
154                 res = part_devt(part);
155                 put_device(part_to_dev(part));
156         }
157
158 no_offset:
159         put_device(dev);
160 done:
161         return res;
162 }
163 #endif
164
165 /*
166  *      Convert a name into device number.  We accept the following variants:
167  *
168  *      1) device number in hexadecimal represents itself
169  *      2) /dev/nfs represents Root_NFS (0xff)
170  *      3) /dev/<disk_name> represents the device number of disk
171  *      4) /dev/<disk_name><decimal> represents the device number
172  *         of partition - device number of disk plus the partition number
173  *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
174  *         used when disk name of partitioned disk ends on a digit.
175  *      6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
176  *         unique id of a partition if the partition table provides it.
177  *      7) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
178  *         a partition with a known unique id.
179  *
180  *      If name doesn't have fall into the categories above, we return (0,0).
181  *      block_class is used to check if something is a disk name. If the disk
182  *      name contains slashes, the device name has them replaced with
183  *      bangs.
184  */
185
186 dev_t name_to_dev_t(char *name)
187 {
188         char s[32];
189         char *p;
190         dev_t res = 0;
191         int part;
192
193 #ifdef CONFIG_BLOCK
194         if (strncmp(name, "PARTUUID=", 9) == 0) {
195                 name += 9;
196                 res = devt_from_partuuid(name);
197                 if (!res)
198                         goto fail;
199                 goto done;
200         }
201 #endif
202
203         if (strncmp(name, "/dev/", 5) != 0) {
204                 unsigned maj, min;
205
206                 if (sscanf(name, "%u:%u", &maj, &min) == 2) {
207                         res = MKDEV(maj, min);
208                         if (maj != MAJOR(res) || min != MINOR(res))
209                                 goto fail;
210                 } else {
211                         res = new_decode_dev(simple_strtoul(name, &p, 16));
212                         if (*p)
213                                 goto fail;
214                 }
215                 goto done;
216         }
217
218         name += 5;
219         res = Root_NFS;
220         if (strcmp(name, "nfs") == 0)
221                 goto done;
222         res = Root_RAM0;
223         if (strcmp(name, "ram") == 0)
224                 goto done;
225
226         if (strlen(name) > 31)
227                 goto fail;
228         strcpy(s, name);
229         for (p = s; *p; p++)
230                 if (*p == '/')
231                         *p = '!';
232         res = blk_lookup_devt(s, 0);
233         if (res)
234                 goto done;
235
236         /*
237          * try non-existent, but valid partition, which may only exist
238          * after revalidating the disk, like partitioned md devices
239          */
240         while (p > s && isdigit(p[-1]))
241                 p--;
242         if (p == s || !*p || *p == '0')
243                 goto fail;
244
245         /* try disk name without <part number> */
246         part = simple_strtoul(p, NULL, 10);
247         *p = '\0';
248         res = blk_lookup_devt(s, part);
249         if (res)
250                 goto done;
251
252         /* try disk name without p<part number> */
253         if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
254                 goto fail;
255         p[-1] = '\0';
256         res = blk_lookup_devt(s, part);
257         if (res)
258                 goto done;
259
260 fail:
261         return 0;
262 done:
263         return res;
264 }
265
266 static int __init root_dev_setup(char *line)
267 {
268         strlcpy(saved_root_name, line, sizeof(saved_root_name));
269         return 1;
270 }
271
272 __setup("root=", root_dev_setup);
273
274 static int __init rootwait_setup(char *str)
275 {
276         if (*str)
277                 return 0;
278         root_wait = 1;
279         return 1;
280 }
281
282 __setup("rootwait", rootwait_setup);
283
284 static char * __initdata root_mount_data;
285 static int __init root_data_setup(char *str)
286 {
287         root_mount_data = str;
288         return 1;
289 }
290
291 static char * __initdata root_fs_names;
292 static int __init fs_names_setup(char *str)
293 {
294         root_fs_names = str;
295         return 1;
296 }
297
298 static unsigned int __initdata root_delay;
299 static int __init root_delay_setup(char *str)
300 {
301         root_delay = simple_strtoul(str, NULL, 0);
302         return 1;
303 }
304
305 __setup("rootflags=", root_data_setup);
306 __setup("rootfstype=", fs_names_setup);
307 __setup("rootdelay=", root_delay_setup);
308
309 static void __init get_fs_names(char *page)
310 {
311         char *s = page;
312
313         if (root_fs_names) {
314                 strcpy(page, root_fs_names);
315                 while (*s++) {
316                         if (s[-1] == ',')
317                                 s[-1] = '\0';
318                 }
319         } else {
320                 int len = get_filesystem_list(page);
321                 char *p, *next;
322
323                 page[len] = '\0';
324                 for (p = page-1; p; p = next) {
325                         next = strchr(++p, '\n');
326                         if (*p++ != '\t')
327                                 continue;
328                         while ((*s++ = *p++) != '\n')
329                                 ;
330                         s[-1] = '\0';
331                 }
332         }
333         *s = '\0';
334 }
335
336 static int __init do_mount_root(char *name, char *fs, int flags, void *data)
337 {
338         struct super_block *s;
339         int err = sys_mount(name, "/root", fs, flags, data);
340         if (err)
341                 return err;
342
343         sys_chdir("/root");
344         s = current->fs->pwd.dentry->d_sb;
345         ROOT_DEV = s->s_dev;
346         printk(KERN_INFO
347                "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
348                s->s_type->name,
349                s->s_flags & MS_RDONLY ?  " readonly" : "",
350                MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
351         return 0;
352 }
353
354 void __init mount_block_root(char *name, int flags)
355 {
356         char *fs_names = __getname_gfp(GFP_KERNEL
357                 | __GFP_NOTRACK_FALSE_POSITIVE);
358         char *p;
359 #ifdef CONFIG_BLOCK
360         char b[BDEVNAME_SIZE];
361 #else
362         const char *b = name;
363 #endif
364
365         get_fs_names(fs_names);
366 retry:
367         for (p = fs_names; *p; p += strlen(p)+1) {
368                 int err = do_mount_root(name, p, flags, root_mount_data);
369                 switch (err) {
370                         case 0:
371                                 goto out;
372                         case -EACCES:
373                                 flags |= MS_RDONLY;
374                                 goto retry;
375                         case -EINVAL:
376                                 continue;
377                 }
378                 /*
379                  * Allow the user to distinguish between failed sys_open
380                  * and bad superblock on root device.
381                  * and give them a list of the available devices
382                  */
383 #ifdef CONFIG_BLOCK
384                 __bdevname(ROOT_DEV, b);
385 #endif
386                 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
387                                 root_device_name, b, err);
388                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
389
390                 printk_all_partitions();
391 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
392                 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
393                        "explicit textual name for \"root=\" boot option.\n");
394 #endif
395                 panic("VFS: Unable to mount root fs on %s", b);
396         }
397
398         printk("List of all partitions:\n");
399         printk_all_partitions();
400         printk("No filesystem could mount root, tried: ");
401         for (p = fs_names; *p; p += strlen(p)+1)
402                 printk(" %s", p);
403         printk("\n");
404 #ifdef CONFIG_BLOCK
405         __bdevname(ROOT_DEV, b);
406 #endif
407         panic("VFS: Unable to mount root fs on %s", b);
408 out:
409         putname(fs_names);
410 }
411  
412 #ifdef CONFIG_ROOT_NFS
413
414 #define NFSROOT_TIMEOUT_MIN     5
415 #define NFSROOT_TIMEOUT_MAX     30
416 #define NFSROOT_RETRY_MAX       5
417
418 static int __init mount_nfs_root(void)
419 {
420         char *root_dev, *root_data;
421         unsigned int timeout;
422         int try, err;
423
424         err = nfs_root_data(&root_dev, &root_data);
425         if (err != 0)
426                 return 0;
427
428         /*
429          * The server or network may not be ready, so try several
430          * times.  Stop after a few tries in case the client wants
431          * to fall back to other boot methods.
432          */
433         timeout = NFSROOT_TIMEOUT_MIN;
434         for (try = 1; ; try++) {
435                 err = do_mount_root(root_dev, "nfs",
436                                         root_mountflags, root_data);
437                 if (err == 0)
438                         return 1;
439                 if (try > NFSROOT_RETRY_MAX)
440                         break;
441
442                 /* Wait, in case the server refused us immediately */
443                 ssleep(timeout);
444                 timeout <<= 1;
445                 if (timeout > NFSROOT_TIMEOUT_MAX)
446                         timeout = NFSROOT_TIMEOUT_MAX;
447         }
448         return 0;
449 }
450 #endif
451
452 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
453 void __init change_floppy(char *fmt, ...)
454 {
455         struct termios termios;
456         char buf[80];
457         char c;
458         int fd;
459         va_list args;
460         va_start(args, fmt);
461         vsprintf(buf, fmt, args);
462         va_end(args);
463         fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
464         if (fd >= 0) {
465                 sys_ioctl(fd, FDEJECT, 0);
466                 sys_close(fd);
467         }
468         printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
469         fd = sys_open("/dev/console", O_RDWR, 0);
470         if (fd >= 0) {
471                 sys_ioctl(fd, TCGETS, (long)&termios);
472                 termios.c_lflag &= ~ICANON;
473                 sys_ioctl(fd, TCSETSF, (long)&termios);
474                 sys_read(fd, &c, 1);
475                 termios.c_lflag |= ICANON;
476                 sys_ioctl(fd, TCSETSF, (long)&termios);
477                 sys_close(fd);
478         }
479 }
480 #endif
481
482 void __init mount_root(void)
483 {
484 #ifdef CONFIG_ROOT_NFS
485         if (ROOT_DEV == Root_NFS) {
486                 if (mount_nfs_root())
487                         return;
488
489                 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
490                 ROOT_DEV = Root_FD0;
491         }
492 #endif
493 #ifdef CONFIG_BLK_DEV_FD
494         if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
495                 /* rd_doload is 2 for a dual initrd/ramload setup */
496                 if (rd_doload==2) {
497                         if (rd_load_disk(1)) {
498                                 ROOT_DEV = Root_RAM1;
499                                 root_device_name = NULL;
500                         }
501                 } else
502                         change_floppy("root floppy");
503         }
504 #endif
505 #ifdef CONFIG_BLOCK
506         create_dev("/dev/root", ROOT_DEV);
507         mount_block_root("/dev/root", root_mountflags);
508 #endif
509 }
510
511 /*
512  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
513  */
514 void __init prepare_namespace(void)
515 {
516         int is_floppy;
517
518         if (root_delay) {
519                 printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
520                        root_delay);
521                 ssleep(root_delay);
522         }
523
524         /*
525          * wait for the known devices to complete their probing
526          *
527          * Note: this is a potential source of long boot delays.
528          * For example, it is not atypical to wait 5 seconds here
529          * for the touchpad of a laptop to initialize.
530          */
531         wait_for_device_probe();
532
533         md_run_setup();
534
535         if (saved_root_name[0]) {
536                 root_device_name = saved_root_name;
537                 if (!strncmp(root_device_name, "mtd", 3) ||
538                     !strncmp(root_device_name, "ubi", 3)) {
539                         mount_block_root(root_device_name, root_mountflags);
540                         goto out;
541                 }
542                 ROOT_DEV = name_to_dev_t(root_device_name);
543                 if (strncmp(root_device_name, "/dev/", 5) == 0)
544                         root_device_name += 5;
545         }
546
547         if (initrd_load())
548                 goto out;
549
550         /* wait for any asynchronous scanning to complete */
551         if ((ROOT_DEV == 0) && root_wait) {
552                 printk(KERN_INFO "Waiting for root device %s...\n",
553                         saved_root_name);
554                 while (driver_probe_done() != 0 ||
555                         (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
556                         msleep(100);
557                 async_synchronize_full();
558         }
559
560         is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
561
562         if (is_floppy && rd_doload && rd_load_disk(0))
563                 ROOT_DEV = Root_RAM0;
564
565         mount_root();
566 out:
567         devtmpfs_mount("dev");
568         sys_mount(".", "/", NULL, MS_MOVE, NULL);
569         sys_chroot(".");
570 }