SAFE public projects git trees. - safe/jmp/linux-2.6/blob - init/do_mounts_rd.c

   1
   2 #include <linux/kernel.h>
   3 #include <linux/fs.h>
   4 #include <linux/minix_fs.h>
   5 #include <linux/ext2_fs.h>
   6 #include <linux/romfs_fs.h>
   7 #include <linux/cramfs_fs.h>
   8 #include <linux/initrd.h>
   9 #include <linux/string.h>
  10
  11 #include "do_mounts.h"
  12
  13 #include <linux/decompress/generic.h>
  14
  15 #include <linux/decompress/bunzip2.h>
  16 #include <linux/decompress/unlzma.h>
  17 #include <linux/decompress/inflate.h>
  18
  19 int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
  20
  21 static int __init prompt_ramdisk(char *str)
  22 {
  23         rd_prompt = simple_strtol(str,NULL,0) & 1;
  24         return 1;
  25 }
  26 __setup("prompt_ramdisk=", prompt_ramdisk);
  27
  28 int __initdata rd_image_start;          /* starting block # of image */
  29
  30 static int __init ramdisk_start_setup(char *str)
  31 {
  32         rd_image_start = simple_strtol(str,NULL,0);
  33         return 1;
  34 }
  35 __setup("ramdisk_start=", ramdisk_start_setup);
  36
  37 static int __init crd_load(int in_fd, int out_fd, decompress_fn deco);
  38
  39 /*
  40  * This routine tries to find a RAM disk image to load, and returns the
  41  * number of blocks to read for a non-compressed image, 0 if the image
  42  * is a compressed image, and -1 if an image with the right magic
  43  * numbers could not be found.
  44  *
  45  * We currently check for the following magic numbers:
  46  *      minix
  47  *      ext2
  48  *      romfs
  49  *      cramfs
  50  *      gzip
  51  */
  52 static int __init
  53 identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
  54 {
  55         const int size = 512;
  56         struct minix_super_block *minixsb;
  57         struct ext2_super_block *ext2sb;
  58         struct romfs_super_block *romfsb;
  59         struct cramfs_super *cramfsb;
  60         int nblocks = -1;
  61         unsigned char *buf;
  62
  63         buf = kmalloc(size, GFP_KERNEL);
  64         if (!buf)
  65                 return -1;
  66
  67         minixsb = (struct minix_super_block *) buf;
  68         ext2sb = (struct ext2_super_block *) buf;
  69         romfsb = (struct romfs_super_block *) buf;
  70         cramfsb = (struct cramfs_super *) buf;
  71         memset(buf, 0xe5, size);
  72
  73         /*
  74          * Read block 0 to test for gzipped kernel
  75          */
  76         sys_lseek(fd, start_block * BLOCK_SIZE, 0);
  77         sys_read(fd, buf, size);
  78
  79 #ifdef CONFIG_RD_GZIP
  80         /*
  81          * If it matches the gzip magic numbers, return 0
  82          */
  83         if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
  84                 printk(KERN_NOTICE
  85                        "RAMDISK: Compressed image found at block %d\n",
  86                        start_block);
  87                 *decompressor = gunzip;
  88                 nblocks = 0;
  89                 goto done;
  90         }
  91 #endif
  92
  93 #ifdef CONFIG_RD_BZIP2
  94         /*
  95          * If it matches the bzip2 magic numbers, return -1
  96          */
  97         if (buf[0] == 0x42 && (buf[1] == 0x5a)) {
  98                 printk(KERN_NOTICE
  99                        "RAMDISK: Bzipped image found at block %d\n",
 100                        start_block);
 101                 *decompressor = bunzip2;
 102                 nblocks = 0;
 103                 goto done;
 104         }
 105 #endif
 106
 107 #ifdef CONFIG_RD_LZMA
 108         /*
 109          * If it matches the lzma magic numbers, return -1
 110          */
 111         if (buf[0] == 0x5d && (buf[1] == 0x00)) {
 112                 printk(KERN_NOTICE
 113                        "RAMDISK: Lzma image found at block %d\n",
 114                        start_block);
 115                 *decompressor = unlzma;
 116                 nblocks = 0;
 117                 goto done;
 118         }
 119 #endif
 120
 121         /* romfs is at block zero too */
 122         if (romfsb->word0 == ROMSB_WORD0 &&
 123             romfsb->word1 == ROMSB_WORD1) {
 124                 printk(KERN_NOTICE
 125                        "RAMDISK: romfs filesystem found at block %d\n",
 126                        start_block);
 127                 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
 128                 goto done;
 129         }
 130
 131         if (cramfsb->magic == CRAMFS_MAGIC) {
 132                 printk(KERN_NOTICE
 133                        "RAMDISK: cramfs filesystem found at block %d\n",
 134                        start_block);
 135                 nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
 136                 goto done;
 137         }
 138
 139         /*
 140          * Read block 1 to test for minix and ext2 superblock
 141          */
 142         sys_lseek(fd, (start_block+1) * BLOCK_SIZE, 0);
 143         sys_read(fd, buf, size);
 144
 145         /* Try minix */
 146         if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
 147             minixsb->s_magic == MINIX_SUPER_MAGIC2) {
 148                 printk(KERN_NOTICE
 149                        "RAMDISK: Minix filesystem found at block %d\n",
 150                        start_block);
 151                 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
 152                 goto done;
 153         }
 154
 155         /* Try ext2 */
 156         if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
 157                 printk(KERN_NOTICE
 158                        "RAMDISK: ext2 filesystem found at block %d\n",
 159                        start_block);
 160                 nblocks = le32_to_cpu(ext2sb->s_blocks_count) <<
 161                         le32_to_cpu(ext2sb->s_log_block_size);
 162                 goto done;
 163         }
 164
 165         printk(KERN_NOTICE
 166                "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
 167                start_block);
 168
 169 done:
 170         sys_lseek(fd, start_block * BLOCK_SIZE, 0);
 171         kfree(buf);
 172         return nblocks;
 173 }
 174
 175 int __init rd_load_image(char *from)
 176 {
 177         int res = 0;
 178         int in_fd, out_fd;
 179         unsigned long rd_blocks, devblocks;
 180         int nblocks, i, disk;
 181         char *buf = NULL;
 182         unsigned short rotate = 0;
 183         decompress_fn decompressor = NULL;
 184 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
 185         char rotator[4] = { '|' , '/' , '-' , '\\' };
 186 #endif
 187
 188         out_fd = sys_open("/dev/ram", O_RDWR, 0);
 189         if (out_fd < 0)
 190                 goto out;
 191
 192         in_fd = sys_open(from, O_RDONLY, 0);
 193         if (in_fd < 0)
 194                 goto noclose_input;
 195
 196         nblocks = identify_ramdisk_image(in_fd, rd_image_start, &decompressor);
 197         if (nblocks < 0)
 198                 goto done;
 199
 200         if (nblocks == 0) {
 201                 if (crd_load(in_fd, out_fd, decompressor) == 0)
 202                         goto successful_load;
 203                 goto done;
 204         }
 205
 206         /*
 207          * NOTE NOTE: nblocks is not actually blocks but
 208          * the number of kibibytes of data to load into a ramdisk.
 209          * So any ramdisk block size that is a multiple of 1KiB should
 210          * work when the appropriate ramdisk_blocksize is specified
 211          * on the command line.
 212          *
 213          * The default ramdisk_blocksize is 1KiB and it is generally
 214          * silly to use anything else, so make sure to use 1KiB
 215          * blocksize while generating ext2fs ramdisk-images.
 216          */
 217         if (sys_ioctl(out_fd, BLKGETSIZE, (unsigned long)&rd_blocks) < 0)
 218                 rd_blocks = 0;
 219         else
 220                 rd_blocks >>= 1;
 221
 222         if (nblocks > rd_blocks) {
 223                 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
 224                        nblocks, rd_blocks);
 225                 goto done;
 226         }
 227
 228         /*
 229          * OK, time to copy in the data
 230          */
 231         if (sys_ioctl(in_fd, BLKGETSIZE, (unsigned long)&devblocks) < 0)
 232                 devblocks = 0;
 233         else
 234                 devblocks >>= 1;
 235
 236         if (strcmp(from, "/initrd.image") == 0)
 237                 devblocks = nblocks;
 238
 239         if (devblocks == 0) {
 240                 printk(KERN_ERR "RAMDISK: could not determine device size\n");
 241                 goto done;
 242         }
 243
 244         buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
 245         if (!buf) {
 246                 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
 247                 goto done;
 248         }
 249
 250         printk(KERN_NOTICE "RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
 251                 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
 252         for (i = 0, disk = 1; i < nblocks; i++) {
 253                 if (i && (i % devblocks == 0)) {
 254                         printk("done disk #%d.\n", disk++);
 255                         rotate = 0;
 256                         if (sys_close(in_fd)) {
 257                                 printk("Error closing the disk.\n");
 258                                 goto noclose_input;
 259                         }
 260                         change_floppy("disk #%d", disk);
 261                         in_fd = sys_open(from, O_RDONLY, 0);
 262                         if (in_fd < 0)  {
 263                                 printk("Error opening disk.\n");
 264                                 goto noclose_input;
 265                         }
 266                         printk("Loading disk #%d... ", disk);
 267                 }
 268                 sys_read(in_fd, buf, BLOCK_SIZE);
 269                 sys_write(out_fd, buf, BLOCK_SIZE);
 270 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
 271                 if (!(i % 16)) {
 272                         printk("%c\b", rotator[rotate & 0x3]);
 273                         rotate++;
 274                 }
 275 #endif
 276         }
 277         printk("done.\n");
 278
 279 successful_load:
 280         res = 1;
 281 done:
 282         sys_close(in_fd);
 283 noclose_input:
 284         sys_close(out_fd);
 285 out:
 286         kfree(buf);
 287         sys_unlink("/dev/ram");
 288         return res;
 289 }
 290
 291 int __init rd_load_disk(int n)
 292 {
 293         if (rd_prompt)
 294                 change_floppy("root floppy disk to be loaded into RAM disk");
 295         create_dev("/dev/root", ROOT_DEV);
 296         create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
 297         return rd_load_image("/dev/root");
 298 }
 299
 300 static int exit_code;
 301 static int decompress_error;
 302 static int crd_infd, crd_outfd;
 303
 304 static int __init compr_fill(void *buf, unsigned int len)
 305 {
 306         int r = sys_read(crd_infd, buf, len);
 307         if (r < 0)
 308                 printk(KERN_ERR "RAMDISK: error while reading compressed data");
 309         else if (r == 0)
 310                 printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
 311         return r;
 312 }
 313
 314 static int __init compr_flush(void *window, unsigned int outcnt)
 315 {
 316         int written = sys_write(crd_outfd, window, outcnt);
 317         if (written != outcnt) {
 318                 if (decompress_error == 0)
 319                         printk(KERN_ERR
 320                                "RAMDISK: incomplete write (%d != %d)\n",
 321                                written, outcnt);
 322                 decompress_error = 1;
 323                 return -1;
 324         }
 325         return outcnt;
 326 }
 327
 328 static void __init error(char *x)
 329 {
 330         printk(KERN_ERR "%s\n", x);
 331         exit_code = 1;
 332         decompress_error = 1;
 333 }
 334
 335 static int __init crd_load(int in_fd, int out_fd, decompress_fn deco)
 336 {
 337         int result;
 338         crd_infd = in_fd;
 339         crd_outfd = out_fd;
 340         result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
 341         if (decompress_error)
 342                 result = 1;
 343         return result;
 344 }