lib: Update LZ4 module to v1.9.3+

Update lz4 module using official repository from revision [1].

Keep in mind lz4hc wasn't updated thus it is not used. It may not
compile anymore.

[1]: https://github.com/lz4/lz4/tree/4ebe313e00aa52c837ee029ede39a0503a8a39c9

Signed-off-by: Cyber Knight <cyberknight755@gmail.com>

Author: xNombre

include/linux/lz4.h

@@ -42,7 +42,7 @@
 #define __LZ4_H__
 
 #include <linux/types.h>
-#include <linux/string.h>	 /* memset, memcpy */
+#include <linux/string.h> /* memset, memcpy */
 
 /*-************************************************************************
  *	CONSTANTS
@@ -57,23 +57,24 @@
  */
 #define LZ4_MEMORY_USAGE 14
 
-#define LZ4_MAX_INPUT_SIZE	0x7E000000 /* 2 113 929 216 bytes */
-#define LZ4_COMPRESSBOUND(isize)	(\
-	(unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE \
-	? 0 \
-	: (isize) + ((isize)/255) + 16)
+#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */
+#define LZ4_COMPRESSBOUND(isize)                                               \
+	((unsigned int)(isize) > (unsigned int)LZ4_MAX_INPUT_SIZE ?            \
+		 0 :                                                           \
+		 (isize) + ((isize) / 255) + 16)
 
 #define LZ4_ACCELERATION_DEFAULT 1
-#define LZ4_HASHLOG	 (LZ4_MEMORY_USAGE-2)
+#define LZ4_ACCELERATION_MAX 65537
+#define LZ4_HASHLOG (LZ4_MEMORY_USAGE - 2)
 #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
 #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)
 
-#define LZ4HC_MIN_CLEVEL			3
-#define LZ4HC_DEFAULT_CLEVEL			9
-#define LZ4HC_MAX_CLEVEL			16
+#define LZ4HC_MIN_CLEVEL 3
+#define LZ4HC_DEFAULT_CLEVEL 9
+#define LZ4HC_MAX_CLEVEL 16
 
 #define LZ4HC_DICTIONARY_LOGSIZE 16
-#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
+#define LZ4HC_MAXD (1 << LZ4HC_DICTIONARY_LOGSIZE)
 #define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
 #define LZ4HC_HASH_LOG (LZ4HC_DICTIONARY_LOGSIZE - 1)
 #define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
@@ -82,51 +83,54 @@
 /*-************************************************************************
  *	STREAMING CONSTANTS AND STRUCTURES
  **************************************************************************/
-#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE - 3)) + 4)
-#define LZ4_STREAMSIZE	(LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
+#define LZ4_STREAMSIZE                                                         \
+	((1UL << LZ4_MEMORY_USAGE) +                                           \
+	 32) /* static size, for inter-version compatibility */
+#define LZ4_STREAMSIZE_VOIDP (LZ4_STREAMSIZE / sizeof(void *))
 
-#define LZ4_STREAMHCSIZE        262192
-#define LZ4_STREAMHCSIZE_SIZET (262192 / sizeof(size_t))
+#define LZ4_STREAMDECODESIZE_U64                                               \
+	(4 + ((sizeof(void *) == 16) ? 2 : 0) /*AS-400*/)
+#define LZ4_STREAMDECODESIZE                                                   \
+	(LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
 
-#define LZ4_STREAMDECODESIZE_U64	4
-#define LZ4_STREAMDECODESIZE		 (LZ4_STREAMDECODESIZE_U64 * \
-	sizeof(unsigned long long))
+#define LZ4_STREAMHCSIZE_SIZET (262192 / sizeof(size_t))
 
 /*
  * LZ4_stream_t - information structure to track an LZ4 stream.
  */
