Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 30d65dbf authored by Alain Knaff's avatar Alain Knaff Committed by H. Peter Anvin
Browse files

bzip2/lzma: config and initramfs support for bzip2/lzma decompression 



Impact: New code for initramfs decompression, new features

This is the second part of the bzip2/lzma patch

The bzip patch is based on an idea by Christian Ludwig, includes support for
compressing the kernel with bzip2 or lzma rather than gzip. Both
compressors give smaller sizes than gzip.  Lzma's decompresses faster
than bzip2.

It also supports ramdisks and initramfs' compressed using these two
compressors.

The functionality has been successfully used for a couple of years by
the udpcast project

This version applies to "tip" kernel 2.6.28

This part contains:
- support for new compressions (bzip2 and lzma) in initramfs and
old-style ramdisk
- config dialog for kernel compression (but new kernel compressions
not yet supported)

Signed-off-by: default avatarAlain Knaff <alain@knaff.lu>
Signed-off-by: default avatarH. Peter Anvin <hpa@zytor.com>
parent bc22c17e

drivers/block/Kconfig

+25 −0
Original line number Diff line number Diff line
@@ -358,6 +358,31 @@ config BLK_DEV_XIP 
	  will prevent RAM block device backing store memory from being

	  allocated from highmem (only a problem for highmem systems).



config RD_BZIP2

	bool "Initial ramdisk compressed using bzip2"

	default n

	depends on BLK_DEV_INITRD=y

	help

	  Support loading of a bzip2 encoded initial ramdisk or cpio buffer

	  If unsure, say N.



config RD_LZMA

	bool "Initial ramdisk compressed using lzma"

	default n

	depends on BLK_DEV_INITRD=y

	help

	  Support loading of a lzma encoded initial ramdisk or cpio buffer

	  If unsure, say N.



config RD_GZIP

	bool "Initial ramdisk compressed using gzip"

	default y

	depends on BLK_DEV_INITRD=y

	select ZLIB_INFLATE

	help

	  Support loading of a gzip encoded initial ramdisk or cpio buffer.

	  If unsure, say Y.



config CDROM_PKTCDVD

	tristate "Packet writing on CD/DVD media"

	depends on !UML

init/Kconfig

+50 −0
Original line number Diff line number Diff line
@@ -101,6 +101,56 @@ config LOCALVERSION_AUTO 


	  which is done within the script "scripts/setlocalversion".)



choice

        prompt "Kernel compression mode"

        default KERNEL_GZIP

        help

	  The linux kernel is a kind of self-extracting executable.

	  Several compression algorithms are available, which differ

	  in efficiency, compression and decompression speed.

	  Compression speed is only relevant when building a kernel.

	  Decompression speed is relevant at each boot.



	  If you have any problems with bzip2 or lzma compressed

	  kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older

	  version of this functionality (bzip2 only), for 2.4, was

	  supplied by Christian Ludwig)



	  High compression options are mostly useful for users, who

	  are low on disk space (embedded systems), but for whom ram

	  size matters less.



	  If in doubt, select 'gzip'



config KERNEL_GZIP

       bool "Gzip"

       help

         The old and tried gzip compression. Its compression ratio is

	 the poorest among the 3 choices; however its speed (both

	 compression and decompression) is the fastest.



config KERNEL_BZIP2

	bool "Bzip2"

	help

	  Its compression ratio and speed is intermediate.

	  Decompression speed is slowest among the 3.

	  The kernel size is about 10 per cent smaller with bzip2,

	  in comparison to gzip.

	  Bzip2 uses a large amount of memory. For modern kernels

	  you will need at least 8MB RAM or more for booting.



config KERNEL_LZMA

       bool "LZMA"

       help

         The most recent compression algorithm.

	 Its ratio is best, decompression speed is between the other

	 2. Compression is slowest.

	 The kernel size is about 33 per cent smaller with lzma,

	 in comparison to gzip.



endchoice





config SWAP

	bool "Support for paging of anonymous memory (swap)"

	depends on MMU && BLOCK

init/do_mounts_rd.c

+65 −117
Original line number Diff line number Diff line
@@ -10,6 +10,12 @@ 


#include "do_mounts.h"



#include <linux/decompress/generic.h>



#include <linux/decompress/bunzip2.h>

#include <linux/decompress/unlzma.h>

