mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Yinghai Lu](/assets/img/avatar_default.png)
Now with 64bit bzImage and kexec tools, we support ramdisk that size is bigger than 2g, as we could put it above 4G. Found compressed initramfs image could not be decompressed properly. It turns out that image length is int during decompress detection, and it will become < 0 when length is more than 2G. Furthermore, during decompressing len as int is used for inbuf count, that has problem too. Change len to long, that should be ok as on 32 bit platform long is 32bits. Tested with following compressed initramfs image as root with kexec. gzip, bzip2, xz, lzma, lzop, lz4. run time for populate_rootfs(): size name Nehalem-EX Westmere-EX Ivybridge-EX 9034400256 root_img : 26s 24s 30s 3561095057 root_img.lz4 : 28s 27s 27s 3459554629 root_img.lzo : 29s 29s 28s 3219399480 root_img.gz : 64s 62s 49s 2251594592 root_img.xz : 262s 260s 183s 2226366598 root_img.lzma: 386s 376s 277s 2901482513 root_img.bz2 : 635s 599s Signed-off-by: Yinghai Lu <yinghai@kernel.org> Cc: "H. Peter Anvin" <hpa@zytor.com> Cc: Ingo Molnar <mingo@elte.hu> Cc: Rashika Kheria <rashika.kheria@gmail.com> Cc: Josh Triplett <josh@joshtriplett.org> Cc: Kyungsik Lee <kyungsik.lee@lge.com> Cc: P J P <ppandit@redhat.com> Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp> Cc: "Daniel M. Weeks" <dan@danweeks.net> Cc: Alexandre Courbot <acourbot@nvidia.com> Cc: Jan Beulich <JBeulich@suse.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
209 lines
4.1 KiB
C
209 lines
4.1 KiB
C
/*
|
|
* Wrapper for decompressing LZ4-compressed kernel, initramfs, and initrd
|
|
*
|
|
* Copyright (C) 2013, LG Electronics, Kyungsik Lee <kyungsik.lee@lge.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#ifdef STATIC
|
|
#define PREBOOT
|
|
#include "lz4/lz4_decompress.c"
|
|
#else
|
|
#include <linux/decompress/unlz4.h>
|
|
#endif
|
|
#include <linux/types.h>
|
|
#include <linux/lz4.h>
|
|
#include <linux/decompress/mm.h>
|
|
#include <linux/compiler.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
/*
|
|
* Note: Uncompressed chunk size is used in the compressor side
|
|
* (userspace side for compression).
|
|
* It is hardcoded because there is not proper way to extract it
|
|
* from the binary stream which is generated by the preliminary
|
|
* version of LZ4 tool so far.
|
|
*/
|
|
#define LZ4_DEFAULT_UNCOMPRESSED_CHUNK_SIZE (8 << 20)
|
|
#define ARCHIVE_MAGICNUMBER 0x184C2102
|
|
|
|
STATIC inline int INIT unlz4(u8 *input, long in_len,
|
|
long (*fill)(void *, unsigned long),
|
|
long (*flush)(void *, unsigned long),
|
|
u8 *output, long *posp,
|
|
void (*error) (char *x))
|
|
{
|
|
int ret = -1;
|
|
size_t chunksize = 0;
|
|
size_t uncomp_chunksize = LZ4_DEFAULT_UNCOMPRESSED_CHUNK_SIZE;
|
|
u8 *inp;
|
|
u8 *inp_start;
|
|
u8 *outp;
|
|
long size = in_len;
|
|
#ifdef PREBOOT
|
|
size_t out_len = get_unaligned_le32(input + in_len);
|
|
#endif
|
|
size_t dest_len;
|
|
|
|
|
|
if (output) {
|
|
outp = output;
|
|
} else if (!flush) {
|
|
error("NULL output pointer and no flush function provided");
|
|
goto exit_0;
|
|
} else {
|
|
outp = large_malloc(uncomp_chunksize);
|
|
if (!outp) {
|
|
error("Could not allocate output buffer");
|
|
goto exit_0;
|
|
}
|
|
}
|
|
|
|
if (input && fill) {
|
|
error("Both input pointer and fill function provided,");
|
|
goto exit_1;
|
|
} else if (input) {
|
|
inp = input;
|
|
} else if (!fill) {
|
|
error("NULL input pointer and missing fill function");
|
|
goto exit_1;
|
|
} else {
|
|
inp = large_malloc(lz4_compressbound(uncomp_chunksize));
|
|
if (!inp) {
|
|
error("Could not allocate input buffer");
|
|
goto exit_1;
|
|
}
|
|
}
|
|
inp_start = inp;
|
|
|
|
if (posp)
|
|
*posp = 0;
|
|
|
|
if (fill) {
|
|
size = fill(inp, 4);
|
|
if (size < 4) {
|
|
error("data corrupted");
|
|
goto exit_2;
|
|
}
|
|
}
|
|
|
|
chunksize = get_unaligned_le32(inp);
|
|
if (chunksize == ARCHIVE_MAGICNUMBER) {
|
|
if (!fill) {
|
|
inp += 4;
|
|
size -= 4;
|
|
}
|
|
} else {
|
|
error("invalid header");
|
|
goto exit_2;
|
|
}
|
|
|
|
if (posp)
|
|
*posp += 4;
|
|
|
|
for (;;) {
|
|
|
|
if (fill) {
|
|
size = fill(inp, 4);
|
|
if (size == 0)
|
|
break;
|
|
if (size < 4) {
|
|
error("data corrupted");
|
|
goto exit_2;
|
|
}
|
|
}
|
|
|
|
chunksize = get_unaligned_le32(inp);
|
|
if (chunksize == ARCHIVE_MAGICNUMBER) {
|
|
if (!fill) {
|
|
inp += 4;
|
|
size -= 4;
|
|
}
|
|
if (posp)
|
|
*posp += 4;
|
|
continue;
|
|
}
|
|
|
|
|
|
if (posp)
|
|
*posp += 4;
|
|
|
|
if (!fill) {
|
|
inp += 4;
|
|
size -= 4;
|
|
} else {
|
|
if (chunksize > lz4_compressbound(uncomp_chunksize)) {
|
|
error("chunk length is longer than allocated");
|
|
goto exit_2;
|
|
}
|
|
size = fill(inp, chunksize);
|
|
if (size < chunksize) {
|
|
error("data corrupted");
|
|
goto exit_2;
|
|
}
|
|
}
|
|
#ifdef PREBOOT
|
|
if (out_len >= uncomp_chunksize) {
|
|
dest_len = uncomp_chunksize;
|
|
out_len -= dest_len;
|
|
} else
|
|
dest_len = out_len;
|
|
ret = lz4_decompress(inp, &chunksize, outp, dest_len);
|
|
#else
|
|
dest_len = uncomp_chunksize;
|
|
ret = lz4_decompress_unknownoutputsize(inp, chunksize, outp,
|
|
&dest_len);
|
|
#endif
|
|
if (ret < 0) {
|
|
error("Decoding failed");
|
|
goto exit_2;
|
|
}
|
|
|
|
ret = -1;
|
|
if (flush && flush(outp, dest_len) != dest_len)
|
|
goto exit_2;
|
|
if (output)
|
|
outp += dest_len;
|
|
if (posp)
|
|
*posp += chunksize;
|
|
|
|
if (!fill) {
|
|
size -= chunksize;
|
|
|
|
if (size == 0)
|
|
break;
|
|
else if (size < 0) {
|
|
error("data corrupted");
|
|
goto exit_2;
|
|
}
|
|
inp += chunksize;
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
exit_2:
|
|
if (!input)
|
|
large_free(inp_start);
|
|
exit_1:
|
|
if (!output)
|
|
large_free(outp);
|
|
exit_0:
|
|
return ret;
|
|
}
|
|
|
|
#ifdef PREBOOT
|
|
STATIC int INIT decompress(unsigned char *buf, long in_len,
|
|
long (*fill)(void*, unsigned long),
|
|
long (*flush)(void*, unsigned long),
|
|
unsigned char *output,
|
|
long *posp,
|
|
void(*error)(char *x)
|
|
)
|
|
{
|
|
return unlz4(buf, in_len - 4, fill, flush, output, posp, error);
|
|
}
|
|
#endif
|