wok view syslinux/stuff/extra/loadhigh.u @ rev 18759

Up tazpanel (561)
author Pascal Bellard <pascal.bellard@slitaz.org>
date Tue Dec 29 15:59:32 2015 +0100 (2015-12-29)
parents 924e6ea5da10
children 8ebcb0ded385
line source
1 --- core/fs/loadhigh.c
2 +++ core/fs/loadhigh.c
3 @@ -36,6 +36,11 @@
4 #include <minmax.h>
5 #include "core.h"
6 #include "fs.h"
7 +#define LZLOAD ".c32 modules can be compressed with lz4 or lzma"
8 +#ifdef LZLOAD
9 +#include "../unlz4.c"
10 +#include "../unlzma.c"
11 +#endif
12
13 #define MAX_CHUNK (1 << 20) /* 1 MB */
14
15 @@ -51,6 +56,10 @@
16 uint32_t sector_mask;
17 size_t pad;
18 uint32_t retflags = 0;
19 +#ifdef LZLOAD
20 + char *unpacked = (char *) regs->edi.l;
21 + size_t unpackedsz;
22 +#endif
23
24 bytes = regs->eax.l;
25 zero_mask = regs->edx.w[0];
26 @@ -101,6 +110,27 @@
27 break;
28 }
29 }
30 +
31 +#ifdef LZLOAD
32 + unpackedsz = buf - unpacked;
33 + switch (* (short *) unpacked) {
34 + char *packed;
35 + case 0x005D:
36 + packed = unpacked + * (unsigned long *) (unpacked + 5)
37 + - unpackedsz + 1024;
38 +
39 + if (packed < unpacked + 1024)
40 + packed = unpacked + 1024;
41 + memmove(packed, unpacked, unpackedsz);
42 + unlzma(packed, unpacked, packed + unpackedsz /* head */);
43 + buf = packed;
44 + break;
45 + case 0x2204:
46 + case 0x2102:
47 + buf = (char *) unlz4((unsigned char *) unpacked, (unsigned char *) buf);
48 + break;
49 + }
50 +#endif
51
52 pad = (size_t)buf & zero_mask;
53 if (pad)
54 --- /dev/null
55 +++ core/unlzma.c
56 @@ -0,0 +1,385 @@
57 +typedef unsigned char uint8_t;
58 +typedef unsigned short uint16_t;
59 +typedef unsigned uint32_t;
60 +typedef unsigned long long uint64_t;
61 +typedef unsigned size_t;
62 +#define SWAP_LE32(x) (x)
63 +#define SWAP_LE64(x) (x)
64 +/* vi: set sw=4 ts=4: */
65 +/*
66 + * Small lzma deflate implementation.
67 + * Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
68 + *
69 + * Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
70 + * Copyright (C) 1999-2005 Igor Pavlov
71 + *
72 + * Licensed under GPLv2 or later, see file LICENSE in this source tree.
73 + */
74 +
75 +#include <string.h>
76 +
77 +#define PACKED __attribute__ ((packed))
78 +#define ALWAYS_INLINE inline
79 +#define speed_inline
80 +#define size_inline ALWAYS_INLINE
81 +
82 +
83 +typedef struct {
84 + uint8_t *ptr;
85 +
86 + uint32_t code;
87 + uint32_t range;
88 + uint32_t bound;
89 +} rc_t;
90 +
91 +#define RC_TOP_BITS 24
92 +#define RC_MOVE_BITS 5
93 +#define RC_MODEL_TOTAL_BITS 11
94 +
95 +/* Called twice, but one callsite is in speed_inline'd rc_is_bit_1() */
96 +static void rc_do_normalize(rc_t *rc)
97 +{
98 + rc->range <<= 8;
99 + rc->code = (rc->code << 8) | *rc->ptr++;
100 +}
101 +
102 +static ALWAYS_INLINE void rc_normalize(rc_t *rc)
103 +{
104 + if (rc->range < (1 << RC_TOP_BITS)) {
105 + rc_do_normalize(rc);
106 + }
107 +}
108 +
109 +/* Called once */
110 +static void rc_init(rc_t *rc) /*, int buffer_size) */
111 +{
112 + int i;
113 +
114 + rc->range = 0;
115 + for (i = 0; i < 5; i++) {
116 + rc_do_normalize(rc);
117 + }
118 + rc->range = 0xffffffff;
119 +}
120 +
121 +/* rc_is_bit_1 is called 9 times */
122 +static speed_inline int rc_is_bit_1(rc_t *rc, uint16_t *p)
123 +{
124 + rc_normalize(rc);
125 + rc->bound = *p * (rc->range >> RC_MODEL_TOTAL_BITS);
126 + if (rc->code < rc->bound) {
127 + rc->range = rc->bound;
128 + *p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
129 + return 0;
130 + }
131 + rc->range -= rc->bound;
132 + rc->code -= rc->bound;
133 + *p -= *p >> RC_MOVE_BITS;
134 + return 1;
135 +}
136 +
137 +/* Called 4 times in unlzma loop */
138 +static ALWAYS_INLINE int rc_get_bit(rc_t *rc, uint16_t *p, int *symbol)
139 +{
140 + int ret = rc_is_bit_1(rc, p);
141 + *symbol = *symbol * 2 + ret;
142 + return ret;
143 +}
144 +
145 +/* Called once */
146 +static ALWAYS_INLINE int rc_direct_bit(rc_t *rc)
147 +{
148 + rc_normalize(rc);
149 + rc->range >>= 1;
150 + if (rc->code >= rc->range) {
151 + rc->code -= rc->range;
152 + return 1;
153 + }
154 + return 0;
155 +}
156 +
157 +/* Called twice */
158 +static speed_inline void
159 +rc_bit_tree_decode(rc_t *rc, uint16_t *p, int num_levels, int *symbol)
160 +{
161 + int i = num_levels;
162 +
163 + *symbol = 1;
164 + while (i--)
165 + rc_get_bit(rc, p + *symbol, symbol);
166 + *symbol -= 1 << num_levels;
167 +}
168 +
169 +
170 +typedef struct {
171 + uint8_t pos;
172 + uint32_t dict_size;
173 + uint64_t dst_size;
174 +} PACKED lzma_header_t;
175 +
176 +
177 +/* #defines will force compiler to compute/optimize each one with each usage.
178 + * Have heart and use enum instead. */
179 +enum {
180 + LZMA_BASE_SIZE = 1846,
181 + LZMA_LIT_SIZE = 768,
182 +
183 + LZMA_NUM_POS_BITS_MAX = 4,
184 +
185 + LZMA_LEN_NUM_LOW_BITS = 3,
186 + LZMA_LEN_NUM_MID_BITS = 3,
187 + LZMA_LEN_NUM_HIGH_BITS = 8,
188 +
189 + LZMA_LEN_CHOICE = 0,
190 + LZMA_LEN_CHOICE_2 = (LZMA_LEN_CHOICE + 1),
191 + LZMA_LEN_LOW = (LZMA_LEN_CHOICE_2 + 1),
192 + LZMA_LEN_MID = (LZMA_LEN_LOW \
193 + + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS))),
194 + LZMA_LEN_HIGH = (LZMA_LEN_MID \
195 + + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS))),
196 + LZMA_NUM_LEN_PROBS = (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS)),
197 +
198 + LZMA_NUM_STATES = 12,
199 + LZMA_NUM_LIT_STATES = 7,
200 +
201 + LZMA_START_POS_MODEL_INDEX = 4,
202 + LZMA_END_POS_MODEL_INDEX = 14,
203 + LZMA_NUM_FULL_DISTANCES = (1 << (LZMA_END_POS_MODEL_INDEX >> 1)),
204 +
205 + LZMA_NUM_POS_SLOT_BITS = 6,
206 + LZMA_NUM_LEN_TO_POS_STATES = 4,
207 +
208 + LZMA_NUM_ALIGN_BITS = 4,
209 +
210 + LZMA_MATCH_MIN_LEN = 2,
211 +
212 + LZMA_IS_MATCH = 0,
213 + LZMA_IS_REP = (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX)),
214 + LZMA_IS_REP_G0 = (LZMA_IS_REP + LZMA_NUM_STATES),
215 + LZMA_IS_REP_G1 = (LZMA_IS_REP_G0 + LZMA_NUM_STATES),
216 + LZMA_IS_REP_G2 = (LZMA_IS_REP_G1 + LZMA_NUM_STATES),
217 + LZMA_IS_REP_0_LONG = (LZMA_IS_REP_G2 + LZMA_NUM_STATES),
218 + LZMA_POS_SLOT = (LZMA_IS_REP_0_LONG \
219 + + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX)),
220 + LZMA_SPEC_POS = (LZMA_POS_SLOT \
221 + + (LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS)),
222 + LZMA_ALIGN = (LZMA_SPEC_POS \
223 + + LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX),
224 + LZMA_LEN_CODER = (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS)),
225 + LZMA_REP_LEN_CODER = (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS),
226 + LZMA_LITERAL = (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS),
227 +};
228 +
229 +
230 +void unlzma(char *from, char *to, char *heap)
231 +{
232 + lzma_header_t header;
233 + int lc, pb, lp;
234 + uint32_t pos_state_mask;
235 + uint32_t literal_pos_mask;
236 + uint16_t *p;
237 + rc_t *rc = (rc_t *) heap;
238 + int i;
239 + uint8_t *buffer = (void *) to;
240 + uint8_t previous_byte = 0;
241 + size_t buffer_pos = 0;
242 + int len = 0;
243 + int state = 0;
244 + uint32_t rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
245 +
246 + memcpy(&header, from, sizeof(header));
247 + from += sizeof(header);
248 + heap += sizeof(*rc);
249 + rc->ptr = (void *) from;
250 +
251 + i = header.pos / 9;
252 + lc = header.pos % 9;
253 + pb = i / 5;
254 + lp = i % 5;
255 + pos_state_mask = (1 << pb) - 1;
256 + literal_pos_mask = (1 << lp) - 1;
257 +
258 + /* Example values from linux-3.3.4.tar.lzma:
259 + * dict_size: 64M, dst_size: 2^64-1
260 + */
261 + header.dict_size = SWAP_LE32(header.dict_size);
262 + header.dst_size = SWAP_LE64(header.dst_size);
263 +
264 + //if (header.dict_size == 0)
265 + // header.dict_size++;
266 +
267 + rc_init(rc);
268 +
269 + {
270 + int num_probs;
271 +
272 + num_probs = LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp));
273 + //p = xmalloc(num_probs * sizeof(*p));
274 + p = (void *) heap;
275 + num_probs += LZMA_LITERAL - LZMA_BASE_SIZE;
276 + for (i = 0; i < num_probs; i++)
277 + p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
278 + }
279 +
280 +
281 + while (buffer_pos < header.dst_size) {
282 + int pos_state = buffer_pos & pos_state_mask;
283 + uint16_t *prob = p + LZMA_IS_MATCH + (state << LZMA_NUM_POS_BITS_MAX) + pos_state;
284 +
285 + if (!rc_is_bit_1(rc, prob)) {
286 + static const char next_state[LZMA_NUM_STATES] =
287 + { 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5 };
288 + int mi = 1;
289 +
290 + prob = (p + LZMA_LITERAL
291 + + (LZMA_LIT_SIZE * (((buffer_pos & literal_pos_mask) << lc)
292 + + (previous_byte >> (8 - lc))
293 + )
294 + )
295 + );
296 +
297 + if (state >= LZMA_NUM_LIT_STATES) {
298 + int match_byte;
299 + uint32_t pos = buffer_pos - rep0;
300 +
301 + while (pos >= header.dict_size)
302 + pos += header.dict_size;
303 + match_byte = buffer[pos];
304 + do {
305 + int bit;
306 +
307 + match_byte <<= 1;
308 + bit = match_byte & 0x100;
309 + bit ^= (rc_get_bit(rc, prob + 0x100 + bit + mi, &mi) << 8); /* 0x100 or 0 */
310 + if (bit)
311 + break;
312 + } while (mi < 0x100);
313 + }
314 + while (mi < 0x100) {
315 + rc_get_bit(rc, prob + mi, &mi);
316 + }
317 +
318 + state = next_state[state];
319 +
320 + previous_byte = (uint8_t) mi;
321 + len = 1;
322 + goto one_byte2;
323 + } else {
324 + int num_bits;
325 + int offset;
326 + uint16_t *prob2;
327 +#define prob_len prob2
328 +
329 + prob2 = p + LZMA_IS_REP + state;
330 + if (!rc_is_bit_1(rc, prob2)) {
331 + rep3 = rep2;
332 + rep2 = rep1;
333 + rep1 = rep0;
334 + state = state < LZMA_NUM_LIT_STATES ? 0 : 3;
335 + prob2 = p + LZMA_LEN_CODER;
336 + } else {
337 + prob2 += LZMA_IS_REP_G0 - LZMA_IS_REP;
338 + if (!rc_is_bit_1(rc, prob2)) {
339 + prob2 = (p + LZMA_IS_REP_0_LONG
340 + + (state << LZMA_NUM_POS_BITS_MAX)
341 + + pos_state
342 + );
343 + if (!rc_is_bit_1(rc, prob2)) {
344 + state = state < LZMA_NUM_LIT_STATES ? 9 : 11;
345 + len = 1;
346 + goto string;
347 + }
348 + } else {
349 + uint32_t distance;
350 +
351 + prob2 += LZMA_IS_REP_G1 - LZMA_IS_REP_G0;
352 + distance = rep1;
353 + if (rc_is_bit_1(rc, prob2)) {
354 + prob2 += LZMA_IS_REP_G2 - LZMA_IS_REP_G1;
355 + distance = rep2;
356 + if (rc_is_bit_1(rc, prob2)) {
357 + distance = rep3;
358 + rep3 = rep2;
359 + }
360 + rep2 = rep1;
361 + }
362 + rep1 = rep0;
363 + rep0 = distance;
364 + }
365 + state = state < LZMA_NUM_LIT_STATES ? 8 : 11;
366 + prob2 = p + LZMA_REP_LEN_CODER;
367 + }
368 +
369 + prob_len = prob2 + LZMA_LEN_CHOICE;
370 + num_bits = LZMA_LEN_NUM_LOW_BITS;
371 + if (!rc_is_bit_1(rc, prob_len)) {
372 + prob_len += LZMA_LEN_LOW - LZMA_LEN_CHOICE
373 + + (pos_state << LZMA_LEN_NUM_LOW_BITS);
374 + offset = 0;
375 + } else {
376 + prob_len += LZMA_LEN_CHOICE_2 - LZMA_LEN_CHOICE;
377 + if (!rc_is_bit_1(rc, prob_len)) {
378 + prob_len += LZMA_LEN_MID - LZMA_LEN_CHOICE_2
379 + + (pos_state << LZMA_LEN_NUM_MID_BITS);
380 + offset = 1 << LZMA_LEN_NUM_LOW_BITS;
381 + num_bits += LZMA_LEN_NUM_MID_BITS - LZMA_LEN_NUM_LOW_BITS;
382 + } else {
383 + prob_len += LZMA_LEN_HIGH - LZMA_LEN_CHOICE_2;
384 + offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
385 + + (1 << LZMA_LEN_NUM_MID_BITS));
386 + num_bits += LZMA_LEN_NUM_HIGH_BITS - LZMA_LEN_NUM_LOW_BITS;
387 + }
388 + }
389 + rc_bit_tree_decode(rc, prob_len, num_bits, &len);
390 + len += offset;
391 +
392 + if (state < 4) {
393 + int pos_slot;
394 + uint16_t *prob3;
395 +
396 + state += LZMA_NUM_LIT_STATES;
397 + prob3 = p + LZMA_POS_SLOT +
398 + ((len < LZMA_NUM_LEN_TO_POS_STATES ? len :
399 + LZMA_NUM_LEN_TO_POS_STATES - 1)
400 + << LZMA_NUM_POS_SLOT_BITS);
401 + rc_bit_tree_decode(rc, prob3,
402 + LZMA_NUM_POS_SLOT_BITS, &pos_slot);
403 + rep0 = pos_slot;
404 + if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
405 + int i2, mi2, num_bits2 = (pos_slot >> 1) - 1;
406 + rep0 = 2 | (pos_slot & 1);
407 + if (pos_slot < LZMA_END_POS_MODEL_INDEX) {
408 + rep0 <<= num_bits2;
409 + prob3 = p + LZMA_SPEC_POS + rep0 - pos_slot - 1;
410 + } else {
411 + for (; num_bits2 != LZMA_NUM_ALIGN_BITS; num_bits2--)
412 + rep0 = (rep0 << 1) | rc_direct_bit(rc);
413 + rep0 <<= LZMA_NUM_ALIGN_BITS;
414 + prob3 = p + LZMA_ALIGN;
415 + }
416 + i2 = 1;
417 + mi2 = 1;
418 + while (num_bits2--) {
419 + if (rc_get_bit(rc, prob3 + mi2, &mi2))
420 + rep0 |= i2;
421 + i2 <<= 1;
422 + }
423 + }
424 + if (++rep0 == 0)
425 + break;
426 + }
427 +
428 + len += LZMA_MATCH_MIN_LEN;
429 + string:
430 + do {
431 + uint32_t pos = buffer_pos - rep0;
432 + while (pos >= header.dict_size)
433 + pos += header.dict_size;
434 + previous_byte = buffer[pos];
435 + one_byte2:
436 + buffer[buffer_pos++] = previous_byte;
437 + len--;
438 + } while (len != 0 && buffer_pos < header.dst_size);
439 + }
440 + }
441 +}
442 --- /dev/null
443 +++ core/unlz4.c
444 @@ -0,0 +1,114 @@
445 +/*
446 + * Copyright (C) 2015, pascal.bellard@slitaz.org
447 + *
448 + * This program is free software; you can redistribute it and/or modify
449 + * it under the terms of the GNU General Public License version 2 as
450 + * published by the Free Software Foundation.
451 + */
452 +
453 +#include <string.h>
454 +
455 +#define LZ4_MAGIC 0x184D2204 /* Spec 1.5.0 */
456 +#define LZ4_LEGACY 0x184C2102
457 +#define LZ4_SKIP(n) ((((n) - 0x184D2A50) >> 4) == 0)
458 +
459 +static unsigned lz4cnt(unsigned char **p, unsigned n)
460 +{
461 + int i;
462 +
463 + if (n == 0xF) do {
464 + i = *(*p)++;
465 + n += i;
466 + } while (i == 0xFF);
467 + return n;
468 +}
469 +
470 +unsigned char *unlz4(unsigned char *from, unsigned char *end)
471 +{
472 + unsigned char *p, *end_chunk, *to, flags, mask;
473 + long magic;
474 + unsigned i, n, size;
475 +
476 + for (p = from, flags = size = 0; p < end;) {
477 + while (1) {
478 + magic = * (long *) p;
479 + p += sizeof(long);
480 + if (magic == LZ4_LEGACY) continue;
481 + if (magic != LZ4_MAGIC) break;
482 + flags = *p;
483 + if (flags & 8) {
484 + size = * (unsigned *) (p + 2);
485 + goto sizefound;
486 + }
487 + p += 3; /* skip FLG BD HC */
488 + }
489 + if (LZ4_SKIP(magic)) {
490 + p += 4 + * (long *) p;
491 + continue;
492 + }
493 + mask = 4; /* Content checksum */
494 + if (magic) {
495 + if (magic > 0)
496 + for (end_chunk = p + magic; p < end_chunk;) {
497 + unsigned char token = *p++;
498 +
499 + n = lz4cnt(&p, token >> 4);
500 + size += n;
501 + p += n;
502 + if (p >= end_chunk) break;
503 + p += sizeof(unsigned short);
504 + size += 4 + lz4cnt(&p, token & 0xF);
505 + }
506 + else {
507 + magic &= 0x7FffFFff;
508 + p += magic;
509 + size += magic;
510 + }
511 + mask = 0x10; /* Block checksum */
512 + }
513 + if (flags & mask) p += 4; /* skip block checksum */
514 + }
515 +sizefound:
516 + size += 16 - (p - from);
517 + memmove(from + size, from, p - from);
518 + for (to = from, p = from += size, end += size, flags = 0; p < end;) {
519 + while (1) {
520 + magic = * (long *) p;
521 + p += sizeof(long);
522 + if (magic == LZ4_LEGACY) continue;
523 + if (magic != LZ4_MAGIC) break;
524 + flags = *p;
525 + if (flags & 8) p += 8; /* skip size */
526 + p += 3; /* skip FLG BD HC */
527 + }
528 + if (LZ4_SKIP(magic)) {
529 + p += 4 + * (long *) p;
530 + continue;
531 + }
532 + mask = 4; /* Content checksum */
533 + if (magic) {
534 + if (magic > 0)
535 + for (end_chunk = p + magic; p < end_chunk;) {
536 + unsigned char *dico;
537 + unsigned char token = *p++;
538 +
539 + n = lz4cnt(&p, token >> 4);
540 + for (i = 0; i < n; i++)
541 + *to++ = *p++;
542 + if (p >= end_chunk) break;
543 + dico = to - (* (unsigned short *) p);
544 + p += sizeof(unsigned short);
545 + n = 4 + lz4cnt(&p, token & 0xF);
546 + for (i = 0; i < n; i++)
547 + *to++ = *dico++;
548 + }
549 + else for (end_chunk = p + (magic & 0x7FffFFff);
550 + p < end_chunk;) {
551 + *to++ = *p++;
552 + }
553 + mask = 0x10; /* Block checksum */
554 + }
555 + if (flags & mask) p += 4; /* Skip checksum */
556 + }
557 + return to;
558 +}