[thirdparty/kernel/stable.git] / init / do_mounts_rd.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/minix_fs.h>
#include <linux/ext2_fs.h>
#include <linux/romfs_fs.h>
#include <uapi/linux/cramfs_fs.h>
#include <linux/initrd.h>
#include <linux/string.h>
#include <linux/slab.h>

#include "do_mounts.h"
#include "../fs/squashfs/squashfs_fs.h"

#include <linux/decompress/generic.h>

static struct file *in_file, *out_file;
static loff_t in_pos, out_pos;

static int __init prompt_ramdisk(char *str)
{
	pr_warn("ignoring the deprecated prompt_ramdisk= option\n");
	return 1;
}
__setup("prompt_ramdisk=", prompt_ramdisk);

int __initdata rd_image_start;		/* starting block # of image */

static int __init ramdisk_start_setup(char *str)
{
	rd_image_start = simple_strtol(str,NULL,0);
	return 1;
}
__setup("ramdisk_start=", ramdisk_start_setup);

static int __init crd_load(decompress_fn deco);

/*
 * This routine tries to find a RAM disk image to load, and returns the
 * number of blocks to read for a non-compressed image, 0 if the image
 * is a compressed image, and -1 if an image with the right magic
 * numbers could not be found.
 *
 * We currently check for the following magic numbers:
 *	minix
 *	ext2
 *	romfs
 *	cramfs
 *	squashfs
 *	gzip
 *	bzip2
 *	lzma
 *	xz
 *	lzo
 *	lz4
 */
static int __init
identify_ramdisk_image(struct file *file, loff_t pos,
		decompress_fn *decompressor)
{
	const int size = 512;
	struct minix_super_block *minixsb;
	struct romfs_super_block *romfsb;
	struct cramfs_super *cramfsb;
	struct squashfs_super_block *squashfsb;
	int nblocks = -1;
	unsigned char *buf;
	const char *compress_name;
	unsigned long n;
	int start_block = rd_image_start;

	buf = kmalloc(size, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	minixsb = (struct minix_super_block *) buf;
	romfsb = (struct romfs_super_block *) buf;
	cramfsb = (struct cramfs_super *) buf;
	squashfsb = (struct squashfs_super_block *) buf;
	memset(buf, 0xe5, size);

	/*
	 * Read block 0 to test for compressed kernel
	 */
	pos = start_block * BLOCK_SIZE;
	kernel_read(file, buf, size, &pos);

	*decompressor = decompress_method(buf, size, &compress_name);
	if (compress_name) {
		printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n",
		       compress_name, start_block);
		if (!*decompressor)
			printk(KERN_EMERG
			       "RAMDISK: %s decompressor not configured!\n",
			       compress_name);
		nblocks = 0;
		goto done;
	}

	/* romfs is at block zero too */
	if (romfsb->word0 == ROMSB_WORD0 &&
	    romfsb->word1 == ROMSB_WORD1) {
		printk(KERN_NOTICE
		       "RAMDISK: romfs filesystem found at block %d\n",
		       start_block);
		nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
		goto done;
	}

	if (cramfsb->magic == CRAMFS_MAGIC) {
		printk(KERN_NOTICE
		       "RAMDISK: cramfs filesystem found at block %d\n",
		       start_block);
		nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
		goto done;
	}

	/* squashfs is at block zero too */
	if (le32_to_cpu(squashfsb->s_magic) == SQUASHFS_MAGIC) {
		printk(KERN_NOTICE
		       "RAMDISK: squashfs filesystem found at block %d\n",
		       start_block);
		nblocks = (le64_to_cpu(squashfsb->bytes_used) + BLOCK_SIZE - 1)
			 >> BLOCK_SIZE_BITS;
		goto done;
	}

	/*
	 * Read 512 bytes further to check if cramfs is padded
	 */
	pos = start_block * BLOCK_SIZE + 0x200;
	kernel_read(file, buf, size, &pos);

	if (cramfsb->magic == CRAMFS_MAGIC) {
		printk(KERN_NOTICE
		       "RAMDISK: cramfs filesystem found at block %d\n",
		       start_block);
		nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
		goto done;
	}

	/*
	 * Read block 1 to test for minix and ext2 superblock
	 */
	pos = (start_block + 1) * BLOCK_SIZE;
	kernel_read(file, buf, size, &pos);

	/* Try minix */
	if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
	    minixsb->s_magic == MINIX_SUPER_MAGIC2) {
		printk(KERN_NOTICE
		       "RAMDISK: Minix filesystem found at block %d\n",
		       start_block);
		nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
		goto done;
	}

	/* Try ext2 */
	n = ext2_image_size(buf);
	if (n) {
		printk(KERN_NOTICE
		       "RAMDISK: ext2 filesystem found at block %d\n",
		       start_block);
		nblocks = n;
		goto done;
	}

	printk(KERN_NOTICE
	       "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
	       start_block);