-typedef struct {
+typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
+struct LZ4_stream_t_internal {
 	uint32_t hashTable[LZ4_HASH_SIZE_U32];
 	uint32_t currentOffset;
-	uint32_t initCheck;
+	uint32_t tableType;
 	const uint8_t *dictionary;
-	uint8_t *bufferStart;
+	const LZ4_stream_t_internal *dictCtx;
 	uint32_t dictSize;
-} LZ4_stream_t_internal;
+};
 typedef union {
-	unsigned long long table[LZ4_STREAMSIZE_U64];
+	void *table[LZ4_STREAMSIZE_VOIDP];
 	LZ4_stream_t_internal internal_donotuse;
 } LZ4_stream_t;
 
 /*
  * LZ4_streamHC_t - information structure to track an LZ4HC stream.
  */
 typedef struct {
-	unsigned int	 hashTable[LZ4HC_HASHTABLESIZE];
-	unsigned short	 chainTable[LZ4HC_MAXD];
+	unsigned int hashTable[LZ4HC_HASHTABLESIZE];
+	unsigned short chainTable[LZ4HC_MAXD];
 	/* next block to continue on current prefix */
 	const unsigned char *end;
 	/* All index relative to this position */
 	const unsigned char *base;
 	/* alternate base for extDict */
 	const unsigned char *dictBase;
 	/* below that point, need extDict */
-	unsigned int	 dictLimit;
+	unsigned int dictLimit;
 	/* below that point, no more dict */
-	unsigned int	 lowLimit;
+	unsigned int lowLimit;
 	/* index from which to continue dict update */
-	unsigned int	 nextToUpdate;
-	unsigned int	 compressionLevel;
+	unsigned int nextToUpdate;
+	unsigned int compressionLevel;
 } LZ4HC_CCtx_internal;
 typedef union {
 	size_t table[LZ4_STREAMHCSIZE_SIZET];
@@ -153,8 +157,8 @@ typedef union {
 /*-************************************************************************
  *	SIZE OF STATE
  **************************************************************************/
-#define LZ4_MEM_COMPRESS	LZ4_STREAMSIZE
-#define LZ4HC_MEM_COMPRESS	LZ4_STREAMHCSIZE
+#define LZ4_MEM_COMPRESS LZ4_STREAMSIZE
+#define LZ4HC_MEM_COMPRESS LZ4_STREAMHCSIZE
 
 /*-************************************************************************
  *	Compression Functions
@@ -195,7 +199,7 @@ static inline int LZ4_compressBound(size_t isize)
  *	(necessarily <= maxOutputSize) or 0 if compression fails
  */
 int LZ4_compress_default(const char *source, char *dest, int inputSize,
-	int maxOutputSize, void *wrkmem);
+			 int maxOutputSize, void *wrkmem);
 
 /**
  * LZ4_compress_fast() - As LZ4_compress_default providing an acceleration param
@@ -219,7 +223,7 @@ int LZ4_compress_default(const char *source, char *dest, int inputSize,
  *	(necessarily <= maxOutputSize) or 0 if compression fails
  */
 int LZ4_compress_fast(const char *source, char *dest, int inputSize,
-	int maxOutputSize, int acceleration, void *wrkmem);
+		      int maxOutputSize, int acceleration, void *wrkmem);
 
 /**
  * LZ4_compress_destSize() - Compress as much data as possible
@@ -243,33 +247,12 @@ int LZ4_compress_fast(const char *source, char *dest, int inputSize,
  *	or 0 if compression fails
  */
 int LZ4_compress_destSize(const char *source, char *dest, int *sourceSizePtr,
-	int targetDestSize, void *wrkmem);
+			  int targetDestSize, void *wrkmem);
 
 /*-************************************************************************
  *	Decompression Functions
  **************************************************************************/
 
-/**
- * LZ4_decompress_fast() - Decompresses data from 'source' into 'dest'
- * @source: source address of the compressed data
- * @dest: output buffer address of the uncompressed data
- *	which must be already allocated with 'originalSize' bytes
- * @originalSize: is the original and therefore uncompressed size
- *
- * Decompresses data from 'source' into 'dest'.
- * This function fully respect memory boundaries for properly formed
- * compressed data.
- * It is a bit faster than LZ4_decompress_safe().
- * However, it does not provide any protection against intentionally
- * modified data stream (malicious input).
- * Use this function in trusted environment only
- * (data to decode comes from a trusted source).
- *
- * Return: number of bytes read from the source buffer
- *	or a negative result if decompression fails.
- */
-int LZ4_decompress_fast(const char *source, char *dest, int originalSize);
-
 /**
  * LZ4_decompress_safe() - Decompression protected against buffer overflow
  * @source: source address of the compressed data
@@ -290,7 +273,7 @@ int LZ4_decompress_fast(const char *source, char *dest, int originalSize);
  *	or a negative result in case of error
  */
 int LZ4_decompress_safe(const char *source, char *dest, int compressedSize,
-	int maxDecompressedSize);
+			int maxDecompressedSize);
 
 /**
  * LZ4_decompress_safe_partial() - Decompress a block of size 'compressedSize'
@@ -318,7 +301,8 @@ int LZ4_decompress_safe(const char *source, char *dest, int compressedSize,
  *
  */
 int LZ4_decompress_safe_partial(const char *source, char *dest,
-	int compressedSize, int targetOutputSize, int maxDecompressedSize);
+				int compressedSize, int targetOutputSize,
+				int maxDecompressedSize);
 
 /*-************************************************************************
  *	LZ4 HC Compression
@@ -344,7 +328,7 @@ int LZ4_decompress_safe_partial(const char *source, char *dest,
  * Return : the number of bytes written into 'dst' or 0 if compression fails.
  */
 int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity,
-	int compressionLevel, void *wrkmem);
+		    int compressionLevel, void *wrkmem);
 
 /**
  * LZ4_resetStreamHC() - Init an allocated 'LZ4_streamHC_t' structure
@@ -373,8 +357,8 @@ void LZ4_resetStreamHC(LZ4_streamHC_t *streamHCPtr, int compressionLevel);
  *
  * Return : dictionary size, in bytes (necessarily <= 64 KB)
  */
