dm-crypt: use __bio_add_page to add single page to clone bio

[linux-block.git] / lib / decompress_unzstd.c

diff --git a/lib/decompress_unzstd.c b/lib/decompress_unzstd.c
index 6b629ab31c1eb727ab8d24acf720d5abf8f3a3a1..a512b99ae16a938b43a8a9e2af8cfa28ca0903bc 100644 (file)
--- a/lib/decompress_unzstd.c
+++ b/lib/decompress_unzstd.c
@@ -68,11 +68,7 @@
 #ifdef STATIC
 # define UNZSTD_PREBOOT
 # include "xxhash.c"
-# include "zstd/entropy_common.c"
-# include "zstd/fse_decompress.c"
-# include "zstd/huf_decompress.c"
-# include "zstd/zstd_common.c"
-# include "zstd/decompress.c"
+# include "zstd/decompress_sources.h"
 #endif
 
 #include <linux/decompress/mm.h>
@@ -91,11 +87,15 @@
 
 static int INIT handle_zstd_error(size_t ret, void (*error)(char *x))
 {
-       const int err = ZSTD_getErrorCode(ret);
+       const zstd_error_code err = zstd_get_error_code(ret);
 
-       if (!ZSTD_isError(ret))
+       if (!zstd_is_error(ret))
                return 0;
 
+       /*
+        * zstd_get_error_name() cannot be used because error takes a char *
+        * not a const char *
+        */
        switch (err) {
        case ZSTD_error_memory_allocation:
                error("ZSTD decompressor ran out of memory");
@@ -124,28 +124,28 @@ static int INIT decompress_single(const u8 *in_buf, long in_len, u8 *out_buf,
                                  long out_len, long *in_pos,
                                  void (*error)(char *x))
 {
-       const size_t wksp_size = ZSTD_DCtxWorkspaceBound();
+       const size_t wksp_size = zstd_dctx_workspace_bound();
        void *wksp = large_malloc(wksp_size);
-       ZSTD_DCtx *dctx = ZSTD_initDCtx(wksp, wksp_size);
+       zstd_dctx *dctx = zstd_init_dctx(wksp, wksp_size);
        int err;
        size_t ret;
 
        if (dctx == NULL) {
-               error("Out of memory while allocating ZSTD_DCtx");
+               error("Out of memory while allocating zstd_dctx");
                err = -1;
                goto out;
        }
        /*
         * Find out how large the frame actually is, there may be junk at
-        * the end of the frame that ZSTD_decompressDCtx() can't handle.
+        * the end of the frame that zstd_decompress_dctx() can't handle.
         */
-       ret = ZSTD_findFrameCompressedSize(in_buf, in_len);
+       ret = zstd_find_frame_compressed_size(in_buf, in_len);
        err = handle_zstd_error(ret, error);
        if (err)
                goto out;
        in_len = (long)ret;
 
-       ret = ZSTD_decompressDCtx(dctx, out_buf, out_len, in_buf, in_len);
+       ret = zstd_decompress_dctx(dctx, out_buf, out_len, in_buf, in_len);
        err = handle_zstd_error(ret, error);
        if (err)
                goto out;
@@ -167,14 +167,14 @@ static int INIT __unzstd(unsigned char *in_buf, long in_len,
                         long *in_pos,
                         void (*error)(char *x))
 {
-       ZSTD_inBuffer in;
-       ZSTD_outBuffer out;
-       ZSTD_frameParams params;
+       zstd_in_buffer in;
+       zstd_out_buffer out;
+       zstd_frame_header header;
        void *in_allocated = NULL;
        void *out_allocated = NULL;
        void *wksp = NULL;
        size_t wksp_size;
-       ZSTD_DStream *dstream;
+       zstd_dstream *dstream;
        int err;
        size_t ret;
 
@@ -238,13 +238,13 @@ static int INIT __unzstd(unsigned char *in_buf, long in_len,
        out.size = out_len;
 
        /*
-        * We need to know the window size to allocate the ZSTD_DStream.
+        * We need to know the window size to allocate the zstd_dstream.
         * Since we are streaming, we need to allocate a buffer for the sliding
         * window. The window size varies from 1 KB to ZSTD_WINDOWSIZE_MAX
         * (8 MB), so it is important to use the actual value so as not to
         * waste memory when it is smaller.
         */
-       ret = ZSTD_getFrameParams(&params, in.src, in.size);
+       ret = zstd_get_frame_header(&header, in.src, in.size);
        err = handle_zstd_error(ret, error);
        if (err)
                goto out;
@@ -253,19 +253,19 @@ static int INIT __unzstd(unsigned char *in_buf, long in_len,
                err = -1;
                goto out;
        }
-       if (params.windowSize > ZSTD_WINDOWSIZE_MAX) {
+       if (header.windowSize > ZSTD_WINDOWSIZE_MAX) {
                error("ZSTD-compressed data has too large a window size");
                err = -1;
                goto out;
        }
 
        /*
-        * Allocate the ZSTD_DStream now that we know how much memory is
+        * Allocate the zstd_dstream now that we know how much memory is
         * required.
         */
-       wksp_size = ZSTD_DStreamWorkspaceBound(params.windowSize);
+       wksp_size = zstd_dstream_workspace_bound(header.windowSize);
        wksp = large_malloc(wksp_size);
-       dstream = ZSTD_initDStream(params.windowSize, wksp, wksp_size);
+       dstream = zstd_init_dstream(header.windowSize, wksp, wksp_size);
        if (dstream == NULL) {
                error("Out of memory while allocating ZSTD_DStream");
                err = -1;
@@ -298,7 +298,7 @@ static int INIT __unzstd(unsigned char *in_buf, long in_len,
                        in.size = in_len;
                }
                /* Returns zero when the frame is complete. */
-               ret = ZSTD_decompressStream(dstream, &out, &in);
+               ret = zstd_decompress_stream(dstream, &out, &in);
                err = handle_zstd_error(ret, error);
                if (err)
                        goto out;