Skip to contentSkip to conversation

lib/lzo: clean-up by introducing COPY16

PATCH In review Dave Rodgman 4 participants 9 messages Nov 21, 2018 – Nov 22, 2018

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

PATCH 1/6 lib/lzo: clean-up by introducing COPY16

From: Matt Sealey <[email protected]>

Most compilers should be able to merge adjacent loads/stores of sizes which are less than but effect a multiple of a machine word size (in effect a memcpy() of a constant amount). However the semantics of the macro are that it just does the copy, the pointer increment is in the code, hence we see

    *a = *b
    a += 8
    b += 8
    *a = *b
    a += 8
    b += 8

This introduces a dependency between the two groups of statements which seems to defeat said compiler optimizers and generate some very strange sequences of addition and subtraction of address offsets (i.e. it is overcomplicated).

Since COPY8 is only ever used to copy amounts of 16 bytes (in pairs), just define COPY16 as COPY8,COPY8. We leave the definition to preserve the need to do unaligned accesses to machine-sized words per the original code intent, we just don't use it in the code proper.

COPY16 then gives us code like:

    *a = *b
    *(a+8) = *(b+8)
    a += 16
    b += 16

This seems to allow compilers to generate much better code by using base register writeback or simply positively incrementing offsets which seems to positively affect performance. It is, at least, fewer instructions to do the same job.

---
 lib/lzo/lzo1x_compress.c        |  9 +++------
 lib/lzo/lzo1x_decompress_safe.c | 18 ++++++------------
 lib/lzo/lzodefs.h               |  3 +++
 3 files changed, 12 insertions(+), 18 deletions(-)
