Skip to content

Commit

Permalink
bzip2/lzma: config and initramfs support for bzip2/lzma decompression
Browse files Browse the repository at this point in the history 
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: Alain Knaff <alain@knaff.lu>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
  • Loading branch information
Alain Knaff authored and H. Peter Anvin committed Jan 4, 2009
1 parent bc22c17 commit 30d65db
Show file tree
Hide file tree
Showing 5 changed files with 184 additions and 199 deletions.
25 changes: 25 additions & 0 deletions drivers/block/Kconfig
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
50 changes: 50 additions & 0 deletions init/Kconfig
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
182 changes: 65 additions & 117 deletions init/do_mounts_rd.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand All @@ -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
Expand All @@ -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;
Expand All @@ -70,16 +76,47 @@ 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
*/
if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
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 &&
Expand Down Expand Up @@ -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
Expand All @@ -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;
}
Expand Down Expand Up @@ -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;
}

inptr = 1;

return inbuf[0];
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;
}

/* ===========================================================================
* 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);
}
crc = c;
bytes_out += (ulg)outcnt;
outcnt = 0;
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;
}
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;
}
Loading

0 comments on commit 30d65db

Please sign in to comment.