do_mounts_rd.c

  1// SPDX-License-Identifier: GPL-2.0
  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 <uapi/linux/cramfs_fs.h>
  8#include <linux/initrd.h>
  9#include <linux/string.h>
 10#include <linux/string_choices.h>
 11#include <linux/slab.h>
 12
 13#include "do_mounts.h"
 14#include "../fs/squashfs/squashfs_fs.h"
 15
 16#include <linux/decompress/generic.h>
 17
 18static struct file *in_file, *out_file;
 19static loff_t in_pos, out_pos;
 20
 21static int __init prompt_ramdisk(char *str)
 22{
 23	pr_warn("ignoring the deprecated prompt_ramdisk= option\n");
 24	return 1;
 25}
 26__setup("prompt_ramdisk=", prompt_ramdisk);
 27
 28int __initdata rd_image_start;		/* starting block # of image */
 29
 30static int __init ramdisk_start_setup(char *str)
 31{
 32	return kstrtoint(str, 0, &rd_image_start) == 0;
 33}
 34__setup("ramdisk_start=", ramdisk_start_setup);
 35
 36static int __init crd_load(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 *	bzip2
 52 *	lzma
 53 *	xz
 54 *	lzo
 55 *	lz4
 56 */
 57static int __init
 58identify_ramdisk_image(struct file *file, loff_t pos,
 59		decompress_fn *decompressor)
 60{
 61	const int size = 512;
 62	struct minix_super_block *minixsb;
 63	struct romfs_super_block *romfsb;
 64	struct cramfs_super *cramfsb;
 65	struct squashfs_super_block *squashfsb;
 66	int nblocks = -1;
 67	unsigned char *buf;
 68	const char *compress_name;
 69	unsigned long n;
 70	int start_block = rd_image_start;
 71
 72	buf = kmalloc(size, GFP_KERNEL);
 73	if (!buf)
 74		return -ENOMEM;
 75
 76	minixsb = (struct minix_super_block *) buf;
 77	romfsb = (struct romfs_super_block *) buf;
 78	cramfsb = (struct cramfs_super *) buf;
 79	squashfsb = (struct squashfs_super_block *) buf;
 80	memset(buf, 0xe5, size);
 81
 82	/*
 83	 * Read block 0 to test for compressed kernel
 84	 */
 85	pos = start_block * BLOCK_SIZE;
 86	kernel_read(file, buf, size, &pos);
 87
 88	*decompressor = decompress_method(buf, size, &compress_name);
 89	if (compress_name) {
 90		printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n",
 91		       compress_name, start_block);
 92		if (!*decompressor)
 93			printk(KERN_EMERG
 94			       "RAMDISK: %s decompressor not configured!\n",
 95			       compress_name);
 96		nblocks = 0;
 97		goto done;
 98	}
 99
100	/* romfs is at block zero too */
101	if (romfsb->word0 == ROMSB_WORD0 &&
102	    romfsb->word1 == ROMSB_WORD1) {
103		printk(KERN_NOTICE
104		       "RAMDISK: romfs filesystem found at block %d\n",
105		       start_block);
106		nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
107		goto done;
108	}
109
110	if (cramfsb->magic == CRAMFS_MAGIC) {
111		printk(KERN_NOTICE
112		       "RAMDISK: cramfs filesystem found at block %d\n",
113		       start_block);
114		nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
115		goto done;
116	}
117
118	/* squashfs is at block zero too */
119	if (le32_to_cpu(squashfsb->s_magic) == SQUASHFS_MAGIC) {
120		printk(KERN_NOTICE
121		       "RAMDISK: squashfs filesystem found at block %d\n",
122		       start_block);
123		nblocks = (le64_to_cpu(squashfsb->bytes_used) + BLOCK_SIZE - 1)
124			 >> BLOCK_SIZE_BITS;
125		goto done;
126	}
127
128	/*
129	 * Read 512 bytes further to check if cramfs is padded
130	 */
131	pos = start_block * BLOCK_SIZE + 0x200;
132	kernel_read(file, buf, size, &pos);
133
134	if (cramfsb->magic == CRAMFS_MAGIC) {
135		printk(KERN_NOTICE
136		       "RAMDISK: cramfs filesystem found at block %d\n",
137		       start_block);
138		nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
139		goto done;
140	}
141
142	/*
143	 * Read block 1 to test for minix and ext2 superblock
144	 */
145	pos = (start_block + 1) * BLOCK_SIZE;
146	kernel_read(file, buf, size, &pos);
147
148	/* Try minix */
149	if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
150	    minixsb->s_magic == MINIX_SUPER_MAGIC2) {
151		printk(KERN_NOTICE
152		       "RAMDISK: Minix filesystem found at block %d\n",
153		       start_block);
154		nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
155		goto done;
156	}
157
158	/* Try ext2 */
159	n = ext2_image_size(buf);
160	if (n) {
161		printk(KERN_NOTICE
162		       "RAMDISK: ext2 filesystem found at block %d\n",
163		       start_block);
164		nblocks = n;
165		goto done;
166	}
167
168	printk(KERN_NOTICE
169	       "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
170	       start_block);
171
172done:
173	kfree(buf);
174	return nblocks;
175}
176
177static unsigned long nr_blocks(struct file *file)
178{
179	struct inode *inode = file->f_mapping->host;
180
181	if (!S_ISBLK(inode->i_mode))
182		return 0;
183	return i_size_read(inode) >> 10;
184}
185
186int __init rd_load_image(char *from)
187{
188	int res = 0;
189	unsigned long rd_blocks, devblocks, nr_disks;
190	int nblocks, i;
191	char *buf = NULL;
192	unsigned short rotate = 0;
193	decompress_fn decompressor = NULL;
194	char rotator[4] = { '|' , '/' , '-' , '\\' };
195
196	out_file = filp_open("/dev/ram", O_RDWR, 0);
197	if (IS_ERR(out_file))
198		goto out;
199
200	in_file = filp_open(from, O_RDONLY, 0);
201	if (IS_ERR(in_file))
202		goto noclose_input;
203
204	in_pos = rd_image_start * BLOCK_SIZE;
205	nblocks = identify_ramdisk_image(in_file, in_pos, &decompressor);
206	if (nblocks < 0)
207		goto done;
208
209	if (nblocks == 0) {
210		if (crd_load(decompressor) == 0)
211			goto successful_load;
212		goto done;
213	}
214
215	/*
216	 * NOTE NOTE: nblocks is not actually blocks but
217	 * the number of kibibytes of data to load into a ramdisk.
218	 */
219	rd_blocks = nr_blocks(out_file);
220	if (nblocks > rd_blocks) {
221		printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
222		       nblocks, rd_blocks);
223		goto done;
224	}
225
226	/*
227	 * OK, time to copy in the data
228	 */
229	if (strcmp(from, "/initrd.image") == 0)
230		devblocks = nblocks;
231	else
232		devblocks = nr_blocks(in_file);
233
234	if (devblocks == 0) {
235		printk(KERN_ERR "RAMDISK: could not determine device size\n");
236		goto done;
237	}
238
239	buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
240	if (!buf) {
241		printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
242		goto done;
243	}
244
245	nr_disks = (nblocks - 1) / devblocks + 1;
246	pr_notice("RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
247		  nblocks, nr_disks, str_plural(nr_disks));
248	for (i = 0; i < nblocks; i++) {
249		if (i && (i % devblocks == 0)) {
250			pr_cont("done disk #1.\n");
251			rotate = 0;
252			fput(in_file);
253			break;
254		}
255		kernel_read(in_file, buf, BLOCK_SIZE, &in_pos);
256		kernel_write(out_file, buf, BLOCK_SIZE, &out_pos);
257		if (!IS_ENABLED(CONFIG_S390) && !(i % 16)) {
258			pr_cont("%c\b", rotator[rotate & 0x3]);
259			rotate++;
260		}
261	}
262	pr_cont("done.\n");
263
264successful_load:
265	res = 1;
266done:
267	fput(in_file);
268noclose_input:
269	fput(out_file);
270out:
271	kfree(buf);
272	init_unlink("/dev/ram");
273	return res;
274}
275
276int __init rd_load_disk(int n)
277{
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;
285
286static long __init compr_fill(void *buf, unsigned long len)
287{
288	long r = kernel_read(in_file, buf, len, &in_pos);
289	if (r < 0)
290		printk(KERN_ERR "RAMDISK: error while reading compressed data");
291	else if (r == 0)
292		printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
293	return r;
294}
295
296static long __init compr_flush(void *window, unsigned long outcnt)
297{
298	long written = kernel_write(out_file, window, outcnt, &out_pos);
299	if (written != outcnt) {
300		if (decompress_error == 0)
301			printk(KERN_ERR
302			       "RAMDISK: incomplete write (%ld != %ld)\n",
303			       written, outcnt);
304		decompress_error = 1;
305		return -1;
306	}
307	return outcnt;
308}
309
310static void __init error(char *x)
311{
312	printk(KERN_ERR "%s\n", x);
313	exit_code = 1;
314	decompress_error = 1;
315}
316
317static int __init crd_load(decompress_fn deco)
318{
319	int result;
320
321	if (!deco) {
322		pr_emerg("Invalid ramdisk decompression routine.  "
323			 "Select appropriate config option.\n");
324		panic("Could not decompress initial ramdisk image.");
325	}
326
327	result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
328	if (decompress_error)
329		result = 1;
330	return result;
331}