lib/lzo/lzo1x_compress.c +3 -6
index 236eb21167b5..82fb5571ce5e 100644
@@ -60,8 +60,7 @@ lzo1x_1_do_compress(const unsigned char *in, size_t in_len,
 				op += t;
 			} else if (t <= 16) {
 				*op++ = (t - 3);
-				COPY8(op, ii);
-				COPY8(op + 8, ii + 8);
+				COPY16(op, ii);
 				op += t;
 			} else {
 				if (t <= 18) {
@@ -76,8 +75,7 @@ lzo1x_1_do_compress(const unsigned char *in, size_t in_len,
 					*op++ = tt;
 				}
 				do {
-					COPY8(op, ii);
-					COPY8(op + 8, ii + 8);
+					COPY16(op, ii);
 					op += 16;
 					ii += 16;
 					t -= 16;
@@ -255,8 +253,7 @@ int lzo1x_1_compress(const unsigned char *in, size_t in_len,
 			*op++ = tt;
 		}
 		if (t >= 16) do {
-			COPY8(op, ii);
-			COPY8(op + 8, ii + 8);
+			COPY16(op, ii);
 			op += 16;
 			ii += 16;
 			t -= 16;
lib/lzo/lzo1x_decompress_safe.c +6 -12
index a1c387f6afba..aa95d3066b7d 100644
@@ -86,12 +86,9 @@ int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
 					const unsigned char *ie = ip + t;
 					unsigned char *oe = op + t;
 					do {
-						COPY8(op, ip);
-						op += 8;
-						ip += 8;
-						COPY8(op, ip);
-						op += 8;
-						ip += 8;
+						COPY16(op, ip);
+						op += 16;
+						ip += 16;
 					} while (ip < ie);
 					ip = ie;
 					op = oe;
@@ -187,12 +184,9 @@ int lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
 			unsigned char *oe = op + t;
 			if (likely(HAVE_OP(t + 15))) {
 				do {
-					COPY8(op, m_pos);
-					op += 8;
-					m_pos += 8;
-					COPY8(op, m_pos);
-					op += 8;
-					m_pos += 8;
+					COPY16(op, m_pos);
+					op += 16;
+					m_pos += 16;
 				} while (op < oe);
 				op = oe;
 				if (HAVE_IP(6)) {
lib/lzo/lzodefs.h +3 -0
index 4edefd2f540c..9f167eaabb28 100644
@@ -23,6 +23,9 @@
 		COPY4(dst, src); COPY4((dst) + 4, (src) + 4)
 #endif
 
+#define COPY16(dst, src) \
+	do { COPY8(dst, src); COPY8((dst) + 8, (src) + 8); } while (0)
+
 #if defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN)
 #error "conflicting endian definitions"
 #elif defined(__x86_64__)
Signature · 1 line
2.16.4
#1 lore raw

PATCH 2/6 lib/lzo: enable 64-bit CTZ on Arm

From: Matt Sealey <[email protected]>

ARMv6 Thumb state introduced an RBIT instruction which, combined with CLZ as present in ARMv5, introduces an extremely fast path for counting trailing zeroes.

Enable the use of the GCC builtin for this on ARMv6+ with CONFIG_THUMB2_KERNEL to ensure we get the 'new' instruction usage.

We do not bother enabling LZO_USE_CTZ64 support for ARMv5 as the builtin code path does the same thing as the LZO_USE_CTZ32 code, only with more register pressure.

---
 lib/lzo/lzodefs.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
lib/lzo/lzodefs.h +6 -1
index 9f167eaabb28..a9927bbce21f 100644
@@ -33,9 +33,14 @@
 #define LZO_USE_CTZ32	1
 #elif defined(__i386__) || defined(__powerpc__)
 #define LZO_USE_CTZ32	1
-#elif defined(__arm__) && (__LINUX_ARM_ARCH__ >= 5)
+#elif defined(__arm__)
+#if (__LINUX_ARM_ARCH__ >= 5)
 #define LZO_USE_CTZ32	1
 #endif
+#if (__LINUX_ARM_ARCH__ >= 6) && (CONFIG_THUMB2_KERNEL)
+#define LZO_USE_CTZ64	1
+#endif
+#endif
 
 #define M1_MAX_OFFSET	0x0400
 #define M2_MAX_OFFSET	0x0800
Signature · 1 line
2.16.4
#2 lore raw

Re: [PATCH 2/6] lib/lzo: enable 64-bit CTZ on Arm

lib/lzo/lzodefs.h line 41

Quoted 10 lines

#define LZO_USE_CTZ32 1
#elif defined(__i386__) || defined(__powerpc__)
#define LZO_USE_CTZ32 1

lib/lzo/lzodefs.h +4 -1
-#elif defined(__arm__) && (__LINUX_ARM_ARCH__ >= 5)
+#elif defined(__arm__)
+#if (__LINUX_ARM_ARCH__ >= 5)
 #define LZO_USE_CTZ32	1
 #endif
+#if (__LINUX_ARM_ARCH__ >= 6) && (CONFIG_THUMB2_KERNEL)
+#define LZO_USE_CTZ64	1

All of this really needs to be driven by Kconfig symbols that the architecture selects instead of magic arch ifdefs here.

#3 lore raw

RE: [PATCH 2/6] lib/lzo: enable 64-bit CTZ on Arm

Hi Christoph,

Quoted 5 lines
Quoted 5 lines

#define LZO_USE_CTZ32 1
#elif defined(__i386__) || defined(__powerpc__)
#define LZO_USE_CTZ32 1

lib/lzo/lzodefs.h +1 -1
-#elif defined(__arm__) && (__LINUX_ARM_ARCH__ >= 5)
+#elif defined(__arm__)
Quoted 8 lines

lib/lzo/lzodefs.h line 41

Quoted 5 lines
lib/lzo/lzodefs.h +3 -0
+#if (__LINUX_ARM_ARCH__ >= 5)
 #define LZO_USE_CTZ32	1
 #endif
+#if (__LINUX_ARM_ARCH__ >= 6) && (CONFIG_THUMB2_KERNEL)
+#define LZO_USE_CTZ64	1

All of this really needs to be driven by Kconfig symbols that the architecture selects instead of magic arch ifdefs here.

TL;DR summary: Low hanging fruit.

TL explanation of the thought process:

Rather than using arch ifdefs, it seems we can do __builtin_ctzll() and __builtin_clzll() on all architectures with no measurable impact to codegen - libgcc implements them as __builtin_ctz/clz everywhere I've looked, so gcc at least is going to use that code for the builtins. On 32-bit Arm it introduces a tiny bit of extra register pressure in the instruction sequence but it's not measurable.

That is to say that the difference between architectures or architecture versions isn't the availability of a count-leading-zeros optimization or the builtin or an efficient algorithm, but the code preceding it to collect a 64-bit quantity to count.

That is a whole other cleanup.

Longer:

Just to further the point, though, if we rationalize the use of builtins to use the 64-bit versions, then we may as well use the kernel version -- __ffs64 is __builtin_clzll in asm-generic with the right magic arch Kconfig, and if not arches provide exactly the same code as LZO's fallback when LZO_USE_CxZnn isn't defined.

Even the distinction between little and big endian is moot, since

    __builtin_clzll(cpu_to_be32(n)) 

amounts to precisely the same disassembly on both arm and arm64 as __builtin_ctzll(n), so we can just go the whole hog, replace the 32-bit loads and xor with 64-bit ones, and do:

    __ffs64(cpu_to_be32(n))

which greatly reduces code complexity in the main LZO code by removing the distinction.

It turns out the compiler knows what it's doing, and where it doesn't, the arch maintainers do.

Therein lies the rub; the source gets smaller and we lose the arch/endian distinction but the efficiency of the preceding 64-bit load and exclusive-or needs investigation. We still have to figure out per architecture what the most efficient element size is or if there's a hideous xor((u64) n) implementation.

I simply don't have confidence in anything except that the magic arch ifdefs work to improve performance without changing too much, and the mess it introduces here belies the performance improvement it provides. Versus the true scope of the code cleanup to do it right, it's a very concise and reliable and within-style improvement.

Would we agree to let it in for now on the basis that we thought about it but I side with MFXJO's urgency?

Ta!
Matt Sealey <[email protected]>
Arm Partner Enablement Group

#4 lore raw

Re: [PATCH 2/6] lib/lzo: enable 64-bit CTZ on Arm

In reply to Christoph Hellwig
Quoted 5 lines · Christoph Hellwig
Quoted 5 lines

#define LZO_USE_CTZ32 1
#elif defined(__i386__) || defined(__powerpc__)
#define LZO_USE_CTZ32 1

lib/lzo/lzodefs.h +1 -1
-#elif defined(__arm__) && (__LINUX_ARM_ARCH__ >= 5)
+#elif defined(__arm__)
Quoted 8 lines

lib/lzo/lzodefs.h line 41

Quoted 5 lines
lib/lzo/lzodefs.h +3 -0
+#if (__LINUX_ARM_ARCH__ >= 5)
 #define LZO_USE_CTZ32	1
 #endif
+#if (__LINUX_ARM_ARCH__ >= 6) && (CONFIG_THUMB2_KERNEL)
+#define LZO_USE_CTZ64	1

All of this really needs to be driven by Kconfig symbols that the architecture selects instead of magic arch ifdefs here.

LZO_USE_CTZ32 and LZO_USE_CTZ64 should only be defined if there is a *fast* hardware instruction.

It would be nice if there exists a kernel #define we could use for detecting that.

Signature · 1 line
Markus Oberhumer, <[email protected]>, http://www.oberhumer.com/
#5 lore raw

PATCH 3/6 lib/lzo: 64-bit CTZ on Arm aarch64

In reply to Dave Rodgman

From: Matt Sealey <[email protected]>

LZO leaves some performance on the table by not realising that AArch64 can optimize count-trailing-zeros bit operations.

Add __aarch64__ to the checked definitions alongside __x86_64__ to enable the use of rbit/clz instructions on full 64-bit quantities.

---
 lib/lzo/lzodefs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
lib/lzo/lzodefs.h +1 -1
index a9927bbce21f..d167f8fc6795 100644
@@ -28,7 +28,7 @@
 
 #if defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN)
 #error "conflicting endian definitions"
-#elif defined(__x86_64__)
+#elif defined(__x86_64__) || defined(__aarch64__)
 #define LZO_USE_CTZ64	1
 #define LZO_USE_CTZ32	1
 #elif defined(__i386__) || defined(__powerpc__)
Signature · 1 line
2.16.4
#6 lore raw

PATCH 4/6 lib/lzo: fast 8-byte copy on arm64

In reply to Dave Rodgman

From: Matt Sealey <[email protected]>

Enable faster 8-byte copies on arm64.

---
 lib/lzo/lzodefs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
lib/lzo/lzodefs.h +1 -1
index d167f8fc6795..341d0f6095ab 100644
@@ -15,7 +15,7 @@
 
 #define COPY4(dst, src)	\
 		put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
-#if defined(__x86_64__)
+#if defined(__x86_64__) || defined(__aarch64__)
 #define COPY8(dst, src)	\
 		put_unaligned(get_unaligned((const u64 *)(src)), (u64 *)(dst))
 #else
Signature · 1 line
2.16.4
#7 lore raw

PATCH 5/6 lib/lzo: implement run-length encoding

In reply to Dave Rodgman

When using zram, we frequently encounter long runs of zero bytes. This adds a special case which identifies runs of zeros and encodes them using run-length encoding.

This is faster for both compression and decompresion. For high-entropy data which doesn't hit this case, impact is minimal.

Compression ratio is within a few percent in all cases.

This modifies the bitstream in a way which is backwards compatible (i.e., we can decompress old bitstreams, but old versions of lzo cannot decompress new bitstreams).

---
 Documentation/lzo.txt           | 35 ++++++++++++---
 include/linux/lzo.h             |  2 +-
 lib/lzo/lzo1x_compress.c        | 98 ++++++++++++++++++++++++++++++++++++-----
 lib/lzo/lzo1x_decompress_safe.c | 75 +++++++++++++++++++++----------
 lib/lzo/lzodefs.h               | 12 ++++-
 5 files changed, 180 insertions(+), 42 deletions(-)
Documentation/lzo.txt +28 -7
index 6fa6a93d0949..306c60344ca7 100644
@@ -78,16 +78,30 @@ Description
      is an implementation design choice independent on the algorithm or
      encoding.
 
+Versions
+
+0: Original version
+1: LZO-RLE
+
+Version 1 of LZO implements an extension to encode runs of zeros using run
+length encoding. This improves speed for data with many zeros, which is a
+common case for zram. This modifies the bitstream in a backwards compatible way
+(v1 can correctly decompress v0 compressed data, but v0 cannot read v1 data).
+
 Byte sequences
 ==============
 
   First byte encoding::
 
-      0..17   : follow regular instruction encoding, see below. It is worth
-                noting that codes 16 and 17 will represent a block copy from
-                the dictionary which is empty, and that they will always be
+      0..16   : follow regular instruction encoding, see below. It is worth
+                noting that code 16 will represent a block copy from the
+                dictionary which is empty, and that it will always be
                 invalid at this place.
 
+      17      : bitstream version. If the first byte is 17, the next byte
+                gives the bitstream version. If the first byte is not 17,
+                the bitstream version is 0.
+
       18..21  : copy 0..3 literals
                 state = (byte - 17) = 0..3  [ copy <state> literals ]
                 skip byte
@@ -140,6 +154,11 @@ Byte sequences
            state = S (copy S literals after this block)
            End of stream is reached if distance == 16384
 
+        In version 1, this instruction is also used to encode a run of zeros if
+        distance = 0xbfff, i.e. H = 1 and the D bits are all 1.
+           In this case, it is followed by a fourth byte, X.
+           run length = ((X << 3) | (0 0 0 0 0 L L L)) + 4.
+
       0 0 1 L L L L L  (32..63)
            Copy of small block within 16kB distance (preferably less than 34B)
            length = 2 + (L ?: 31 + (zero_bytes * 255) + non_zero_byte)
@@ -165,7 +184,9 @@ Authors
 =======
 
   This document was written by Willy Tarreau <[email protected]> on 2014/07/19 during an
-  analysis of the decompression code available in Linux 3.16-rc5. The code is
-  tricky, it is possible that this document contains mistakes or that a few
-  corner cases were overlooked. In any case, please report any doubt, fix, or
-  proposed updates to the author(s) so that the document can be updated.
+  analysis of the decompression code available in Linux 3.16-rc5, and updated
+  by Dave Rodgman <[email protected]> on 2018/10/30 to introduce run-length
+  encoding. The code is tricky, it is possible that this document contains
+  mistakes or that a few corner cases were overlooked. In any case, please
+  report any doubt, fix, or proposed updates to the author(s) so that the
+  document can be updated.
include/linux/lzo.h +1 -1
index 2ae27cb89927..547a86c71e1b 100644
@@ -18,7 +18,7 @@
 #define LZO1X_1_MEM_COMPRESS	(8192 * sizeof(unsigned short))
 #define LZO1X_MEM_COMPRESS	LZO1X_1_MEM_COMPRESS
 
-#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)
+#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3 + 2)
 
 /* This requires 'wrkmem' of size LZO1X_1_MEM_COMPRESS */
 int lzo1x_1_compress(const unsigned char *src, size_t src_len,
lib/lzo/lzo1x_compress.c +88 -10

158 lines not on this page · raw message

lib/lzo/lzo1x_decompress_safe.c +52 -23

95 lines not on this page · raw message

lib/lzo/lzodefs.h +11 -1
index 341d0f6095ab..436bb400ac87 100644
@@ -13,6 +13,12 @@
  */
 
 
+/* Version
+ * 0: original lzo version
+ * 1: lzo with support for RLE
+ */
+#define LZO_VERSION 1
+
 #define COPY4(dst, src)	\
 		put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))
 #if defined(__x86_64__) || defined(__aarch64__)
@@ -31,6 +37,7 @@
 #elif defined(__x86_64__) || defined(__aarch64__)
 #define LZO_USE_CTZ64	1
 #define LZO_USE_CTZ32	1
+#define LZO_FAST_64BIT_MEMORY_ACCESS
 #elif defined(__i386__) || defined(__powerpc__)
 #define LZO_USE_CTZ32	1
 #elif defined(__arm__)
@@ -45,7 +52,7 @@
 #define M1_MAX_OFFSET	0x0400
 #define M2_MAX_OFFSET	0x0800
 #define M3_MAX_OFFSET	0x4000
-#define M4_MAX_OFFSET	0xbfff
+#define M4_MAX_OFFSET	0xbffe
 
 #define M1_MIN_LEN	2
 #define M1_MAX_LEN	2
@@ -61,6 +68,9 @@
 #define M3_MARKER	32
 #define M4_MARKER	16
 
+#define MIN_ZERO_RUN_LENGTH	4
+#define MAX_ZERO_RUN_LENGTH	(2047 + MIN_ZERO_RUN_LENGTH)
+
 #define lzo_dict_t      unsigned short
 #define D_BITS		13
 #define D_SIZE		(1u << D_BITS)
Signature · 1 line
2.16.4
#8 lore raw

PATCH 6/6 lib/lzo: separate lzo-rle from lzo

In reply to Dave Rodgman

To prevent any issues with persistent data, separate lzo-rle from lzo so that it is treated as a separate algorithm, and lzo is still available.

Use lzo-rle as the default algorithm for
zram.

---
 Documentation/lzo.txt         |  12 ++-
 crypto/Makefile               |   2 +-
 crypto/lzo-rle.c              | 171 ++++++++++++++++++++++++++++++++++++++++++
 crypto/tcrypt.c               |   4 +-
 drivers/block/zram/zcomp.c    |   1 +
 drivers/block/zram/zram_drv.c |   2 +-
 include/linux/lzo.h           |   4 +
 lib/lzo/lzo1x_compress.c      |  42 ++++++++---
 lib/lzo/lzodefs.h             |   3 +-
 9 files changed, 223 insertions(+), 18 deletions(-)
 create mode 100644 crypto/lzo-rle.c
Documentation/lzo.txt +8 -4
index 306c60344ca7..f79934225d8d 100644
@@ -88,6 +88,10 @@ length encoding. This improves speed for data with many zeros, which is a
 common case for zram. This modifies the bitstream in a backwards compatible way
 (v1 can correctly decompress v0 compressed data, but v0 cannot read v1 data).
 
+For maximum compatibility, both versions are available under different names
+(lzo and lzo-rle). Differences in the encoding are noted in this document with
+e.g.: version 1 only.
+
 Byte sequences
 ==============
 
@@ -99,8 +103,8 @@ Byte sequences
                 invalid at this place.
 
       17      : bitstream version. If the first byte is 17, the next byte
-                gives the bitstream version. If the first byte is not 17,
-                the bitstream version is 0.
+                gives the bitstream version (version 1 only). If the first byte
+                is not 17, the bitstream version is 0.
 
       18..21  : copy 0..3 literals
                 state = (byte - 17) = 0..3  [ copy <state> literals ]
@@ -154,8 +158,8 @@ Byte sequences
            state = S (copy S literals after this block)
            End of stream is reached if distance == 16384
 
-        In version 1, this instruction is also used to encode a run of zeros if
-        distance = 0xbfff, i.e. H = 1 and the D bits are all 1.
+        In version 1 only, this instruction is also used to encode a run of
+        zeros if distance = 0xbfff, i.e. H = 1 and the D bits are all 1.
            In this case, it is followed by a fourth byte, X.
            run length = ((X << 3) | (0 0 0 0 0 L L L)) + 4.
 
crypto/Makefile +1 -1
index 6d1d40eeb964..4b482fa11fee 100644
@@ -125,7 +125,7 @@ obj-$(CONFIG_CRYPTO_CRC32C) += crc32c_generic.o
 obj-$(CONFIG_CRYPTO_CRC32) += crc32_generic.o
 obj-$(CONFIG_CRYPTO_CRCT10DIF) += crct10dif_common.o crct10dif_generic.o
 obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o
-obj-$(CONFIG_CRYPTO_LZO) += lzo.o
+obj-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o
 obj-$(CONFIG_CRYPTO_LZ4) += lz4.o
 obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o
 obj-$(CONFIG_CRYPTO_842) += 842.o
crypto/lzo-rle.c new file +171 -0

171 lines not on this page · raw message

crypto/tcrypt.c +2 -2
index bdde95e8d369..c154bc657e3a 100644
@@ -76,8 +76,8 @@ static char *check[] = {
 	"cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
 	"khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
 	"camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
-	"lzo", "cts", "zlib", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
-	NULL
+	"lzo", "lzo-rle", "cts", "zlib", "sha3-224", "sha3-256", "sha3-384",
+	"sha3-512", NULL
 };
 
 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
drivers/block/zram/zcomp.c +1 -0
index 4ed0a78fdc09..4d9a38890965 100644
@@ -20,6 +20,7 @@
 
 static const char * const backends[] = {
 	"lzo",
+	"lzo-rle",
 #if IS_ENABLED(CONFIG_CRYPTO_LZ4)
 	"lz4",
 #endif
drivers/block/zram/zram_drv.c +1 -1
index a1d6b5597c17..bc127f21d1e9 100644
@@ -41,7 +41,7 @@ static DEFINE_IDR(zram_index_idr);
 static DEFINE_MUTEX(zram_index_mutex);
 
 static int zram_major;
-static const char *default_compressor = "lzo";
+static const char *default_compressor = "lzo-rle";
 
 /* Module params (documentation at end) */
 static unsigned int num_devices = 1;
include/linux/lzo.h +4 -0
index 547a86c71e1b..e95c7d1092b2 100644
@@ -24,6 +24,10 @@
 int lzo1x_1_compress(const unsigned char *src, size_t src_len,
 		     unsigned char *dst, size_t *dst_len, void *wrkmem);
 
+/* This requires 'wrkmem' of size LZO1X_1_MEM_COMPRESS */
+int lzorle1x_1_compress(const unsigned char *src, size_t src_len,
+		     unsigned char *dst, size_t *dst_len, void *wrkmem);
+
 /* safe decompression with overrun testing */
 int lzo1x_decompress_safe(const unsigned char *src, size_t src_len,
 			  unsigned char *dst, size_t *dst_len);
lib/lzo/lzo1x_compress.c +33 -9

84 lines not on this page · raw message

lib/lzo/lzodefs.h +2 -1
index 436bb400ac87..60b5c63afcdb 100644
@@ -52,7 +52,8 @@
 #define M1_MAX_OFFSET	0x0400
 #define M2_MAX_OFFSET	0x0800
 #define M3_MAX_OFFSET	0x4000
-#define M4_MAX_OFFSET	0xbffe
+#define M4_MAX_OFFSET_V0	0xbfff
+#define M4_MAX_OFFSET_V1	0xbffe
 
 #define M1_MIN_LEN	2
 #define M1_MAX_LEN	2
Signature · 1 line
2.16.4