Skip to content

Commit

Permalink
lib/lz4: remove back-compat wrappers
Browse files Browse the repository at this point in the history 
Remove the functions introduced as wrappers for providing backwards
compatibility to the prior LZ4 version.  They're not needed anymore
since there's no callers left.

Link: http://lkml.kernel.org/r/1486321748-19085-6-git-send-email-4sschmid@informatik.uni-hamburg.de
Signed-off-by: Sven Schmidt <[email protected]>
Cc: Bongkyu Kim <[email protected]>
Cc: Rui Salvaterra <[email protected]>
Cc: Sergey Senozhatsky <[email protected]>
Cc: Greg Kroah-Hartman <[email protected]>
Cc: Herbert Xu <[email protected]>
Cc: David S. Miller <[email protected]>
Cc: Anton Vorontsov <[email protected]>
Cc: Colin Cross <[email protected]>
Cc: Kees Cook <[email protected]>
Cc: Tony Luck <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>
  • Loading branch information
@SvSchmidt @torvalds
SvSchmidt authored and torvalds committed Feb 25, 2017
1 parent d21b5ff commit 69c7842
Show file tree
Hide file tree
Showing 4 changed files with 0 additions and 156 deletions.
69 changes: 0 additions & 69 deletions include/linux/lz4.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -172,18 +172,6 @@ static inline int LZ4_compressBound(size_t isize)
return LZ4_COMPRESSBOUND(isize);
}

/**
* lz4_compressbound() - For backwards compatibility; see LZ4_compressBound
* @isize: Size of the input data
*
* Return: Max. size LZ4 may output in a "worst case" szenario
* (data not compressible)
*/
static inline int lz4_compressbound(size_t isize)
{
return LZ4_COMPRESSBOUND(isize);
}

/**
* LZ4_compress_default() - Compress data from source to dest
* @source: source address of the original data
Expand Down Expand Up @@ -257,20 +245,6 @@ int LZ4_compress_fast(const char *source, char *dest, int inputSize,
int LZ4_compress_destSize(const char *source, char *dest, int *sourceSizePtr,
int targetDestSize, void *wrkmem);

/*
* lz4_compress() - For backward compatibility, see LZ4_compress_default
* @src: source address of the original data
* @src_len: size of the original data
* @dst: output buffer address of the compressed data. This requires 'dst'
* of size LZ4_COMPRESSBOUND
* @dst_len: is the output size, which is returned after compress done
* @workmem: address of the working memory.
*
* Return: Success if return 0, Error if return < 0
*/
int lz4_compress(const unsigned char *src, size_t src_len, unsigned char *dst,
size_t *dst_len, void *wrkmem);

/*-************************************************************************
* Decompression Functions
**************************************************************************/
Expand Down Expand Up @@ -346,34 +320,6 @@ 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);

/*
* lz4_decompress_unknownoutputsize() - For backwards compatibility,
* see LZ4_decompress_safe
* @src: source address of the compressed data
* @src_len: is the input size, therefore the compressed size
* @dest: output buffer address of the decompressed data
* which must be already allocated
* @dest_len: is the max size of the destination buffer, which is
* returned with actual size of decompressed data after decompress done
*
* Return: Success if return 0, Error if return (< 0)
*/
int lz4_decompress_unknownoutputsize(const unsigned char *src, size_t src_len,
unsigned char *dest, size_t *dest_len);

/**
* lz4_decompress() - For backwards cocmpatibility, see LZ4_decompress_fast
* @src: source address of the compressed data
* @src_len: is the input size, which is returned after decompress done
* @dest: output buffer address of the decompressed data,
* which must be already allocated
* @actual_dest_len: is the size of uncompressed data, supposing it's known
*
* Return: Success if return 0, Error if return (< 0)
*/
int lz4_decompress(const unsigned char *src, size_t *src_len,
unsigned char *dest, size_t actual_dest_len);

/*-************************************************************************
* LZ4 HC Compression
**************************************************************************/
Expand All @@ -400,21 +346,6 @@ int lz4_decompress(const unsigned char *src, size_t *src_len,
int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity,
int compressionLevel, void *wrkmem);

