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"
12 #include "../fs/squashfs/squashfs_fs.h"
14 #include <linux/decompress/generic.h>
17 int __initdata rd_prompt
= 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
19 static int __init
prompt_ramdisk(char *str
)
21 rd_prompt
= simple_strtol(str
,NULL
,0) & 1;
24 __setup("prompt_ramdisk=", prompt_ramdisk
);
26 int __initdata rd_image_start
; /* starting block # of image */
28 static int __init
ramdisk_start_setup(char *str
)
30 rd_image_start
= simple_strtol(str
,NULL
,0);
33 __setup("ramdisk_start=", ramdisk_start_setup
);
35 static int __init
crd_load(int in_fd
, int out_fd
, decompress_fn deco
);
38 * This routine tries to find a RAM disk image to load, and returns the
39 * number of blocks to read for a non-compressed image, 0 if the image
40 * is a compressed image, and -1 if an image with the right magic
41 * numbers could not be found.
43 * We currently check for the following magic numbers:
52 identify_ramdisk_image(int fd
, int start_block
, decompress_fn
*decompressor
)
55 struct minix_super_block
*minixsb
;
56 struct ext2_super_block
*ext2sb
;
57 struct romfs_super_block
*romfsb
;
58 struct cramfs_super
*cramfsb
;
59 struct squashfs_super_block
*squashfsb
;
62 const char *compress_name
;
64 buf
= kmalloc(size
, GFP_KERNEL
);
68 minixsb
= (struct minix_super_block
*) buf
;
69 ext2sb
= (struct ext2_super_block
*) buf
;
70 romfsb
= (struct romfs_super_block
*) buf
;
71 cramfsb
= (struct cramfs_super
*) buf
;
72 squashfsb
= (struct squashfs_super_block
*) buf
;
73 memset(buf
, 0xe5, size
);
76 * Read block 0 to test for compressed kernel
78 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
79 sys_read(fd
, buf
, size
);
81 *decompressor
= decompress_method(buf
, size
, &compress_name
);
83 printk(KERN_NOTICE
"RAMDISK: %s image found at block %d\n",
84 compress_name
, start_block
);
89 /* romfs is at block zero too */
90 if (romfsb
->word0
== ROMSB_WORD0
&&
91 romfsb
->word1
== ROMSB_WORD1
) {
93 "RAMDISK: romfs filesystem found at block %d\n",
95 nblocks
= (ntohl(romfsb
->size
)+BLOCK_SIZE
-1)>>BLOCK_SIZE_BITS
;
99 if (cramfsb
->magic
== CRAMFS_MAGIC
) {
101 "RAMDISK: cramfs filesystem found at block %d\n",
103 nblocks
= (cramfsb
->size
+ BLOCK_SIZE
- 1) >> BLOCK_SIZE_BITS
;
107 /* squashfs is at block zero too */
108 if (le32_to_cpu(squashfsb
->s_magic
) == SQUASHFS_MAGIC
) {
110 "RAMDISK: squashfs filesystem found at block %d\n",
112 nblocks
= (le64_to_cpu(squashfsb
->bytes_used
) + BLOCK_SIZE
- 1)
118 * Read block 1 to test for minix and ext2 superblock
120 sys_lseek(fd
, (start_block
+1) * BLOCK_SIZE
, 0);
121 sys_read(fd
, buf
, size
);
124 if (minixsb
->s_magic
== MINIX_SUPER_MAGIC
||
125 minixsb
->s_magic
== MINIX_SUPER_MAGIC2
) {
127 "RAMDISK: Minix filesystem found at block %d\n",
129 nblocks
= minixsb
->s_nzones
<< minixsb
->s_log_zone_size
;
134 if (ext2sb
->s_magic
== cpu_to_le16(EXT2_SUPER_MAGIC
)) {
136 "RAMDISK: ext2 filesystem found at block %d\n",
138 nblocks
= le32_to_cpu(ext2sb
->s_blocks_count
) <<
139 le32_to_cpu(ext2sb
->s_log_block_size
);
144 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
148 sys_lseek(fd
, start_block
* BLOCK_SIZE
, 0);
153 int __init
rd_load_image(char *from
)
157 unsigned long rd_blocks
, devblocks
;
158 int nblocks
, i
, disk
;
160 unsigned short rotate
= 0;
161 decompress_fn decompressor
= NULL
;
162 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
163 char rotator
[4] = { '|' , '/' , '-' , '\\' };
166 out_fd
= sys_open("/dev/ram", O_RDWR
, 0);
170 in_fd
= sys_open(from
, O_RDONLY
, 0);
174 nblocks
= identify_ramdisk_image(in_fd
, rd_image_start
, &decompressor
);
179 if (crd_load(in_fd
, out_fd
, decompressor
) == 0)
180 goto successful_load
;
185 * NOTE NOTE: nblocks is not actually blocks but
186 * the number of kibibytes of data to load into a ramdisk.
187 * So any ramdisk block size that is a multiple of 1KiB should
188 * work when the appropriate ramdisk_blocksize is specified
189 * on the command line.
191 * The default ramdisk_blocksize is 1KiB and it is generally
192 * silly to use anything else, so make sure to use 1KiB
193 * blocksize while generating ext2fs ramdisk-images.
195 if (sys_ioctl(out_fd
, BLKGETSIZE
, (unsigned long)&rd_blocks
) < 0)
200 if (nblocks
> rd_blocks
) {
201 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
207 * OK, time to copy in the data
209 if (sys_ioctl(in_fd
, BLKGETSIZE
, (unsigned long)&devblocks
) < 0)
214 if (strcmp(from
, "/initrd.image") == 0)
217 if (devblocks
== 0) {
218 printk(KERN_ERR
"RAMDISK: could not determine device size\n");
222 buf
= kmalloc(BLOCK_SIZE
, GFP_KERNEL
);
224 printk(KERN_ERR
"RAMDISK: could not allocate buffer\n");
228 printk(KERN_NOTICE
"RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
229 nblocks
, ((nblocks
-1)/devblocks
)+1, nblocks
>devblocks
? "s" : "");
230 for (i
= 0, disk
= 1; i
< nblocks
; i
++) {
231 if (i
&& (i
% devblocks
== 0)) {
232 printk("done disk #%d.\n", disk
++);
234 if (sys_close(in_fd
)) {
235 printk("Error closing the disk.\n");
238 change_floppy("disk #%d", disk
);
239 in_fd
= sys_open(from
, O_RDONLY
, 0);
241 printk("Error opening disk.\n");
244 printk("Loading disk #%d... ", disk
);
246 sys_read(in_fd
, buf
, BLOCK_SIZE
);
247 sys_write(out_fd
, buf
, BLOCK_SIZE
);
248 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
250 printk("%c\b", rotator
[rotate
& 0x3]);
265 sys_unlink("/dev/ram");
269 int __init
rd_load_disk(int n
)
272 change_floppy("root floppy disk to be loaded into RAM disk");
273 create_dev("/dev/root", ROOT_DEV
);
274 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR
, n
));
275 return rd_load_image("/dev/root");
278 static int exit_code
;
279 static int decompress_error
;
280 static int crd_infd
, crd_outfd
;
282 static int __init
compr_fill(void *buf
, unsigned int len
)
284 int r
= sys_read(crd_infd
, buf
, len
);
286 printk(KERN_ERR
"RAMDISK: error while reading compressed data");
288 printk(KERN_ERR
"RAMDISK: EOF while reading compressed data");
292 static int __init
compr_flush(void *window
, unsigned int outcnt
)
294 int written
= sys_write(crd_outfd
, window
, outcnt
);
295 if (written
!= outcnt
) {
296 if (decompress_error
== 0)
298 "RAMDISK: incomplete write (%d != %d)\n",
300 decompress_error
= 1;
306 static void __init
error(char *x
)
308 printk(KERN_ERR
"%s\n", x
);
310 decompress_error
= 1;
313 static int __init
crd_load(int in_fd
, int out_fd
, decompress_fn deco
)
318 result
= deco(NULL
, 0, compr_fill
, compr_flush
, NULL
, NULL
, error
);
319 if (decompress_error
)