#include <linux/decompress/inflate.h>



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



static int __init prompt_ramdisk(char *str)
@@ -28,7 +34,7 @@ static int __init ramdisk_start_setup(char *str) 
}

__setup("ramdisk_start=", ramdisk_start_setup);



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

static int __init crd_load(int in_fd, int out_fd, decompress_fn deco);



/*

 * This routine tries to find a RAM disk image to load, and returns the
@@ -44,7 +50,7 @@ static int __init crd_load(int in_fd, int out_fd); 
 * 	gzip

 */

static int __init 

identify_ramdisk_image(int fd, int start_block)

identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)

{

	const int size = 512;

	struct minix_super_block *minixsb;
@@ -70,6 +76,7 @@ identify_ramdisk_image(int fd, int start_block) 
	sys_lseek(fd, start_block * BLOCK_SIZE, 0);

	sys_read(fd, buf, size);



#ifdef CONFIG_RD_GZIP

	/*

	 * If it matches the gzip magic numbers, return 0

	 */
@@ -77,9 +84,39 @@ identify_ramdisk_image(int fd, int start_block) 
		printk(KERN_NOTICE

		       "RAMDISK: Compressed image found at block %d\n",

		       start_block);

		*decompressor = gunzip;

		nblocks = 0;

		goto done;

	}

#endif



#ifdef CONFIG_RD_BZIP2

	/*

	 * If it matches the bzip2 magic numbers, return -1

	 */

	if (buf[0] == 0x42 && (buf[1] == 0x5a)) {

		printk(KERN_NOTICE

		       "RAMDISK: Bzipped image found at block %d\n",

		       start_block);

		*decompressor = bunzip2;

		nblocks = 0;

		goto done;

	}

#endif



#ifdef CONFIG_RD_LZMA

	/*

	 * If it matches the lzma magic numbers, return -1

	 */

	if (buf[0] == 0x5d && (buf[1] == 0x00)) {

		printk(KERN_NOTICE

		       "RAMDISK: Lzma image found at block %d\n",

		       start_block);

		*decompressor = unlzma;

		nblocks = 0;

		goto done;

	}

#endif



	/* romfs is at block zero too */

	if (romfsb->word0 == ROMSB_WORD0 &&
@@ -143,6 +180,7 @@ int __init rd_load_image(char *from) 
	int nblocks, i, disk;

	char *buf = NULL;

	unsigned short rotate = 0;

	decompress_fn decompressor = NULL;

#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)

	char rotator[4] = { '|' , '/' , '-' , '\\' };

#endif
@@ -155,12 +193,12 @@ int __init rd_load_image(char *from) 
	if (in_fd < 0)

		goto noclose_input;



	nblocks = identify_ramdisk_image(in_fd, rd_image_start);

	nblocks = identify_ramdisk_image(in_fd, rd_image_start, &decompressor);

	if (nblocks < 0)

		goto done;



	if (nblocks == 0) {

		if (crd_load(in_fd, out_fd) == 0)

		if (crd_load(in_fd, out_fd, decompressor) == 0)

			goto successful_load;

		goto done;

	}
@@ -259,138 +297,48 @@ int __init rd_load_disk(int n) 
	return rd_load_image("/dev/root");

}



