mm: numa: pte_numa() and pmd_numa()
[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         struct page *page = alloc_page(GFP_KERNEL |
357                                         __GFP_NOTRACK_FALSE_POSITIVE);
358         char *fs_names = page_address(page);
359         char *p;
360 #ifdef CONFIG_BLOCK
361         char b[BDEVNAME_SIZE];
362 #else
363         const char *b = name;
364 #endif
365
366         get_fs_names(fs_names);
367 retry:
368         for (p = fs_names; *p; p += strlen(p)+1) {
369                 int err = do_mount_root(name, p, flags, root_mount_data);
370                 switch (err) {
371                         case 0:
372                                 goto out;
373                         case -EACCES:
374                                 flags |= MS_RDONLY;
375                                 goto retry;
376                         case -EINVAL:
377                                 continue;
378                 }
379                 /*
380                  * Allow the user to distinguish between failed sys_open
381                  * and bad superblock on root device.
382                  * and give them a list of the available devices
383                  */
384 #ifdef CONFIG_BLOCK
385                 __bdevname(ROOT_DEV, b);
386 #endif
387                 printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
388                                 root_device_name, b, err);
389                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
390
391                 printk_all_partitions();
392 #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
393                 printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
394                        "explicit textual name for \"root=\" boot option.\n");
395 #endif
396                 panic("VFS: Unable to mount root fs on %s", b);
397         }
398
399         printk("List of all partitions:\n");
400         printk_all_partitions();
401         printk("No filesystem could mount root, tried: ");
402         for (p = fs_names; *p; p += strlen(p)+1)
403                 printk(" %s", p);
404         printk("\n");
405 #ifdef CONFIG_BLOCK
406         __bdevname(ROOT_DEV, b);
407 #endif
408         panic("VFS: Unable to mount root fs on %s", b);
409 out:
410         put_page(page);
411 }
412  
413 #ifdef CONFIG_ROOT_NFS
414
415 #define NFSROOT_TIMEOUT_MIN     5
416 #define NFSROOT_TIMEOUT_MAX     30
417 #define NFSROOT_RETRY_MAX       5
418
419 static int __init mount_nfs_root(void)
420 {
421         char *root_dev, *root_data;
422         unsigned int timeout;
423         int try, err;
424
425         err = nfs_root_data(&root_dev, &root_data);
426         if (err != 0)
427                 return 0;
428
429         /*
430          * The server or network may not be ready, so try several
431          * times.  Stop after a few tries in case the client wants
432          * to fall back to other boot methods.
433          */
434         timeout = NFSROOT_TIMEOUT_MIN;
435         for (try = 1; ; try++) {
436                 err = do_mount_root(root_dev, "nfs",
437                                         root_mountflags, root_data);
438                 if (err == 0)
439                         return 1;
440                 if (try > NFSROOT_RETRY_MAX)
441                         break;
442
443                 /* Wait, in case the server refused us immediately */
444                 ssleep(timeout);
445                 timeout <<= 1;
446                 if (timeout > NFSROOT_TIMEOUT_MAX)
447                         timeout = NFSROOT_TIMEOUT_MAX;
448         }
449         return 0;
450 }
451 #endif
452
453 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
454 void __init change_floppy(char *fmt, ...)
455 {
456         struct termios termios;
457         char buf[80];
458         char c;
459         int fd;
460         va_list args;
461         va_start(args, fmt);
462         vsprintf(buf, fmt, args);
463         va_end(args);
464         fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0);
465         if (fd >= 0) {
466                 sys_ioctl(fd, FDEJECT, 0);
467                 sys_close(fd);
468         }
469         printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
470         fd = sys_open("/dev/console", O_RDWR, 0);
471         if (fd >= 0) {
472                 sys_ioctl(fd, TCGETS, (long)&termios);
473                 termios.c_lflag &= ~ICANON;
474                 sys_ioctl(fd, TCSETSF, (long)&termios);
475                 sys_read(fd, &c, 1);
476                 termios.c_lflag |= ICANON;
477                 sys_ioctl(fd, TCSETSF, (long)&termios);
478                 sys_close(fd);
479         }
480 }
481 #endif
482
483 void __init mount_root(void)
484 {
485 #ifdef CONFIG_ROOT_NFS
486         if (ROOT_DEV == Root_NFS) {
487                 if (mount_nfs_root())
488                         return;
489
490                 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
491                 ROOT_DEV = Root_FD0;
492         }
493 #endif
494 #ifdef CONFIG_BLK_DEV_FD
495         if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
496                 /* rd_doload is 2 for a dual initrd/ramload setup */
497                 if (rd_doload==2) {
498                         if (rd_load_disk(1)) {
499                                 ROOT_DEV = Root_RAM1;
500                                 root_device_name = NULL;
501                         }
502                 } else
503                         change_floppy("root floppy");
504         }
505 #endif
506 #ifdef CONFIG_BLOCK
507         create_dev("/dev/root", ROOT_DEV);
508         mount_block_root("/dev/root", root_mountflags);
509 #endif
510 }
511
512 /*
513  * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
514  */
515 void __init prepare_namespace(void)
516 {
517         int is_floppy;
518
519         if (root_delay) {
520                 printk(KERN_INFO "Waiting %dsec before mounting root device...\n",
521                        root_delay);
522                 ssleep(root_delay);
523         }
524
525         /*
526          * wait for the known devices to complete their probing
527          *
528          * Note: this is a potential source of long boot delays.
529          * For example, it is not atypical to wait 5 seconds here
530          * for the touchpad of a laptop to initialize.
531          */
532         wait_for_device_probe();
533
534         md_run_setup();
535
536         if (saved_root_name[0]) {
537                 root_device_name = saved_root_name;
538                 if (!strncmp(root_device_name, "mtd", 3) ||
539                     !strncmp(root_device_name, "ubi", 3)) {
540                         mount_block_root(root_device_name, root_mountflags);
541                         goto out;
542                 }
543                 ROOT_DEV = name_to_dev_t(root_device_name);
544                 if (strncmp(root_device_name, "/dev/", 5) == 0)
545                         root_device_name += 5;
546         }
547
548         if (initrd_load())
549                 goto out;
550
551         /* wait for any asynchronous scanning to complete */
552         if ((ROOT_DEV == 0) && root_wait) {
553                 printk(KERN_INFO "Waiting for root device %s...\n",
554                         saved_root_name);
555                 while (driver_probe_done() != 0 ||
556                         (ROOT_DEV = name_to_dev_t(saved_root_name)) == 0)
557                         msleep(100);
558                 async_synchronize_full();
559         }
560
561         is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
562
563         if (is_floppy && rd_doload && rd_load_disk(0))
564                 ROOT_DEV = Root_RAM0;
565
566         mount_root();
567 out:
568         devtmpfs_mount("dev");
569         sys_mount(".", "/", NULL, MS_MOVE, NULL);
570         sys_chroot(".");
571 }