/**
* lz4hc_compress() - For backwards compatibility, see LZ4_compress_HC
* @src: source address of the original data
* @src_len: size of the original data
* @dst: output buffer address of the compressed data. This requires 'dst'
* of size LZ4_COMPRESSBOUND.
* @dst_len: is the output size, which is returned after compress done
* @wrkmem: address of the working memory.
* This requires 'workmem' of size LZ4HC_MEM_COMPRESS.
*
* Return : Success if return 0, Error if return (< 0)
*/
int lz4hc_compress(const unsigned char *src, size_t src_len, unsigned char *dst,
size_t *dst_len, void *wrkmem);

/**
* LZ4_resetStreamHC() - Init an allocated 'LZ4_streamHC_t' structure
* @streamHCPtr: pointer to the 'LZ4_streamHC_t' structure
Expand Down
22 changes: 0 additions & 22 deletions lib/lz4/lz4_compress.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -936,27 +936,5 @@ int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream, const char *source,
}
EXPORT_SYMBOL(LZ4_compress_fast_continue);

/*-******************************
* For backwards compatibility
********************************/
int lz4_compress(const unsigned char *src, size_t src_len, unsigned char *dst,
size_t *dst_len, void *wrkmem) {
*dst_len = LZ4_compress_default(src, dst, src_len,
*dst_len, wrkmem);

/*
* Prior lz4_compress will return -1 in case of error
* and 0 on success
* while new LZ4_compress_fast/default
* returns 0 in case of error
* and the output length on success
*/
if (!*dst_len)
return -1;
else
return 0;
}
EXPORT_SYMBOL(lz4_compress);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 compressor");
42 changes: 0 additions & 42 deletions lib/lz4/lz4_decompress.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -493,46 +493,6 @@ int LZ4_decompress_fast_usingDict(const char *source, char *dest,
originalSize, 0, dictStart, dictSize);
}

/*-******************************
* For backwards compatibility
********************************/
int lz4_decompress_unknownoutputsize(const unsigned char *src,
size_t src_len, unsigned char *dest, size_t *dest_len) {
*dest_len = LZ4_decompress_safe(src, dest,
src_len, *dest_len);

/*
* Prior lz4_decompress_unknownoutputsize will return
* 0 for success and a negative result for error
* new LZ4_decompress_safe returns
* - the length of data read on success
* - and also a negative result on error
* meaning when result > 0, we just return 0 here
*/
if (src_len > 0)
return 0;
else
return -1;
}

int lz4_decompress(const unsigned char *src, size_t *src_len,
unsigned char *dest, size_t actual_dest_len) {
*src_len = LZ4_decompress_fast(src, dest, actual_dest_len);

/*
* Prior lz4_decompress will return
* 0 for success and a negative result for error
* new LZ4_decompress_fast returns
* - the length of data read on success
* - and also a negative result on error
* meaning when result > 0, we just return 0 here
*/
if (*src_len > 0)
return 0;
else
return -1;
}

#ifndef STATIC
EXPORT_SYMBOL(LZ4_decompress_safe);
EXPORT_SYMBOL(LZ4_decompress_safe_partial);
Expand All @@ -542,8 +502,6 @@ EXPORT_SYMBOL(LZ4_decompress_safe_continue);
EXPORT_SYMBOL(LZ4_decompress_fast_continue);
EXPORT_SYMBOL(LZ4_decompress_safe_usingDict);
EXPORT_SYMBOL(LZ4_decompress_fast_usingDict);
EXPORT_SYMBOL(lz4_decompress_unknownoutputsize);
EXPORT_SYMBOL(lz4_decompress);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 decompressor");
Expand Down
23 changes: 0 additions & 23 deletions lib/lz4/lz4hc_compress.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -765,28 +765,5 @@ int LZ4_saveDictHC(
}
EXPORT_SYMBOL(LZ4_saveDictHC);

/*-******************************
* For backwards compatibility
********************************/
int lz4hc_compress(const unsigned char *src, size_t src_len,
unsigned char *dst, size_t *dst_len, void *wrkmem)
{
*dst_len = LZ4_compress_HC(src, dst, src_len,
*dst_len, LZ4HC_DEFAULT_CLEVEL, wrkmem);

/*
* Prior lz4hc_compress will return -1 in case of error
* and 0 on success
* while new LZ4_compress_HC
* returns 0 in case of error
* and the output length on success
*/
if (!*dst_len)
return -1;
else
return 0;
}
EXPORT_SYMBOL(lz4hc_compress);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 HC compressor");

0 comments on commit 69c7842

Please sign in to comment.