2 * LZ4 Decompressor for Linux kernel
4 * Copyright (C) 2013, LG Electronics, Kyungsik Lee <kyungsik.lee@lge.com>
6 * Based on LZ4 implementation by Yann Collet.
8 * LZ4 - Fast LZ compression algorithm
9 * Copyright (C) 2011-2012, Yann Collet.
10 * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions are
16 * * Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * * Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following disclaimer
20 * in the documentation and/or other materials provided with the
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 * You can contact the author at :
36 * - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
37 * - LZ4 source repository : http://code.google.com/p/lz4/
41 #include <linux/module.h>
42 #include <linux/kernel.h>
44 #include <linux/lz4.h>
46 #include <asm/unaligned.h>
50 static const int dec32table
[] = {0, 3, 2, 3, 0, 0, 0, 0};
52 static const int dec64table
[] = {0, 0, 0, -1, 0, 1, 2, 3};
55 static int lz4_uncompress(const char *source
, char *dest
, int osize
)
57 const BYTE
*ip
= (const BYTE
*) source
;
59 BYTE
*op
= (BYTE
*) dest
;
60 BYTE
* const oend
= op
+ osize
;
69 length
= (token
>> ML_BITS
);
70 if (length
== RUN_MASK
) {
74 for (; len
== 255; length
+= 255)
76 if (unlikely(length
> (size_t)(length
+ len
)))
83 if (unlikely(cpy
> oend
- COPYLENGTH
)) {
85 * Error: not enough place for another match
86 * (min 4) + 5 literals
91 memcpy(op
, ip
, length
);
95 LZ4_WILDCOPY(ip
, op
, cpy
);
100 LZ4_READ_LITTLEENDIAN_16(ref
, cpy
, ip
);
103 /* Error: offset create reference outside destination buffer */
104 if (unlikely(ref
< (BYTE
*const) dest
))
107 /* get matchlength */
108 length
= token
& ML_MASK
;
109 if (length
== ML_MASK
) {
110 for (; *ip
== 255; length
+= 255)
112 if (unlikely(length
> (size_t)(length
+ *ip
)))
117 /* copy repeated sequence */
118 if (unlikely((op
- ref
) < STEPSIZE
)) {
120 int dec64
= dec64table
[op
- ref
];
130 ref
-= dec32table
[op
-ref
];
135 LZ4_COPYSTEP(ref
, op
);
137 cpy
= op
+ length
- (STEPSIZE
- 4);
138 if (cpy
> (oend
- COPYLENGTH
)) {
140 /* Error: request to write beyond destination buffer */
143 if ((ref
+ COPYLENGTH
) > oend
||
144 (op
+ COPYLENGTH
) > oend
)
146 LZ4_SECURECOPY(ref
, op
, (oend
- COPYLENGTH
));
151 * Check EOF (should never happen, since last 5 bytes
152 * are supposed to be literals)
158 LZ4_SECURECOPY(ref
, op
, cpy
);
159 op
= cpy
; /* correction */
161 /* end of decoding */
162 return (int) (((char *)ip
) - source
);
164 /* write overflow error detected */
169 static int lz4_uncompress_unknownoutputsize(const char *source
, char *dest
,
170 int isize
, size_t maxoutputsize
)
172 const BYTE
*ip
= (const BYTE
*) source
;
173 const BYTE
*const iend
= ip
+ isize
;
177 BYTE
*op
= (BYTE
*) dest
;
178 BYTE
* const oend
= op
+ maxoutputsize
;
189 length
= (token
>> ML_BITS
);
190 if (length
== RUN_MASK
) {
192 while ((ip
< iend
) && (s
== 255)) {
194 if (unlikely(length
> (size_t)(length
+ s
)))
201 if ((cpy
> oend
- COPYLENGTH
) ||
202 (ip
+ length
> iend
- COPYLENGTH
)) {
205 goto _output_error
;/* writes beyond buffer */
207 if (ip
+ length
!= iend
)
208 goto _output_error
;/*
209 * Error: LZ4 format requires
210 * to consume all input
213 memcpy(op
, ip
, length
);
215 break;/* Necessarily EOF, due to parsing restrictions */
217 LZ4_WILDCOPY(ip
, op
, cpy
);
222 LZ4_READ_LITTLEENDIAN_16(ref
, cpy
, ip
);
224 if (ref
< (BYTE
* const) dest
)
227 * Error : offset creates reference
228 * outside of destination buffer
231 /* get matchlength */
232 length
= (token
& ML_MASK
);
233 if (length
== ML_MASK
) {
236 if (unlikely(length
> (size_t)(length
+ s
)))
245 /* copy repeated sequence */
246 if (unlikely((op
- ref
) < STEPSIZE
)) {
248 int dec64
= dec64table
[op
- ref
];
258 ref
-= dec32table
[op
- ref
];
263 LZ4_COPYSTEP(ref
, op
);
265 cpy
= op
+ length
- (STEPSIZE
-4);
266 if (cpy
> oend
- COPYLENGTH
) {
268 goto _output_error
; /* write outside of buf */
270 LZ4_SECURECOPY(ref
, op
, (oend
- COPYLENGTH
));
275 * Check EOF (should never happen, since last 5 bytes
276 * are supposed to be literals)
282 LZ4_SECURECOPY(ref
, op
, cpy
);
283 op
= cpy
; /* correction */
285 /* end of decoding */
286 return (int) (((char *) op
) - dest
);
288 /* write overflow error detected */
293 int lz4_decompress(const unsigned char *src
, size_t *src_len
,
294 unsigned char *dest
, size_t actual_dest_len
)
299 input_len
= lz4_uncompress(src
, dest
, actual_dest_len
);
302 *src_len
= input_len
;
309 EXPORT_SYMBOL(lz4_decompress
);
312 int lz4_decompress_unknownoutputsize(const unsigned char *src
, size_t src_len
,
313 unsigned char *dest
, size_t *dest_len
)
318 out_len
= lz4_uncompress_unknownoutputsize(src
, dest
, src_len
,
329 EXPORT_SYMBOL(lz4_decompress_unknownoutputsize
);
331 MODULE_LICENSE("Dual BSD/GPL");
332 MODULE_DESCRIPTION("LZ4 Decompressor");