Root/package/compcache/patches/000-provide_lzo_kmod.patch

1--- a/Makefile
2+++ b/Makefile
3@@ -1,14 +1,17 @@
4 KERNEL_BUILD_PATH ?= "/lib/modules/$(shell uname -r)/build"
5 
6 XVM = sub-projects/allocators/xvmalloc-kmod
7+LZO = sub-projects/compression/lzo-kmod
8 EXTRA_CFLAGS := -DCONFIG_RAMZSWAP_STATS \
9             -Wall
10 
11-obj-m += ramzswap.o
12+obj-m += ramzswap.o $(LZO)/lzo1x.o
13 ramzswap-objs := ramzswap_drv.o $(XVM)/xvmalloc.o
14+
15 
16 all:
17     make -C $(KERNEL_BUILD_PATH) M=$(PWD) modules
18+ make -C $(KERNEL_BUILD_PATH) M=$(PWD)/$(LZO) modules
19     make -C sub-projects/rzscontrol
20 
21 doc:
22@@ -16,5 +19,6 @@ doc:
23 
24 clean:
25     make -C $(KERNEL_BUILD_PATH) M=$(PWD) clean
26+ make -C $(KERNEL_BUILD_PATH) M=$(PWD)/$(LZO) clean
27     make -C sub-projects/rzscontrol clean
28     @rm -rf *.ko
29--- a/ramzswap_drv.c
30+++ b/ramzswap_drv.c
31@@ -23,13 +23,13 @@
32 #include <linux/device.h>
33 #include <linux/genhd.h>
34 #include <linux/highmem.h>
35-#include <linux/lzo.h>
36 #include <linux/string.h>
37 #include <linux/swap.h>
38 #include <linux/swapops.h>
39 #include <linux/vmalloc.h>
40 #include <linux/version.h>
41 
42+#include "lzo.h"
43 #include "compat.h"
44 #include "ramzswap_drv.h"
45 
46--- /dev/null
47+++ b/sub-projects/compression/lzo-kmod/lzo1x.c
48@@ -0,0 +1,7 @@
49+#include <linux/module.h>
50+
51+#include "lzo1x_compress.c"
52+#include "lzo1x_decompress.c"
53+
54+MODULE_LICENSE("GPL");
55+MODULE_DESCRIPTION("LZO1X Lib");
56--- /dev/null
57+++ b/sub-projects/compression/lzo-kmod/lzo1x_compress.c
58@@ -0,0 +1,227 @@
59+/*
60+ * LZO1X Compressor from MiniLZO
61+ *
62+ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>
63+ *
64+ * The full LZO package can be found at:
65+ * http://www.oberhumer.com/opensource/lzo/
66+ *
67+ * Changed for kernel use by:
68+ * Nitin Gupta <nitingupta910@gmail.com>
69+ * Richard Purdie <rpurdie@openedhand.com>
70+ */
71+
72+#include <linux/module.h>
73+#include <linux/kernel.h>
74+#include <asm/unaligned.h>
75+
76+#include "lzodefs.h"
77+#include "lzo.h"
78+
79+static noinline size_t
80+_lzo1x_1_do_compress(const unsigned char *in, size_t in_len,
81+ unsigned char *out, size_t *out_len, void *wrkmem)
82+{
83+ const unsigned char * const in_end = in + in_len;
84+ const unsigned char * const ip_end = in + in_len - M2_MAX_LEN - 5;
85+ const unsigned char ** const dict = wrkmem;
86+ const unsigned char *ip = in, *ii = ip;
87+ const unsigned char *end, *m, *m_pos;
88+ size_t m_off, m_len, dindex;
89+ unsigned char *op = out;
90+
91+ ip += 4;
92+
93+ for (;;) {
94+ dindex = ((size_t)(0x21 * DX3(ip, 5, 5, 6)) >> 5) & D_MASK;
95+ m_pos = dict[dindex];
96+
97+ if (m_pos < in)
98+ goto literal;
99+
100+ if (ip == m_pos || ((size_t)(ip - m_pos) > M4_MAX_OFFSET))
101+ goto literal;
102+
103+ m_off = ip - m_pos;
104+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
105+ goto try_match;
106+
107+ dindex = (dindex & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f);
108+ m_pos = dict[dindex];
109+
110+ if (m_pos < in)
111+ goto literal;
112+
113+ if (ip == m_pos || ((size_t)(ip - m_pos) > M4_MAX_OFFSET))
114+ goto literal;
115+
116+ m_off = ip - m_pos;
117+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
118+ goto try_match;
119+
120+ goto literal;
121+
122+try_match:
123+ if (get_unaligned((const unsigned short *)m_pos)
124+ == get_unaligned((const unsigned short *)ip)) {
125+ if (likely(m_pos[2] == ip[2]))
126+ goto match;
127+ }
128+
129+literal:
130+ dict[dindex] = ip;
131+ ++ip;
132+ if (unlikely(ip >= ip_end))
133+ break;
134+ continue;
135+
136+match:
137+ dict[dindex] = ip;
138+ if (ip != ii) {
139+ size_t t = ip - ii;
140+
141+ if (t <= 3) {
142+ op[-2] |= t;
143+ } else if (t <= 18) {
144+ *op++ = (t - 3);
145+ } else {
146+ size_t tt = t - 18;
147+
148+ *op++ = 0;
149+ while (tt > 255) {
150+ tt -= 255;
151+ *op++ = 0;
152+ }
153+ *op++ = tt;
154+ }
155+ do {
156+ *op++ = *ii++;
157+ } while (--t > 0);
158+ }
159+
160+ ip += 3;
161+ if (m_pos[3] != *ip++ || m_pos[4] != *ip++
162+ || m_pos[5] != *ip++ || m_pos[6] != *ip++
163+ || m_pos[7] != *ip++ || m_pos[8] != *ip++) {
164+ --ip;
165+ m_len = ip - ii;
166+
167+ if (m_off <= M2_MAX_OFFSET) {
168+ m_off -= 1;
169+ *op++ = (((m_len - 1) << 5)
170+ | ((m_off & 7) << 2));
171+ *op++ = (m_off >> 3);
172+ } else if (m_off <= M3_MAX_OFFSET) {
173+ m_off -= 1;
174+ *op++ = (M3_MARKER | (m_len - 2));
175+ goto m3_m4_offset;
176+ } else {
177+ m_off -= 0x4000;
178+
179+ *op++ = (M4_MARKER | ((m_off & 0x4000) >> 11)
180+ | (m_len - 2));
181+ goto m3_m4_offset;
182+ }
183+ } else {
184+ end = in_end;
185+ m = m_pos + M2_MAX_LEN + 1;
186+
187+ while (ip < end && *m == *ip) {
188+ m++;
189+ ip++;
190+ }
191+ m_len = ip - ii;
192+
193+ if (m_off <= M3_MAX_OFFSET) {
194+ m_off -= 1;
195+ if (m_len <= 33) {
196+ *op++ = (M3_MARKER | (m_len - 2));
197+ } else {
198+ m_len -= 33;
199+ *op++ = M3_MARKER | 0;
200+ goto m3_m4_len;
201+ }
202+ } else {
203+ m_off -= 0x4000;
204+ if (m_len <= M4_MAX_LEN) {
205+ *op++ = (M4_MARKER
206+ | ((m_off & 0x4000) >> 11)
207+ | (m_len - 2));
208+ } else {
209+ m_len -= M4_MAX_LEN;
210+ *op++ = (M4_MARKER
211+ | ((m_off & 0x4000) >> 11));
212+m3_m4_len:
213+ while (m_len > 255) {
214+ m_len -= 255;
215+ *op++ = 0;
216+ }
217+
218+ *op++ = (m_len);
219+ }
220+ }
221+m3_m4_offset:
222+ *op++ = ((m_off & 63) << 2);
223+ *op++ = (m_off >> 6);
224+ }
225+
226+ ii = ip;
227+ if (unlikely(ip >= ip_end))
228+ break;
229+ }
230+
231+ *out_len = op - out;
232+ return in_end - ii;
233+}
234+
235+int lzo1x_1_compress(const unsigned char *in, size_t in_len, unsigned char *out,
236+ size_t *out_len, void *wrkmem)
237+{
238+ const unsigned char *ii;
239+ unsigned char *op = out;
240+ size_t t;
241+
242+ if (unlikely(in_len <= M2_MAX_LEN + 5)) {
243+ t = in_len;
244+ } else {
245+ t = _lzo1x_1_do_compress(in, in_len, op, out_len, wrkmem);
246+ op += *out_len;
247+ }
248+
249+ if (t > 0) {
250+ ii = in + in_len - t;
251+
252+ if (op == out && t <= 238) {
253+ *op++ = (17 + t);
254+ } else if (t <= 3) {
255+ op[-2] |= t;
256+ } else if (t <= 18) {
257+ *op++ = (t - 3);
258+ } else {
259+ size_t tt = t - 18;
260+
261+ *op++ = 0;
262+ while (tt > 255) {
263+ tt -= 255;
264+ *op++ = 0;
265+ }
266+
267+ *op++ = tt;
268+ }
269+ do {
270+ *op++ = *ii++;
271+ } while (--t > 0);
272+ }
273+
274+ *op++ = M4_MARKER | 1;
275+ *op++ = 0;
276+ *op++ = 0;
277+
278+ *out_len = op - out;
279+ return LZO_E_OK;
280+}
281+EXPORT_SYMBOL_GPL(lzo1x_1_compress);
282+
283+MODULE_LICENSE("GPL");
284+MODULE_DESCRIPTION("LZO1X-1 Compressor");
285+
286--- /dev/null
287+++ b/sub-projects/compression/lzo-kmod/lzo1x_decompress.c
288@@ -0,0 +1,255 @@
289+/*
290+ * LZO1X Decompressor from MiniLZO
291+ *
292+ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>
293+ *
294+ * The full LZO package can be found at:
295+ * http://www.oberhumer.com/opensource/lzo/
296+ *
297+ * Changed for kernel use by:
298+ * Nitin Gupta <nitingupta910@gmail.com>
299+ * Richard Purdie <rpurdie@openedhand.com>
300+ */
301+
302+#include <linux/module.h>
303+#include <linux/kernel.h>
304+#include <asm/byteorder.h>
305+#include <asm/unaligned.h>
306+
307+#include "lzodefs.h"
308+#include "lzo.h"
309+
310+#define HAVE_IP(x, ip_end, ip) ((size_t)(ip_end - ip) < (x))
311+#define HAVE_OP(x, op_end, op) ((size_t)(op_end - op) < (x))
312+#define HAVE_LB(m_pos, out, op) (m_pos < out || m_pos >= op)
313+
314+#define COPY4(dst, src) \
315+ put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
316+
317+int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
318+ unsigned char *out, size_t *out_len)
319+{
320+ const unsigned char * const ip_end = in + in_len;
321+ unsigned char * const op_end = out + *out_len;
322+ const unsigned char *ip = in, *m_pos;
323+ unsigned char *op = out;
324+ size_t t;
325+
326+ *out_len = 0;
327+
328+ if (*ip > 17) {
329+ t = *ip++ - 17;
330+ if (t < 4)
331+ goto match_next;
332+ if (HAVE_OP(t, op_end, op))
333+ goto output_overrun;
334+ if (HAVE_IP(t + 1, ip_end, ip))
335+ goto input_overrun;
336+ do {
337+ *op++ = *ip++;
338+ } while (--t > 0);
339+ goto first_literal_run;
340+ }
341+
342+ while ((ip < ip_end)) {
343+ t = *ip++;
344+ if (t >= 16)
345+ goto match;
346+ if (t == 0) {
347+ if (HAVE_IP(1, ip_end, ip))
348+ goto input_overrun;
349+ while (*ip == 0) {
350+ t += 255;
351+ ip++;
352+ if (HAVE_IP(1, ip_end, ip))
353+ goto input_overrun;
354+ }
355+ t += 15 + *ip++;
356+ }
357+ if (HAVE_OP(t + 3, op_end, op))
358+ goto output_overrun;
359+ if (HAVE_IP(t + 4, ip_end, ip))
360+ goto input_overrun;
361+
362+ COPY4(op, ip);
363+ op += 4;
364+ ip += 4;
365+ if (--t > 0) {
366+ if (t >= 4) {
367+ do {
368+ COPY4(op, ip);
369+ op += 4;
370+ ip += 4;
371+ t -= 4;
372+ } while (t >= 4);
373+ if (t > 0) {
374+ do {
375+ *op++ = *ip++;
376+ } while (--t > 0);
377+ }
378+ } else {
379+ do {
380+ *op++ = *ip++;
381+ } while (--t > 0);
382+ }
383+ }
384+
385+first_literal_run:
386+ t = *ip++;
387+ if (t >= 16)
388+ goto match;
389+ m_pos = op - (1 + M2_MAX_OFFSET);
390+ m_pos -= t >> 2;
391+ m_pos -= *ip++ << 2;
392+
393+ if (HAVE_LB(m_pos, out, op))
394+ goto lookbehind_overrun;
395+
396+ if (HAVE_OP(3, op_end, op))
397+ goto output_overrun;
398+ *op++ = *m_pos++;
399+ *op++ = *m_pos++;
400+ *op++ = *m_pos;
401+
402+ goto match_done;
403+
404+ do {
405+match:
406+ if (t >= 64) {
407+ m_pos = op - 1;
408+ m_pos -= (t >> 2) & 7;
409+ m_pos -= *ip++ << 3;
410+ t = (t >> 5) - 1;
411+ if (HAVE_LB(m_pos, out, op))
412+ goto lookbehind_overrun;
413+ if (HAVE_OP(t + 3 - 1, op_end, op))
414+ goto output_overrun;
415+ goto copy_match;
416+ } else if (t >= 32) {
417+ t &= 31;
418+ if (t == 0) {
419+ if (HAVE_IP(1, ip_end, ip))
420+ goto input_overrun;
421+ while (*ip == 0) {
422+ t += 255;
423+ ip++;
424+ if (HAVE_IP(1, ip_end, ip))
425+ goto input_overrun;
426+ }
427+ t += 31 + *ip++;
428+ }
429+ m_pos = op - 1;
430+ m_pos -= le16_to_cpu(get_unaligned(
431+ (const unsigned short *)ip)) >> 2;
432+ ip += 2;
433+ } else if (t >= 16) {
434+ m_pos = op;
435+ m_pos -= (t & 8) << 11;
436+
437+ t &= 7;
438+ if (t == 0) {
439+ if (HAVE_IP(1, ip_end, ip))
440+ goto input_overrun;
441+ while (*ip == 0) {
442+ t += 255;
443+ ip++;
444+ if (HAVE_IP(1, ip_end, ip))
445+ goto input_overrun;
446+ }
447+ t += 7 + *ip++;
448+ }
449+ m_pos -= le16_to_cpu(get_unaligned(
450+ (const unsigned short *)ip)) >> 2;
451+ ip += 2;
452+ if (m_pos == op)
453+ goto eof_found;
454+ m_pos -= 0x4000;
455+ } else {
456+ m_pos = op - 1;
457+ m_pos -= t >> 2;
458+ m_pos -= *ip++ << 2;
459+
460+ if (HAVE_LB(m_pos, out, op))
461+ goto lookbehind_overrun;
462+ if (HAVE_OP(2, op_end, op))
463+ goto output_overrun;
464+
465+ *op++ = *m_pos++;
466+ *op++ = *m_pos;
467+ goto match_done;
468+ }
469+
470+ if (HAVE_LB(m_pos, out, op))
471+ goto lookbehind_overrun;
472+ if (HAVE_OP(t + 3 - 1, op_end, op))
473+ goto output_overrun;
474+
475+ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) {
476+ COPY4(op, m_pos);
477+ op += 4;
478+ m_pos += 4;
479+ t -= 4 - (3 - 1);
480+ do {
481+ COPY4(op, m_pos);
482+ op += 4;
483+ m_pos += 4;
484+ t -= 4;
485+ } while (t >= 4);
486+ if (t > 0)
487+ do {
488+ *op++ = *m_pos++;
489+ } while (--t > 0);
490+ } else {
491+copy_match:
492+ *op++ = *m_pos++;
493+ *op++ = *m_pos++;
494+ do {
495+ *op++ = *m_pos++;
496+ } while (--t > 0);
497+ }
498+match_done:
499+ t = ip[-2] & 3;
500+ if (t == 0)
501+ break;
502+match_next:
503+ if (HAVE_OP(t, op_end, op))
504+ goto output_overrun;
505+ if (HAVE_IP(t + 1, ip_end, ip))
506+ goto input_overrun;
507+
508+ *op++ = *ip++;
509+ if (t > 1) {
510+ *op++ = *ip++;
511+ if (t > 2)
512+ *op++ = *ip++;
513+ }
514+
515+ t = *ip++;
516+ } while (ip < ip_end);
517+ }
518+
519+ *out_len = op - out;
520+ return LZO_E_EOF_NOT_FOUND;
521+
522+eof_found:
523+ *out_len = op - out;
524+ return (ip == ip_end ? LZO_E_OK :
525+ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
526+input_overrun:
527+ *out_len = op - out;
528+ return LZO_E_INPUT_OVERRUN;
529+
530+output_overrun:
531+ *out_len = op - out;
532+ return LZO_E_OUTPUT_OVERRUN;
533+
534+lookbehind_overrun:
535+ *out_len = op - out;
536+ return LZO_E_LOOKBEHIND_OVERRUN;
537+}
538+
539+EXPORT_SYMBOL_GPL(lzo1x_decompress_safe);
540+
541+MODULE_LICENSE("GPL");
542+MODULE_DESCRIPTION("LZO1X Decompressor");
543+
544--- /dev/null
545+++ b/sub-projects/compression/lzo-kmod/lzodefs.h
546@@ -0,0 +1,43 @@
547+/*
548+ * lzodefs.h -- architecture, OS and compiler specific defines
549+ *
550+ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>
551+ *
552+ * The full LZO package can be found at:
553+ * http://www.oberhumer.com/opensource/lzo/
554+ *
555+ * Changed for kernel use by:
556+ * Nitin Gupta <nitingupta910@gmail.com>
557+ * Richard Purdie <rpurdie@openedhand.com>
558+ */
559+
560+#define LZO_VERSION 0x2020
561+#define LZO_VERSION_STRING "2.02"
562+#define LZO_VERSION_DATE "Oct 17 2005"
563+
564+#define M1_MAX_OFFSET 0x0400
565+#define M2_MAX_OFFSET 0x0800
566+#define M3_MAX_OFFSET 0x4000
567+#define M4_MAX_OFFSET 0xbfff
568+
569+#define M1_MIN_LEN 2
570+#define M1_MAX_LEN 2
571+#define M2_MIN_LEN 3
572+#define M2_MAX_LEN 8
573+#define M3_MIN_LEN 3
574+#define M3_MAX_LEN 33
575+#define M4_MIN_LEN 3
576+#define M4_MAX_LEN 9
577+
578+#define M1_MARKER 0
579+#define M2_MARKER 64
580+#define M3_MARKER 32
581+#define M4_MARKER 16
582+
583+#define D_BITS 14
584+#define D_MASK ((1u << D_BITS) - 1)
585+#define D_HIGH ((D_MASK >> 1) + 1)
586+
587+#define DX2(p, s1, s2) (((((size_t)((p)[2]) << (s2)) ^ (p)[1]) \
588+ << (s1)) ^ (p)[0])
589+#define DX3(p, s1, s2, s3) ((DX2((p)+1, s2, s3) << (s1)) ^ (p)[0])
590--- /dev/null
591+++ b/sub-projects/compression/lzo-kmod/lzo.h
592@@ -0,0 +1,44 @@
593+#ifndef __LZO_H__
594+#define __LZO_H__
595+/*
596+ * LZO Public Kernel Interface
597+ * A mini subset of the LZO real-time data compression library
598+ *
599+ * Copyright (C) 1996-2005 Markus F.X.J. Oberhumer <markus@oberhumer.com>
600+ *
601+ * The full LZO package can be found at:
602+ * http://www.oberhumer.com/opensource/lzo/
603+ *
604+ * Changed for kernel use by:
605+ * Nitin Gupta <nitingupta910@gmail.com>
606+ * Richard Purdie <rpurdie@openedhand.com>
607+ */
608+
609+#define LZO1X_MEM_COMPRESS (16384 * sizeof(unsigned char *))
610+#define LZO1X_1_MEM_COMPRESS LZO1X_MEM_COMPRESS
611+
612+#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)
613+
614+/* This requires 'workmem' of size LZO1X_1_MEM_COMPRESS */
615+int lzo1x_1_compress(const unsigned char *src, size_t src_len,
616+ unsigned char *dst, size_t *dst_len, void *wrkmem);
617+
618+/* safe decompression with overrun testing */
619+int lzo1x_decompress_safe(const unsigned char *src, size_t src_len,
620+ unsigned char *dst, size_t *dst_len);
621+
622+/*
623+ * Return values (< 0 = Error)
624+ */
625+#define LZO_E_OK 0
626+#define LZO_E_ERROR (-1)
627+#define LZO_E_OUT_OF_MEMORY (-2)
628+#define LZO_E_NOT_COMPRESSIBLE (-3)
629+#define LZO_E_INPUT_OVERRUN (-4)
630+#define LZO_E_OUTPUT_OVERRUN (-5)
631+#define LZO_E_LOOKBEHIND_OVERRUN (-6)
632+#define LZO_E_EOF_NOT_FOUND (-7)
633+#define LZO_E_INPUT_NOT_CONSUMED (-8)
634+#define LZO_E_NOT_YET_IMPLEMENTED (-9)
635+
636+#endif
637--- /dev/null
638+++ b/sub-projects/compression/lzo-kmod/Makefile
639@@ -0,0 +1,8 @@
640+obj-m += lzo1x_compress.o lzo1x_decompress.o
641+
642+all:
643+ make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
644+
645+clean:
646+ make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
647+
648

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive