Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
do_mounts.c
Go to the documentation of this file.
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 
39 static char * __initdata root_device_name;
40 static char __initdata saved_root_name[64];
41 static int root_wait;
42 
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;
57  return 1;
58 }
59 
60 static int __init readwrite(char *str)
61 {
62  if (*str)
63  return 0;
65  return 1;
66 }
67 
68 __setup("ro", readonly);
69 __setup("rw", readwrite);
70 
71 #ifdef CONFIG_BLOCK
72 
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 
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)
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 
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;
347  "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
348  s->s_type->name,
349  s->s_flags & MS_RDONLY ? " readonly" : "",
351  return 0;
352 }
353 
354 void __init mount_block_root(char *name, int flags)
355 {
356  struct page *page = alloc_page(GFP_KERNEL |
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 
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");
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);
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)) {
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  */
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  */
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);
559  }
560 
561  is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
562 
563  if (is_floppy && rd_doload && rd_load_disk(0))
565 
566  mount_root();
567 out:
568  devtmpfs_mount("dev");
569  sys_mount(".", "/", NULL, MS_MOVE, NULL);
570  sys_chroot(".");
571 }