From f8926c32b4d132a9c2c641a4f331f27b99866f41 Mon Sep 17 00:00:00 2001 From: Vladimir 'phcoder' Serbinenko Date: Tue, 21 Sep 2010 11:22:52 +0200 Subject: [PATCH] C part of decompressor --- grub-core/Makefile.core.def | 9 +- grub-core/boot/decompressor.c | 115 ++++++++++++++++++++++++++ grub-core/kern/mips/cache.S | 2 +- grub-core/lib/LzmaDec.c | 40 +++++++-- grub-core/lib/xzembed/xz_dec_bcj.c | 11 ++- grub-core/lib/xzembed/xz_dec_lzma2.c | 28 ++++++- grub-core/lib/xzembed/xz_dec_stream.c | 57 +++++++++++-- include/grub/decompressor.h | 28 +++++++ include/grub/lib/LzmaDec.h | 2 +- 9 files changed, 272 insertions(+), 20 deletions(-) create mode 100644 grub-core/boot/decompressor.c create mode 100644 include/grub/decompressor.h diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def index 3341cb678..58fd7cf5d 100644 --- a/grub-core/Makefile.core.def +++ b/grub-core/Makefile.core.def @@ -278,9 +278,14 @@ image = { image = { name = decompress; mips = boot/mips/startup_raw.S; - common = lib/LzmaDec.c; + common = boot/decompressor.c; + common = lib/xzembed/xz_dec_bcj.c; + common = lib/xzembed/xz_dec_lzma2.c; + common = lib/xzembed/xz_dec_stream.c; - mips_cppflags = '-DGRUB_MACHINE_LINK_ADDR=0x80200000'; + cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/xzembed'; + + mips_cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/xzembed -DGRUB_EMBED_DECOMPRESSOR=1 -DGRUB_MACHINE_LINK_ADDR=0x80200000'; objcopyflags = '-O binary'; ldflags = '-lgcc -static-libgcc -Wl,-Ttext,0x80100000'; diff --git a/grub-core/boot/decompressor.c b/grub-core/boot/decompressor.c new file mode 100644 index 000000000..5c16fb932 --- /dev/null +++ b/grub-core/boot/decompressor.c @@ -0,0 +1,115 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2010 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include + +#include "xz.h" +#include "xz_stream.h" + +void * +memset (void *s, int c, grub_size_t len) +{ + grub_uint8_t *ptr; + for (ptr = s; len; ptr++, len--) + *ptr = c; + return s; +} + +void * +grub_memmove (void *dest, const void *src, grub_size_t n) +{ + char *d = (char *) dest; + const char *s = (const char *) src; + + if (d < s) + while (n--) + *d++ = *s++; + else + { + d += n; + s += n; + + while (n--) + *--d = *--s; + } + + return dest; +} + +int +grub_memcmp (const void *s1, const void *s2, grub_size_t n) +{ + const char *t1 = s1; + const char *t2 = s2; + + while (n--) + { + if (*t1 != *t2) + return (int) *t1 - (int) *t2; + + t1++; + t2++; + } + + return 0; +} + +int memcmp (const void *s1, const void *s2, grub_size_t n) + __attribute__ ((alias ("grub_memcmp"))); + +void *memmove (void *dest, const void *src, grub_size_t n) + __attribute__ ((alias ("grub_memmove"))); + +void *memcpy (void *dest, const void *src, grub_size_t n) + __attribute__ ((alias ("grub_memmove"))); + +void +grub_decompress_core (void *src, void *dst, unsigned long srcsize, + unsigned long dstsize) +{ + struct xz_dec *dec; + struct xz_buf buf; + + dec = xz_dec_init (GRUB_DECOMPRESSOR_DICT_SIZE); + + buf.in = src; + buf.in_pos = 0; + buf.in_size = srcsize; + buf.out = dst; + buf.out_pos = 0; + buf.out_size = dstsize; + + while (buf.in_pos != buf.in_size) + { + enum xz_ret xzret; + xzret = xz_dec_run (dec, &buf); + switch (xzret) + { + case XZ_MEMLIMIT_ERROR: + case XZ_FORMAT_ERROR: + case XZ_OPTIONS_ERROR: + case XZ_DATA_ERROR: + case XZ_BUF_ERROR: + return; + default: + break; + } + } +} diff --git a/grub-core/kern/mips/cache.S b/grub-core/kern/mips/cache.S index 02dc3355f..999872f6b 100644 --- a/grub-core/kern/mips/cache.S +++ b/grub-core/kern/mips/cache.S @@ -1,8 +1,8 @@ #include - .set nomacro .set noreorder + .set nomacro FUNCTION (grub_cpu_flush_cache) FUNCTION (grub_arch_sync_caches) diff --git a/grub-core/lib/LzmaDec.c b/grub-core/lib/LzmaDec.c index 62ebee686..4d6890b60 100644 --- a/grub-core/lib/LzmaDec.c +++ b/grub-core/lib/LzmaDec.c @@ -26,7 +26,14 @@ #include -#include +static void +memcpy (void *a_, const void *b_, unsigned s) +{ + char *a = a_; + const char *b = b_; + while (s--) + *a++ = *b++; +} #define kNumTopBits 24 #define kTopValue ((UInt32)1 << kNumTopBits) @@ -294,14 +301,14 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte prob = probs + RepLenCoder; } { - unsigned limit, offset; + unsigned limit2, offset; CLzmaProb *probLen = prob + LenChoice; IF_BIT_0(probLen) { UPDATE_0(probLen); probLen = prob + LenLow + (posState << kLenNumLowBits); offset = 0; - limit = (1 << kLenNumLowBits); + limit2 = (1 << kLenNumLowBits); } else { @@ -312,17 +319,17 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte UPDATE_0(probLen); probLen = prob + LenMid + (posState << kLenNumMidBits); offset = kLenNumLowSymbols; - limit = (1 << kLenNumMidBits); + limit2 = (1 << kLenNumMidBits); } else { UPDATE_1(probLen); probLen = prob + LenHigh; offset = kLenNumLowSymbols + kLenNumMidSymbols; - limit = (1 << kLenNumHighBits); + limit2 = (1 << kLenNumHighBits); } } - TREE_DECODE(probLen, limit, len); + TREE_DECODE(probLen, limit2, len); len += offset; } @@ -718,7 +725,7 @@ static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data) p->needFlush = 0; } -void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState) +static void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState) { p->needFlush = 1; p->remainLen = 0; @@ -915,6 +922,7 @@ SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *sr void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc) { + return ; alloc->Free(alloc, p->probs); p->probs = 0; } @@ -957,13 +965,16 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size) return SZ_OK; } +static char sal[30000], *sptr = sal; + static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc) { UInt32 numProbs = LzmaProps_GetNumProbs(propNew); if (p->probs == 0 || numProbs != p->numProbs) { LzmaDec_FreeProbs(p, alloc); - p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb)); + p->probs = (CLzmaProb *) sptr; + sptr += sizeof (CLzmaProb); p->numProbs = numProbs; if (p->probs == 0) return SZ_ERROR_MEM; @@ -1033,3 +1044,16 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, LzmaDec_FreeProbs(&p, alloc); return res; } + +void +grub_decompress_core (void *src, void *dst, unsigned long srcsize, unsigned long dstsize); + +void +grub_decompress_core (void *src, void *dst, unsigned long srcsize, unsigned long dstsize) +{ + char *src_ = src, *dst_ = dst; + (void) dstsize; + while (srcsize--) + *dst_++ = *src_++ ^ 0x5a; +} + diff --git a/grub-core/lib/xzembed/xz_dec_bcj.c b/grub-core/lib/xzembed/xz_dec_bcj.c index 7eec9de7d..f517b0acc 100644 --- a/grub-core/lib/xzembed/xz_dec_bcj.c +++ b/grub-core/lib/xzembed/xz_dec_bcj.c @@ -520,9 +520,18 @@ enum xz_ret xz_dec_bcj_run(struct xz_dec_bcj *s, return s->ret; } +#ifdef GRUB_EMBED_DECOMPRESSOR +struct xz_dec_bcj bcj; +#endif + struct xz_dec_bcj * xz_dec_bcj_create(bool single_call) { - struct xz_dec_bcj *s = kmalloc(sizeof(*s), GFP_KERNEL); + struct xz_dec_bcj *s; +#ifdef GRUB_EMBED_DECOMPRESSOR + s = &bcj; +#else + s = kmalloc(sizeof(*s), GFP_KERNEL); +#endif if (s != NULL) s->single_call = single_call; diff --git a/grub-core/lib/xzembed/xz_dec_lzma2.c b/grub-core/lib/xzembed/xz_dec_lzma2.c index a0d422697..c55773ce0 100644 --- a/grub-core/lib/xzembed/xz_dec_lzma2.c +++ b/grub-core/lib/xzembed/xz_dec_lzma2.c @@ -1100,10 +1100,17 @@ enum xz_ret xz_dec_lzma2_run( return XZ_OK; } +#ifdef GRUB_EMBED_DECOMPRESSOR +#include +static struct xz_dec_lzma2 lzma2; +static char dict[GRUB_DECOMPRESSOR_DICT_SIZE]; +#endif + struct xz_dec_lzma2 * xz_dec_lzma2_create(uint32_t dict_max) { struct xz_dec_lzma2 *s; +#ifndef GRUB_EMBED_DECOMPRESSOR /* Maximum supported dictionary by this implementation is 3 GiB. */ if (dict_max > ((uint32_t)3 << 30)) return NULL; @@ -1120,6 +1127,17 @@ struct xz_dec_lzma2 * xz_dec_lzma2_create(uint32_t dict_max) } } +#else + if (dict_max > GRUB_DECOMPRESSOR_DICT_SIZE) + return NULL; + + s = &lzma2; + + if (dict_max > 0) { + s->dict.buf = (void *) &dict; + } +#endif + s->dict.allocated = dict_max; return s; @@ -1135,6 +1153,7 @@ enum xz_ret xz_dec_lzma2_reset( s->dict.size = 2 + (props & 1); s->dict.size <<= (props >> 1) + 11; +#ifndef GRUB_EMBED_DECOMPRESSOR if (s->dict.allocated > 0 && s->dict.allocated < s->dict.size) { /* enlarge dictionary buffer */ @@ -1146,7 +1165,10 @@ enum xz_ret xz_dec_lzma2_reset( s->dict.buf = newdict; s->dict.allocated = s->dict.size; } - +#else + if (s->dict.allocated > 0 && s->dict.allocated < s->dict.size) + return XZ_MEMLIMIT_ERROR; +#endif s->dict.end = s->dict.size; s->lzma.len = 0; @@ -1159,10 +1181,12 @@ enum xz_ret xz_dec_lzma2_reset( return XZ_OK; } -void xz_dec_lzma2_end(struct xz_dec_lzma2 *s) +void xz_dec_lzma2_end(struct xz_dec_lzma2 *s __attribute__ ((unused))) { +#ifndef GRUB_EMBED_DECOMPRESSOR if (s->dict.allocated > 0) vfree(s->dict.buf); kfree(s); +#endif } diff --git a/grub-core/lib/xzembed/xz_dec_stream.c b/grub-core/lib/xzembed/xz_dec_stream.c index 273041edb..3bf201d50 100644 --- a/grub-core/lib/xzembed/xz_dec_stream.c +++ b/grub-core/lib/xzembed/xz_dec_stream.c @@ -31,7 +31,9 @@ struct xz_dec_hash { vli_type unpadded; vli_type uncompressed; +#ifndef GRUB_EMBED_DECOMPRESSOR uint8_t *crc32_context; +#endif }; struct xz_dec { @@ -247,9 +249,11 @@ static enum xz_ret dec_block(struct xz_dec *s, struct xz_buf *b) > s->block_header.uncompressed) return XZ_DATA_ERROR; +#ifndef GRUB_EMBED_DECOMPRESSOR if (s->has_crc32) GRUB_MD_CRC32->write(s->crc32_context,b->out + s->out_start, b->out_pos - s->out_start); +#endif if (ret == XZ_STREAM_END) { if (s->block_header.compressed != VLI_UNKNOWN @@ -269,8 +273,10 @@ static enum xz_ret dec_block(struct xz_dec *s, struct xz_buf *b) s->block.hash.uncompressed += s->block.uncompressed; +#ifndef GRUB_EMBED_DECOMPRESSOR GRUB_MD_CRC32->write(s->block.hash.crc32_context, (const uint8_t *)&s->block.hash, 2 * sizeof(vli_type)); +#endif ++s->block.count; } @@ -283,7 +289,9 @@ static void index_update(struct xz_dec *s, const struct xz_buf *b) { size_t in_used = b->in_pos - s->in_start; s->index.size += in_used; +#ifndef GRUB_EMBED_DECOMPRESSOR GRUB_MD_CRC32->write(s->crc32_context,b->in + s->in_start, in_used); +#endif } /* @@ -328,8 +336,10 @@ static enum xz_ret dec_index(struct xz_dec *s, struct xz_buf *b) case SEQ_INDEX_UNCOMPRESSED: s->index.hash.uncompressed += s->vli; +#ifndef GRUB_EMBED_DECOMPRESSOR GRUB_MD_CRC32->write(s->index.hash.crc32_context, (const uint8_t *)&s->index.hash, 2 * sizeof(vli_type)); +#endif --s->index.count; s->index.sequence = SEQ_INDEX_UNPADDED; @@ -346,24 +356,30 @@ static enum xz_ret dec_index(struct xz_dec *s, struct xz_buf *b) */ static enum xz_ret crc32_validate(struct xz_dec *s, struct xz_buf *b) { +#ifndef GRUB_EMBED_DECOMPRESSOR if(s->crc32_temp == 0) { GRUB_MD_CRC32->final(s->crc32_context); s->crc32_temp = get_unaligned_be32(GRUB_MD_CRC32->read(s->crc32_context)); } +#endif do { if (b->in_pos == b->in_size) return XZ_OK; +#ifndef GRUB_EMBED_DECOMPRESSOR if (((s->crc32_temp >> s->pos) & 0xFF) != b->in[b->in_pos++]) return XZ_DATA_ERROR; +#endif s->pos += 8; } while (s->pos < 32); +#ifndef GRUB_EMBED_DECOMPRESSOR GRUB_MD_CRC32->init(s->crc32_context); +#endif s->crc32_temp = 0; s->pos = 0; @@ -376,6 +392,7 @@ static enum xz_ret dec_stream_header(struct xz_dec *s) if (! memeq(s->temp.buf, HEADER_MAGIC, HEADER_MAGIC_SIZE)) return XZ_FORMAT_ERROR; +#ifndef GRUB_EMBED_DECOMPRESSOR uint8_t crc32_context[GRUB_MD_CRC32->contextsize]; GRUB_MD_CRC32->init(crc32_context); @@ -387,6 +404,7 @@ static enum xz_ret dec_stream_header(struct xz_dec *s) if(resultcrc != readcrc) return XZ_DATA_ERROR; +#endif /* * Decode the Stream Flags field. Of integrity checks, we support @@ -407,6 +425,7 @@ static enum xz_ret dec_stream_footer(struct xz_dec *s) if (! memeq(s->temp.buf + 10, FOOTER_MAGIC, FOOTER_MAGIC_SIZE)) return XZ_DATA_ERROR; +#ifndef GRUB_EMBED_DECOMPRESSOR uint8_t crc32_context[GRUB_MD_CRC32->contextsize]; GRUB_MD_CRC32->init(crc32_context); @@ -418,6 +437,7 @@ static enum xz_ret dec_stream_footer(struct xz_dec *s) if(resultcrc != readcrc) return XZ_DATA_ERROR; +#endif /* * Validate Backward Size. Note that we never added the size of the @@ -447,7 +467,7 @@ static enum xz_ret dec_block_header(struct xz_dec *s) * eight bytes so this is safe. */ s->temp.size -= 4; - +#ifndef GRUB_EMBED_DECOMPRESSOR uint8_t crc32_context[GRUB_MD_CRC32->contextsize]; GRUB_MD_CRC32->init(crc32_context); @@ -459,6 +479,7 @@ static enum xz_ret dec_block_header(struct xz_dec *s) if (resultcrc != readcrc) return XZ_DATA_ERROR; +#endif s->temp.pos = 2; @@ -669,6 +690,7 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b) /* Finish the CRC32 value and Index size. */ index_update(s, b); +#ifndef GRUB_EMBED_DECOMPRESSOR /* Compare the hashes to validate the Index field. */ GRUB_MD_CRC32->final(s->block.hash.crc32_context); GRUB_MD_CRC32->final(s->index.hash.crc32_context); @@ -681,6 +703,7 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b) { return XZ_DATA_ERROR; } +#endif s->sequence = SEQ_INDEX_CRC32; @@ -764,12 +787,22 @@ enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b) return ret; } +#ifdef GRUB_EMBED_DECOMPRESSOR +struct xz_dec decoder; +#endif + struct xz_dec * xz_dec_init(uint32_t dict_max) { - struct xz_dec *s = kmalloc(sizeof(*s), GFP_KERNEL); + struct xz_dec *s; +#ifdef GRUB_EMBED_DECOMPRESSOR + s = &decoder; +#else + s = kmalloc(sizeof(*s), GFP_KERNEL); if (s == NULL) return NULL; +#endif +#ifndef GRUB_EMBED_DECOMPRESSOR /* prepare CRC32 calculators */ if(GRUB_MD_CRC32 == NULL) { @@ -803,10 +836,11 @@ struct xz_dec * xz_dec_init(uint32_t dict_max) GRUB_MD_CRC32->init(s->crc32_context); - s->crc32_temp = 0; GRUB_MD_CRC32->init(s->index.hash.crc32_context); GRUB_MD_CRC32->init(s->block.hash.crc32_context); +#endif + s->crc32_temp = 0; s->single_call = dict_max == 0; @@ -828,7 +862,9 @@ error_lzma2: xz_dec_bcj_end(s->bcj); error_bcj: #endif +#ifndef GRUB_EMBED_DECOMPRESSOR kfree(s); +#endif return NULL; } @@ -839,34 +875,45 @@ void xz_dec_reset(struct xz_dec *s) s->pos = 0; { +#ifndef GRUB_EMBED_DECOMPRESSOR uint8_t *t; t = s->block.hash.crc32_context; +#endif memzero(&s->block, sizeof(s->block)); +#ifndef GRUB_EMBED_DECOMPRESSOR s->block.hash.crc32_context = t; t = s->index.hash.crc32_context; +#endif memzero(&s->index, sizeof(s->index)); +#ifndef GRUB_EMBED_DECOMPRESSOR s->index.hash.crc32_context = t; +#endif } s->temp.pos = 0; s->temp.size = STREAM_HEADER_SIZE; +#ifndef GRUB_EMBED_DECOMPRESSOR GRUB_MD_CRC32->init(s->crc32_context); - s->crc32_temp = 0; GRUB_MD_CRC32->init(s->index.hash.crc32_context); GRUB_MD_CRC32->init(s->block.hash.crc32_context); - +#endif + s->crc32_temp = 0; } void xz_dec_end(struct xz_dec *s) { if (s != NULL) { xz_dec_lzma2_end(s->lzma2); +#ifndef GRUB_EMBED_DECOMPRESSOR kfree(s->index.hash.crc32_context); kfree(s->block.hash.crc32_context); kfree(s->crc32_context); +#endif #ifdef XZ_DEC_BCJ xz_dec_bcj_end(s->bcj); #endif +#ifndef GRUB_EMBED_DECOMPRESSOR kfree(s); +#endif } } diff --git a/include/grub/decompressor.h b/include/grub/decompressor.h new file mode 100644 index 000000000..4d99c41f7 --- /dev/null +++ b/include/grub/decompressor.h @@ -0,0 +1,28 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2010 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_DECOMPRESSOR_HEADER +#define GRUB_DECOMPRESSOR_HEADER 1 + +void +grub_decompress_core (void *src, void *dst, unsigned long srcsize, + unsigned long dstsize); + +#define GRUB_DECOMPRESSOR_DICT_SIZE (1 << 16) + +#endif diff --git a/include/grub/lib/LzmaDec.h b/include/grub/lib/LzmaDec.h index 1e66b74d7..16914c961 100644 --- a/include/grub/lib/LzmaDec.h +++ b/include/grub/lib/LzmaDec.h @@ -27,7 +27,7 @@ #ifndef __LZMADEC_H #define __LZMADEC_H -#include "Types.h" +#include "LzmaTypes.h" /* #define _LZMA_PROB32 */ /* _LZMA_PROB32 can increase the speed on some CPUs,