1 /*
2 * ramdisk.c - Multiple RAM disk driver - gzip-loading version - v. 0.8 beta.
3 *
4 * (C) Chad Page, Theodore Ts'o, et. al, 1995.
5 *
6 * This RAM disk is designed to have filesystems created on it and mounted
7 * just like a regular floppy disk.
8 *
9 * It also does something suggested by Linus: use the buffer cache as the
10 * RAM disk data. This makes it possible to dynamically allocate the RAM disk
11 * buffer - with some consequences I have to deal with as I write this.
12 *
13 * This code is based on the original ramdisk.c, written mostly by
14 * Theodore Ts'o (TYT) in 1991. The code was largely rewritten by
15 * Chad Page to use the buffer cache to store the RAM disk data in
16 * 1995; Theodore then took over the driver again, and cleaned it up
17 * for inclusion in the mainline kernel.
18 *
19 * The original CRAMDISK code was written by Richard Lyons, and
20 * adapted by Chad Page to use the new RAM disk interface. Theodore
21 * Ts'o rewrote it so that both the compressed RAM disk loader and the
22 * kernel decompressor uses the same inflate.c codebase. The RAM disk
23 * loader now also loads into a dynamic (buffer cache based) RAM disk,
24 * not the old static RAM disk. Support for the old static RAM disk has
25 * been completely removed.
26 *
27 * Loadable module support added by Tom Dyas.
28 *
29 * Further cleanups by Chad Page (page0588@sundance.sjsu.edu):
30 * Cosmetic changes in #ifdef MODULE, code movement, etc.
31 * When the RAM disk module is removed, free the protected buffers
32 * Default RAM disk size changed to 2.88 MB
33 *
34 * Added initrd: Werner Almesberger & Hans Lermen, Feb '96
35 *
36 * 4/25/96 : Made RAM disk size a parameter (default is now 4 MB)
37 * - Chad Page
38 *
39 * Add support for fs images split across >1 disk, Paul Gortmaker, Mar '98
40 *
41 * Make block size and block size shift for RAM disks a global macro
42 * and set blk_size for -ENOSPC, Werner Fink <werner@suse.de>, Apr '99
43 */
44
45 #include <linux/config.h>
46 #include <linux/sched.h>
47 #include <linux/minix_fs.h>
48 #include <linux/ext2_fs.h>
49 #include <linux/romfs_fs.h>
50 #include <linux/fs.h>
51 #include <linux/kernel.h>
52 #include <linux/hdreg.h>
53 #include <linux/string.h>
54 #include <linux/mm.h>
55 #include <linux/mman.h>
56 #include <linux/malloc.h>
57 #include <linux/ioctl.h>
58 #include <linux/fd.h>
59 #include <linux/module.h>
60 #include <linux/init.h>
61 #include <linux/devfs_fs_kernel.h>
62 #include <linux/smp_lock.h>
63
64 #include <asm/system.h>
65 #include <asm/uaccess.h>
66 #include <asm/byteorder.h>
67
68 extern void wait_for_keypress(void);
69
70 /*
71 * 35 has been officially registered as the RAMDISK major number, but
72 * so is the original MAJOR number of 1. We're using 1 in
73 * include/linux/major.h for now
74 */
75 #define MAJOR_NR RAMDISK_MAJOR
76 #include <linux/blk.h>
77 #include <linux/blkpg.h>
78
79 /* The RAM disk size is now a parameter */
80 #define NUM_RAMDISKS 16 /* This cannot be overridden (yet) */
81
82 #ifndef MODULE
83 /* We don't have to load RAM disks or gunzip them in a module. */
84 #define RD_LOADER
85 #define BUILD_CRAMDISK
86
87 void rd_load(void);
88 static int crd_load(struct file *fp, struct file *outfp);
89
90 #ifdef CONFIG_BLK_DEV_INITRD
91 static int initrd_users;
92 #endif
93 #endif
94
95 /* Various static variables go here. Most are used only in the RAM disk code.
96 */
97
98 static unsigned long rd_length[NUM_RAMDISKS]; /* Size of RAM disks in bytes */
99 static int rd_hardsec[NUM_RAMDISKS]; /* Size of real blocks in bytes */
100 static int rd_blocksizes[NUM_RAMDISKS]; /* Size of 1024 byte blocks :) */
101 static int rd_kbsize[NUM_RAMDISKS]; /* Size in blocks of 1024 bytes */
102 static devfs_handle_t devfs_handle;
103 static struct inode *rd_inode[NUM_RAMDISKS]; /* Protected device inodes */
104
105 /*
106 * Parameters for the boot-loading of the RAM disk. These are set by
107 * init/main.c (from arguments to the kernel command line) or from the
108 * architecture-specific setup routine (from the stored boot sector
109 * information).
110 */
111 int rd_size = CONFIG_BLK_DEV_RAM_SIZE; /* Size of the RAM disks */
112 /*
113 * It would be very desiderable to have a soft-blocksize (that in the case
114 * of the ramdisk driver is also the hardblocksize ;) of PAGE_SIZE because
115 * doing that we'll achieve a far better MM footprint. Using a rd_blocksize of
116 * BLOCK_SIZE in the worst case we'll make PAGE_SIZE/BLOCK_SIZE buffer-pages
117 * unfreeable. With a rd_blocksize of PAGE_SIZE instead we are sure that only
118 * 1 page will be protected. Depending on the size of the ramdisk you
119 * may want to change the ramdisk blocksize to achieve a better or worse MM
120 * behaviour. The default is still BLOCK_SIZE (needed by rd_load_image that
121 * supposes the filesystem in the image uses a BLOCK_SIZE blocksize).
122 */
123 int rd_blocksize = BLOCK_SIZE; /* blocksize of the RAM disks */
124
125 #ifndef MODULE
126
127 int rd_doload; /* 1 = load RAM disk, 0 = don't load */
128 int rd_prompt = 1; /* 1 = prompt for RAM disk, 0 = don't prompt */
129 int rd_image_start; /* starting block # of image */
130 #ifdef CONFIG_BLK_DEV_INITRD
131 unsigned long initrd_start, initrd_end;
132 int mount_initrd = 1; /* zero if initrd should not be mounted */
133 int initrd_below_start_ok;
134
135 static int __init no_initrd(char *str)
136 {
137 mount_initrd = 0;
138 return 1;
139 }
140
141 __setup("noinitrd", no_initrd);
142
143 #endif
144
145 static int __init ramdisk_start_setup(char *str)
146 {
147 rd_image_start = simple_strtol(str,NULL,0);
148 return 1;
149 }
150
151 static int __init load_ramdisk(char *str)
152 {
153 rd_doload = simple_strtol(str,NULL,0) & 3;
154 return 1;
155 }
156
157 static int __init prompt_ramdisk(char *str)
158 {
159 rd_prompt = simple_strtol(str,NULL,0) & 1;
160 return 1;
161 }
162
163 static int __init ramdisk_size(char *str)
164 {
165 rd_size = simple_strtol(str,NULL,0);
166 return 1;
167 }
168
169 static int __init ramdisk_size2(char *str)
170 {
171 return ramdisk_size(str);
172 }
173
174 static int __init ramdisk_blocksize(char *str)
175 {
176 rd_blocksize = simple_strtol(str,NULL,0);
177 return 1;
178 }
179
180 __setup("ramdisk_start=", ramdisk_start_setup);
181 __setup("load_ramdisk=", load_ramdisk);
182 __setup("prompt_ramdisk=", prompt_ramdisk);
183 __setup("ramdisk=", ramdisk_size);
184 __setup("ramdisk_size=", ramdisk_size2);
185 __setup("ramdisk_blocksize=", ramdisk_blocksize);
186
187 #endif
188
189 /*
190 * Basically, my strategy here is to set up a buffer-head which can't be
191 * deleted, and make that my Ramdisk. If the request is outside of the
192 * allocated size, we must get rid of it...
193 *
194 * 19-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Added devfs support
195 *
196 */
197 static int rd_make_request(request_queue_t * q, int rw, struct buffer_head *sbh)
198 {
199 unsigned int minor;
200 unsigned long offset, len;
201 struct buffer_head *rbh;
202 char *bdata;
203
204
205 minor = MINOR(sbh->b_rdev);
206
207 if (minor >= NUM_RAMDISKS)
208 goto fail;
209
210
211 offset = sbh->b_rsector << 9;
212 len = sbh->b_size;
213
214 if ((offset + len) > rd_length[minor])
215 goto fail;
216
217 if (rw==READA)
218 rw=READ;
219 if ((rw != READ) && (rw != WRITE)) {
220 printk(KERN_INFO "RAMDISK: bad command: %d\n", rw);
221 goto fail;
222 }
223
224 rbh = getblk(sbh->b_rdev, sbh->b_rsector/(sbh->b_size>>9), sbh->b_size);
225 /* I think that it is safe to assume that rbh is not in HighMem, though
226 * sbh might be - NeilBrown
227 */
228 bdata = bh_kmap(sbh);
229 if (rw == READ) {
230 if (sbh != rbh)
231 memcpy(bdata, rbh->b_data, rbh->b_size);
232 } else
233 if (sbh != rbh)
234 memcpy(rbh->b_data, bdata, rbh->b_size);
235 bh_kunmap(sbh);
236 mark_buffer_protected(rbh);
237 brelse(rbh);
238
239 sbh->b_end_io(sbh,1);
240 return 0;
241 fail:
242 sbh->b_end_io(sbh,0);
243 return 0;
244 }
245
246 static int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
247 {
248 unsigned int minor;
249
250 if (!inode || !inode->i_rdev)
251 return -EINVAL;
252
253 minor = MINOR(inode->i_rdev);
254
255 switch (cmd) {
256 case BLKFLSBUF:
257 if (!capable(CAP_SYS_ADMIN))
258 return -EACCES;
259 /* special: we want to release the ramdisk memory,
260 it's not like with the other blockdevices where
261 this ioctl only flushes away the buffer cache. */
262 if ((atomic_read(&inode->i_bdev->bd_openers) > 2))
263 return -EBUSY;
264 destroy_buffers(inode->i_rdev);
265 rd_blocksizes[minor] = 0;
266 break;
267
268 case BLKGETSIZE: /* Return device size */
269 if (!arg) return -EINVAL;
270 return put_user(rd_kbsize[minor] << 1, (long *) arg);
271
272 case BLKROSET:
273 case BLKROGET:
274 case BLKSSZGET:
275 return blk_ioctl(inode->i_rdev, cmd, arg);
276
277 default:
278 return -EINVAL;
279 };
280
281 return 0;
282 }
283
284
285 #ifdef CONFIG_BLK_DEV_INITRD
286
287 static ssize_t initrd_read(struct file *file, char *buf,
288 size_t count, loff_t *ppos)
289 {
290 int left;
291
292 left = initrd_end - initrd_start - *ppos;
293 if (count > left) count = left;
294 if (count == 0) return 0;
295 copy_to_user(buf, (char *)initrd_start + *ppos, count);
296 *ppos += count;
297 return count;
298 }
299
300
301 static int initrd_release(struct inode *inode,struct file *file)
302 {
303 extern void free_initrd_mem(unsigned long, unsigned long);
304
305 lock_kernel();
306 if (!--initrd_users) {
307 blkdev_put(inode->i_bdev, BDEV_FILE);
308 iput(inode);
309 free_initrd_mem(initrd_start, initrd_end);
310 initrd_start = 0;
311 }
312 unlock_kernel();
313 return 0;
314 }
315
316
317 static struct file_operations initrd_fops = {
318 read: initrd_read,
319 release: initrd_release,
320 };
321
322 #endif
323
324
325 static int rd_open(struct inode * inode, struct file * filp)
326 {
327 #ifdef CONFIG_BLK_DEV_INITRD
328 if (DEVICE_NR(inode->i_rdev) == INITRD_MINOR) {
329 if (!initrd_start) return -ENODEV;
330 initrd_users++;
331 filp->f_op = &initrd_fops;
332 return 0;
333 }
334 #endif
335
336 if (DEVICE_NR(inode->i_rdev) >= NUM_RAMDISKS)
337 return -ENXIO;
338
339 /*
340 * Immunize device against invalidate_buffers() and prune_icache().
341 */
342 if (rd_inode[DEVICE_NR(inode->i_rdev)] == NULL) {
343 if (!inode->i_bdev) return -ENXIO;
344 if ((rd_inode[DEVICE_NR(inode->i_rdev)] = igrab(inode)) != NULL)
345 atomic_inc(&rd_inode[DEVICE_NR(inode->i_rdev)]->i_bdev->bd_openers);
346 }
347
348 MOD_INC_USE_COUNT;
349
350 return 0;
351 }
352
353 static int rd_release(struct inode * inode, struct file * filp)
354 {
355 MOD_DEC_USE_COUNT;
356 return 0;
357 }
358
359 static struct block_device_operations fd_fops = {
360 open: rd_open,
361 release: rd_release,
362 ioctl: rd_ioctl,
363 };
364
365 #ifdef MODULE
366 /* Before freeing the module, invalidate all of the protected buffers! */
367 static void __exit rd_cleanup (void)
368 {
369 int i;
370
371 for (i = 0 ; i < NUM_RAMDISKS; i++) {
372 if (rd_inode[i]) {
373 /* withdraw invalidate_buffers() and prune_icache() immunity */
374 atomic_dec(&rd_inode[i]->i_bdev->bd_openers);
375 /* remove stale pointer to module address space */
376 rd_inode[i]->i_bdev->bd_op = NULL;
377 iput(rd_inode[i]);
378 }
379 destroy_buffers(MKDEV(MAJOR_NR, i));
380 }
381
382 devfs_unregister (devfs_handle);
383 unregister_blkdev( MAJOR_NR, "ramdisk" );
384 hardsect_size[MAJOR_NR] = NULL;
385 blksize_size[MAJOR_NR] = NULL;
386 blk_size[MAJOR_NR] = NULL;
387 }
388 #endif
389
390 /* This is the registration and initialization section of the RAM disk driver */
391 int __init rd_init (void)
392 {
393 int i;
394
395 if (rd_blocksize > PAGE_SIZE || rd_blocksize < 512 ||
396 (rd_blocksize & (rd_blocksize-1)))
397 {
398 printk("RAMDISK: wrong blocksize %d, reverting to defaults\n",
399 rd_blocksize);
400 rd_blocksize = BLOCK_SIZE;
401 }
402
403 if (register_blkdev(MAJOR_NR, "ramdisk", &fd_fops)) {
404 printk("RAMDISK: Could not get major %d", MAJOR_NR);
405 return -EIO;
406 }
407
408 blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), &rd_make_request);
409
410 for (i = 0; i < NUM_RAMDISKS; i++) {
411 /* rd_size is given in kB */
412 rd_length[i] = rd_size << 10;
413 rd_hardsec[i] = rd_blocksize;
414 rd_blocksizes[i] = rd_blocksize;
415 rd_kbsize[i] = rd_size;
416 }
417 devfs_handle = devfs_mk_dir (NULL, "rd", NULL);
418 devfs_register_series (devfs_handle, "%u", NUM_RAMDISKS,
419 DEVFS_FL_DEFAULT, MAJOR_NR, 0,
420 S_IFBLK | S_IRUSR | S_IWUSR,
421 &fd_fops, NULL);
422
423 for (i = 0; i < NUM_RAMDISKS; i++)
424 register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &fd_fops, rd_size<<1);
425
426 #ifdef CONFIG_BLK_DEV_INITRD
427 /* We ought to separate initrd operations here */
428 register_disk(NULL, MKDEV(MAJOR_NR,INITRD_MINOR), 1, &fd_fops, rd_size<<1);
429 #endif
430
431 hardsect_size[MAJOR_NR] = rd_hardsec; /* Size of the RAM disk blocks */
432 blksize_size[MAJOR_NR] = rd_blocksizes; /* Avoid set_blocksize() check */
433 blk_size[MAJOR_NR] = rd_kbsize; /* Size of the RAM disk in kB */
434
435 /* rd_size is given in kB */
436 printk("RAMDISK driver initialized: "
437 "%d RAM disks of %dK size %d blocksize\n",
438 NUM_RAMDISKS, rd_size, rd_blocksize);
439
440 return 0;
441 }
442
443 #ifdef MODULE
444 module_init(rd_init);
445 module_exit(rd_cleanup);
446 #endif
447
448 /* loadable module support */
449 MODULE_PARM (rd_size, "1i");
450 MODULE_PARM_DESC(rd_size, "Size of each RAM disk in kbytes.");
451 MODULE_PARM (rd_blocksize, "i");
452 MODULE_PARM_DESC(rd_blocksize, "Blocksize of each RAM disk in bytes.");
453
454 /* End of non-loading portions of the RAM disk driver */
455
456 #ifdef RD_LOADER
457 /*
458 * This routine tries to find a RAM disk image to load, and returns the
459 * number of blocks to read for a non-compressed image, 0 if the image
460 * is a compressed image, and -1 if an image with the right magic
461 * numbers could not be found.
462 *
463 * We currently check for the following magic numbers:
464 * minix
465 * ext2
466 * romfs
467 * gzip
468 */
469 int __init
470 identify_ramdisk_image(kdev_t device, struct file *fp, int start_block)
471 {
472 const int size = 512;
473 struct minix_super_block *minixsb;
474 struct ext2_super_block *ext2sb;
475 struct romfs_super_block *romfsb;
476 int nblocks = -1;
477 unsigned char *buf;
478
479 buf = kmalloc(size, GFP_KERNEL);
480 if (buf == 0)
481 return -1;
482
483 minixsb = (struct minix_super_block *) buf;
484 ext2sb = (struct ext2_super_block *) buf;
485 romfsb = (struct romfs_super_block *) buf;
486 memset(buf, 0xe5, size);
487
488 /*
489 * Read block 0 to test for gzipped kernel
490 */
491 if (fp->f_op->llseek)
492 fp->f_op->llseek(fp, start_block * BLOCK_SIZE, 0);
493 fp->f_pos = start_block * BLOCK_SIZE;
494
495 fp->f_op->read(fp, buf, size, &fp->f_pos);
496
497 /*
498 * If it matches the gzip magic numbers, return -1
499 */
500 if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
501 printk(KERN_NOTICE
502 "RAMDISK: Compressed image found at block %d\n",
503 start_block);
504 nblocks = 0;
505 goto done;
506 }
507
508 /* romfs is at block zero too */
509 if (romfsb->word0 == ROMSB_WORD0 &&
510 romfsb->word1 == ROMSB_WORD1) {
511 printk(KERN_NOTICE
512 "RAMDISK: romfs filesystem found at block %d\n",
513 start_block);
514 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
515 goto done;
516 }
517
518 /*
519 * Read block 1 to test for minix and ext2 superblock
520 */
521 if (fp->f_op->llseek)
522 fp->f_op->llseek(fp, (start_block+1) * BLOCK_SIZE, 0);
523 fp->f_pos = (start_block+1) * BLOCK_SIZE;
524
525 fp->f_op->read(fp, buf, size, &fp->f_pos);
526
527 /* Try minix */
528 if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
529 minixsb->s_magic == MINIX_SUPER_MAGIC2) {
530 printk(KERN_NOTICE
531 "RAMDISK: Minix filesystem found at block %d\n",
532 start_block);
533 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
534 goto done;
535 }
536
537 /* Try ext2 */
538 if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
539 printk(KERN_NOTICE
540 "RAMDISK: ext2 filesystem found at block %d\n",
541 start_block);
542 nblocks = le32_to_cpu(ext2sb->s_blocks_count);
543 goto done;
544 }
545
546 printk(KERN_NOTICE
547 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
548 start_block);
549
550 done:
551 if (fp->f_op->llseek)
552 fp->f_op->llseek(fp, start_block * BLOCK_SIZE, 0);
553 fp->f_pos = start_block * BLOCK_SIZE;
554
555 kfree(buf);
556 return nblocks;
557 }
558
559 /*
560 * This routine loads in the RAM disk image.
561 */
562 static void __init rd_load_image(kdev_t device, int offset, int unit)
563 {
564 struct inode *inode, *out_inode;
565 struct file infile, outfile;
566 struct dentry in_dentry, out_dentry;
567 mm_segment_t fs;
568 kdev_t ram_device;
569 int nblocks, i;
570 char *buf;
571 unsigned short rotate = 0;
572 unsigned short devblocks = 0;
573 char rotator[4] = { '|' , '/' , '-' , '\\' };
574
575 ram_device = MKDEV(MAJOR_NR, unit);
576
577 if ((inode = get_empty_inode()) == NULL)
578 return;
579 memset(&infile, 0, sizeof(infile));
580 memset(&in_dentry, 0, sizeof(in_dentry));
581 infile.f_mode = 1; /* read only */
582 infile.f_dentry = &in_dentry;
583 in_dentry.d_inode = inode;
584 infile.f_op = &def_blk_fops;
585 init_special_inode(inode, S_IFBLK | S_IRUSR, kdev_t_to_nr(device));
586
587 if ((out_inode = get_empty_inode()) == NULL)
588 goto free_inode;
589 memset(&outfile, 0, sizeof(outfile));
590 memset(&out_dentry, 0, sizeof(out_dentry));
591 outfile.f_mode = 3; /* read/write */
592 outfile.f_dentry = &out_dentry;
593 out_dentry.d_inode = out_inode;
594 outfile.f_op = &def_blk_fops;
595 init_special_inode(out_inode, S_IFBLK | S_IRUSR | S_IWUSR, kdev_t_to_nr(ram_device));
596
597 if (blkdev_open(inode, &infile) != 0)
598 goto free_inode;
599 if (blkdev_open(out_inode, &outfile) != 0)
600 goto free_inodes;
601
602 fs = get_fs();
603 set_fs(KERNEL_DS);
604
605 nblocks = identify_ramdisk_image(device, &infile, offset);
606 if (nblocks < 0)
607 goto done;
608
609 if (nblocks == 0) {
610 #ifdef BUILD_CRAMDISK
611 if (crd_load(&infile, &outfile) == 0)
612 goto successful_load;
613 #else
614 printk(KERN_NOTICE
615 "RAMDISK: Kernel does not support compressed "
616 "RAM disk images\n");
617 #endif
618 goto done;
619 }
620
621 /*
622 * NOTE NOTE: nblocks suppose that the blocksize is BLOCK_SIZE, so
623 * rd_load_image will work only with filesystem BLOCK_SIZE wide!
624 * So make sure to use 1k blocksize while generating ext2fs
625 * ramdisk-images.
626 */
627 if (nblocks > (rd_length[unit] >> BLOCK_SIZE_BITS)) {
628 printk("RAMDISK: image too big! (%d/%ld blocks)\n",
629 nblocks, rd_length[unit] >> BLOCK_SIZE_BITS);
630 goto done;
631 }
632
633 /*
634 * OK, time to copy in the data
635 */
636 buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
637 if (buf == 0) {
638 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
639 goto done;
640 }
641
642 if (blk_size[MAJOR(device)])
643 devblocks = blk_size[MAJOR(device)][MINOR(device)];
644
645 #ifdef CONFIG_BLK_DEV_INITRD
646 if (MAJOR(device) == MAJOR_NR && MINOR(device) == INITRD_MINOR)
647 devblocks = nblocks;
648 #endif
649
650 if (devblocks == 0) {
651 printk(KERN_ERR "RAMDISK: could not determine device size\n");
652 goto done;
653 }
654
655 printk(KERN_NOTICE "RAMDISK: Loading %d blocks [%d disk%s] into ram disk... ",
656 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
657 for (i=0; i < nblocks; i++) {
658 if (i && (i % devblocks == 0)) {
659 printk("done disk #%d.\n", i/devblocks);
660 rotate = 0;
661 invalidate_buffers(device);
662 if (infile.f_op->release)
663 infile.f_op->release(inode, &infile);
664 printk("Please insert disk #%d and press ENTER\n", i/devblocks+1);
665 wait_for_keypress();
666 if (blkdev_open(inode, &infile) != 0) {
667 printk("Error opening disk.\n");
668 goto done;
669 }
670 infile.f_pos = 0;
671 printk("Loading disk #%d... ", i/devblocks+1);
672 }
673 infile.f_op->read(&infile, buf, BLOCK_SIZE, &infile.f_pos);
674 outfile.f_op->write(&outfile, buf, BLOCK_SIZE, &outfile.f_pos);
675 #if !defined(CONFIG_ARCH_S390)
676 if (!(i % 16)) {
677 printk("%c\b", rotator[rotate & 0x3]);
678 rotate++;
679 }
680 #endif
681 }
682 printk("done.\n");
683 kfree(buf);
684
685 successful_load:
686 invalidate_buffers(device);
687 ROOT_DEV = MKDEV(MAJOR_NR, unit);
688 if (ROOT_DEVICE_NAME != NULL) strcpy (ROOT_DEVICE_NAME, "rd/0");
689
690 done:
691 if (infile.f_op->release)
692 infile.f_op->release(inode, &infile);
693 set_fs(fs);
694 return;
695 free_inodes: /* free inodes on error */
696 iput(out_inode);
697 blkdev_put(inode->i_bdev, BDEV_FILE);
698 free_inode:
699 iput(inode);
700 }
701
702 #ifdef CONFIG_MAC_FLOPPY
703 int swim3_fd_eject(int devnum);
704 #endif
705
706 static void __init rd_load_disk(int n)
707 {
708 #ifdef CONFIG_BLK_DEV_INITRD
709 extern kdev_t real_root_dev;
710 #endif
711
712 if (rd_doload == 0)
713 return;
714
715 if (MAJOR(ROOT_DEV) != FLOPPY_MAJOR
716 #ifdef CONFIG_BLK_DEV_INITRD
717 && MAJOR(real_root_dev) != FLOPPY_MAJOR
718 #endif
719 )
720 return;
721
722 if (rd_prompt) {
723 #ifdef CONFIG_BLK_DEV_FD
724 floppy_eject();
725 #endif
726 #ifdef CONFIG_MAC_FLOPPY
727 if(MAJOR(ROOT_DEV) == FLOPPY_MAJOR)
728 swim3_fd_eject(MINOR(ROOT_DEV));
729 else if(MAJOR(real_root_dev) == FLOPPY_MAJOR)
730 swim3_fd_eject(MINOR(real_root_dev));
731 #endif
732 printk(KERN_NOTICE
733 "VFS: Insert root floppy disk to be loaded into RAM disk and press ENTER\n");
734 wait_for_keypress();
735 }
736
737 rd_load_image(ROOT_DEV,rd_image_start, n);
738
739 }
740
741 void __init rd_load(void)
742 {
743 rd_load_disk(0);
744 }
745
746 void __init rd_load_secondary(void)
747 {
748 rd_load_disk(1);
749 }
750
751 #ifdef CONFIG_BLK_DEV_INITRD
752 void __init initrd_load(void)
753 {
754 rd_load_image(MKDEV(MAJOR_NR, INITRD_MINOR),rd_image_start,0);
755 }
756 #endif
757
758 #endif /* RD_LOADER */
759
760 #ifdef BUILD_CRAMDISK
761
762 /*
763 * gzip declarations
764 */
765
766 #define OF(args) args
767
768 #ifndef memzero
769 #define memzero(s, n) memset ((s), 0, (n))
770 #endif
771
772 typedef unsigned char uch;
773 typedef unsigned short ush;
774 typedef unsigned long ulg;
775
776 #define INBUFSIZ 4096
777 #define WSIZE 0x8000 /* window size--must be a power of two, and */
778 /* at least 32K for zip's deflate method */
779
780 static uch *inbuf;
781 static uch *window;
782
783 static unsigned insize; /* valid bytes in inbuf */
784 static unsigned inptr; /* index of next byte to be processed in inbuf */
785 static unsigned outcnt; /* bytes in output buffer */
786 static int exit_code;
787 static long bytes_out;
788 static struct file *crd_infp, *crd_outfp;
789
790 #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
791
792 /* Diagnostic functions (stubbed out) */
793 #define Assert(cond,msg)
794 #define Trace(x)
795 #define Tracev(x)
796 #define Tracevv(x)
797 #define Tracec(c,x)
798 #define Tracecv(c,x)
799
800 #define STATIC static
801
802 static int fill_inbuf(void);
803 static void flush_window(void);
804 static void *malloc(int size);
805 static void free(void *where);
806 static void error(char *m);
807 static void gzip_mark(void **);
808 static void gzip_release(void **);
809
810 #include "../../lib/inflate.c"
811
812 static void __init *malloc(int size)
813 {
814 return kmalloc(size, GFP_KERNEL);
815 }
816
817 static void __init free(void *where)
818 {
819 kfree(where);
820 }
821
822 static void __init gzip_mark(void **ptr)
823 {
824 }
825
826 static void __init gzip_release(void **ptr)
827 {
828 }
829
830
831 /* ===========================================================================
832 * Fill the input buffer. This is called only when the buffer is empty
833 * and at least one byte is really needed.
834 */
835 static int __init fill_inbuf(void)
836 {
837 if (exit_code) return -1;
838
839 insize = crd_infp->f_op->read(crd_infp, inbuf, INBUFSIZ,
840 &crd_infp->f_pos);
841 if (insize == 0) return -1;
842
843 inptr = 1;
844
845 return inbuf[0];
846 }
847
848 /* ===========================================================================
849 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
850 * (Used for the decompressed data only.)
851 */
852 static void __init flush_window(void)
853 {
854 ulg c = crc; /* temporary variable */
855 unsigned n;
856 uch *in, ch;
857
858 crd_outfp->f_op->write(crd_outfp, window, outcnt, &crd_outfp->f_pos);
859 in = window;
860 for (n = 0; n < outcnt; n++) {
861 ch = *in++;
862 c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
863 }
864 crc = c;
865 bytes_out += (ulg)outcnt;
866 outcnt = 0;
867 }
868
869 static void __init error(char *x)
870 {
871 printk(KERN_ERR "%s", x);
872 exit_code = 1;
873 }
874
875 static int __init
876 crd_load(struct file * fp, struct file *outfp)
877 {
878 int result;
879
880 insize = 0; /* valid bytes in inbuf */
881 inptr = 0; /* index of next byte to be processed in inbuf */
882 outcnt = 0; /* bytes in output buffer */
883 exit_code = 0;
884 bytes_out = 0;
885 crc = (ulg)0xffffffffL; /* shift register contents */
886
887 crd_infp = fp;
888 crd_outfp = outfp;
889 inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
890 if (inbuf == 0) {
891 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
892 return -1;
893 }
894 window = kmalloc(WSIZE, GFP_KERNEL);
895 if (window == 0) {
896 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
897 kfree(inbuf);
898 return -1;
899 }
900 makecrc();
901 result = gunzip();
902 kfree(inbuf);
903 kfree(window);
904 return result;
905 }
906
907 #endif /* BUILD_CRAMDISK */
908
909
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.