[linux.git] / init / do_mounts_rd.c


#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/minix_fs.h>
#include <linux/ext2_fs.h>
#include <linux/romfs_fs.h>
#include <linux/cramfs_fs.h>
#include <linux/initrd.h>
#include <linux/string.h>

#include "do_mounts.h"

#define BUILD_CRAMDISK

int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */

static int __init prompt_ramdisk(char *str)
{
	rd_prompt = simple_strtol(str,NULL,0) & 1;
	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(int in_fd, int out_fd);

/*
 * 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
 * 	gzip
 */
static int __init 
identify_ramdisk_image(int fd, int start_block)
{
	const int size = 512;
	struct minix_super_block *minixsb;
	struct ext2_super_block *ext2sb;
	struct romfs_super_block *romfsb;
	struct cramfs_super *cramfsb;
	int nblocks = -1;
	unsigned char *buf;

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

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

	/*
	 * Read block 0 to test for gzipped kernel
	 */
	sys_lseek(fd, start_block * BLOCK_SIZE, 0);
	sys_read(fd, buf, size);

	/*
	 * If it matches the gzip magic numbers, return -1
	 */
	if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
		printk(KERN_NOTICE
		       "RAMDISK: Compressed image found at block %d\n",
		       start_block);
		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;
	}

	/*
	 * Read block 1 to test for minix and ext2 superblock
	 */
	sys_lseek(fd, (start_block+1) * BLOCK_SIZE, 0);
	sys_read(fd, buf, size);

	/* 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 */
	if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
		printk(KERN_NOTICE
		       "RAMDISK: ext2 filesystem found at block %d\n",
		       start_block);
		nblocks = le32_to_cpu(ext2sb->s_blocks_count) <<
			le32_to_cpu(ext2sb->s_log_block_size);
		goto done;
	}

	printk(KERN_NOTICE
	       "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
	       start_block);
	
done:
	sys_lseek(fd, start_block * BLOCK_SIZE, 0);
	kfree(buf);
	return nblocks;
}

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

	out_fd = sys_open("/dev/ram", O_RDWR, 0);
	if (out_fd < 0)
		goto out;

	in_fd = sys_open(from, O_RDONLY, 0);
	if (in_fd < 0)
		goto noclose_input;

	nblocks = identify_ramdisk_image(in_fd, rd_image_start);
	if (nblocks < 0)
		goto done;

	if (nblocks == 0) {
#ifdef BUILD_CRAMDISK
		if (crd_load(in_fd, out_fd) == 0)
			goto successful_load;
#else
		printk(KERN_NOTICE
		       "RAMDISK: Kernel does not support compressed "
		       "RAM disk images\n");
#endif
		goto done;
	}

	/*
	 * NOTE NOTE: nblocks is not actually blocks but
	 * the number of kibibytes of data to load into a ramdisk.
	 * So any ramdisk block size that is a multiple of 1KiB should
	 * work when the appropriate ramdisk_blocksize is specified
	 * on the command line.
	 *
	 * The default ramdisk_blocksize is 1KiB and it is generally
	 * silly to use anything else, so make sure to use 1KiB
	 * blocksize while generating ext2fs ramdisk-images.
	 */
	if (sys_ioctl(out_fd, BLKGETSIZE, (unsigned long)&rd_blocks) < 0)
		rd_blocks = 0;
	else
		rd_blocks >>= 1;

	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 (sys_ioctl(in_fd, BLKGETSIZE, (unsigned long)&devblocks) < 0)
		devblocks = 0;
	else
		devblocks >>= 1;

	if (strcmp(from, "/initrd.image") == 0)
		devblocks = nblocks;

	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, disk = 1; i < nblocks; i++) {
		if (i && (i % devblocks == 0)) {
			printk("done disk #%d.\n", disk++);
			rotate = 0;
			if (sys_close(in_fd)) {
				printk("Error closing the disk.\n");
				goto noclose_input;
			}
			change_floppy("disk #%d", disk);
			in_fd = sys_open(from, O_RDONLY, 0);
			if (in_fd < 0)  {
				printk("Error opening disk.\n");
				goto noclose_input;
			}
			printk("Loading disk #%d... ", disk);
		}
		sys_read(in_fd, buf, BLOCK_SIZE);
		sys_write(out_fd, buf, BLOCK_SIZE);
#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
		if (!(i % 16)) {
			printk("%c\b", rotator[rotate & 0x3]);
			rotate++;
		}
#endif
	}
	printk("done.\n");

successful_load:
	res = 1;
done:
	sys_close(in_fd);
noclose_input:
	sys_close(out_fd);
out:
	kfree(buf);
	sys_unlink("/dev/ram");
	return res;
}

