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 #define BUILD_CRAMDISK
14
15 int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
16
17 static int __init prompt_ramdisk(char *str)
18 {
19 rd_prompt = simple_strtol(str,NULL,0) & 1;
20 return 1;
21 }
22 __setup("prompt_ramdisk=", prompt_ramdisk);
23
24 int __initdata rd_image_start; /* starting block # of image */
25
26 static int __init ramdisk_start_setup(char *str)
27 {
28 rd_image_start = simple_strtol(str,NULL,0);
29 return 1;
30 }
31 __setup("ramdisk_start=", ramdisk_start_setup);
32
33 static int __init crd_load(int in_fd, int out_fd);
34
35 /*
36 * This routine tries to find a RAM disk image to load, and returns the
37 * number of blocks to read for a non-compressed image, 0 if the image
38 * is a compressed image, and -1 if an image with the right magic
39 * numbers could not be found.
40 *
41 * We currently check for the following magic numbers:
42 * minix
43 * ext2
44 * romfs
45 * cramfs
46 * gzip
47 */
48 static int __init
49 identify_ramdisk_image(int fd, int start_block)
50 {
51 const int size = 512;
52 struct minix_super_block *minixsb;
53 struct ext2_super_block *ext2sb;
54 struct romfs_super_block *romfsb;
55 struct cramfs_super *cramfsb;
56 int nblocks = -1;
57 unsigned char *buf;
58
59 buf = kmalloc(size, GFP_KERNEL);
60 if (buf == 0)
61 return -1;
62
63 minixsb = (struct minix_super_block *) buf;
64 ext2sb = (struct ext2_super_block *) buf;
65 romfsb = (struct romfs_super_block *) buf;
66 cramfsb = (struct cramfs_super *) buf;
67 memset(buf, 0xe5, size);
68
69 /*
70 * Read block 0 to test for gzipped kernel
71 */
72 sys_lseek(fd, start_block * BLOCK_SIZE, 0);
73 sys_read(fd, buf, size);
74
75 /*
76 * If it matches the gzip magic numbers, return -1
77 */
78 if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
79 printk(KERN_NOTICE
80 "RAMDISK: Compressed image found at block %d\n",
81 start_block);
82 nblocks = 0;
83 goto done;
84 }
85
86 /* romfs is at block zero too */
87 if (romfsb->word0 == ROMSB_WORD0 &&
88 romfsb->word1 == ROMSB_WORD1) {
89 printk(KERN_NOTICE
90 "RAMDISK: romfs filesystem found at block %d\n",
91 start_block);
92 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
93 goto done;
94 }
95
96 if (cramfsb->magic == CRAMFS_MAGIC) {
97 printk(KERN_NOTICE
98 "RAMDISK: cramfs filesystem found at block %d\n",
99 start_block);
100 nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
101 goto done;
102 }
103
104 /*
105 * Read block 1 to test for minix and ext2 superblock
106 */
107 sys_lseek(fd, (start_block+1) * BLOCK_SIZE, 0);
108 sys_read(fd, buf, size);
109
110 /* Try minix */
111 if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
112 minixsb->s_magic == MINIX_SUPER_MAGIC2) {
113 printk(KERN_NOTICE
114 "RAMDISK: Minix filesystem found at block %d\n",
115 start_block);
116 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
117 goto done;
118 }
119
120 /* Try ext2 */
121 if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
122 printk(KERN_NOTICE
123 "RAMDISK: ext2 filesystem found at block %d\n",
124 start_block);
125 nblocks = le32_to_cpu(ext2sb->s_blocks_count) <<
126 le32_to_cpu(ext2sb->s_log_block_size);
127 goto done;
128 }
129
130 printk(KERN_NOTICE
131 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
132 start_block);
133
134 done:
135 sys_lseek(fd, start_block * BLOCK_SIZE, 0);
136 kfree(buf);
137 return nblocks;
138 }
139
140 int __init rd_load_image(char *from)
141 {
142 int res = 0;
143 int in_fd, out_fd;
144 unsigned long rd_blocks, devblocks;
145 int nblocks, i, disk;
146 char *buf = NULL;
147 unsigned short rotate = 0;
148 #if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
149 char rotator[4] = { '|' , '/' , '-' , '\\' };
150 #endif
151
152 out_fd = sys_open("/dev/ram", O_RDWR, 0);
153 if (out_fd < 0)
154 goto out;
155
156 in_fd = sys_open(from, O_RDONLY, 0);
157 if (in_fd < 0)
158 goto noclose_input;
159
160 nblocks = identify_ramdisk_image(in_fd, rd_image_start);
161 if (nblocks < 0)
162 goto done;
163
164 if (nblocks == 0) {
165 #ifdef BUILD_CRAMDISK
166 if (crd_load(in_fd, out_fd) == 0)
167 goto successful_load;
168 #else
169 printk(KERN_NOTICE
170 "RAMDISK: Kernel does not support compressed "
171 "RAM disk images\n");
172 #endif
173 goto done;
174 }
175
176 /*
177 * NOTE NOTE: nblocks is not actually blocks but
178 * the number of kibibytes of data to load into a ramdisk.
179 * So any ramdisk block size that is a multiple of 1KiB should
180 * work when the appropriate ramdisk_blocksize is specified
181 * on the command line.
182 *
183 * The default ramdisk_blocksize is 1KiB and it is generally
184 * silly to use anything else, so make sure to use 1KiB
185 * blocksize while generating ext2fs ramdisk-images.
186 */
187 if (sys_ioctl(out_fd, BLKGETSIZE, (unsigned long)&rd_blocks) < 0)
188 rd_blocks = 0;
189 else
190 rd_blocks >>= 1;
191
192 if (nblocks > rd_blocks) {
193 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
194 nblocks, rd_blocks);
195 goto done;
196 }
197
198 /*
199 * OK, time to copy in the data
200 */
201 if (sys_ioctl(in_fd, BLKGETSIZE, (unsigned long)&devblocks) < 0)
202 devblocks = 0;
203 else
204 devblocks >>= 1;
205
206 if (strcmp(from, "/initrd.image") == 0)
207 devblocks = nblocks;
208
209 if (devblocks == 0) {
210 printk(KERN_ERR "RAMDISK: could not determine device size\n");
211 goto done;
212 }
213
214 buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
215 if (buf == 0) {
216 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
217 goto done;
218 }
219
220 printk(KERN_NOTICE "RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
221 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
222 for (i = 0, disk = 1; i < nblocks; i++) {
223 if (i && (i % devblocks == 0)) {
224 printk("done disk #%d.\n", disk++);
225 rotate = 0;
226 if (sys_close(in_fd)) {
227 printk("Error closing the disk.\n");
228 goto noclose_input;
229 }
230 change_floppy("disk #%d", disk);
231 in_fd = sys_open(from, O_RDONLY, 0);
232 if (in_fd < 0) {
233 printk("Error opening disk.\n");
234 goto noclose_input;
235 }
236 printk("Loading disk #%d... ", disk);
237 }
238 sys_read(in_fd, buf, BLOCK_SIZE);
239 sys_write(out_fd, buf, BLOCK_SIZE);
240 #if !defined(CONFIG_ARCH_S390) && !defined(CONFIG_PPC_ISERIES)
241 if (!(i % 16)) {
242 printk("%c\b", rotator[rotate & 0x3]);
243 rotate++;
244 }
245 #endif
246 }
247 printk("done.\n");
248
249 successful_load:
250 res = 1;
251 done:
252 sys_close(in_fd);
253 noclose_input:
254 sys_close(out_fd);
255 out:
256 kfree(buf);
257 sys_unlink("/dev/ram");
258 return res;
259 }
260
261 int __init rd_load_disk(int n)
262 {
263 if (rd_prompt)
264 change_floppy("root floppy disk to be loaded into RAM disk");
265 create_dev("/dev/root", ROOT_DEV, root_device_name);
266 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n), NULL);
267 return rd_load_image("/dev/root");
268 }
269
270 #ifdef BUILD_CRAMDISK
271
272 /*
273 * gzip declarations
274 */
275
276 #define OF(args) args
277
278 #ifndef memzero
279 #define memzero(s, n) memset ((s), 0, (n))
280 #endif
281
282 typedef unsigned char uch;
283 typedef unsigned short ush;
284 typedef unsigned long ulg;
285
286 #define INBUFSIZ 4096
287 #define WSIZE 0x8000 /* window size--must be a power of two, and */
288 /* at least 32K for zip's deflate method */
289
290 static uch *inbuf;
291 static uch *window;
292
293 static unsigned insize; /* valid bytes in inbuf */
294 static unsigned inptr; /* index of next byte to be processed in inbuf */
295 static unsigned outcnt; /* bytes in output buffer */
296 static int exit_code;
297 static int unzip_error;
298 static long bytes_out;
299 static int crd_infd, crd_outfd;
300
301 #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
302
303 /* Diagnostic functions (stubbed out) */
304 #define Assert(cond,msg)
305 #define Trace(x)
306 #define Tracev(x)
307 #define Tracevv(x)
308 #define Tracec(c,x)
309 #define Tracecv(c,x)
310
311 #define STATIC static
312 #define INIT __init
313
314 static int __init fill_inbuf(void);
315 static void __init flush_window(void);
316 static void __init *malloc(size_t size);
317 static void __init free(void *where);
318 static void __init error(char *m);
319 static void __init gzip_mark(void **);
320 static void __init gzip_release(void **);
321
322 #include "../lib/inflate.c"
323
324 static void __init *malloc(size_t size)
325 {
326 return kmalloc(size, GFP_KERNEL);
327 }
328
329 static void __init free(void *where)
330 {
331 kfree(where);
332 }
333
334 static void __init gzip_mark(void **ptr)
335 {
336 }
337
338 static void __init gzip_release(void **ptr)
339 {
340 }
341
342
343 /* ===========================================================================
344 * Fill the input buffer. This is called only when the buffer is empty
345 * and at least one byte is really needed.
346 * Returning -1 does not guarantee that gunzip() will ever return.
347 */
348 static int __init fill_inbuf(void)
349 {
350 if (exit_code) return -1;
351
352 insize = sys_read(crd_infd, inbuf, INBUFSIZ);
353 if (insize == 0) {
354 error("RAMDISK: ran out of compressed data");
355 return -1;
356 }
357
358 inptr = 1;
359
360 return inbuf[0];
361 }
362
363 /* ===========================================================================
364 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
365 * (Used for the decompressed data only.)
366 */
367 static void __init flush_window(void)
368 {
369 ulg c = crc; /* temporary variable */
370 unsigned n, written;
371 uch *in, ch;
372
373 written = sys_write(crd_outfd, window, outcnt);
374 if (written != outcnt && unzip_error == 0) {
375 printk(KERN_ERR "RAMDISK: incomplete write (%d != %d) %ld\n",
376 written, outcnt, bytes_out);
377 unzip_error = 1;
378 }
379 in = window;
380 for (n = 0; n < outcnt; n++) {
381 ch = *in++;
382 c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
383 }
384 crc = c;
385 bytes_out += (ulg)outcnt;
386 outcnt = 0;
387 }
388
389 static void __init error(char *x)
390 {
391 printk(KERN_ERR "%s\n", x);
392 exit_code = 1;
393 unzip_error = 1;
394 }
395
396 static int __init crd_load(int in_fd, int out_fd)
397 {
398 int result;
399
400 insize = 0; /* valid bytes in inbuf */
401 inptr = 0; /* index of next byte to be processed in inbuf */
402 outcnt = 0; /* bytes in output buffer */
403 exit_code = 0;
404 bytes_out = 0;
405 crc = (ulg)0xffffffffL; /* shift register contents */
406
407 crd_infd = in_fd;
408 crd_outfd = out_fd;
409 inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
410 if (inbuf == 0) {
411 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
412 return -1;
413 }
414 window = kmalloc(WSIZE, GFP_KERNEL);
415 if (window == 0) {
416 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
417 kfree(inbuf);
418 return -1;
419 }
420 makecrc();
421 result = gunzip();
422 if (unzip_error)
423 result = 1;
424 kfree(inbuf);
425 kfree(window);
426 return result;
427 }
428
429 #endif /* BUILD_CRAMDISK */
430
|
This page was automatically generated by the
LXR engine.
|