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