From 419cbeb06d2733095b4cf9dad8b088f2338e1420 Mon Sep 17 00:00:00 2001 From: Vladimir 'phcoder' Serbinenko Date: Sat, 25 Sep 2010 19:33:05 +0200 Subject: [PATCH] hook Reed-Solomon into startup.S --- Makefile.util.def | 2 +- grub-core/Makefile.am | 4 + grub-core/kern/i386/pc/startup.S | 16 ++ {util => grub-core/lib}/reed_solomon.c | 327 ++++++++++++++----------- include/grub/offsets.h | 4 +- 5 files changed, 209 insertions(+), 144 deletions(-) rename {util => grub-core/lib}/reed_solomon.c (63%) diff --git a/Makefile.util.def b/Makefile.util.def index 5d091f7f5..bf66d45bc 100644 --- a/Makefile.util.def +++ b/Makefile.util.def @@ -244,7 +244,7 @@ program = { common = util/grub-setup.c; common = util/raid.c; common = util/lvm.c; - common = util/reed_solomon.c; + common = grub-core/lib/reed_solomon.c; sparc64_ieee1275 = util/ieee1275/ofpath.c; diff --git a/grub-core/Makefile.am b/grub-core/Makefile.am index addc83417..307467f44 100644 --- a/grub-core/Makefile.am +++ b/grub-core/Makefile.am @@ -48,6 +48,10 @@ CLEANFILES += grub_script.tab.c grub_script.tab.h grub_script.yy.h: script/yylex.l $(LEX) -o grub_script.yy.c --header-file=grub_script.yy.h $< grub_script.yy.c: grub_script.yy.h + +rs_decoder.S: $(srcdir)/lib/reed_solomon.c + $(TARGET_CC) $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) -I$(top_builddir) -S -DSTANDALONE -o $@ $< + CLEANFILES += grub_script.yy.c grub_script.yy.h include $(srcdir)/Makefile.core.am diff --git a/grub-core/kern/i386/pc/startup.S b/grub-core/kern/i386/pc/startup.S index 01825396c..283fc4f49 100644 --- a/grub-core/kern/i386/pc/startup.S +++ b/grub-core/kern/i386/pc/startup.S @@ -206,6 +206,22 @@ LOCAL (codestart): incl %eax call grub_gate_a20 + movl EXT_C(grub_kernel_image_size), %eax + addl EXT_C(grub_total_module_size), %eax + movl reed_solomon_redundancy, %ecx + leal _start + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_PART, %edx + testl %eax, %eax + jz post_reed_solomon + call EXT_C (grub_reed_solomon_recover) + jmp post_reed_solomon + +#include "/home/phcoder/compile/grub-core/rs_decoder.S" + + .text + + . = _start + GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_PART +post_reed_solomon: + #ifdef ENABLE_LZMA movl $GRUB_MEMORY_MACHINE_DECOMPRESSION_ADDR, %edi movl $(_start + GRUB_KERNEL_MACHINE_RAW_SIZE), %esi diff --git a/util/reed_solomon.c b/grub-core/lib/reed_solomon.c similarity index 63% rename from util/reed_solomon.c rename to grub-core/lib/reed_solomon.c index c20d023e7..290eb9482 100644 --- a/util/reed_solomon.c +++ b/grub-core/lib/reed_solomon.c @@ -18,25 +18,48 @@ #ifdef TEST #include +#define xmalloc malloc +#define grub_memset memset +#define grub_memcpy memcpy +#endif + +#ifndef STANDALONE +#ifdef TEST #include #include typedef unsigned int grub_size_t; typedef unsigned char grub_uint8_t; typedef unsigned short grub_uint16_t; -#define xmalloc malloc -#define grub_memset memset -#define grub_memcpy memcpy #else #include #include #include #include #endif +#endif + +#ifdef STANDALONE +#ifdef TEST +typedef unsigned int grub_size_t; +typedef unsigned char grub_uint8_t; +typedef unsigned short grub_uint16_t; +#else +#include +#endif +void +grub_reed_solomon_recover (void *ptr_, grub_size_t s, grub_size_t rs); +#endif #define GF_SIZE 8 typedef grub_uint8_t gf_single_t; typedef grub_uint16_t gf_double_t; -const gf_single_t gf_polynomial = 0x1d; +#define GF_POLYNOMIAL 0x1d +#define GF_INVERT2 0x8e +#ifdef STANDALONE +static char *scratch __attribute__ ((section(".text"))) = (void *) 0x100000; +#else +static char *scratch; +#endif #define SECTOR_SIZE 512 #define MAX_BLOCK_SIZE (200 * SECTOR_SIZE) @@ -47,7 +70,7 @@ gf_reduce (gf_double_t a) int i; for (i = GF_SIZE - 1; i >= 0; i--) if (a & (1ULL << (i + GF_SIZE))) - a ^= (((gf_double_t) gf_polynomial) << i); + a ^= (((gf_double_t) GF_POLYNOMIAL) << i); return a & ((1ULL << GF_SIZE) - 1); } @@ -62,50 +85,19 @@ gf_mul (gf_single_t a, gf_single_t b) return gf_reduce (res); } -static int -bin_log2 (gf_double_t a) +static grub_uint8_t gf_invert[256]; + +static void +init_inverts (void) { - int i = 0; - while (a) + gf_single_t a = 1, ai = 1; + do { - a >>= 1; - i++; + a = gf_mul (a, 2); + ai = gf_mul (ai, GF_INVERT2); + gf_invert[a] = ai; } - return i - 1; -} - -static gf_single_t -gf_invert (gf_single_t a) -{ - /* We start with: */ - /* 1 * a + 0 * p = a */ - /* 0 * a + 1 * p = p */ - gf_double_t x1 = 1, y1 = 0, z1 = a, x2 = 0, y2 = 1; - gf_double_t z2 = gf_polynomial | (1ULL << GF_SIZE), t; - /* invariant: z1 < z2*/ - while (z1 != 0) - { - int k; - k = bin_log2 (z2) - bin_log2 (z1); - x2 ^= (x1 << k); - y2 ^= (y1 << k); - z2 ^= (z1 << k); - - if (z1 >= z2) - { - t = x2; - x2 = x1; - x1 = t; - t = y2; - y2 = y1; - y1 = t; - t = z2; - z2 = z1; - z1 = t; - } - } - - return gf_reduce (x2); + while (a != 1); } static gf_single_t @@ -121,6 +113,7 @@ pol_evaluate (gf_single_t *pol, grub_size_t degree, gf_single_t x) return s; } +#if !defined (STANDALONE) || defined (TEST) static void rs_encode (gf_single_t *data, grub_size_t s, grub_size_t rs) { @@ -139,7 +132,7 @@ rs_encode (gf_single_t *data, grub_size_t s, grub_size_t rs) if (a & (1 << (GF_SIZE - 1))) { a <<= 1; - a ^= gf_polynomial; + a ^= GF_POLYNOMIAL; } else a <<= 1; @@ -157,21 +150,21 @@ rs_encode (gf_single_t *data, grub_size_t s, grub_size_t rs) free (rs_polynomial); grub_memcpy (data + s, m + s, rs * sizeof (gf_single_t)); free (m); - } +#endif static void syndroms (gf_single_t *m, grub_size_t s, grub_size_t rs, gf_single_t *sy) { gf_single_t xn = 1; - int i; + unsigned i; for (i = 0; i < rs; i++) { if (xn & (1 << (GF_SIZE - 1))) { xn <<= 1; - xn ^= gf_polynomial; + xn ^= GF_POLYNOMIAL; } else xn <<= 1; @@ -179,6 +172,66 @@ syndroms (gf_single_t *m, grub_size_t s, grub_size_t rs, } } +static void +gauss_eliminate (gf_single_t *eq, int n, int m, int *chosen) +{ + int i, j; + + for (i = 0 ; i < n; i++) + { + int nzidx; + int k; + gf_single_t r; + for (nzidx = 0; nzidx < m && (eq[i * (m + 1) + nzidx] == 0); + nzidx++); + if (nzidx == m) + continue; + chosen[i] = nzidx; + r = gf_invert [eq[i * (m + 1) + nzidx]]; + for (j = 0; j < m + 1; j++) + eq[i * (m + 1) + j] = gf_mul (eq[i * (m + 1) + j], r); + for (j = i + 1; j < n; j++) + { + gf_single_t rr = eq[j * (m + 1) + nzidx]; + for (k = 0; k < m + 1; k++) + eq[j * (m + 1) + k] ^= gf_mul (eq[i * (m + 1) + k], rr); + } + } +} + +static void +gauss_solve (gf_single_t *eq, int n, int m, gf_single_t *sol) +{ + int *chosen; + int i, j; + +#ifndef STANDALONE + chosen = xmalloc (n * sizeof (int)); + grub_memset (chosen, -1, n * sizeof (int)); +#else + chosen = (void *) scratch; + scratch += n; +#endif + for (i = 0; i < m; i++) + sol[i] = 0; + gauss_eliminate (eq, n, m, chosen); + for (i = n - 1; i >= 0; i--) + { + gf_single_t s = 0; + if (chosen[i] == -1) + continue; + for (j = 0; j < m; j++) + s ^= gf_mul (eq[i * (m + 1) + j], sol[j]); + s ^= eq[i * (m + 1) + m]; + sol[chosen[i]] = s; + } +#ifndef STANDALONE + free (chosen); +#else + scratch -= n; +#endif +} + static void rs_recover (gf_single_t *m, grub_size_t s, grub_size_t rs) { @@ -190,76 +243,61 @@ rs_recover (gf_single_t *m, grub_size_t s, grub_size_t rs) int errnum = 0; int i, j; +#ifndef STANDALONE sigma = xmalloc (rs2 * sizeof (gf_single_t)); errpot = xmalloc (rs2 * sizeof (gf_single_t)); errpos = xmalloc (rs2 * sizeof (int)); sy = xmalloc (rs * sizeof (gf_single_t)); +#else + sigma = (void *) scratch; + scratch += rs2 * sizeof (gf_single_t); + errpot = (void *) scratch; + scratch += rs2 * sizeof (gf_single_t); + errpos = (void *) scratch; + scratch += rs2 * sizeof (int); + sy = (void *) scratch; + scratch += rs * sizeof (gf_single_t); +#endif syndroms (m, s, rs, sy); { gf_single_t *eq; - int *chosen; +#ifndef STANDALONE eq = xmalloc (rs2 * (rs2 + 1) * sizeof (gf_single_t)); - chosen = xmalloc (rs2 * sizeof (int)); +#else + eq = (void *) scratch; + scratch += rs2 * (rs2 + 1) * sizeof (gf_single_t); +#endif - for (i = 0; i < rs; i++) + for (i = 0; i < (int) rs; i++) if (sy[i] != 0) break; /* No error detected. */ - if (i == rs) + if (i == (int) rs) return; - for (i = 0; i < rs2; i++) - for (j = 0; j < rs2 + 1; j++) + for (i = 0; i < (int) rs2; i++) + for (j = 0; j < (int) rs2 + 1; j++) eq[i * (rs2 + 1) + j] = sy[i+j]; - grub_memset (sigma, 0, rs2 * sizeof (gf_single_t)); - grub_memset (chosen, -1, rs2 * sizeof (int)); + for (i = 0; i < (int) rs2; i++) + sigma[i] = 0; - for (i = 0 ; i < rs2; i++) - { - int nzidx; - int k; - gf_single_t r; - for (nzidx = 0; nzidx < rs2 && (eq[i * (rs2 + 1) + nzidx] == 0); - nzidx++); - if (nzidx == rs2) - { - break; - } - chosen[i] = nzidx; - r = gf_invert (eq[i * (rs2 + 1) + nzidx]); - for (j = 0; j < rs2 + 1; j++) - eq[i * (rs2 + 1) + j] = gf_mul (eq[i * (rs2 + 1) + j], r); - for (j = i + 1; j < rs2; j++) - { - gf_single_t rr = eq[j * (rs2 + 1) + nzidx]; - for (k = 0; k < rs2 + 1; k++) - eq[j * (rs2 + 1) + k] ^= gf_mul (eq[i * (rs2 + 1) + k], rr);; - } - } - for (i = rs2 - 1; i >= 0; i--) - { - gf_single_t s = 0; - if (chosen[i] == -1) - continue; - for (j = 0; j < rs2; j++) - s ^= gf_mul (eq[i * (rs2 + 1) + j], sigma[j]); - s ^= eq[i * (rs2 + 1) + rs2]; - sigma[chosen[i]] = s; - } + gauss_solve (eq, rs2, rs2, sigma); - free (chosen); +#ifndef STANDALONE free (eq); +#else + scratch -= rs2 * (rs2 + 1) * sizeof (gf_single_t); +#endif } { - gf_single_t xn = 1, xx = gf_invert (2), yn = 1; - int lp = 0; - for (i = 0; i < rs + s; i++) + gf_single_t xn = 1, yn = 1; + for (i = 0; i < (int) (rs + s); i++) { gf_single_t ev = (gf_mul (pol_evaluate (sigma, rs2 - 1, xn), xn) ^ 1); if (ev == 0) @@ -268,96 +306,87 @@ rs_recover (gf_single_t *m, grub_size_t s, grub_size_t rs) errpos[errnum++] = s + rs - i - 1; } yn = gf_mul (yn, 2); - xn = gf_mul (xn, xx); + xn = gf_mul (xn, GF_INVERT2); } } { - gf_single_t *eq; - int *chosen; gf_single_t *errvals; + gf_single_t *eq; +#ifndef STANDALONE eq = xmalloc (rs * (errnum + 1) * sizeof (gf_single_t)); - chosen = xmalloc (rs * sizeof (int)); errvals = xmalloc (errnum * sizeof (int)); - - grub_memset (chosen, -1, rs * sizeof (int)); - grub_memset (errvals, 0, errnum * sizeof (gf_single_t)); +#else + eq = (void *) scratch; + scratch += rs * (errnum + 1) * sizeof (gf_single_t); + errvals = (void *) scratch; + scratch += errnum * sizeof (int); +#endif for (j = 0; j < errnum; j++) eq[j] = errpot[j]; eq[errnum] = sy[0]; - for (i = 1; i < rs; i++) + for (i = 1; i < (int) rs; i++) { - for (j = 0; j < errnum; j++) + for (j = 0; j < (int) errnum; j++) eq[(errnum + 1) * i + j] = gf_mul (errpot[j], eq[(errnum + 1) * (i - 1) + j]); eq[(errnum + 1) * i + errnum] = sy[i]; } - for (i = 0 ; i < rs; i++) - { - int nzidx; - int k; - gf_single_t r; - for (nzidx = 0; nzidx < errnum && (eq[i * (errnum + 1) + nzidx] == 0); - nzidx++); - if (nzidx == errnum) - continue; - chosen[i] = nzidx; - r = gf_invert (eq[i * (errnum + 1) + nzidx]); - for (j = 0; j < errnum + 1; j++) - eq[i * (errnum + 1) + j] = gf_mul (eq[i * (errnum + 1) + j], r); - for (j = i + 1; j < rs; j++) - { - gf_single_t rr = eq[j * (errnum + 1) + nzidx]; - for (k = 0; k < errnum + 1; k++) - eq[j * (errnum + 1) + k] ^= gf_mul (eq[i * (errnum + 1) + k], rr); - } - } - for (i = rs - 1; i >= 0; i--) - { - gf_single_t s = 0; - if (chosen[i] == -1) - continue; - for (j = 0; j < errnum; j++) - s ^= gf_mul (eq[i * (errnum + 1) + j], errvals[j]); - s ^= eq[i * (errnum + 1) + errnum]; - errvals[chosen[i]] = s; - } - for (i = 0; i < errnum; i++) + + gauss_solve (eq, rs, errnum, errvals); + + for (i = 0; i < (int) errnum; i++) m[errpos[i]] ^= errvals[i]; +#ifndef STANDALONE + free (eq); + free (errvals); +#else + scratch -= rs * (errnum + 1) * sizeof (gf_single_t); + scratch -= errnum * sizeof (int); +#endif } +#ifndef STANDALONE + free (sigma); + free (errpot); + free (errpos); free (sy); +#else + scratch -= rs2 * sizeof (gf_single_t); + scratch -= rs2 * sizeof (gf_single_t); + scratch -= rs2 * sizeof (int); + scratch -= rs * sizeof (gf_single_t); +#endif } static void decode_block (gf_single_t *ptr, grub_size_t s, gf_single_t *rptr, grub_size_t rs) { - grub_size_t ss; - int i, j, k; + int i, j; for (i = 0; i < SECTOR_SIZE; i++) { grub_size_t ds = (s + SECTOR_SIZE - 1 - i) / SECTOR_SIZE; grub_size_t rr = (rs + SECTOR_SIZE - 1 - i) / SECTOR_SIZE; gf_single_t m[ds + rr]; - for (j = 0; j < ds; j++) + for (j = 0; j < (int) ds; j++) m[j] = ptr[SECTOR_SIZE * j + i]; - for (j = 0; j < rr; j++) + for (j = 0; j < (int) rr; j++) m[j + ds] = rptr[SECTOR_SIZE * j + i]; rs_recover (m, ds, rr); - for (j = 0; j < ds; j++) + for (j = 0; j < (int) ds; j++) ptr[SECTOR_SIZE * j + i] = m[j]; } } +#if !defined (STANDALONE) || defined (TEST) static void encode_block (gf_single_t *ptr, grub_size_t s, gf_single_t *rptr, grub_size_t rs) { - grub_size_t ss; int i, j; for (i = 0; i < SECTOR_SIZE; i++) { @@ -371,7 +400,9 @@ encode_block (gf_single_t *ptr, grub_size_t s, rptr[SECTOR_SIZE * j + i] = m[j + ds]; } } +#endif +#if !defined (STANDALONE) || defined (TEST) void grub_reed_solomon_add_redundancy (void *buffer, grub_size_t data_size, grub_size_t redundancy) @@ -400,11 +431,18 @@ grub_reed_solomon_add_redundancy (void *buffer, grub_size_t data_size, rs -= crs; } } +#endif void -grub_reed_solomon_recover (void *ptr, grub_size_t s, grub_size_t rs) +grub_reed_solomon_recover (void *ptr_, grub_size_t s, grub_size_t rs) { + gf_single_t *ptr = ptr_; gf_single_t *rptr = ptr + s; + +#if defined (STANDALONE) && !defined (TEST) + init_inverts (); +#endif + while (s > 0) { grub_size_t tt; @@ -432,6 +470,13 @@ main (int argc, char **argv) FILE *in, *out; grub_size_t s, rs; char *buf; + +#ifdef STANDALONE + scratch = xmalloc (1048576); +#endif + + init_inverts (); + in = fopen ("tst.bin", "rb"); if (!in) return 1; diff --git a/include/grub/offsets.h b/include/grub/offsets.h index d1cf8720f..b8fbe40d4 100644 --- a/include/grub/offsets.h +++ b/include/grub/offsets.h @@ -41,9 +41,9 @@ #define GRUB_KERNEL_I386_PC_MULTIBOOT_SIGNATURE 0x20 /* The size of the first region which won't be compressed. */ -#define GRUB_KERNEL_I386_PC_RAW_SIZE 0x5E0 +#define GRUB_KERNEL_I386_PC_RAW_SIZE 0xc6c -#define GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_PART 0x300 +#define GRUB_KERNEL_I386_PC_NO_REED_SOLOMON_PART 0x748 /* The offset of GRUB_PREFIX. */ #define GRUB_KERNEL_I386_PC_PREFIX GRUB_KERNEL_I386_PC_RAW_SIZE