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