-int	LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
-	int dictSize);
+int LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
+		   int dictSize);
 
 /**
  * LZ4_compress_HC_continue() - Compress 'src' using data from previously
@@ -413,7 +397,7 @@ int	LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
  * Return: Number of bytes written into buffer 'dst'  or 0 if compression fails
  */
 int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src,
-	char *dst, int srcSize, int maxDstSize);
+			     char *dst, int srcSize, int maxDstSize);
 
 /**
  * LZ4_saveDictHC() - Save static dictionary from LZ4HC_stream
@@ -432,7 +416,7 @@ int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src,
  *	or 0 if error.
  */
 int LZ4_saveDictHC(LZ4_streamHC_t *streamHCPtr, char *safeBuffer,
-	int maxDictSize);
+		   int maxDictSize);
 
 /*-*********************************************
  *	Streaming Compression Functions
@@ -462,8 +446,7 @@ void LZ4_resetStream(LZ4_stream_t *LZ4_stream);
  *
  * Return : dictionary size, in bytes (necessarily <= 64 KB)
  */
-int LZ4_loadDict(LZ4_stream_t *streamPtr, const char *dictionary,
-	int dictSize);
+int LZ4_loadDict(LZ4_stream_t *streamPtr, const char *dictionary, int dictSize);
 
 /**
  * LZ4_saveDict() - Save static dictionary from LZ4_stream
@@ -505,7 +488,8 @@ int LZ4_saveDict(LZ4_stream_t *streamPtr, char *safeBuffer, int dictSize);
  * Return: Number of bytes written into buffer 'dst'  or 0 if compression fails
  */
 int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src,
-	char *dst, int srcSize, int maxDstSize, int acceleration);
+			       char *dst, int srcSize, int maxDstSize,
+			       int acceleration);
 
 /**
  * LZ4_setStreamDecode() - Instruct where to find dictionary
@@ -519,7 +503,7 @@ int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src,
  * Return: 1 if OK, 0 if error
  */
 int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
-	const char *dictionary, int dictSize);
+			const char *dictionary, int dictSize);
 
 /**
  * LZ4_decompress_fast_continue() - Decompress blocks in streaming mode
@@ -558,8 +542,32 @@ int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
  *	or a negative result in case of error
  */
 int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
-	const char *source, char *dest, int compressedSize,
-	int maxDecompressedSize);
+				 const char *source, char *dest,
+				 int compressedSize, int maxDecompressedSize);
+
+/* \/ Following methods are disabled because they are deprecated \/ */
+
+/**
+ * LZ4_decompress_fast() - Decompresses data from 'source' into 'dest'
+ * @source: source address of the compressed data
+ * @dest: output buffer address of the uncompressed data
+ *	which must be already allocated with 'originalSize' bytes
+ * @originalSize: is the original and therefore uncompressed size
+ *
+ * Decompresses data from 'source' into 'dest'.
+ * This function fully respect memory boundaries for properly formed
+ * compressed data.
+ * It is a bit faster than LZ4_decompress_safe().
+ * However, it does not provide any protection against intentionally
+ * modified data stream (malicious input).
+ * Use this function in trusted environment only
+ * (data to decode comes from a trusted source).
+ *
+ * Return: number of bytes read from the source buffer
+ *	or a negative result if decompression fails.
+ */
+
+//int LZ4_decompress_fast(const char *source, char *dest, int originalSize);
 
 /**
  * LZ4_decompress_fast_continue() - Decompress blocks in streaming mode
@@ -596,8 +604,9 @@ int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
  *	(necessarily <= maxDecompressedSize)
  *	or a negative result in case of error
  */
-int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
-	const char *source, char *dest, int originalSize);
+
+//int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
+//	const char *source, char *dest, int originalSize);
 
 /**
  * LZ4_decompress_safe_usingDict() - Same as LZ4_setStreamDecode()
@@ -619,9 +628,9 @@ int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
  *	(necessarily <= maxDecompressedSize)
  *	or a negative result in case of error
  */
-int LZ4_decompress_safe_usingDict(const char *source, char *dest,
-	int compressedSize, int maxDecompressedSize, const char *dictStart,
-	int dictSize);
+//int LZ4_decompress_safe_usingDict(const char *source, char *dest,
+//	int compressedSize, int maxDecompressedSize, const char *dictStart,
+//	int dictSize);
 
 /**
  * LZ4_decompress_fast_usingDict() - Same as LZ4_setStreamDecode()
@@ -642,7 +651,7 @@ int LZ4_decompress_safe_usingDict(const char *source, char *dest,
  *	(necessarily <= maxDecompressedSize)
  *	or a negative result in case of error
  */
-int LZ4_decompress_fast_usingDict(const char *source, char *dest,
-	int originalSize, const char *dictStart, int dictSize);
+//int LZ4_decompress_fast_usingDict(const char *source, char *dest,
+//	int originalSize, const char *dictStart, int dictSize);
 
 #endif