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;
+
+ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/xzembed';
- mips_cppflags = '-DGRUB_MACHINE_LINK_ADDR=0x80200000';
+ 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';
--- /dev/null
+/*
+ * 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;
+ }
+ }
+}
#include <grub/symbol.h>
- .set nomacro
.set noreorder
+ .set nomacro
FUNCTION (grub_cpu_flush_cache)
FUNCTION (grub_arch_sync_caches)
#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)
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
{
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;
}
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;
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
{
+ return ;
alloc->Free(alloc, p->probs);
p->probs = 0;
}
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;
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;
+}
+
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;
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;
}
}
+#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;
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 */
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;
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
}
struct xz_dec_hash {
vli_type unpadded;
vli_type uncompressed;
+#ifndef GRUB_EMBED_DECOMPRESSOR
uint8_t *crc32_context;
+#endif
};
struct xz_dec {
> 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
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;
}
{
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
}
/*
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;
*/
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;
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);
if(resultcrc != readcrc)
return XZ_DATA_ERROR;
+#endif
/*
* Decode the Stream Flags field. Of integrity checks, we support
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);
if(resultcrc != readcrc)
return XZ_DATA_ERROR;
+#endif
/*
* Validate Backward Size. Note that we never added the size of the
* 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);
if (resultcrc != readcrc)
return XZ_DATA_ERROR;
+#endif
s->temp.pos = 2;
/* 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);
{
return XZ_DATA_ERROR;
}
+#endif
s->sequence = SEQ_INDEX_CRC32;
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)
{
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;
xz_dec_bcj_end(s->bcj);
error_bcj:
#endif
+#ifndef GRUB_EMBED_DECOMPRESSOR
kfree(s);
+#endif
return NULL;
}
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
}
}
--- /dev/null
+/*
+ * 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
#ifndef __LZMADEC_H
#define __LZMADEC_H
-#include "Types.h"
+#include "LzmaTypes.h"
/* #define _LZMA_PROB32 */
/* _LZMA_PROB32 can increase the speed on some CPUs,
projects / thirdparty / grub.git / commitdiff