/*

 * 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 decompress_error;

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 error(char *m);



#define NO_INFLATE_MALLOC



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



/* ===========================================================================

 * 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)

static int __init compr_fill(void *buf, unsigned int len)

{

	if (exit_code) return -1;

	

	insize = sys_read(crd_infd, inbuf, INBUFSIZ);

	if (insize == 0) {

		error("RAMDISK: ran out of compressed data");

		return -1;

	int r = sys_read(crd_infd, buf, len);

	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;

}



	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)

static int __init compr_flush(void *window, unsigned int outcnt)

{

    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);

	int written = sys_write(crd_outfd, window, outcnt);

	if (written != outcnt) {

		if (decompress_error == 0)

			printk(KERN_ERR

			       "RAMDISK: incomplete write (%d != %d)\n",

			       written, outcnt);

		decompress_error = 1;

		return -1;

	}

    crc = c;

    bytes_out += (ulg)outcnt;

    outcnt = 0;

	return outcnt;

}



static void __init error(char *x)

{

	printk(KERN_ERR "%s\n", x);

	exit_code = 1;

	unzip_error = 1;

	decompress_error = 1;

}



static int __init crd_load(int in_fd, int out_fd)

static int __init crd_load(int in_fd, int out_fd, decompress_fn deco)

{

	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 = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);

	if (decompress_error)

		result = 1;

	kfree(inbuf);

	kfree(window);

	return result;

}

init/initramfs.c

+42 −81
Original line number Diff line number Diff line
@@ -389,11 +389,14 @@ static int __init write_buffer(char *buf, unsigned len) 
	return len - count;

}



static void __init flush_buffer(char *buf, unsigned len)



static int __init flush_buffer(void *bufv, unsigned len)

{

	char *buf = (char *) bufv;

	int written;

	int origLen = len;

	if (message)

		return;

		return -1;

	while ((written = write_buffer(buf, len)) < len && !message) {

		char c = buf[written];

		if (c == '0') {
@@ -407,73 +410,14 @@ static void __init flush_buffer(char *buf, unsigned len) 
		} else

			error("junk in compressed archive");

	}

	return origLen;

}



/*

 * 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 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 long bytes_out;



#define get_byte()  (inptr < insize ? inbuf[inptr++] : -1)

		

/* 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 void __init flush_window(void);

static void __init error(char *m);



#define NO_INFLATE_MALLOC

static unsigned my_inptr;   /* index of next byte to be processed in inbuf */



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



/* ===========================================================================

 * 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;

	uch *in, ch;



	flush_buffer(window, outcnt);

	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;

}

#include <linux/decompress/bunzip2.h>

#include <linux/decompress/unlzma.h>

#include <linux/decompress/inflate.h>



static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)

{
@@ -482,9 +426,10 @@ static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only) 
	header_buf = kmalloc(110, GFP_KERNEL);

	symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);

	name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);

	window = kmalloc(WSIZE, GFP_KERNEL);

	if (!window || !header_buf || !symlink_buf || !name_buf)



	if (!header_buf || !symlink_buf || !name_buf)

		panic("can't allocate buffers");



	state = Start;

	this_header = 0;

	message = NULL;
@@ -504,22 +449,38 @@ static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only) 
			continue;

		}

		this_header = 0;

		insize = len;

		inbuf = buf;

		inptr = 0;

		outcnt = 0;		/* bytes in output buffer */

		bytes_out = 0;

		crc = (ulg)0xffffffffL; /* shift register contents */

		makecrc();

		gunzip();

		if (!gunzip(buf, len, NULL, flush_buffer, NULL,

			    &my_inptr, error) &&

		    message == NULL)

			goto ok;



#ifdef CONFIG_RD_BZIP2

		message = NULL; /* Zero out message, or else cpio will

				   think an error has already occured */

		if (!bunzip2(buf, len, NULL, flush_buffer, NULL,

			     &my_inptr, error) &&

		    message == NULL) {

			goto ok;

		}

#endif



#ifdef CONFIG_RD_LZMA

		message = NULL; /* Zero out message, or else cpio will

				   think an error has already occured */

		if (!unlzma(buf, len, NULL, flush_buffer, NULL,

			    &my_inptr, error) &&

		    message == NULL) {

			goto ok;

		}

#endif

ok:

		if (state != Reset)

			error("junk in gzipped archive");

		this_header = saved_offset + inptr;

		buf += inptr;

		len -= inptr;

			error("junk in compressed archive");

		this_header = saved_offset + my_inptr;

		buf += my_inptr;

		len -= my_inptr;

	}

	dir_utime();

	kfree(window);

	kfree(name_buf);

	kfree(symlink_buf);

	kfree(header_buf);

lib/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -11,7 +11,8 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \ 
	 rbtree.o radix-tree.o dump_stack.o \

	 idr.o int_sqrt.o extable.o prio_tree.o \

	 sha1.o irq_regs.o reciprocal_div.o argv_split.o \

	 proportions.o prio_heap.o ratelimit.o show_mem.o is_single_threaded.o

	 proportions.o prio_heap.o ratelimit.o show_mem.o is_single_threaded.o \

	 decompress_inflate.o decompress_bunzip2.o decompress_unlzma.o



lib-$(CONFIG_MMU) += ioremap.o

lib-$(CONFIG_SMP) += cpumask.o