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,