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/mount.h> 11 #include <linux/device.h> 12 #include <linux/init.h> 13 14 #include <linux/nfs_fs.h> 15 #include <linux/nfs_fs_sb.h> 16 #include <linux/nfs_mount.h> 17 18 #include "do_mounts.h" 19 20 extern int get_filesystem_list(char * buf); 21 22 int __initdata rd_doload; /* 1 = load RAM disk, 0 = don't load */ 23 24 int root_mountflags = MS_RDONLY | MS_SILENT; 25 char * __initdata root_device_name; 26 static char __initdata saved_root_name[64]; 27 28 dev_t ROOT_DEV; 29 30 static 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 37 static int __init readonly(char *str) 38 { 39 if (*str) 40 return 0; 41 root_mountflags |= MS_RDONLY; 42 return 1; 43 } 44 45 static 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 56 static 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; 115 fail: 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 * Sysfs 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 sysfs node has them replaced with 134 * bangs. try_name() does the actual checks, assuming that sysfs 135 * is mounted on rootfs /sys. 136 */ 137 138 dev_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); 197 done: 198 #ifdef CONFIG_SYSFS 199 sys_umount("/sys", 0); 200 out: 201 if (!mkdir_err) 202 sys_rmdir("/sys"); 203 #endif 204 return res; 205 fail: 206 res = 0; 207 goto done; 208 } 209 210 static 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 218 static char * __initdata root_mount_data; 219 static int __init root_data_setup(char *str) 220 { 221 root_mount_data = str; 222 return 1; 223 } 224 225 static char * __initdata root_fs_names; 226 static int __init fs_names_setup(char *str) 227 { 228 root_fs_names = str; 229 return 1; 230 } 231 232 static unsigned int __initdata root_delay; 233 static 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 243 static 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 270 static 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 285 void __init mount_block_root(char *name, int flags) 286 { 287 char *fs_names = __getname(); 288 char *p; 289 #ifdef CONFIG_BLOCK 290 char b[BDEVNAME_SIZE]; 291 #else 292 const char *b = name; 293 #endif 294 295 get_fs_names(fs_names); 296 retry: 297 for (p = fs_names; *p; p += strlen(p)+1) { 298 int err = do_mount_root(name, p, flags, root_mount_data); 299 switch (err) { 300 case 0: 301 goto out; 302 case -EACCES: 303 flags |= MS_RDONLY; 304 goto retry; 305 case -EINVAL: 306 continue; 307 } 308 /* 309 * Allow the user to distinguish between failed sys_open 310 * and bad superblock on root device. 311 */ 312 #ifdef CONFIG_BLOCK 313 __bdevname(ROOT_DEV, b); 314 #endif 315 printk("VFS: Cannot open root device \"%s\" or %s\n", 316 root_device_name, b); 317 printk("Please append a correct \"root=\" boot option\n"); 318 319 panic("VFS: Unable to mount root fs on %s", b); 320 } 321 322 printk("No filesystem could mount root, tried: "); 323 for (p = fs_names; *p; p += strlen(p)+1) 324 printk(" %s", p); 325 printk("\n"); 326 #ifdef CONFIG_BLOCK 327 __bdevname(ROOT_DEV, b); 328 #endif 329 panic("VFS: Unable to mount root fs on %s", b); 330 out: 331 putname(fs_names); 332 } 333 334 #ifdef CONFIG_ROOT_NFS 335 static int __init mount_nfs_root(void) 336 { 337 void *data = nfs_root_data(); 338 339 create_dev("/dev/root", ROOT_DEV); 340 if (data && 341 do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0) 342 return 1; 343 return 0; 344 } 345 #endif 346 347 #if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD) 348 void __init change_floppy(char *fmt, ...) 349 { 350 struct termios termios; 351 char buf[80]; 352 char c; 353 int fd; 354 va_list args; 355 va_start(args, fmt); 356 vsprintf(buf, fmt, args); 357 va_end(args); 358 fd = sys_open("/dev/root", O_RDWR | O_NDELAY, 0); 359 if (fd >= 0) { 360 sys_ioctl(fd, FDEJECT, 0); 361 sys_close(fd); 362 } 363 printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf); 364 fd = sys_open("/dev/console", O_RDWR, 0); 365 if (fd >= 0) { 366 sys_ioctl(fd, TCGETS, (long)&termios); 367 termios.c_lflag &= ~ICANON; 368 sys_ioctl(fd, TCSETSF, (long)&termios); 369 sys_read(fd, &c, 1); 370 termios.c_lflag |= ICANON; 371 sys_ioctl(fd, TCSETSF, (long)&termios); 372 sys_close(fd); 373 } 374 } 375 #endif 376 377 void __init mount_root(void) 378 { 379 #ifdef CONFIG_ROOT_NFS 380 if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) { 381 if (mount_nfs_root()) 382 return; 383 384 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n"); 385 ROOT_DEV = Root_FD0; 386 } 387 #endif 388 #ifdef CONFIG_BLK_DEV_FD 389 if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) { 390 /* rd_doload is 2 for a dual initrd/ramload setup */ 391 if (rd_doload==2) { 392 if (rd_load_disk(1)) { 393 ROOT_DEV = Root_RAM1; 394 root_device_name = NULL; 395 } 396 } else 397 change_floppy("root floppy"); 398 } 399 #endif 400 #ifdef CONFIG_BLOCK 401 create_dev("/dev/root", ROOT_DEV); 402 mount_block_root("/dev/root", root_mountflags); 403 #endif 404 } 405 406 /* 407 * Prepare the namespace - decide what/where to mount, load ramdisks, etc. 408 */ 409 void __init prepare_namespace(void) 410 { 411 int is_floppy; 412 413 if (root_delay) { 414 printk(KERN_INFO "Waiting %dsec before mounting root device...\n", 415 root_delay); 416 ssleep(root_delay); 417 } 418 419 /* wait for the known devices to complete their probing */ 420 while (driver_probe_done() != 0) 421 msleep(100); 422 423 md_run_setup(); 424 425 if (saved_root_name[0]) { 426 root_device_name = saved_root_name; 427 if (!strncmp(root_device_name, "mtd", 3)) { 428 mount_block_root(root_device_name, root_mountflags); 429 goto out; 430 } 431 ROOT_DEV = name_to_dev_t(root_device_name); 432 if (strncmp(root_device_name, "/dev/", 5) == 0) 433 root_device_name += 5; 434 } 435 436 is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR; 437 438 if (initrd_load()) 439 goto out; 440 441 if (is_floppy && rd_doload && rd_load_disk(0)) 442 ROOT_DEV = Root_RAM0; 443 444 mount_root(); 445 out: 446 sys_mount(".", "/", NULL, MS_MOVE, NULL); 447 sys_chroot("."); 448 security_sb_post_mountroot(); 449 } 450 451