done:
	kfree(buf);
	return nblocks;
}

static unsigned long nr_blocks(struct file *file)
{
	struct inode *inode = file->f_mapping->host;

	if (!S_ISBLK(inode->i_mode))
		return 0;
	return i_size_read(inode) >> 10;
}

int __init rd_load_image(char *from)
{
	int res = 0;
	unsigned long rd_blocks, devblocks;
	int nblocks, i;
	char *buf = NULL;
	unsigned short rotate = 0;
	decompress_fn decompressor = NULL;
#if !defined(CONFIG_S390)
	char rotator[4] = { '|' , '/' , '-' , '\\' };
#endif

	out_file = filp_open("/dev/ram", O_RDWR, 0);
	if (IS_ERR(out_file))
		goto out;

	in_file = filp_open(from, O_RDONLY, 0);
	if (IS_ERR(in_file))
		goto noclose_input;

	in_pos = rd_image_start * BLOCK_SIZE;
	nblocks = identify_ramdisk_image(in_file, in_pos, &decompressor);
	if (nblocks < 0)
		goto done;

	if (nblocks == 0) {
		if (crd_load(decompressor) == 0)
			goto successful_load;
		goto done;
	}

	/*
	 * NOTE NOTE: nblocks is not actually blocks but
	 * the number of kibibytes of data to load into a ramdisk.
	 */
	rd_blocks = nr_blocks(out_file);
	if (nblocks > rd_blocks) {
		printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
		       nblocks, rd_blocks);
		goto done;
	}

	/*
	 * OK, time to copy in the data
	 */
	if (strcmp(from, "/initrd.image") == 0)
		devblocks = nblocks;
	else
		devblocks = nr_blocks(in_file);

	if (devblocks == 0) {
		printk(KERN_ERR "RAMDISK: could not determine device size\n");
		goto done;
	}

	buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
	if (!buf) {
		printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
		goto done;
	}

	printk(KERN_NOTICE "RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
		nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
	for (i = 0; i < nblocks; i++) {
		if (i && (i % devblocks == 0)) {
			pr_cont("done disk #1.\n");
			rotate = 0;
			fput(in_file);
			break;
		}
		kernel_read(in_file, buf, BLOCK_SIZE, &in_pos);
		kernel_write(out_file, buf, BLOCK_SIZE, &out_pos);
#if !defined(CONFIG_S390)
		if (!(i % 16)) {
			pr_cont("%c\b", rotator[rotate & 0x3]);
			rotate++;
		}
#endif
	}
	pr_cont("done.\n");

successful_load:
	res = 1;
done:
	fput(in_file);
noclose_input:
	fput(out_file);
out:
	kfree(buf);
	init_unlink("/dev/ram");
	return res;
}

int __init rd_load_disk(int n)
{
	create_dev("/dev/root", ROOT_DEV);
	create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
	return rd_load_image("/dev/root");
}

static int exit_code;
static int decompress_error;

static long __init compr_fill(void *buf, unsigned long len)
{
	long r = kernel_read(in_file, buf, len, &in_pos);
	if (r < 0)
		printk(KERN_ERR "RAMDISK: error while reading compressed data");
	else if (r == 0)
		printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
	return r;
}

