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:
53 identify_ramdisk_image(int fd
, int start_block
, decompress_fn
*decompressor
)
56 struct minix_super_block
*minixsb
;
57 struct ext2_super_block
*ext2sb
;
58 struct romfs_super_block
*romfsb
;
59 struct cramfs_super
*cramfsb
;
63 buf
= kmalloc(size
, GFP_KERNEL
);
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
);
74 * Read block 0 to test for gzipped kernel
76 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
77 sys_read(fd
, buf
, size
);
81 * If it matches the gzip magic numbers, return 0
83 if (buf
[0] == 037 && ((buf
[1] == 0213) || (buf
[1] == 0236))) {
85 "RAMDISK: Compressed image found at block %d\n",
87 *decompressor
= gunzip
;
93 #ifdef CONFIG_RD_BZIP2
95 * If it matches the bzip2 magic numbers, return -1
97 if (buf
[0] == 0x42 && (buf
[1] == 0x5a)) {
99 "RAMDISK: Bzipped image found at block %d\n",
101 *decompressor
= bunzip2
;
107 #ifdef CONFIG_RD_LZMA
109 * If it matches the lzma magic numbers, return -1
111 if (buf
[0] == 0x5d && (buf
[1] == 0x00)) {
113 "RAMDISK: Lzma image found at block %d\n",
115 *decompressor
= unlzma
;
121 /* romfs is at block zero too */
122 if (romfsb
->word0
== ROMSB_WORD0
&&
123 romfsb
->word1
== ROMSB_WORD1
) {
125 "RAMDISK: romfs filesystem found at block %d\n",
127 nblocks
= (ntohl(romfsb
->size
)+BLOCK_SIZE
-1)>>BLOCK_SIZE_BITS
;
131 if (cramfsb
->magic
== CRAMFS_MAGIC
) {
133 "RAMDISK: cramfs filesystem found at block %d\n",
135 nblocks
= (cramfsb
->size
+ BLOCK_SIZE
- 1) >> BLOCK_SIZE_BITS
;
140 * Read block 1 to test for minix and ext2 superblock
142 sys_lseek(fd
, (start_block
+1) * BLOCK_SIZE
, 0);
143 sys_read(fd
, buf
, size
);
146 if (minixsb
->s_magic
== MINIX_SUPER_MAGIC
||
147 minixsb
->s_magic
== MINIX_SUPER_MAGIC2
) {
149 "RAMDISK: Minix filesystem found at block %d\n",
151 nblocks
= minixsb
->s_nzones
<< minixsb
->s_log_zone_size
;
156 if (ext2sb
->s_magic
== cpu_to_le16(EXT2_SUPER_MAGIC
)) {
158 "RAMDISK: ext2 filesystem found at block %d\n",
160 nblocks
= le32_to_cpu(ext2sb
->s_blocks_count
) <<
161 le32_to_cpu(ext2sb
->s_log_block_size
);
166 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
170 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
175 int __init
rd_load_image(char *from
)
179 unsigned long rd_blocks
, devblocks
;
180 int nblocks
, i
, disk
;
182 unsigned short rotate
= 0;
183 decompress_fn decompressor
= NULL
;
184 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
185 char rotator
[4] = { '|' , '/' , '-' , '\\' };
188 out_fd
= sys_open("/dev/ram", O_RDWR
, 0);
192 in_fd
= sys_open(from
, O_RDONLY
, 0);
196 nblocks
= identify_ramdisk_image(in_fd
, rd_image_start
, &decompressor
);
201 if (crd_load(in_fd
, out_fd
, decompressor
) == 0)
202 goto successful_load
;
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.
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.
217 if (sys_ioctl(out_fd
, BLKGETSIZE
, (unsigned long)&rd_blocks
) < 0)
222 if (nblocks
> rd_blocks
) {
223 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
229 * OK, time to copy in the data
231 if (sys_ioctl(in_fd
, BLKGETSIZE
, (unsigned long)&devblocks
) < 0)
236 if (strcmp(from
, "/initrd.image") == 0)
239 if (devblocks
== 0) {
240 printk(KERN_ERR
"RAMDISK: could not determine device size\n");
244 buf
= kmalloc(BLOCK_SIZE
, GFP_KERNEL
);
246 printk(KERN_ERR
"RAMDISK: could not allocate buffer\n");
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
++);
256 if (sys_close(in_fd
)) {
257 printk("Error closing the disk.\n");
260 change_floppy("disk #%d", disk
);
261 in_fd
= sys_open(from
, O_RDONLY
, 0);
263 printk("Error opening disk.\n");
266 printk("Loading disk #%d... ", disk
);
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)
272 printk("%c\b", rotator
[rotate
& 0x3]);
287 sys_unlink("/dev/ram");
291 int __init
rd_load_disk(int n
)
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");
300 static int exit_code
;
301 static int decompress_error
;
302 static int crd_infd
, crd_outfd
;
304 static int __init
compr_fill(void *buf
, unsigned int len
)
306 int r
= sys_read(crd_infd
, buf
, len
);
308 printk(KERN_ERR
"RAMDISK: error while reading compressed data");
310 printk(KERN_ERR
"RAMDISK: EOF while reading compressed data");
314 static int __init
compr_flush(void *window
, unsigned int outcnt
)
316 int written
= sys_write(crd_outfd
, window
, outcnt
);
317 if (written
!= outcnt
) {
318 if (decompress_error
== 0)
320 "RAMDISK: incomplete write (%d != %d)\n",
322 decompress_error
= 1;
328 static void __init
error(char *x
)
330 printk(KERN_ERR
"%s\n", x
);
332 decompress_error
= 1;
335 static int __init
crd_load(int in_fd
, int out_fd
, decompress_fn deco
)
340 result
= deco(NULL
, 0, compr_fill
, compr_flush
, NULL
, NULL
, error
);
341 if (decompress_error
)