1#define __KERNEL_SYSCALLS__
2#include <linux/config.h>
3#include <linux/slab.h>
4#include <linux/devfs_fs_kernel.h>
5#include <linux/unistd.h>
6#include <linux/ctype.h>
7#include <linux/blk.h>
8#include <linux/fd.h>
9#include <linux/tty.h>
10#include <linux/init.h>
11
12#include <linux/nfs_fs.h>
13#include <linux/nfs_fs_sb.h>
14#include <linux/nfs_mount.h>
15#include <linux/minix_fs.h>
16#include <linux/ext2_fs.h>
17#include <linux/romfs_fs.h>
18
19#define BUILD_CRAMDISK
20
21extern int get_filesystem_list(char * buf);
22
23extern asmlinkage long sys_mount(char *dev_name, char *dir_name, char *type,
24 unsigned long flags, void *data);
25extern asmlinkage long sys_mkdir(const char *name, int mode);
26extern asmlinkage long sys_chdir(const char *name);
27extern asmlinkage long sys_fchdir(int fd);
28extern asmlinkage long sys_chroot(const char *name);
29extern asmlinkage long sys_unlink(const char *name);
30extern asmlinkage long sys_symlink(const char *old, const char *new);
31extern asmlinkage long sys_mknod(const char *name, int mode, dev_t dev);
32extern asmlinkage long sys_umount(char *name, int flags);
33extern asmlinkage long sys_ioctl(int fd, int cmd, unsigned long arg);
34
35#ifdef CONFIG_BLK_DEV_INITRD
36unsigned int real_root_dev;
37static int __initdata mount_initrd = 1;
38
39static int __init no_initrd(char *str)
40{
41 mount_initrd = 0;
42 return 1;
43}
44
45__setup("noinitrd", no_initrd);
46#else
47static int __initdata mount_initrd = 0;
48#endif
49
50int __initdata rd_doload;
51
52int root_mountflags = MS_RDONLY | MS_VERBOSE;
53static char root_device_name[64];
54
55
56kdev_t ROOT_DEV;
57
58static int do_devfs = 0;
59
60static int __init load_ramdisk(char *str)
61{
62 rd_doload = simple_strtol(str,NULL,0) & 3;
63 return 1;
64}
65__setup("load_ramdisk=", load_ramdisk);
66
67static int __init readonly(char *str)
68{
69 if (*str)
70 return 0;
71 root_mountflags |= MS_RDONLY;
72 return 1;
73}
74
75static int __init readwrite(char *str)
76{
77 if (*str)
78 return 0;
79 root_mountflags &= ~MS_RDONLY;
80 return 1;
81}
82
83__setup("ro", readonly);
84__setup("rw", readwrite);
85
86static struct dev_name_struct {
87 const char *name;
88 const int num;
89} root_dev_names[] __initdata = {
90 { "nfs", 0x00ff },
91 { "hda", 0x0300 },
92 { "hdb", 0x0340 },
93 { "loop", 0x0700 },
94 { "hdc", 0x1600 },
95 { "hdd", 0x1640 },
96 { "hde", 0x2100 },
97 { "hdf", 0x2140 },
98 { "hdg", 0x2200 },
99 { "hdh", 0x2240 },
100 { "hdi", 0x3800 },
101 { "hdj", 0x3840 },
102 { "hdk", 0x3900 },
103 { "hdl", 0x3940 },
104 { "hdm", 0x5800 },
105 { "hdn", 0x5840 },
106 { "hdo", 0x5900 },
107 { "hdp", 0x5940 },
108 { "hdq", 0x5A00 },
109 { "hdr", 0x5A40 },
110 { "hds", 0x5B00 },
111 { "hdt", 0x5B40 },
112 { "sda", 0x0800 },
113 { "sdb", 0x0810 },
114 { "sdc", 0x0820 },
115 { "sdd", 0x0830 },
116 { "sde", 0x0840 },
117 { "sdf", 0x0850 },
118 { "sdg", 0x0860 },
119 { "sdh", 0x0870 },
120 { "sdi", 0x0880 },
121 { "sdj", 0x0890 },
122 { "sdk", 0x08a0 },
123 { "sdl", 0x08b0 },
124 { "sdm", 0x08c0 },
125 { "sdn", 0x08d0 },
126 { "sdo", 0x08e0 },
127 { "sdp", 0x08f0 },
128 { "ada", 0x1c00 },
129 { "adb", 0x1c10 },
130 { "adc", 0x1c20 },
131 { "add", 0x1c30 },
132 { "ade", 0x1c40 },
133 { "fd", 0x0200 },
134 { "md", 0x0900 },
135 { "xda", 0x0d00 },
136 { "xdb", 0x0d40 },
137 { "ram", 0x0100 },
138 { "scd", 0x0b00 },
139 { "mcd", 0x1700 },
140 { "cdu535", 0x1800 },
141 { "sonycd", 0x1800 },
142 { "aztcd", 0x1d00 },
143 { "cm206cd", 0x2000 },
144 { "gscd", 0x1000 },
145 { "sbpcd", 0x1900 },
146 { "eda", 0x2400 },
147 { "edb", 0x2440 },
148 { "pda", 0x2d00 },
149 { "pdb", 0x2d10 },
150 { "pdc", 0x2d20 },
151 { "pdd", 0x2d30 },
152 { "pcd", 0x2e00 },
153 { "pf", 0x2f00 },
154 { "apblock", APBLOCK_MAJOR << 8},
155 { "ddv", DDV_MAJOR << 8},
156 { "jsfd", JSFD_MAJOR << 8},
157#if defined(CONFIG_ARCH_S390)
158 { "dasda", (DASD_MAJOR << MINORBITS) },
159 { "dasdb", (DASD_MAJOR << MINORBITS) + (1 << 2) },
160 { "dasdc", (DASD_MAJOR << MINORBITS) + (2 << 2) },
161 { "dasdd", (DASD_MAJOR << MINORBITS) + (3 << 2) },
162 { "dasde", (DASD_MAJOR << MINORBITS) + (4 << 2) },
163 { "dasdf", (DASD_MAJOR << MINORBITS) + (5 << 2) },
164 { "dasdg", (DASD_MAJOR << MINORBITS) + (6 << 2) },
165 { "dasdh", (DASD_MAJOR << MINORBITS) + (7 << 2) },
166#endif
167#if defined(CONFIG_BLK_CPQ_DA) || defined(CONFIG_BLK_CPQ_DA_MODULE)
168 { "ida/c0d0p",0x4800 },
169 { "ida/c0d1p",0x4810 },
170 { "ida/c0d2p",0x4820 },
171 { "ida/c0d3p",0x4830 },
172 { "ida/c0d4p",0x4840 },
173 { "ida/c0d5p",0x4850 },
174 { "ida/c0d6p",0x4860 },
175 { "ida/c0d7p",0x4870 },
176 { "ida/c0d8p",0x4880 },
177 { "ida/c0d9p",0x4890 },
178 { "ida/c0d10p",0x48A0 },
179 { "ida/c0d11p",0x48B0 },
180 { "ida/c0d12p",0x48C0 },
181 { "ida/c0d13p",0x48D0 },
182 { "ida/c0d14p",0x48E0 },
183 { "ida/c0d15p",0x48F0 },
184 { "ida/c1d0p",0x4900 },
185 { "ida/c2d0p",0x4A00 },
186 { "ida/c3d0p",0x4B00 },
187 { "ida/c4d0p",0x4C00 },
188 { "ida/c5d0p",0x4D00 },
189 { "ida/c6d0p",0x4E00 },
190 { "ida/c7d0p",0x4F00 },
191#endif
192#if defined(CONFIG_BLK_CPQ_CISS_DA) || defined(CONFIG_BLK_CPQ_CISS_DA_MODULE)
193 { "cciss/c0d0p",0x6800 },
194 { "cciss/c0d1p",0x6810 },
195 { "cciss/c0d2p",0x6820 },
196 { "cciss/c0d3p",0x6830 },
197 { "cciss/c0d4p",0x6840 },
198 { "cciss/c0d5p",0x6850 },
199 { "cciss/c0d6p",0x6860 },
200 { "cciss/c0d7p",0x6870 },
201 { "cciss/c0d8p",0x6880 },
202 { "cciss/c0d9p",0x6890 },
203 { "cciss/c0d10p",0x68A0 },
204 { "cciss/c0d11p",0x68B0 },
205 { "cciss/c0d12p",0x68C0 },
206 { "cciss/c0d13p",0x68D0 },
207 { "cciss/c0d14p",0x68E0 },
208 { "cciss/c0d15p",0x68F0 },
209 { "cciss/c1d0p",0x6900 },
210 { "cciss/c2d0p",0x6A00 },
211 { "cciss/c3d0p",0x6B00 },
212 { "cciss/c4d0p",0x6C00 },
213 { "cciss/c5d0p",0x6D00 },
214 { "cciss/c6d0p",0x6E00 },
215 { "cciss/c7d0p",0x6F00 },
216#endif
217 { "ataraid/d0p",0x7200 },
218 { "ataraid/d1p",0x7210 },
219 { "ataraid/d2p",0x7220 },
220 { "ataraid/d3p",0x7230 },
221 { "ataraid/d4p",0x7240 },
222 { "ataraid/d5p",0x7250 },
223 { "ataraid/d6p",0x7260 },
224 { "ataraid/d7p",0x7270 },
225 { "ataraid/d8p",0x7280 },
226 { "ataraid/d9p",0x7290 },
227 { "ataraid/d10p",0x72A0 },
228 { "ataraid/d11p",0x72B0 },
229 { "ataraid/d12p",0x72C0 },
230 { "ataraid/d13p",0x72D0 },
231 { "ataraid/d14p",0x72E0 },
232 { "ataraid/d15p",0x72F0 },
233 { "nftla", 0x5d00 },
234 { "nftlb", 0x5d10 },
235 { "nftlc", 0x5d20 },
236 { "nftld", 0x5d30 },
237 { "ftla", 0x2c00 },
238 { "ftlb", 0x2c08 },
239 { "ftlc", 0x2c10 },
240 { "ftld", 0x2c18 },
241 { "mtdblock", 0x1f00 },
242 { NULL, 0 }
243};
244
245kdev_t __init name_to_kdev_t(char *line)
246{
247 int base = 0, offs;
248 char *end;
249
250 if (strncmp(line,"/dev/",5) == 0) {
251 struct dev_name_struct *dev = root_dev_names;
252 line += 5;
253 do {
254 int len = strlen(dev->name);
255 if (strncmp(line,dev->name,len) == 0) {
256 line += len;
257 base = dev->num;
258 break;
259 }
260 dev++;
261 } while (dev->name);
262 }
263 offs = simple_strtoul(line, &end, base?10:16);
264 if (*end)
265 offs = 0;
266 return to_kdev_t(base + offs);
267}
268
269static int __init root_dev_setup(char *line)
270{
271 int i;
272 char ch;
273
274 ROOT_DEV = name_to_kdev_t(line);
275 memset (root_device_name, 0, sizeof root_device_name);
276 if (strncmp (line, "/dev/", 5) == 0) line += 5;
277 for (i = 0; i < sizeof root_device_name - 1; ++i)
278 {
279 ch = line[i];
280 if ( isspace (ch) || (ch == ',') || (ch == '\0') ) break;
281 root_device_name[i] = ch;
282 }
283 return 1;
284}
285
286__setup("root=", root_dev_setup);
287
288static char * __initdata root_mount_data;
289static int __init root_data_setup(char *str)
290{
291 root_mount_data = str;
292 return 1;
293}
294
295static char * __initdata root_fs_names;
296static int __init fs_names_setup(char *str)
297{
298 root_fs_names = str;
299 return 1;
300}
301
302__setup("rootflags=", root_data_setup);
303__setup("rootfstype=", fs_names_setup);
304
305static void __init get_fs_names(char *page)
306{
307 char *s = page;
308
309 if (root_fs_names) {
310 strcpy(page, root_fs_names);
311 while (*s++) {
312 if (s[-1] == ',')
313 s[-1] = '\0';
314 }
315 } else {
316 int len = get_filesystem_list(page);
317 char *p, *next;
318
319 page[len] = '\0';
320 for (p = page-1; p; p = next) {
321 next = strchr(++p, '\n');
322 if (*p++ != '\t')
323 continue;
324 while ((*s++ = *p++) != '\n')
325 ;
326 s[-1] = '\0';
327 }
328 }
329 *s = '\0';
330}
331static void __init mount_block_root(char *name, int flags)
332{
333 char *fs_names = __getname();
334 char *p;
335
336 get_fs_names(fs_names);
337retry:
338 for (p = fs_names; *p; p += strlen(p)+1) {
339 int err = sys_mount(name, "/root", p, flags, root_mount_data);
340 switch (err) {
341 case 0:
342 goto out;
343 case -EACCES:
344 flags |= MS_RDONLY;
345 goto retry;
346 case -EINVAL:
347 continue;
348 }
349
350
351
352
353 printk ("VFS: Cannot open root device \"%s\" or %s\n",
354 root_device_name, kdevname (ROOT_DEV));
355 printk ("Please append a correct \"root=\" boot option\n");
356 panic("VFS: Unable to mount root fs on %s",
357 kdevname(ROOT_DEV));
358 }
359 panic("VFS: Unable to mount root fs on %s", kdevname(ROOT_DEV));
360out:
361 putname(fs_names);
362 sys_chdir("/root");
363 ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev;
364 printk("VFS: Mounted root (%s filesystem)%s.\n",
365 current->fs->pwdmnt->mnt_sb->s_type->name,
366 (current->fs->pwdmnt->mnt_sb->s_flags & MS_RDONLY) ? " readonly" : "");
367}
368
369#ifdef CONFIG_ROOT_NFS
370static int __init mount_nfs_root(void)
371{
372 void *data = nfs_root_data();
373
374 if (data && sys_mount("/dev/root","/root","nfs",root_mountflags,data) == 0)
375 return 1;
376 return 0;
377}
378#endif
379
380static int __init create_dev(char *name, kdev_t dev, char *devfs_name)
381{
382 void *handle;
383 char path[64];
384 int n;
385
386 sys_unlink(name);
387 if (!do_devfs)
388 return sys_mknod(name, S_IFBLK|0600, kdev_t_to_nr(dev));
389
390 handle = devfs_find_handle(NULL, dev ? NULL : devfs_name,
391 MAJOR(dev), MINOR(dev), DEVFS_SPECIAL_BLK, 1);
392 if (!handle)
393 return -1;
394 n = devfs_generate_path(handle, path + 5, sizeof (path) - 5);
395 if (n < 0)
396 return -1;
397 return sys_symlink(path + n + 5, name);
398}
399
400#if defined(CONFIG_BLK_DEV_RAM) || defined(CONFIG_BLK_DEV_FD)
401static void __init change_floppy(char *fmt, ...)
402{
403 struct termios termios;
404 char buf[80];
405 char c;
406 int fd;
407 va_list args;
408 va_start(args, fmt);
409 vsprintf(buf, fmt, args);
410 va_end(args);
411 fd = open("/dev/root", O_RDWR | O_NDELAY, 0);
412 if (fd >= 0) {
413 sys_ioctl(fd, FDEJECT, 0);
414 close(fd);
415 }
416 printk(KERN_NOTICE "VFS: Insert %s and press ENTER\n", buf);
417 fd = open("/dev/console", O_RDWR, 0);
418 if (fd >= 0) {
419 sys_ioctl(fd, TCGETS, (long)&termios);
420 termios.c_lflag &= ~ICANON;
421 sys_ioctl(fd, TCSETSF, (long)&termios);
422 read(fd, &c, 1);
423 termios.c_lflag |= ICANON;
424 sys_ioctl(fd, TCSETSF, (long)&termios);
425 close(fd);
426 }
427}
428#endif
429
430#ifdef CONFIG_BLK_DEV_RAM
431
432int __initdata rd_prompt = 1;
433
434static int __init prompt_ramdisk(char *str)
435{
436 rd_prompt = simple_strtol(str,NULL,0) & 1;
437 return 1;
438}
439__setup("prompt_ramdisk=", prompt_ramdisk);
440
441int __initdata rd_image_start;
442
443static int __init ramdisk_start_setup(char *str)
444{
445 rd_image_start = simple_strtol(str,NULL,0);
446 return 1;
447}
448__setup("ramdisk_start=", ramdisk_start_setup);
449
450static int __init crd_load(int in_fd, int out_fd);
451
452
453
454
455
456
457
458
459
460
461
462
463
464static int __init
465identify_ramdisk_image(int fd, int start_block)
466{
467 const int size = 512;
468 struct minix_super_block *minixsb;
469 struct ext2_super_block *ext2sb;
470 struct romfs_super_block *romfsb;
471 int nblocks = -1;
472 unsigned char *buf;
473
474 buf = kmalloc(size, GFP_KERNEL);
475 if (buf == 0)
476 return -1;
477
478 minixsb = (struct minix_super_block *) buf;
479 ext2sb = (struct ext2_super_block *) buf;
480 romfsb = (struct romfs_super_block *) buf;
481 memset(buf, 0xe5, size);
482
483
484
485
486 lseek(fd, start_block * BLOCK_SIZE, 0);
487 read(fd, buf, size);
488
489
490
491
492 if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
493 printk(KERN_NOTICE
494 "RAMDISK: Compressed image found at block %d\n",
495 start_block);
496 nblocks = 0;
497 goto done;
498 }
499
500
501 if (romfsb->word0 == ROMSB_WORD0 &&
502 romfsb->word1 == ROMSB_WORD1) {
503 printk(KERN_NOTICE
504 "RAMDISK: romfs filesystem found at block %d\n",
505 start_block);
506 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
507 goto done;
508 }
509
510
511
512
513 lseek(fd, (start_block+1) * BLOCK_SIZE, 0);
514 read(fd, buf, size);
515
516
517 if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
518 minixsb->s_magic == MINIX_SUPER_MAGIC2) {
519 printk(KERN_NOTICE
520 "RAMDISK: Minix filesystem found at block %d\n",
521 start_block);
522 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
523 goto done;
524 }
525
526
527 if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
528 printk(KERN_NOTICE
529 "RAMDISK: ext2 filesystem found at block %d\n",
530 start_block);
531 nblocks = le32_to_cpu(ext2sb->s_blocks_count);
532 goto done;
533 }
534
535 printk(KERN_NOTICE
536 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
537 start_block);
538
539done:
540 lseek(fd, start_block * BLOCK_SIZE, 0);
541 kfree(buf);
542 return nblocks;
543}
544#endif
545
546static int __init rd_load_image(char *from)
547{
548 int res = 0;
549
550#ifdef CONFIG_BLK_DEV_RAM
551 int in_fd, out_fd;
552 unsigned long rd_blocks, devblocks;
553 int nblocks, i;
554 char *buf;
555 unsigned short rotate = 0;
556#if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
557 char rotator[4] = { '|' , '/' , '-' , '\\' };
558#endif
559
560 out_fd = open("/dev/ram", O_RDWR, 0);
561 if (out_fd < 0)
562 goto out;
563
564 in_fd = open(from, O_RDONLY, 0);
565 if (in_fd < 0)
566 goto noclose_input;
567
568 nblocks = identify_ramdisk_image(in_fd, rd_image_start);
569 if (nblocks < 0)
570 goto done;
571
572 if (nblocks == 0) {
573#ifdef BUILD_CRAMDISK
574 if (crd_load(in_fd, out_fd) == 0)
575 goto successful_load;
576#else
577 printk(KERN_NOTICE
578 "RAMDISK: Kernel does not support compressed "
579 "RAM disk images\n");
580#endif
581 goto done;
582 }
583
584
585
586
587
588
589
590 if (sys_ioctl(out_fd, BLKGETSIZE, (unsigned long)&rd_blocks) < 0)
591 rd_blocks = 0;
592 else
593 rd_blocks >>= 1;
594
595 if (nblocks > rd_blocks) {
596 printk("RAMDISK: image too big! (%d/%d blocks)\n",
597 nblocks, rd_blocks);
598 goto done;
599 }
600
601
602
603
604 buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
605 if (buf == 0) {
606 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
607 goto done;
608 }
609
610 if (sys_ioctl(in_fd, BLKGETSIZE, (unsigned long)&devblocks) < 0)
611 devblocks = 0;
612 else
613 devblocks >>= 1;
614
615 if (strcmp(from, "/dev/initrd") == 0)
616 devblocks = nblocks;
617
618 if (devblocks == 0) {
619 printk(KERN_ERR "RAMDISK: could not determine device size\n");
620 goto done;
621 }
622
623 printk(KERN_NOTICE "RAMDISK: Loading %d blocks [%d disk%s] into ram disk... ",
624 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
625 for (i=0; i < nblocks; i++) {
626 if (i && (i % devblocks == 0)) {
627 printk("done disk #%d.\n", i/devblocks);
628 rotate = 0;
629 if (close(in_fd)) {
630 printk("Error closing the disk.\n");
631 goto noclose_input;
632 }
633 change_floppy("disk #%d", i/devblocks+1);
634 in_fd = open(from, O_RDONLY, 0);
635 if (in_fd < 0) {
636 printk("Error opening disk.\n");
637 goto noclose_input;
638 }
639 printk("Loading disk #%d... ", i/devblocks+1);
640 }
641 read(in_fd, buf, BLOCK_SIZE);
642 write(out_fd, buf, BLOCK_SIZE);
643#if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
644 if (!(i % 16)) {
645 printk("%c\b", rotator[rotate & 0x3]);
646 rotate++;
647 }
648#endif
649 }
650 printk("done.\n");
651 kfree(buf);
652
653successful_load:
654 res = 1;
655done:
656 close(in_fd);
657noclose_input:
658 close(out_fd);
659out:
660 sys_unlink("/dev/ram");
661#endif
662 return res;
663}
664
665static int __init rd_load_disk(int n)
666{
667#ifdef CONFIG_BLK_DEV_RAM
668 if (rd_prompt)
669 change_floppy("root floppy disk to be loaded into RAM disk");
670 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n), NULL);
671#endif
672 return rd_load_image("/dev/root");
673}
674
675#ifdef CONFIG_DEVFS_FS
676
677static void __init convert_name(char *prefix, char *name, char *p, int part)
678{
679 int host, bus, target, lun;
680 char dest[64];
681 char src[64];
682 char *base = p - 1;
683
684
685 if (*p++ != 'c')
686 return;
687 host = simple_strtol(p, &p, 10);
688 if (*p++ != 'b')
689 return;
690 bus = simple_strtol(p, &p, 10);
691 if (*p++ != 't')
692 return;
693 target = simple_strtol(p, &p, 10);
694 if (*p++ != 'u')
695 return;
696 lun = simple_strtol(p, &p, 10);
697 if (!part)
698 sprintf(dest, "%s/host%d/bus%d/target%d/lun%d",
699 prefix, host, bus, target, lun);
700 else if (*p++ == 'p')
701 sprintf(dest, "%s/host%d/bus%d/target%d/lun%d/part%s",
702 prefix, host, bus, target, lun, p);
703 else
704 sprintf(dest, "%s/host%d/bus%d/target%d/lun%d/disc",
705 prefix, host, bus, target, lun);
706 *base = '\0';
707 sprintf(src, "/dev/%s", name);
708 sys_mkdir(src, 0755);
709 *base = '/';
710 sprintf(src, "/dev/%s", name);
711 sys_symlink(dest, src);
712}
713
714static void __init devfs_make_root(char *name)
715{
716
717 if (!strncmp(name, "sd/", 3))
718 convert_name("../scsi", name, name+3, 1);
719 else if (!strncmp(name, "sr/", 3))
720 convert_name("../scsi", name, name+3, 0);
721 else if (!strncmp(name, "ide/hd/", 7))
722 convert_name("..", name, name + 7, 1);
723 else if (!strncmp(name, "ide/cd/", 7))
724 convert_name("..", name, name + 7, 0);
725}
726#else
727static void __init devfs_make_root(char *name)
728{
729}
730#endif
731
732static void __init mount_root(void)
733{
734#ifdef CONFIG_ROOT_NFS
735 if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) {
736 if (mount_nfs_root()) {
737 sys_chdir("/root");
738 ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev;
739 printk("VFS: Mounted root (nfs filesystem).\n");
740 return;
741 }
742 printk(KERN_ERR "VFS: Unable to mount root fs via NFS, trying floppy.\n");
743 ROOT_DEV = MKDEV(FLOPPY_MAJOR, 0);
744 }
745#endif
746 devfs_make_root(root_device_name);
747 create_dev("/dev/root", ROOT_DEV, root_device_name);
748#ifdef CONFIG_BLK_DEV_FD
749 if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
750
751 if (rd_doload==2) {
752 if (rd_load_disk(1)) {
753 ROOT_DEV = MKDEV(RAMDISK_MAJOR, 1);
754 create_dev("/dev/root", ROOT_DEV, NULL);
755 }
756 } else
757 change_floppy("root floppy");
758 }
759#endif
760 mount_block_root("/dev/root", root_mountflags);
761}
762
763#ifdef CONFIG_BLK_DEV_INITRD
764static int old_fd, root_fd;
765static int do_linuxrc(void * shell)
766{
767 static char *argv[] = { "linuxrc", NULL, };
768 extern char * envp_init[];
769
770 close(old_fd);
771 close(root_fd);
772 close(0);
773 close(1);
774 close(2);
775 setsid();
776 (void) open("/dev/console",O_RDWR,0);
777 (void) dup(0);
778 (void) dup(0);
779 return execve(shell, argv, envp_init);
780}
781
782#endif
783
784static void __init handle_initrd(void)
785{
786#ifdef CONFIG_BLK_DEV_INITRD
787 int ram0 = kdev_t_to_nr(MKDEV(RAMDISK_MAJOR,0));
788 int error;
789 int i, pid;
790
791 create_dev("/dev/root.old", ram0, NULL);
792
793 mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
794 sys_mkdir("/old", 0700);
795 root_fd = open("/", 0, 0);
796 old_fd = open("/old", 0, 0);
797
798 sys_chdir("/root");
799 sys_mount(".", "/", NULL, MS_MOVE, NULL);
800 sys_chroot(".");
801 mount_devfs_fs ();
802
803 pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
804 if (pid > 0) {
805 while (pid != wait(&i))
806 yield();
807 }
808
809
810 sys_fchdir(old_fd);
811 sys_mount("/", ".", NULL, MS_MOVE, NULL);
812
813 sys_fchdir(root_fd);
814 sys_chroot(".");
815 sys_umount("/old/dev", 0);
816
817 if (real_root_dev == ram0) {
818 sys_chdir("/old");
819 return;
820 }
821
822 ROOT_DEV = real_root_dev;
823 mount_root();
824
825 printk(KERN_NOTICE "Trying to move old root to /initrd ... ");
826 error = sys_mount("/old", "/root/initrd", NULL, MS_MOVE, NULL);
827 if (!error)
828 printk("okay\n");
829 else {
830 int fd = open("/dev/root.old", O_RDWR, 0);
831 printk("failed\n");
832 printk(KERN_NOTICE "Unmounting old root\n");
833 sys_umount("/old", MNT_DETACH);
834 printk(KERN_NOTICE "Trying to free ramdisk memory ... ");
835 if (fd < 0) {
836 error = fd;
837 } else {
838 error = sys_ioctl(fd, BLKFLSBUF, 0);
839 close(fd);
840 }
841 printk(!error ? "okay\n" : "failed\n");
842 }
843#endif
844}
845
846static int __init initrd_load(void)
847{
848#ifdef CONFIG_BLK_DEV_INITRD
849 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, 0), NULL);
850 create_dev("/dev/initrd", MKDEV(RAMDISK_MAJOR, INITRD_MINOR), NULL);
851#endif
852 return rd_load_image("/dev/initrd");
853}
854
855
856
857
858void prepare_namespace(void)
859{
860 int is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;
861#ifdef CONFIG_ALL_PPC
862 extern void arch_discover_root(void);
863 arch_discover_root();
864#endif
865#ifdef CONFIG_BLK_DEV_INITRD
866 if (!initrd_start)
867 mount_initrd = 0;
868 real_root_dev = ROOT_DEV;
869#endif
870 sys_mkdir("/dev", 0700);
871 sys_mkdir("/root", 0700);
872 sys_mknod("/dev/console", S_IFCHR|0600, MKDEV(TTYAUX_MAJOR, 1));
873#ifdef CONFIG_DEVFS_FS
874 sys_mount("devfs", "/dev", "devfs", 0, NULL);
875 do_devfs = 1;
876#endif
877
878 create_dev("/dev/root", ROOT_DEV, NULL);
879 if (mount_initrd) {
880 if (initrd_load() && ROOT_DEV != MKDEV(RAMDISK_MAJOR, 0)) {
881 handle_initrd();
882 goto out;
883 }
884 } else if (is_floppy && rd_doload && rd_load_disk(0))
885 ROOT_DEV = MKDEV(RAMDISK_MAJOR, 0);
886 mount_root();
887out:
888 sys_umount("/dev", 0);
889 sys_mount(".", "/", NULL, MS_MOVE, NULL);
890 sys_chroot(".");
891 mount_devfs_fs ();
892}
893
894#if defined(BUILD_CRAMDISK) && defined(CONFIG_BLK_DEV_RAM)
895
896
897
898
899
900#define OF(args) args
901
902#ifndef memzero
903#define memzero(s, n) memset ((s), 0, (n))
904#endif
905
906typedef unsigned char uch;
907typedef unsigned short ush;
908typedef unsigned long ulg;
909
910#define INBUFSIZ 4096
911#define WSIZE 0x8000
912
913
914static uch *inbuf;
915static uch *window;
916
917static unsigned insize;
918static unsigned inptr;
919static unsigned outcnt;
920static int exit_code;
921static long bytes_out;
922static int crd_infd, crd_outfd;
923
924#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
925
926
927#define Assert(cond,msg)
928#define Trace(x)
929#define Tracev(x)
930#define Tracevv(x)
931#define Tracec(c,x)
932#define Tracecv(c,x)
933
934#define STATIC static
935
936static int fill_inbuf(void);
937static void flush_window(void);
938static void *malloc(int size);
939static void free(void *where);
940static void error(char *m);
941static void gzip_mark(void **);
942static void gzip_release(void **);
943
944#include "../lib/inflate.c"
945
946static void __init *malloc(int size)
947{
948 return kmalloc(size, GFP_KERNEL);
949}
950
951static void __init free(void *where)
952{
953 kfree(where);
954}
955
956static void __init gzip_mark(void **ptr)
957{
958}
959
960static void __init gzip_release(void **ptr)
961{
962}
963
964
965
966
967
968
969static int __init fill_inbuf(void)
970{
971 if (exit_code) return -1;
972
973 insize = read(crd_infd, inbuf, INBUFSIZ);
974 if (insize == 0) return -1;
975
976 inptr = 1;
977
978 return inbuf[0];
979}
980
981
982
983
984
985static void __init flush_window(void)
986{
987 ulg c = crc;
988 unsigned n;
989 uch *in, ch;
990
991 write(crd_outfd, window, outcnt);
992 in = window;
993 for (n = 0; n < outcnt; n++) {
994 ch = *in++;
995 c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
996 }
997 crc = c;
998 bytes_out += (ulg)outcnt;
999 outcnt = 0;
1000}
1001
1002static void __init error(char *x)
1003{
1004 printk(KERN_ERR "%s", x);
1005 exit_code = 1;
1006}
1007
1008static int __init crd_load(int in_fd, int out_fd)
1009{
1010 int result;
1011
1012 insize = 0;
1013 inptr = 0;
1014 outcnt = 0;
1015 exit_code = 0;
1016 bytes_out = 0;
1017 crc = (ulg)0xffffffffL;
1018
1019 crd_infd = in_fd;
1020 crd_outfd = out_fd;
1021 inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
1022 if (inbuf == 0) {
1023 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
1024 return -1;
1025 }
1026 window = kmalloc(WSIZE, GFP_KERNEL);
1027 if (window == 0) {
1028 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
1029 kfree(inbuf);
1030 return -1;
1031 }
1032 makecrc();
1033 result = gunzip();
1034 kfree(inbuf);
1035 kfree(window);
1036 return result;
1037}
1038
1039#endif
1040