int __init rd_load_disk(int n)
{
	if (rd_prompt)
		change_floppy("root floppy disk to be loaded into RAM disk");
	create_dev("/dev/root", ROOT_DEV);
	create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
	return rd_load_image("/dev/root");
}

#ifdef BUILD_CRAMDISK

/*
 * gzip declarations
 */

#define OF(args)  args

#ifndef memzero
#define memzero(s, n)     memset ((s), 0, (n))
#endif

typedef unsigned char  uch;
typedef unsigned short ush;
typedef unsigned long  ulg;

#define INBUFSIZ 4096
#define WSIZE 0x8000    /* window size--must be a power of two, and */
			/*  at least 32K for zip's deflate method */

static uch *inbuf;
static uch *window;

static unsigned insize;  /* valid bytes in inbuf */
static unsigned inptr;   /* index of next byte to be processed in inbuf */
static unsigned outcnt;  /* bytes in output buffer */
static int exit_code;
static int unzip_error;
static long bytes_out;
static int crd_infd, crd_outfd;

#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
		
/* Diagnostic functions (stubbed out) */
#define Assert(cond,msg)
#define Trace(x)
#define Tracev(x)
#define Tracevv(x)
#define Tracec(c,x)
#define Tracecv(c,x)

#define STATIC static
#define INIT __init

static int  __init fill_inbuf(void);
static void __init flush_window(void);
static void __init *malloc(size_t size);
static void __init free(void *where);
static void __init error(char *m);
static void __init gzip_mark(void **);
static void __init gzip_release(void **);

#include "../lib/inflate.c"

static void __init *malloc(size_t size)
{
	return kmalloc(size, GFP_KERNEL);
}

static void __init free(void *where)
{
	kfree(where);
}

static void __init gzip_mark(void **ptr)
{
}

static void __init gzip_release(void **ptr)
{
}


/* ===========================================================================
 * Fill the input buffer. This is called only when the buffer is empty
 * and at least one byte is really needed.
 * Returning -1 does not guarantee that gunzip() will ever return.
 */
static int __init fill_inbuf(void)
{
	if (exit_code) return -1;
	
	insize = sys_read(crd_infd, inbuf, INBUFSIZ);
	if (insize == 0) {
		error("RAMDISK: ran out of compressed data");
		return -1;
	}

	inptr = 1;

	return inbuf[0];
}

/* ===========================================================================
 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
 * (Used for the decompressed data only.)
 */
static void __init flush_window(void)
{
    ulg c = crc;         /* temporary variable */
    unsigned n, written;
    uch *in, ch;
    
    written = sys_write(crd_outfd, window, outcnt);
    if (written != outcnt && unzip_error == 0) {
	printk(KERN_ERR "RAMDISK: incomplete write (%d != %d) %ld\n",
	       written, outcnt, bytes_out);
	unzip_error = 1;
    }
    in = window;
    for (n = 0; n < outcnt; n++) {
	    ch = *in++;
	    c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
    }
    crc = c;
    bytes_out += (ulg)outcnt;
    outcnt = 0;
}

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

static int __init crd_load(int in_fd, int out_fd)
{
	int result;

	insize = 0;		/* valid bytes in inbuf */
	inptr = 0;		/* index of next byte to be processed in inbuf */
	outcnt = 0;		/* bytes in output buffer */
	exit_code = 0;
	bytes_out = 0;
	crc = (ulg)0xffffffffL; /* shift register contents */

	crd_infd = in_fd;
	crd_outfd = out_fd;
	inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
	if (!inbuf) {
		printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
		return -1;
	}
	window = kmalloc(WSIZE, GFP_KERNEL);
	if (!window) {
		printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
		kfree(inbuf);
		return -1;
	}
	makecrc();
	result = gunzip();
	if (unzip_error)
		result = 1;
	kfree(inbuf);
	kfree(window);
	return result;
}

#endif  /* BUILD_CRAMDISK */
Commit	Line	Data
1da177e4 LT	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);
c80544dc	60	if (!buf)
1da177e4 LT	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;
347a8dc3	148	#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
1da177e4 LT	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);
d613c3e2	215	if (!buf) {
1da177e4 LT	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);
347a8dc3	240	#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
1da177e4 LT	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");
bdaf8529 GKH	265	create_dev("/dev/root", ROOT_DEV);
bdaf8529 GKH	266	create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
1da177e4 LT	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);
c80544dc	410	if (!inbuf) {
1da177e4 LT	411	printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
	412	return -1;
	413	}
	414	window = kmalloc(WSIZE, GFP_KERNEL);
c80544dc	415	if (!window) {
1da177e4 LT	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 */