C part of decompressor

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

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 <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;
+	}
+    }
+}

grub-core/kern/mips/cache.S

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

grub-core/lib/LzmaDec.c

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

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;
 

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

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

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

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,