static long __init compr_flush(void *window, unsigned long outcnt)
{
	long written = kernel_write(out_file, window, outcnt, &out_pos);
	if (written != outcnt) {
		if (decompress_error == 0)
			printk(KERN_ERR
			       "RAMDISK: incomplete write (%ld != %ld)\n",
			       written, outcnt);
		decompress_error = 1;
		return -1;
	}
	return outcnt;
}

static void __init error(char *x)
{
	printk(KERN_ERR "%s\n", x);
	exit_code = 1;
	decompress_error = 1;
}

static int __init crd_load(decompress_fn deco)
{
	int result;

	if (!deco) {
		pr_emerg("Invalid ramdisk decompression routine.  "
			 "Select appropriate config option.\n");
		panic("Could not decompress initial ramdisk image.");
	}

	result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
	if (decompress_error)
		result = 1;
	return result;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	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>
f7f4f4dd	7	#include <uapi/linux/cramfs_fs.h>
1da177e4 LT	8	#include <linux/initrd.h>
1da177e4 LT	9	#include <linux/string.h>
5a0e3ad6	10	#include <linux/slab.h>
1da177e4 LT	11
1da177e4 LT	12	#include "do_mounts.h"
b8fed87d	13	#include "../fs/squashfs/squashfs_fs.h"
1da177e4	14
30d65dbf AK	15	#include <linux/decompress/generic.h>
30d65dbf AK	16
bef17329 CH	17	static struct file in_file, out_file;
bef17329 CH	18	static loff_t in_pos, out_pos;
30d65dbf	19
1da177e4 LT	20	static int __init prompt_ramdisk(char *str)
1da177e4 LT	21	{
c8376994	22	pr_warn("ignoring the deprecated prompt_ramdisk= option\n");
1da177e4 LT	23	return 1;
	24	}
	25	__setup("prompt_ramdisk=", prompt_ramdisk);
	26
	27	int __initdata rd_image_start; /* starting block # of image */
	28
	29	static 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
bef17329	36	static int __init crd_load(decompress_fn deco);
1da177e4 LT	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:
b172fd88 PA	45	* minix
b172fd88 PA	46	* ext2
1da177e4 LT	47	* romfs
1da177e4 LT	48	* cramfs
b8fed87d	49	* squashfs
b172fd88	50	* gzip
1bf49dd4	51	* bzip2
	52	* lzma
	53	* xz
	54	* lzo
	55	* lz4
1da177e4	56	*/
b172fd88	57	static int __init
bef17329 CH	58	identify_ramdisk_image(struct file *file, loff_t pos,
bef17329 CH	59	decompress_fn *decompressor)
1da177e4 LT	60	{
	61	const int size = 512;
	62	struct minix_super_block *minixsb;
1da177e4 LT	63	struct romfs_super_block *romfsb;
1da177e4 LT	64	struct cramfs_super *cramfsb;
b8fed87d	65	struct squashfs_super_block *squashfsb;
1da177e4 LT	66	int nblocks = -1;
1da177e4 LT	67	unsigned char *buf;
889c92d2	68	const char *compress_name;
39429c5e	69	unsigned long n;
bef17329	70	int start_block = rd_image_start;
1da177e4 LT	71
1da177e4 LT	72	buf = kmalloc(size, GFP_KERNEL);
c80544dc	73	if (!buf)
ea611b26	74	return -ENOMEM;
1da177e4 LT	75
1da177e4 LT	76	minixsb = (struct minix_super_block *) buf;
1da177e4 LT	77	romfsb = (struct romfs_super_block *) buf;
1da177e4 LT	78	cramfsb = (struct cramfs_super *) buf;
b8fed87d	79	squashfsb = (struct squashfs_super_block *) buf;
1da177e4 LT	80	memset(buf, 0xe5, size);
	81
	82	/*
b172fd88	83	* Read block 0 to test for compressed kernel
1da177e4	84	*/
bef17329 CH	85	pos = start_block * BLOCK_SIZE;
bef17329 CH	86	kernel_read(file, buf, size, &pos);
1da177e4	87
889c92d2	88	*decompressor = decompress_method(buf, size, &compress_name);
23a22d57	89	if (compress_name) {
889c92d2 PA	90	printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n",
889c92d2 PA	91	compress_name, start_block);
23a22d57	92	if (!*decompressor)
73310a16 PA	93	printk(KERN_EMERG
73310a16 PA	94	"RAMDISK: %s decompressor not configured!\n",
23a22d57	95	compress_name);
889c92d2 PA	96	nblocks = 0;
889c92d2 PA	97	goto done;
1da177e4 LT	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
b8fed87d PL	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
f919b923 NA	128	/*
	129	* Read 512 bytes further to check if cramfs is padded
	130	*/
bef17329 CH	131	pos = start_block * BLOCK_SIZE + 0x200;
bef17329 CH	132	kernel_read(file, buf, size, &pos);
f919b923 NA	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
1da177e4 LT	142	/*
	143	* Read block 1 to test for minix and ext2 superblock
	144	*/
bef17329 CH	145	pos = (start_block + 1) * BLOCK_SIZE;
bef17329 CH	146	kernel_read(file, buf, size, &pos);
1da177e4 LT	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 */
39429c5e AV	159	n = ext2_image_size(buf);
39429c5e AV	160	if (n) {
1da177e4 LT	161	printk(KERN_NOTICE
	162	"RAMDISK: ext2 filesystem found at block %d\n",
	163	start_block);
39429c5e	164	nblocks = n;
1da177e4 LT	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);
b172fd88	171
1da177e4	172	done:
1da177e4 LT	173	kfree(buf);
	174	return nblocks;
	175	}
	176
bef17329 CH	177	static 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
1da177e4 LT	186	int __init rd_load_image(char *from)
	187	{
	188	int res = 0;
1da177e4	189	unsigned long rd_blocks, devblocks;
c8376994	190	int nblocks, i;
1da177e4 LT	191	char *buf = NULL;
1da177e4 LT	192	unsigned short rotate = 0;
30d65dbf	193	decompress_fn decompressor = NULL;
bc58450b	194	#if !defined(CONFIG_S390)
1da177e4 LT	195	char rotator[4] = { '\|' , '/' , '-' , '\\' };
	196	#endif
	197
bef17329 CH	198	out_file = filp_open("/dev/ram", O_RDWR, 0);
bef17329 CH	199	if (IS_ERR(out_file))
1da177e4 LT	200	goto out;
1da177e4 LT	201
bef17329 CH	202	in_file = filp_open(from, O_RDONLY, 0);
bef17329 CH	203	if (IS_ERR(in_file))
1da177e4 LT	204	goto noclose_input;
1da177e4 LT	205
bef17329 CH	206	in_pos = rd_image_start * BLOCK_SIZE;
bef17329 CH	207	nblocks = identify_ramdisk_image(in_file, in_pos, &decompressor);
1da177e4 LT	208	if (nblocks < 0)
	209	goto done;
	210
	211	if (nblocks == 0) {
bef17329	212	if (crd_load(decompressor) == 0)
1da177e4	213	goto successful_load;
1da177e4 LT	214	goto done;
	215	}
	216
	217	/*
	218	* NOTE NOTE: nblocks is not actually blocks but
	219	* the number of kibibytes of data to load into a ramdisk.
1da177e4	220	*/
bef17329	221	rd_blocks = nr_blocks(out_file);
1da177e4 LT	222	if (nblocks > rd_blocks) {
	223	printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
	224	nblocks, rd_blocks);
	225	goto done;
	226	}
b172fd88	227
1da177e4 LT	228	/*
	229	* OK, time to copy in the data
	230	*/
1da177e4 LT	231	if (strcmp(from, "/initrd.image") == 0)
1da177e4 LT	232	devblocks = nblocks;
bef17329 CH	233	else
bef17329 CH	234	devblocks = nr_blocks(in_file);
1da177e4 LT	235
	236	if (devblocks == 0) {
	237	printk(KERN_ERR "RAMDISK: could not determine device size\n");
	238	goto done;
	239	}
	240
	241	buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
d613c3e2	242	if (!buf) {
1da177e4 LT	243	printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
	244	goto done;
	245	}
	246
	247	printk(KERN_NOTICE "RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
	248	nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
c8376994	249	for (i = 0; i < nblocks; i++) {
1da177e4	250	if (i && (i % devblocks == 0)) {
c8376994	251	pr_cont("done disk #1.\n");
1da177e4	252	rotate = 0;
bef17329	253	fput(in_file);
c8376994	254	break;
1da177e4	255	}
bef17329 CH	256	kernel_read(in_file, buf, BLOCK_SIZE, &in_pos);
bef17329 CH	257	kernel_write(out_file, buf, BLOCK_SIZE, &out_pos);
bc58450b	258	#if !defined(CONFIG_S390)
1da177e4	259	if (!(i % 16)) {
18594e9b	260	pr_cont("%c\b", rotator[rotate & 0x3]);
1da177e4 LT	261	rotate++;
	262	}
	263	#endif
	264	}
1a6a05a4	265	pr_cont("done.\n");
1da177e4 LT	266
	267	successful_load:
	268	res = 1;
	269	done:
bef17329	270	fput(in_file);
1da177e4	271	noclose_input:
bef17329	272	fput(out_file);
1da177e4 LT	273	out:
1da177e4 LT	274	kfree(buf);
8fb9f73e	275	init_unlink("/dev/ram");
1da177e4 LT	276	return res;
	277	}
	278
	279	int __init rd_load_disk(int n)
	280	{
bdaf8529 GKH	281	create_dev("/dev/root", ROOT_DEV);
bdaf8529 GKH	282	create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
1da177e4 LT	283	return rd_load_image("/dev/root");
	284	}
	285
1da177e4	286	static int exit_code;
30d65dbf	287	static int decompress_error;
1da177e4	288
d97b07c5	289	static long __init compr_fill(void *buf, unsigned long len)
1da177e4	290	{
bef17329	291	long r = kernel_read(in_file, buf, len, &in_pos);
30d65dbf AK	292	if (r < 0)
	293	printk(KERN_ERR "RAMDISK: error while reading compressed data");
	294	else if (r == 0)
	295	printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
	296	return r;
1da177e4 LT	297	}
1da177e4 LT	298
d97b07c5	299	static long __init compr_flush(void *window, unsigned long outcnt)
1da177e4	300	{
bef17329	301	long written = kernel_write(out_file, window, outcnt, &out_pos);
30d65dbf AK	302	if (written != outcnt) {
	303	if (decompress_error == 0)
	304	printk(KERN_ERR
d97b07c5	305	"RAMDISK: incomplete write (%ld != %ld)\n",
30d65dbf AK	306	written, outcnt);
	307	decompress_error = 1;
	308	return -1;
	309	}
	310	return outcnt;
1da177e4 LT	311	}
	312
	313	static void __init error(char *x)
	314	{
	315	printk(KERN_ERR "%s\n", x);
	316	exit_code = 1;
30d65dbf	317	decompress_error = 1;
1da177e4 LT	318	}
1da177e4 LT	319
bef17329	320	static int __init crd_load(decompress_fn deco)
1da177e4 LT	321	{
1da177e4 LT	322	int result;
df3ef3af	323
	324	if (!deco) {
	325	pr_emerg("Invalid ramdisk decompression routine. "
	326	"Select appropriate config option.\n");
	327	panic("Could not decompress initial ramdisk image.");
	328	}
	329
30d65dbf AK	330	result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
30d65dbf AK	331	if (decompress_error)
1da177e4	332	result = 1;
1da177e4 LT	333	return result;
1da177e4 LT	334	}