1 #ifndef __LZ4DEFS_H__ 2 #define __LZ4DEFS_H__ 3 4 /* 5 * lz4defs.h -- common and architecture specific defines for the kernel usage 6 7 * LZ4 - Fast LZ compression algorithm 8 * Copyright (C) 2011-2016, Yann Collet. 9 * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions are 12 * met: 13 * * Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * * Redistributions in binary form must reproduce the above 16 * copyright notice, this list of conditions and the following disclaimer 17 * in the documentation and/or other materials provided with the 18 * distribution. 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 * You can contact the author at : 31 * - LZ4 homepage : http://www.lz4.org 32 * - LZ4 source repository : https://github.com/lz4/lz4 33 * 34 * Changed for kernel usage by: 35 * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> 36 */ 37 38 #include <asm/unaligned.h> 39 #include <linux/string.h> /* memset, memcpy */ 40 41 #define FORCE_INLINE __always_inline 42 43 /*-************************************ 44 * Basic Types 45 **************************************/ 46 #include <linux/types.h> 47 48 typedef uint8_t BYTE; 49 typedef uint16_t U16; 50 typedef uint32_t U32; 51 typedef int32_t S32; 52 typedef uint64_t U64; 53 typedef uintptr_t uptrval; 54 55 /*-************************************ 56 * Architecture specifics 57 **************************************/ 58 #if defined(CONFIG_64BIT) 59 #define LZ4_ARCH64 1 60 #else 61 #define LZ4_ARCH64 0 62 #endif 63 64 #if defined(__LITTLE_ENDIAN) 65 #define LZ4_LITTLE_ENDIAN 1 66 #else 67 #define LZ4_LITTLE_ENDIAN 0 68 #endif 69 70 /*-************************************ 71 * Constants 72 **************************************/ 73 #define MINMATCH 4 74 75 #define WILDCOPYLENGTH 8 76 #define LASTLITERALS 5 77 #define MFLIMIT (WILDCOPYLENGTH + MINMATCH) 78 /* 79 * ensure it's possible to write 2 x wildcopyLength 80 * without overflowing output buffer 81 */ 82 #define MATCH_SAFEGUARD_DISTANCE ((2 * WILDCOPYLENGTH) - MINMATCH) 83 84 /* Increase this value ==> compression run slower on incompressible data */ 85 #define LZ4_SKIPTRIGGER 6 86 87 #define HASH_UNIT sizeof(size_t) 88 89 #define KB (1 << 10) 90 #define MB (1 << 20) 91 #define GB (1U << 30) 92 93 #define MAXD_LOG 16 94 #define MAX_DISTANCE ((1 << MAXD_LOG) - 1) 95 #define STEPSIZE sizeof(size_t) 96 97 #define ML_BITS 4 98 #define ML_MASK ((1U << ML_BITS) - 1) 99 #define RUN_BITS (8 - ML_BITS) 100 #define RUN_MASK ((1U << RUN_BITS) - 1) 101 102 /*-************************************ 103 * Reading and writing into memory 104 **************************************/ 105 static FORCE_INLINE U16 LZ4_read16(const void *ptr) 106 { 107 return get_unaligned((const U16 *)ptr); 108 } 109 110 static FORCE_INLINE U32 LZ4_read32(const void *ptr) 111 { 112 return get_unaligned((const U32 *)ptr); 113 } 114 115 static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr) 116 { 117 return get_unaligned((const size_t *)ptr); 118 } 119 120 static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value) 121 { 122 put_unaligned(value, (U16 *)memPtr); 123 } 124 125 static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value) 126 { 127 put_unaligned(value, (U32 *)memPtr); 128 } 129 130 static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr) 131 { 132 return get_unaligned_le16(memPtr); 133 } 134 135 static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value) 136 { 137 return put_unaligned_le16(value, memPtr); 138 } 139 140 /* 141 * LZ4 relies on memcpy with a constant size being inlined. In freestanding 142 * environments, the compiler can't assume the implementation of memcpy() is 143 * standard compliant, so apply its specialized memcpy() inlining logic. When 144 * possible, use __builtin_memcpy() to tell the compiler to analyze memcpy() 145 * as-if it were standard compliant, so it can inline it in freestanding 146 * environments. This is needed when decompressing the Linux Kernel, for example. 147 */ 148 #define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) 149 150 static FORCE_INLINE void LZ4_copy8(void *dst, const void *src) 151 { 152 #if LZ4_ARCH64 153 U64 a = get_unaligned((const U64 *)src); 154 155 put_unaligned(a, (U64 *)dst); 156 #else 157 U32 a = get_unaligned((const U32 *)src); 158 U32 b = get_unaligned((const U32 *)src + 1); 159 160 put_unaligned(a, (U32 *)dst); 161 put_unaligned(b, (U32 *)dst + 1); 162 #endif 163 } 164 165 /* 166 * customized variant of memcpy, 167 * which can overwrite up to 7 bytes beyond dstEnd 168 */ 169 static FORCE_INLINE void LZ4_wildCopy(void *dstPtr, 170 const void *srcPtr, void *dstEnd) 171 { 172 BYTE *d = (BYTE *)dstPtr; 173 const BYTE *s = (const BYTE *)srcPtr; 174 BYTE *const e = (BYTE *)dstEnd; 175 176 do { 177 LZ4_copy8(d, s); 178 d += 8; 179 s += 8; 180 } while (d < e); 181 } 182 183 static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val) 184 { 185 #if LZ4_LITTLE_ENDIAN 186 return __ffs(val) >> 3; 187 #else 188 return (BITS_PER_LONG - 1 - __fls(val)) >> 3; 189 #endif 190 } 191 192 static FORCE_INLINE unsigned int LZ4_count( 193 const BYTE *pIn, 194 const BYTE *pMatch, 195 const BYTE *pInLimit) 196 { 197 const BYTE *const pStart = pIn; 198 199 while (likely(pIn < pInLimit - (STEPSIZE - 1))) { 200 size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn); 201 202 if (!diff) { 203 pIn += STEPSIZE; 204 pMatch += STEPSIZE; 205 continue; 206 } 207 208 pIn += LZ4_NbCommonBytes(diff); 209 210 return (unsigned int)(pIn - pStart); 211 } 212 213 #if LZ4_ARCH64 214 if ((pIn < (pInLimit - 3)) 215 && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { 216 pIn += 4; 217 pMatch += 4; 218 } 219 #endif 220 221 if ((pIn < (pInLimit - 1)) 222 && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { 223 pIn += 2; 224 pMatch += 2; 225 } 226 227 if ((pIn < pInLimit) && (*pMatch == *pIn)) 228 pIn++; 229 230 return (unsigned int)(pIn - pStart); 231 } 232 233 typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive; 234 typedef enum { byPtr, byU32, byU16 } tableType_t; 235 236 typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive; 237 typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; 238 239 typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive; 240 typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; 241 242 #define LZ4_STATIC_ASSERT(c) BUILD_BUG_ON(!(c)) 243 244 #endif 245