vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

C part of decompressor

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2010-09-21 11:22:52 +02:00
parent c5b4cd370e
commit f8926c32b4
9 changed files with 272 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
grub-core/Makefile.core.def
View file

@ -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';

115
grub-core/boot/decompressor.c Normal file
View file

@ -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 <http://www.gnu.org/licenses/>.
*/
#include <grub/types.h>
#include <grub/misc.h>
#include <grub/decompressor.h>
#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;
}
}
}

2
grub-core/kern/mips/cache.S
View file

@ -1,8 +1,8 @@
#include <grub/symbol.h>
.set nomacro
.set noreorder
.set nomacro
FUNCTION (grub_cpu_flush_cache)
FUNCTION (grub_arch_sync_caches)

40
grub-core/lib/LzmaDec.c
View file

@ -26,7 +26,14 @@
#include <grub/lib/LzmaDec.h>
#include <string.h>
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;
}

11
grub-core/lib/xzembed/xz_dec_bcj.c
View file

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

28
grub-core/lib/xzembed/xz_dec_lzma2.c
View file

@ -1100,10 +1100,17 @@ enum xz_ret xz_dec_lzma2_run(
return XZ_OK;
}
#ifdef GRUB_EMBED_DECOMPRESSOR
#include <grub/decompressor.h>
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
}

57
grub-core/lib/xzembed/xz_dec_stream.c
View file

@ -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
}
}

28
include/grub/decompressor.h Normal file
View file

@ -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 <http://www.gnu.org/licenses/>.
*/
#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

2
include/grub/lib/LzmaDec.h
View file

@ -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,