2 #include <linux/kernel.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>
11 #include "do_mounts.h"
13 #include <linux/decompress/generic.h>
15 #include <linux/decompress/bunzip2.h>
16 #include <linux/decompress/unlzma.h>
17 #include <linux/decompress/inflate.h>
19 int __initdata rd_prompt
= 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
21 static int __init
prompt_ramdisk(char *str
)
23 rd_prompt
= simple_strtol(str
,NULL
,0) & 1;
26 __setup("prompt_ramdisk=", prompt_ramdisk
);
28 int __initdata rd_image_start
; /* starting block # of image */
30 static int __init
ramdisk_start_setup(char *str
)
32 rd_image_start
= simple_strtol(str
,NULL
,0);
35 __setup("ramdisk_start=", ramdisk_start_setup
);
37 static int __init
crd_load(int in_fd
, int out_fd
, decompress_fn deco
);
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.
45 * We currently check for the following magic numbers:
52 static const struct compress_format
{
53 unsigned char magic
[2];
55 decompress_fn decompressor
;
56 } compressed_formats
[] = {
58 { {037, 0213}, "gzip", gunzip
},
59 { {037, 0236}, "gzip", gunzip
},
61 #ifdef CONFIG_RD_BZIP2
62 { {0x42, 0x5a}, "bzip2", bunzip2
},
65 { {0x5d, 0x00}, "lzma", unlzma
},
67 { {0, 0}, NULL
, NULL
}
71 identify_ramdisk_image(int fd
, int start_block
, decompress_fn
*decompressor
)
74 struct minix_super_block
*minixsb
;
75 struct ext2_super_block
*ext2sb
;
76 struct romfs_super_block
*romfsb
;
77 struct cramfs_super
*cramfsb
;
80 const struct compress_format
*cf
;
82 buf
= kmalloc(size
, GFP_KERNEL
);
86 minixsb
= (struct minix_super_block
*) buf
;
87 ext2sb
= (struct ext2_super_block
*) buf
;
88 romfsb
= (struct romfs_super_block
*) buf
;
89 cramfsb
= (struct cramfs_super
*) buf
;
90 memset(buf
, 0xe5, size
);
93 * Read block 0 to test for compressed kernel
95 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
96 sys_read(fd
, buf
, size
);
98 for (cf
= compressed_formats
; cf
->decompressor
; cf
++) {
99 if (buf
[0] == cf
->magic
[0] && buf
[1] == cf
->magic
[1]) {
101 "RAMDISK: %s image found at block %d\n",
102 cf
->name
, start_block
);
103 *decompressor
= cf
->decompressor
;
109 /* romfs is at block zero too */
110 if (romfsb
->word0
== ROMSB_WORD0
&&
111 romfsb
->word1
== ROMSB_WORD1
) {
113 "RAMDISK: romfs filesystem found at block %d\n",
115 nblocks
= (ntohl(romfsb
->size
)+BLOCK_SIZE
-1)>>BLOCK_SIZE_BITS
;
119 if (cramfsb
->magic
== CRAMFS_MAGIC
) {
121 "RAMDISK: cramfs filesystem found at block %d\n",
123 nblocks
= (cramfsb
->size
+ BLOCK_SIZE
- 1) >> BLOCK_SIZE_BITS
;
128 * Read block 1 to test for minix and ext2 superblock
130 sys_lseek(fd
, (start_block
+1) * BLOCK_SIZE
, 0);
131 sys_read(fd
, buf
, size
);
134 if (minixsb
->s_magic
== MINIX_SUPER_MAGIC
||
135 minixsb
->s_magic
== MINIX_SUPER_MAGIC2
) {
137 "RAMDISK: Minix filesystem found at block %d\n",
139 nblocks
= minixsb
->s_nzones
<< minixsb
->s_log_zone_size
;
144 if (ext2sb
->s_magic
== cpu_to_le16(EXT2_SUPER_MAGIC
)) {
146 "RAMDISK: ext2 filesystem found at block %d\n",
148 nblocks
= le32_to_cpu(ext2sb
->s_blocks_count
) <<
149 le32_to_cpu(ext2sb
->s_log_block_size
);
154 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
158 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
163 int __init
rd_load_image(char *from
)
167 unsigned long rd_blocks
, devblocks
;
168 int nblocks
, i
, disk
;
170 unsigned short rotate
= 0;
171 decompress_fn decompressor
= NULL
;
172 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
173 char rotator
[4] = { '|' , '/' , '-' , '\\' };
176 out_fd
= sys_open("/dev/ram", O_RDWR
, 0);
180 in_fd
= sys_open(from
, O_RDONLY
, 0);
184 nblocks
= identify_ramdisk_image(in_fd
, rd_image_start
, &decompressor
);
189 if (crd_load(in_fd
, out_fd
, decompressor
) == 0)
190 goto successful_load
;
195 * NOTE NOTE: nblocks is not actually blocks but
196 * the number of kibibytes of data to load into a ramdisk.
197 * So any ramdisk block size that is a multiple of 1KiB should
198 * work when the appropriate ramdisk_blocksize is specified
199 * on the command line.
201 * The default ramdisk_blocksize is 1KiB and it is generally
202 * silly to use anything else, so make sure to use 1KiB
203 * blocksize while generating ext2fs ramdisk-images.
205 if (sys_ioctl(out_fd
, BLKGETSIZE
, (unsigned long)&rd_blocks
) < 0)
210 if (nblocks
> rd_blocks
) {
211 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
217 * OK, time to copy in the data
219 if (sys_ioctl(in_fd
, BLKGETSIZE
, (unsigned long)&devblocks
) < 0)
224 if (strcmp(from
, "/initrd.image") == 0)
227 if (devblocks
== 0) {
228 printk(KERN_ERR
"RAMDISK: could not determine device size\n");
232 buf
= kmalloc(BLOCK_SIZE
, GFP_KERNEL
);
234 printk(KERN_ERR
"RAMDISK: could not allocate buffer\n");
238 printk(KERN_NOTICE
"RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
239 nblocks
, ((nblocks
-1)/devblocks
)+1, nblocks
>devblocks
? "s" : "");
240 for (i
= 0, disk
= 1; i
< nblocks
; i
++) {
241 if (i
&& (i
% devblocks
== 0)) {
242 printk("done disk #%d.\n", disk
++);
244 if (sys_close(in_fd
)) {
245 printk("Error closing the disk.\n");
248 change_floppy("disk #%d", disk
);
249 in_fd
= sys_open(from
, O_RDONLY
, 0);
251 printk("Error opening disk.\n");
254 printk("Loading disk #%d... ", disk
);
256 sys_read(in_fd
, buf
, BLOCK_SIZE
);
257 sys_write(out_fd
, buf
, BLOCK_SIZE
);
258 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
260 printk("%c\b", rotator
[rotate
& 0x3]);
275 sys_unlink("/dev/ram");
279 int __init
rd_load_disk(int n
)
282 change_floppy("root floppy disk to be loaded into RAM disk");
283 create_dev("/dev/root", ROOT_DEV
);
284 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR
, n
));
285 return rd_load_image("/dev/root");
288 static int exit_code
;
289 static int decompress_error
;
290 static int crd_infd
, crd_outfd
;
292 static int __init
compr_fill(void *buf
, unsigned int len
)
294 int r
= sys_read(crd_infd
, buf
, len
);
296 printk(KERN_ERR
"RAMDISK: error while reading compressed data");
298 printk(KERN_ERR
"RAMDISK: EOF while reading compressed data");
302 static int __init
compr_flush(void *window
, unsigned int outcnt
)
304 int written
= sys_write(crd_outfd
, window
, outcnt
);
305 if (written
!= outcnt
) {
306 if (decompress_error
== 0)
308 "RAMDISK: incomplete write (%d != %d)\n",
310 decompress_error
= 1;
316 static void __init
error(char *x
)
318 printk(KERN_ERR
"%s\n", x
);
320 decompress_error
= 1;
323 static int __init
crd_load(int in_fd
, int out_fd
, decompress_fn deco
)
328 result
= deco(NULL
, 0, compr_fill
, compr_flush
, NULL
, NULL
, error
);
329 if (decompress_error
)