drivers/block/rd.c

   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 = 4096;             /* 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;  /* Size 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 void rd_request(request_queue_t * q)
 198 {
 199         unsigned int minor;
 200         unsigned long offset, len;
 201         struct buffer_head *rbh;
 202         struct buffer_head *sbh;
 203
 204 repeat:
 205         INIT_REQUEST;
 206
 207         minor = MINOR(CURRENT->rq_dev);
 208
 209         if (minor >= NUM_RAMDISKS) {
 210                 end_request(0);
 211                 goto repeat;
 212         }
 213
 214         offset = CURRENT->sector << 9;
 215         len = CURRENT->current_nr_sectors << 9;
 216
 217         if ((offset + len) > rd_length[minor]) {
 218                 end_request(0);
 219                 goto repeat;
 220         }
 221
 222         if ((CURRENT->cmd != READ) && (CURRENT->cmd != WRITE)) {
 223                 printk(KERN_INFO "RAMDISK: bad command: %d\n", CURRENT->cmd);
 224                 end_request(0);
 225                 goto repeat;
 226         }
 227
 228         sbh = CURRENT->bh;
 229         rbh = getblk(sbh->b_dev, sbh->b_blocknr, sbh->b_size);
 230         if (CURRENT->cmd == READ) {
 231                 if (sbh != rbh)
 232                         memcpy(CURRENT->buffer, rbh->b_data, rbh->b_size);
 233         } else
 234                 if (sbh != rbh)
 235                         memcpy(rbh->b_data, CURRENT->buffer, rbh->b_size);
 236         mark_buffer_protected(rbh);
 237         brelse(rbh);
 238
 239         end_request(1);
 240         goto repeat;
 241 }
 242
 243 static int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 244 {
 245         unsigned int minor;
 246
 247         if (!inode || !inode->i_rdev)
 248                 return -EINVAL;
 249
 250         minor = MINOR(inode->i_rdev);
 251
 252         switch (cmd) {
 253                 case BLKFLSBUF:
 254                         if (!capable(CAP_SYS_ADMIN))
 255                                 return -EACCES;
 256                         /* special: we want to release the ramdisk memory,
 257                            it's not like with the other blockdevices where
 258                            this ioctl only flushes away the buffer cache. */
 259                         if ((atomic_read(&inode->i_bdev->bd_openers) > 2))
 260                                 return -EBUSY;
 261                         destroy_buffers(inode->i_rdev);
 262                         rd_blocksizes[minor] = 0;
 263                         break;
 264
 265                 case BLKGETSIZE:   /* Return device size */
 266                         if (!arg)  return -EINVAL;
 267                         return put_user(rd_kbsize[minor] << 1, (long *) arg);
 268
 269                 case BLKROSET:
 270                 case BLKROGET:
 271                 case BLKSSZGET:
 272                         return blk_ioctl(inode->i_rdev, cmd, arg);
 273
 274                 default:
 275                         return -EINVAL;
 276         };
 277
 278         return 0;
 279 }
 280
 281
 282 #ifdef CONFIG_BLK_DEV_INITRD
 283
 284 static ssize_t initrd_read(struct file *file, char *buf,
 285                            size_t count, loff_t *ppos)
 286 {
 287         int left;
 288
 289         left = initrd_end - initrd_start - *ppos;
 290         if (count > left) count = left;
 291         if (count == 0) return 0;
 292         copy_to_user(buf, (char *)initrd_start + *ppos, count);
 293         *ppos += count;
 294         return count;
 295 }
 296
 297
 298 static int initrd_release(struct inode *inode,struct file *file)
 299 {
 300         extern void free_initrd_mem(unsigned long, unsigned long);
 301
 302         lock_kernel();
 303         if (!--initrd_users) {
 304                 blkdev_put(inode->i_bdev, BDEV_FILE);
 305                 iput(inode);
 306                 free_initrd_mem(initrd_start, initrd_end);
 307                 initrd_start = 0;
 308         }
 309         unlock_kernel();
 310         return 0;
 311 }
 312
 313
 314 static struct file_operations initrd_fops = {
 315         read:           initrd_read,
 316         release:        initrd_release,
 317 };
 318
 319 #endif
 320
 321
 322 static int rd_open(struct inode * inode, struct file * filp)
 323 {
 324 #ifdef CONFIG_BLK_DEV_INITRD
 325         if (DEVICE_NR(inode->i_rdev) == INITRD_MINOR) {
 326                 if (!initrd_start) return -ENODEV;
 327                 initrd_users++;
 328                 filp->f_op = &initrd_fops;
 329                 return 0;
 330         }
 331 #endif
 332
 333         if (DEVICE_NR(inode->i_rdev) >= NUM_RAMDISKS)
 334                 return -ENXIO;
 335
 336         /*
 337          * Immunize device against invalidate_buffers() and prune_icache().
 338          */
 339         if (rd_inode[DEVICE_NR(inode->i_rdev)] == NULL) {
 340                 if (!inode->i_bdev) return -ENXIO;
 341                 if ((rd_inode[DEVICE_NR(inode->i_rdev)] = igrab(inode)) != NULL)
 342                         atomic_inc(&rd_inode[DEVICE_NR(inode->i_rdev)]->i_bdev->bd_openers);
 343         }
 344
 345         MOD_INC_USE_COUNT;
 346
 347         return 0;
 348 }
 349
 350 static int rd_release(struct inode * inode, struct file * filp)
 351 {
 352         MOD_DEC_USE_COUNT;
 353         return 0;
 354 }
 355
 356 static struct block_device_operations fd_fops = {
 357         open:           rd_open,
 358         release:        rd_release,
 359         ioctl:          rd_ioctl,
 360 };
 361
 362 #ifdef MODULE
 363 /* Before freeing the module, invalidate all of the protected buffers! */
 364 static void __exit rd_cleanup (void)
 365 {
 366         int i;
 367
 368         for (i = 0 ; i < NUM_RAMDISKS; i++) {
 369                 if (rd_inode[i]) {
 370                         /* withdraw invalidate_buffers() and prune_icache() immunity */
 371                         atomic_dec(&rd_inode[i]->i_bdev->bd_openers);
 372                         /* remove stale pointer to module address space */
 373                         rd_inode[i]->i_bdev->bd_op = NULL;
 374                         iput(rd_inode[i]);
 375                 }
 376                 destroy_buffers(MKDEV(MAJOR_NR, i));
 377         }
 378
 379         devfs_unregister (devfs_handle);
 380         unregister_blkdev( MAJOR_NR, "ramdisk" );
 381         blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
 382         hardsect_size[MAJOR_NR] = NULL;
 383         blksize_size[MAJOR_NR] = NULL;
 384         blk_size[MAJOR_NR] = NULL;
 385 }
 386 #endif
 387
 388 /* This is the registration and initialization section of the RAM disk driver */
 389 int __init rd_init (void)
 390 {
 391         int             i;
 392
 393         if (rd_blocksize > PAGE_SIZE || rd_blocksize < 512 ||
 394             (rd_blocksize & (rd_blocksize-1)))
 395         {
 396                 printk("RAMDISK: wrong blocksize %d, reverting to defaults\n",
 397                        rd_blocksize);
 398                 rd_blocksize = BLOCK_SIZE;
 399         }
 400
 401         if (register_blkdev(MAJOR_NR, "ramdisk", &fd_fops)) {
 402                 printk("RAMDISK: Could not get major %d", MAJOR_NR);
 403                 return -EIO;
 404         }
 405
 406         blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &rd_request);
 407
 408         for (i = 0; i < NUM_RAMDISKS; i++) {
 409                 /* rd_size is given in kB */
 410                 rd_length[i] = rd_size << 10;
 411                 rd_hardsec[i] = rd_blocksize;
 412                 rd_blocksizes[i] = rd_blocksize;
 413                 rd_kbsize[i] = rd_size;
 414         }
 415         devfs_handle = devfs_mk_dir (NULL, "rd", NULL);
 416         devfs_register_series (devfs_handle, "%u", NUM_RAMDISKS,
 417                                DEVFS_FL_DEFAULT, MAJOR_NR, 0,
 418                                S_IFBLK | S_IRUSR | S_IWUSR,
 419                                &fd_fops, NULL);
 420
 421         for (i = 0; i < NUM_RAMDISKS; i++)
 422                 register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &fd_fops, rd_size<<1);
 423
 424 #ifdef CONFIG_BLK_DEV_INITRD
 425         /* We ought to separate initrd operations here */
 426         register_disk(NULL, MKDEV(MAJOR_NR,INITRD_MINOR), 1, &fd_fops, rd_size<<1);
 427 #endif
 428
 429         hardsect_size[MAJOR_NR] = rd_hardsec;           /* Size of the RAM disk blocks */
 430         blksize_size[MAJOR_NR] = rd_blocksizes;         /* Avoid set_blocksize() check */
 431         blk_size[MAJOR_NR] = rd_kbsize;                 /* Size of the RAM disk in kB  */
 432
 433                 /* rd_size is given in kB */
 434         printk("RAMDISK driver initialized: "
 435                "%d RAM disks of %dK size %d blocksize\n",
 436                NUM_RAMDISKS, rd_size, rd_blocksize);
 437
 438         return 0;
 439 }
 440
 441 #ifdef MODULE
 442 module_init(rd_init);
 443 module_exit(rd_cleanup);
 444 #endif
 445
 446 /* loadable module support */
 447 MODULE_PARM     (rd_size, "1i");
 448 MODULE_PARM_DESC(rd_size, "Size of each RAM disk in kbytes.");
 449 MODULE_PARM     (rd_blocksize, "i");
 450 MODULE_PARM_DESC(rd_blocksize, "Blocksize of each RAM disk in bytes.");
 451
 452 /* End of non-loading portions of the RAM disk driver */
 453
 454 #ifdef RD_LOADER
 455 /*
 456  * This routine tries to find a RAM disk image to load, and returns the
 457  * number of blocks to read for a non-compressed image, 0 if the image
 458  * is a compressed image, and -1 if an image with the right magic
 459  * numbers could not be found.
 460  *
 461  * We currently check for the following magic numbers:
 462  *      minix
 463  *      ext2
 464  *      romfs
 465  *      gzip
 466  */
 467 int __init
 468 identify_ramdisk_image(kdev_t device, struct file *fp, int start_block)
 469 {
 470         const int size = 512;
 471         struct minix_super_block *minixsb;
 472         struct ext2_super_block *ext2sb;
 473         struct romfs_super_block *romfsb;
 474         int nblocks = -1;
 475         unsigned char *buf;
 476
 477         buf = kmalloc(size, GFP_KERNEL);
 478         if (buf == 0)
 479                 return -1;
 480
 481         minixsb = (struct minix_super_block *) buf;
 482         ext2sb = (struct ext2_super_block *) buf;
 483         romfsb = (struct romfs_super_block *) buf;
 484         memset(buf, 0xe5, size);
 485
 486         /*
 487          * Read block 0 to test for gzipped kernel
 488          */
 489         if (fp->f_op->llseek)
 490                 fp->f_op->llseek(fp, start_block * BLOCK_SIZE, 0);
 491         fp->f_pos = start_block * BLOCK_SIZE;
 492
 493         fp->f_op->read(fp, buf, size, &fp->f_pos);
 494
 495         /*
 496          * If it matches the gzip magic numbers, return -1
 497          */
 498         if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
 499                 printk(KERN_NOTICE
 500                        "RAMDISK: Compressed image found at block %d\n",
 501                        start_block);
 502                 nblocks = 0;
 503                 goto done;
 504         }
 505
 506         /* romfs is at block zero too */
 507         if (romfsb->word0 == ROMSB_WORD0 &&
 508             romfsb->word1 == ROMSB_WORD1) {
 509                 printk(KERN_NOTICE
 510                        "RAMDISK: romfs filesystem found at block %d\n",
 511                        start_block);
 512                 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
 513                 goto done;
 514         }
 515
 516         /*
 517          * Read block 1 to test for minix and ext2 superblock
 518          */
 519         if (fp->f_op->llseek)
 520                 fp->f_op->llseek(fp, (start_block+1) * BLOCK_SIZE, 0);
 521         fp->f_pos = (start_block+1) * BLOCK_SIZE;
 522
 523         fp->f_op->read(fp, buf, size, &fp->f_pos);
 524
 525         /* Try minix */
 526         if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
 527             minixsb->s_magic == MINIX_SUPER_MAGIC2) {
 528                 printk(KERN_NOTICE
 529                        "RAMDISK: Minix filesystem found at block %d\n",
 530                        start_block);
 531                 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
 532                 goto done;
 533         }
 534
 535         /* Try ext2 */
 536         if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
 537                 printk(KERN_NOTICE
 538                        "RAMDISK: ext2 filesystem found at block %d\n",
 539                        start_block);
 540                 nblocks = le32_to_cpu(ext2sb->s_blocks_count);
 541                 goto done;
 542         }
 543
 544         printk(KERN_NOTICE
 545                "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
 546                start_block);
 547
 548 done:
 549         if (fp->f_op->llseek)
 550                 fp->f_op->llseek(fp, start_block * BLOCK_SIZE, 0);
 551         fp->f_pos = start_block * BLOCK_SIZE;
 552
 553         kfree(buf);
 554         return nblocks;
 555 }
 556
 557 /*
 558  * This routine loads in the RAM disk image.
 559  */
 560 static void __init rd_load_image(kdev_t device, int offset, int unit)
 561 {
 562         struct inode *inode, *out_inode;
 563         struct file infile, outfile;
 564         struct dentry in_dentry, out_dentry;
 565         mm_segment_t fs;
 566         kdev_t ram_device;
 567         int nblocks, i;
 568         char *buf;
 569         unsigned short rotate = 0;
 570         unsigned short devblocks = 0;
 571         char rotator[4] = { '|' , '/' , '-' , '\\' };
 572
 573         ram_device = MKDEV(MAJOR_NR, unit);
 574
 575         if ((inode = get_empty_inode()) == NULL)
 576                 return;
 577         memset(&infile, 0, sizeof(infile));
 578         memset(&in_dentry, 0, sizeof(in_dentry));
 579         infile.f_mode = 1; /* read only */
 580         infile.f_dentry = &in_dentry;
 581         in_dentry.d_inode = inode;
 582         infile.f_op = &def_blk_fops;
 583         init_special_inode(inode, S_IFBLK | S_IRUSR, kdev_t_to_nr(device));
 584
 585         if ((out_inode = get_empty_inode()) == NULL)
 586                 goto free_inode;
 587         memset(&outfile, 0, sizeof(outfile));
 588         memset(&out_dentry, 0, sizeof(out_dentry));
 589         outfile.f_mode = 3; /* read/write */
 590         outfile.f_dentry = &out_dentry;
 591         out_dentry.d_inode = out_inode;
 592         outfile.f_op = &def_blk_fops;
 593         init_special_inode(out_inode, S_IFBLK | S_IRUSR | S_IWUSR, kdev_t_to_nr(ram_device));
 594
 595         if (blkdev_open(inode, &infile) != 0)
 596                 goto free_inode;
 597         if (blkdev_open(out_inode, &outfile) != 0)
 598                 goto free_inodes;
 599
 600         fs = get_fs();
 601         set_fs(KERNEL_DS);
 602
 603         nblocks = identify_ramdisk_image(device, &infile, offset);
 604         if (nblocks < 0)
 605                 goto done;
 606
 607         if (nblocks == 0) {
 608 #ifdef BUILD_CRAMDISK
 609                 if (crd_load(&infile, &outfile) == 0)
 610                         goto successful_load;
 611 #else
 612                 printk(KERN_NOTICE
 613                        "RAMDISK: Kernel does not support compressed "
 614                        "RAM disk images\n");
 615 #endif
 616                 goto done;
 617         }
 618
 619         /*
 620          * NOTE NOTE: nblocks suppose that the blocksize is BLOCK_SIZE, so
 621          * rd_load_image will work only with filesystem BLOCK_SIZE wide!
 622          * So make sure to use 1k blocksize while generating ext2fs
 623          * ramdisk-images.
 624          */
 625         if (nblocks > (rd_length[unit] >> BLOCK_SIZE_BITS)) {
 626                 printk("RAMDISK: image too big! (%d/%ld blocks)\n",
 627                        nblocks, rd_length[unit] >> BLOCK_SIZE_BITS);
 628                 goto done;
 629         }
 630
 631         /*
 632          * OK, time to copy in the data
 633          */
 634         buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
 635         if (buf == 0) {
 636                 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
 637                 goto done;
 638         }
 639
 640         if (blk_size[MAJOR(device)])
 641                 devblocks = blk_size[MAJOR(device)][MINOR(device)];
 642
 643 #ifdef CONFIG_BLK_DEV_INITRD
 644         if (MAJOR(device) == MAJOR_NR && MINOR(device) == INITRD_MINOR)
 645                 devblocks = nblocks;
 646 #endif
 647
 648         if (devblocks == 0) {
 649                 printk(KERN_ERR "RAMDISK: could not determine device size\n");
 650                 goto done;
 651         }
 652
 653         printk(KERN_NOTICE "RAMDISK: Loading %d blocks [%d disk%s] into ram disk... ",
 654                 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
 655         for (i=0; i < nblocks; i++) {
 656                 if (i && (i % devblocks == 0)) {
 657                         printk("done disk #%d.\n", i/devblocks);
 658                         rotate = 0;
 659                         invalidate_buffers(device);
 660                         if (infile.f_op->release)
 661                                 infile.f_op->release(inode, &infile);
 662                         printk("Please insert disk #%d and press ENTER\n", i/devblocks+1);
 663                         wait_for_keypress();
 664                         if (blkdev_open(inode, &infile) != 0)  {
 665                                 printk("Error opening disk.\n");
 666                                 goto done;
 667                         }
 668                         infile.f_pos = 0;
 669                         printk("Loading disk #%d... ", i/devblocks+1);
 670                 }
 671                 infile.f_op->read(&infile, buf, BLOCK_SIZE, &infile.f_pos);
 672                 outfile.f_op->write(&outfile, buf, BLOCK_SIZE, &outfile.f_pos);
 673 #if !defined(CONFIG_ARCH_S390)
 674                 if (!(i % 16)) {
 675                         printk("%c\b", rotator[rotate & 0x3]);
 676                         rotate++;
 677                 }
 678 #endif
 679         }
 680         printk("done.\n");
 681         kfree(buf);
 682
 683 successful_load:
 684         invalidate_buffers(device);
 685         ROOT_DEV = MKDEV(MAJOR_NR, unit);
 686         if (ROOT_DEVICE_NAME != NULL) strcpy (ROOT_DEVICE_NAME, "rd/0");
 687
 688 done:
 689         if (infile.f_op->release)
 690                 infile.f_op->release(inode, &infile);
 691         set_fs(fs);
 692         return;
 693 free_inodes: /* free inodes on error */
 694         iput(out_inode);
 695         blkdev_put(inode->i_bdev, BDEV_FILE);
 696 free_inode:
 697         iput(inode);
 698 }
 699
 700 #ifdef CONFIG_MAC_FLOPPY
 701 int swim3_fd_eject(int devnum);
 702 #endif
 703
 704 static void __init rd_load_disk(int n)
 705 {
 706 #ifdef CONFIG_BLK_DEV_INITRD
 707         extern kdev_t real_root_dev;
 708 #endif
 709
 710         if (rd_doload == 0)
 711                 return;
 712
 713         if (MAJOR(ROOT_DEV) != FLOPPY_MAJOR
 714 #ifdef CONFIG_BLK_DEV_INITRD
 715                 && MAJOR(real_root_dev) != FLOPPY_MAJOR
 716 #endif
 717         )
 718                 return;
 719
 720         if (rd_prompt) {
 721 #ifdef CONFIG_BLK_DEV_FD
 722                 floppy_eject();
 723 #endif
 724 #ifdef CONFIG_MAC_FLOPPY
 725                 if(MAJOR(ROOT_DEV) == FLOPPY_MAJOR)
 726                         swim3_fd_eject(MINOR(ROOT_DEV));
 727                 else if(MAJOR(real_root_dev) == FLOPPY_MAJOR)
 728                         swim3_fd_eject(MINOR(real_root_dev));
 729 #endif
 730                 printk(KERN_NOTICE
 731                        "VFS: Insert root floppy disk to be loaded into RAM disk and press ENTER\n");
 732                 wait_for_keypress();
 733         }
 734
 735         rd_load_image(ROOT_DEV,rd_image_start, n);
 736
 737 }
 738
 739 void __init rd_load(void)
 740 {
 741         rd_load_disk(0);
 742 }
 743
 744 void __init rd_load_secondary(void)
 745 {
 746         rd_load_disk(1);
 747 }
 748
 749 #ifdef CONFIG_BLK_DEV_INITRD
 750 void __init initrd_load(void)
 751 {
 752         rd_load_image(MKDEV(MAJOR_NR, INITRD_MINOR),rd_image_start,0);
 753 }
 754 #endif
 755
 756 #endif /* RD_LOADER */
 757
 758 #ifdef BUILD_CRAMDISK
 759
 760 /*
 761  * gzip declarations
 762  */
 763
 764 #define OF(args)  args
 765
 766 #ifndef memzero
 767 #define memzero(s, n)     memset ((s), 0, (n))
 768 #endif
 769
 770 typedef unsigned char  uch;
 771 typedef unsigned short ush;
 772 typedef unsigned long  ulg;
 773
 774 #define INBUFSIZ 4096
 775 #define WSIZE 0x8000    /* window size--must be a power of two, and */
 776                         /*  at least 32K for zip's deflate method */
 777
 778 static uch *inbuf;
 779 static uch *window;
 780
 781 static unsigned insize;  /* valid bytes in inbuf */
 782 static unsigned inptr;   /* index of next byte to be processed in inbuf */
 783 static unsigned outcnt;  /* bytes in output buffer */
 784 static int exit_code;
 785 static long bytes_out;
 786 static struct file *crd_infp, *crd_outfp;
 787
 788 #define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
 789
 790 /* Diagnostic functions (stubbed out) */
 791 #define Assert(cond,msg)
 792 #define Trace(x)
 793 #define Tracev(x)
 794 #define Tracevv(x)
 795 #define Tracec(c,x)
 796 #define Tracecv(c,x)
 797
 798 #define STATIC static
 799
 800 static int  fill_inbuf(void);
 801 static void flush_window(void);
 802 static void *malloc(int size);
 803 static void free(void *where);
 804 static void error(char *m);
 805 static void gzip_mark(void **);
 806 static void gzip_release(void **);
 807
 808 #include "../../lib/inflate.c"
 809
 810 static void __init *malloc(int size)
 811 {
 812         return kmalloc(size, GFP_KERNEL);
 813 }
 814
 815 static void __init free(void *where)
 816 {
 817         kfree(where);
 818 }
 819
 820 static void __init gzip_mark(void **ptr)
 821 {
 822 }
 823
 824 static void __init gzip_release(void **ptr)
 825 {
 826 }
 827
 828
 829 /* ===========================================================================
 830  * Fill the input buffer. This is called only when the buffer is empty
 831  * and at least one byte is really needed.
 832  */
 833 static int __init fill_inbuf(void)
 834 {
 835         if (exit_code) return -1;
 836
 837         insize = crd_infp->f_op->read(crd_infp, inbuf, INBUFSIZ,
 838                                       &crd_infp->f_pos);
 839         if (insize == 0) return -1;
 840
 841         inptr = 1;
 842
 843         return inbuf[0];
 844 }
 845
 846 /* ===========================================================================
 847  * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 848  * (Used for the decompressed data only.)
 849  */
 850 static void __init flush_window(void)
 851 {
 852     ulg c = crc;         /* temporary variable */
 853     unsigned n;
 854     uch *in, ch;
 855
 856     crd_outfp->f_op->write(crd_outfp, window, outcnt, &crd_outfp->f_pos);
 857     in = window;
 858     for (n = 0; n < outcnt; n++) {
 859             ch = *in++;
 860             c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
 861     }
 862     crc = c;
 863     bytes_out += (ulg)outcnt;
 864     outcnt = 0;
 865 }
 866
 867 static void __init error(char *x)
 868 {
 869         printk(KERN_ERR "%s", x);
 870         exit_code = 1;
 871 }
 872
 873 static int __init
 874 crd_load(struct file * fp, struct file *outfp)
 875 {
 876         int result;
 877
 878         insize = 0;             /* valid bytes in inbuf */
 879         inptr = 0;              /* index of next byte to be processed in inbuf */
 880         outcnt = 0;             /* bytes in output buffer */
 881         exit_code = 0;
 882         bytes_out = 0;
 883         crc = (ulg)0xffffffffL; /* shift register contents */
 884
 885         crd_infp = fp;
 886         crd_outfp = outfp;
 887         inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
 888         if (inbuf == 0) {
 889                 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
 890                 return -1;
 891         }
 892         window = kmalloc(WSIZE, GFP_KERNEL);
 893         if (window == 0) {
 894                 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
 895                 kfree(inbuf);
 896                 return -1;
 897         }
 898         makecrc();
 899         result = gunzip();
 900         kfree(inbuf);
 901         kfree(window);
 902         return result;
 903 }
 904
 905 #endif  /* BUILD_CRAMDISK */
 906