Merge pull request #2406 from terrelln/linux-wrapper-api

[linux] Add the linux wrapper API

contrib/linux-kernel/Makefile

@@ -22,8 +22,6 @@ libzstd:
 		--xxh64-prefix 'xxh64' \
 		--rewrite-include '<limits\.h>=<linux/limits.h>' \
 		--rewrite-include '<stddef\.h>=<linux/types.h>' \
-		--rewrite-include '"\.\./zstd.h"=<linux/zstd.h>' \
-		--rewrite-include '"(\.\./common/)?zstd_errors.h"=<linux/zstd_errors.h>' \
 		-DZSTD_NO_INTRINSICS \
 		-DZSTD_NO_UNUSED_FUNCTIONS \
 		-DZSTD_LEGACY_SUPPORT=0 \
@@ -48,8 +46,7 @@ libzstd:
 		-U_WIN32 \
 		-RZSTDLIB_VISIBILITY= \
 		-RZSTDERRORLIB_VISIBILITY=
-	mv linux/lib/zstd/zstd.h linux/include/linux
-	mv linux/lib/zstd/common/zstd_errors.h linux/include/linux
+	cp linux_zstd.h linux/include/linux/zstd.h
 	cp zstd_compress_module.c linux/lib/zstd
 	cp zstd_decompress_module.c linux/lib/zstd
 	cp decompress_sources.h linux/lib/zstd
@@ -62,9 +59,20 @@ import: libzstd
 	rm -f $(LINUX)/include/linux/zstd.h
 	rm -f $(LINUX)/include/linux/zstd_errors.h
 	rm -rf $(LINUX)/lib/zstd
-	mv linux/include/linux/zstd.h $(LINUX)/include/linux
-	mv linux/include/linux/zstd_errors.h $(LINUX)/include/linux
-	mv linux/lib/zstd $(LINUX)/lib
+	cp linux/include/linux/zstd.h $(LINUX)/include/linux
+	cp -r linux/lib/zstd $(LINUX)/lib
+
+import-upstream:
+	rm -rf $(LINUX)/lib/zstd
+	mkdir $(LINUX)/lib/zstd
+	cp ../../lib/zstd.h $(LINUX)/lib/zstd
+	cp -r ../../lib/common $(LINUX)/lib/zstd
+	cp -r ../../lib/compress $(LINUX)/lib/zstd
+	cp -r ../../lib/decompress $(LINUX)/lib/zstd
+	rm $(LINUX)/lib/zstd/common/threading.*
+	rm $(LINUX)/lib/zstd/common/pool.*
+	rm $(LINUX)/lib/zstd/common/xxhash.*
+	rm $(LINUX)/lib/zstd/compress/zstdmt_*
 
 .PHONY: test
 test: libzstd

contrib/linux-kernel/decompress_sources.h

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0-only
+/* SPDX-License-Identifier: GPL-2.0-only */
 
 /*
  * This file includes every .c file needed for decompression.
@@ -16,3 +16,4 @@
 #include "decompress/zstd_ddict.c"
 #include "decompress/zstd_decompress.c"
 #include "decompress/zstd_decompress_block.c"
+#include "zstd_decompress_module.c"

contrib/linux-kernel/linux_zstd.h

@@ -0,0 +1,459 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of https://github.com/facebook/zstd.
+ * An additional grant of patent rights can be found in the PATENTS file in the
+ * same directory.
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation. This program is dual-licensed; you may select
+ * either version 2 of the GNU General Public License ("GPL") or BSD license
+ * ("BSD").
+ */
+
+#ifndef LINUX_ZSTD_H
+#define LINUX_ZSTD_H
+
+/**
+ * This is a kernel-style API that wraps the upstream zstd API, which cannot be
+ * used directly because the symbols aren't exported. It exposes the minimal
+ * functionality which is currently required by users of zstd in the kernel.
+ * Expose extra functions from lib/zstd/zstd.h as needed.
+ */
+
+/* ======   Dependency   ====== */
+#include <linux/types.h>
+
+/* ======   Helper Functions   ====== */
+/**
+ * zstd_compress_bound() - maximum compressed size in worst case scenario
+ * @src_size: The size of the data to compress.
+ *
+ * Return:    The maximum compressed size in the worst case scenario.
+ */
+size_t zstd_compress_bound(size_t src_size);
+
+/**
+ * zstd_is_error() - tells if a size_t function result is an error code
+ * @code:  The function result to check for error.
+ *
+ * Return: Non-zero iff the code is an error.
+ */
+unsigned int zstd_is_error(size_t code);
+
+/**
+ * zstd_get_error_code() - translates an error function result to an error code
+ * @code:  The function result for which zstd_is_error(code) is true.
+ *
+ * Return: A unique error code for this error.
+ */
+int zstd_get_error_code(size_t code);
+
+/**
+ * zstd_get_error_name() - translates an error function result to a string
+ * @code:  The function result for which zstd_is_error(code) is true.
+ *
+ * Return: An error string corresponding to the error code.
+ */
+const char *zstd_get_error_name(size_t code);
+
+/* ======   Parameter Selection   ====== */
+
+/**
+ * enum zstd_strategy - zstd compression search strategy
+ *
+ * From faster to stronger.
+ */
+enum zstd_strategy {
+	zstd_fast = 1,
+	zstd_dfast = 2,
+	zstd_greedy = 3,
+	zstd_lazy = 4,
+	zstd_lazy2 = 5,
+	zstd_btlazy2 = 6,
+	zstd_btopt = 7,
+	zstd_btultra = 8,
+	zstd_btultra2 = 9
+};
+
+/**
+ * struct zstd_compression_parameters - zstd compression parameters
+ * @window_log:    Log of the largest match distance. Larger means more
+ *                 compression, and more memory needed during decompression.
+ * @chain_log:     Fully searched segment. Larger means more compression,
+ *                 slower, and more memory (useless for fast).
+ * @hash_log:      Dispatch table. Larger means more compression,
+ *                 slower, and more memory.
+ * @search_log:    Number of searches. Larger means more compression and slower.
+ * @search_length: Match length searched. Larger means faster decompression,
+ *                 sometimes less compression.
+ * @target_length: Acceptable match size for optimal parser (only). Larger means
+ *                 more compression, and slower.
+ * @strategy:      The zstd compression strategy.
+ */
+struct zstd_compression_parameters {
+	unsigned int window_log;
+	unsigned int chain_log;
+	unsigned int hash_log;
+	unsigned int search_log;
+	unsigned int search_length;
+	unsigned int target_length;
+	enum zstd_strategy strategy;
+};
+
+/**
+ * struct zstd_frame_parameters - zstd frame parameters
+ * @content_size_flag: Controls whether content size will be present in the
+ *                     frame header (when known).
+ * @checksum_flag:     Controls whether a 32-bit checksum is generated at the
+ *                     end of the frame for error detection.
+ * @no_dict_id_flag:   Controls whether dictID will be saved into the frame
+ *                     header when using dictionary compression.
+ *
+ * The default value is all fields set to 0.
+ */
+struct zstd_frame_parameters {
+	unsigned int content_size_flag;
+	unsigned int checksum_flag;
+	unsigned int no_dict_id_flag;
+};
+
+/**
+ * struct zstd_parameters - zstd parameters
+ * @cparams: The compression parameters.
+ * @fparams: The frame parameters.
+ */
+struct zstd_parameters {
+	struct zstd_compression_parameters cparams;
+	struct zstd_frame_parameters fparams;
+};
+
+/**
+ * zstd_get_params() - returns zstd_parameters for selected level
+ * @level:              The compression level
+ * @estimated_src_size: The estimated source size to compress or 0
+ *                      if unknown.
+ *
+ * Return:              The selected zstd_parameters.
+ */
+struct zstd_parameters zstd_get_params(int level,
+	unsigned long long estimated_src_size);
+
+/* ======   Single-pass Compression   ====== */
+
+typedef struct ZSTD_CCtx_s zstd_cctx;
+
+/**
+ * zstd_cctx_workspace_bound() - max memory needed to initialize a zstd_cctx
+ * @parameters: The compression parameters to be used.
+ *
+ * If multiple compression parameters might be used, the caller must call
+ * zstd_cctx_workspace_bound() for each set of parameters and use the maximum
+ * size.
+ *
+ * Return:      A lower bound on the size of the workspace that is passed to
+ *              zstd_init_cctx().
+ */
+size_t zstd_cctx_workspace_bound(
+	const struct zstd_compression_parameters *parameters);
+
+/**
+ * zstd_init_cctx() - initialize a zstd compression context
+ * @workspace:      The workspace to emplace the context into. It must outlive
+ *                  the returned context.
+ * @workspace_size: The size of workspace. Use zstd_cctx_workspace_bound() to
+ *                  determine how large the workspace must be.
+ *
+ * Return:          A zstd compression context or NULL on error.
+ */
+zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size);
+
+/**
+ * zstd_compress_cctx() - compress src into dst with the initialized parameters
+ * @cctx:         The context. Must have been initialized with zstd_init_cctx().
+ * @dst:          The buffer to compress src into.
+ * @dst_capacity: The size of the destination buffer. May be any size, but
+ *                ZSTD_compressBound(srcSize) is guaranteed to be large enough.
+ * @src:          The data to compress.
+ * @src_size:     The size of the data to compress.
+ * @parameters:   The compression parameters to be used.
+ *
+ * Return:        The compressed size or an error, which can be checked using
+ *                zstd_is_error().
+ */
+size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
+	const void *src, size_t src_size, const struct zstd_parameters *parameters);
+
+/* ======   Single-pass Decompression   ====== */
+
+typedef struct ZSTD_DCtx_s zstd_dctx;
+
+/**
+ * zstd_dctx_workspace_bound() - max memory needed to initialize a zstd_dctx
+ *
+ * Return: A lower bound on the size of the workspace that is passed to
+ *         zstd_init_dctx().
+ */
+size_t zstd_dctx_workspace_bound(void);
+
+/**
+ * zstd_init_dctx() - initialize a zstd decompression context
+ * @workspace:      The workspace to emplace the context into. It must outlive
+ *                  the returned context.
+ * @workspace_size: The size of workspace. Use zstd_dctx_workspace_bound() to
+ *                  determine how large the workspace must be.
+ *
+ * Return:          A zstd decompression context or NULL on error.
+ */
+zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size);
+
+/**
+ * zstd_decompress_dctx() - decompress zstd compressed src into dst
+ * @dctx:         The decompression context.
+ * @dst:          The buffer to decompress src into.
+ * @dst_capacity: The size of the destination buffer. Must be at least as large
+ *                as the decompressed size. If the caller cannot upper bound the
+ *                decompressed size, then it's better to use the streaming API.
+ * @src:          The zstd compressed data to decompress. Multiple concatenated
+ *                frames and skippable frames are allowed.
+ * @src_size:     The exact size of the data to decompress.
+ *
+ * Return:        The decompressed size or an error, which can be checked using
+ *                zstd_is_error().
+ */
+size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,
+	const void *src, size_t src_size);
+
+/* ======   Streaming Buffers   ====== */
+
+/**
+ * struct zstd_in_buffer - input buffer for streaming
+ * @src:  Start of the input buffer.
+ * @size: Size of the input buffer.
+ * @pos:  Position where reading stopped. Will be updated.
+ *        Necessarily 0 <= pos <= size.
+ */
+struct zstd_in_buffer {
+	const void *src;
+	size_t size;
+	size_t pos;
+};
+
+/**
+ * struct zstd_out_buffer - output buffer for streaming
+ * @dst:  Start of the output buffer.
+ * @size: Size of the output buffer.
+ * @pos:  Position where writing stopped. Will be updated.
+ *        Necessarily 0 <= pos <= size.
+ */
+struct zstd_out_buffer {
+	void *dst;
+	size_t size;
+	size_t pos;
+};
+
+/* ======   Streaming Compression   ====== */
+
+typedef struct ZSTD_CCtx_s zstd_cstream;
+
+/**
+ * zstd_cstream_workspace_bound() - memory needed to initialize a zstd_cstream
+ * @cparams: The compression parameters to be used for compression.
+ *
+ * Return:   A lower bound on the size of the workspace that is passed to
+ *           zstd_init_cstream().
+ */
+size_t zstd_cstream_workspace_bound(
+	const struct zstd_compression_parameters *cparams);
+
+/**
+ * zstd_init_cstream() - initialize a zstd streaming compression context
+ * @parameters        The zstd parameters to use for compression.
+ * @pledged_src_size: If params.fParams.contentSizeFlag == 1 then the caller
+ *                    must pass the source size (zero means empty source).
+ *                    Otherwise, the caller may optionally pass the source
+ *                    size, or zero if unknown.
+ * @workspace:        The workspace to emplace the context into. It must outlive
+ *                    the returned context.
+ * @workspace_size:   The size of workspace.
+ *                    Use zstd_cstream_workspace_bound(params->cparams) to
+ *                    determine how large the workspace must be.
+ *
+ * Return:            The zstd streaming compression context or NULL on error.
+ */
+zstd_cstream *zstd_init_cstream(const struct zstd_parameters *parameters,
+	unsigned long long pledged_src_size, void *workspace, size_t workspace_size);
+
+/**
+ * zstd_reset_cstream() - reset the context using parameters from creation
+ * @cstream:          The zstd streaming compression context to reset.
+ * @pledged_src_size: Optionally the source size, or zero if unknown.
+ *
+ * Resets the context using the parameters from creation. Skips dictionary
+ * loading, since it can be reused. If `pledged_src_size` is non-zero the frame
+ * content size is always written into the frame header.
+ *
+ * Return:            Zero or an error, which can be checked using
+ *                    zstd_is_error().
+ */
+size_t zstd_reset_cstream(zstd_cstream *cstream,
+	unsigned long long pledged_src_size);
+
+/**
+ * zstd_compress_stream() - streaming compress some of input into output
+ * @cstream: The zstd streaming compression context.
+ * @output:  Destination buffer. `output->pos` is updated to indicate how much
+ *           compressed data was written.
+ * @input:   Source buffer. `input->pos` is updated to indicate how much data
+ *           was read. Note that it may not consume the entire input, in which
+ *           case `input->pos < input->size`, and it's up to the caller to
+ *           present remaining data again.
+ *
+ * The `input` and `output` buffers may be any size. Guaranteed to make some
+ * forward progress if `input` and `output` are not empty.
+ *
+ * Return:   A hint for the number of bytes to use as the input for the next
+ *           function call or an error, which can be checked using
+ *           zstd_is_error().
+ */
+size_t zstd_compress_stream(zstd_cstream *cstream,
+	struct zstd_out_buffer *output, struct zstd_in_buffer *input);
+
+/**
+ * zstd_flush_stream() - flush internal buffers into output
+ * @cstream: The zstd streaming compression context.
+ * @output:  Destination buffer. `output->pos` is updated to indicate how much
+ *           compressed data was written.
+ *
+ * zstd_flush_stream() must be called until it returns 0, meaning all the data
+ * has been flushed. Since zstd_flush_stream() causes a block to be ended,
+ * calling it too often will degrade the compression ratio.
+ *
+ * Return:   The number of bytes still present within internal buffers or an
+ *           error, which can be checked using zstd_is_error().
+ */
+size_t zstd_flush_stream(zstd_cstream *cstream, struct zstd_out_buffer *output);
+
+/**
+ * zstd_end_stream() - flush internal buffers into output and end the frame
+ * @cstream: The zstd streaming compression context.
+ * @output:  Destination buffer. `output->pos` is updated to indicate how much
+ *           compressed data was written.
+ *
+ * zstd_end_stream() must be called until it returns 0, meaning all the data has
+ * been flushed and the frame epilogue has been written.
+ *
+ * Return:   The number of bytes still present within internal buffers or an
+ *           error, which can be checked using zstd_is_error().
+ */
+size_t zstd_end_stream(zstd_cstream *cstream, struct zstd_out_buffer *output);
+
+/* ======   Streaming Decompression   ====== */
+
+typedef struct ZSTD_DCtx_s zstd_dstream;
+
+/**
+ * zstd_dstream_workspace_bound() - memory needed to initialize a zstd_dstream
+ * @max_window_size: The maximum window size allowed for compressed frames.
+ *
+ * Return:           A lower bound on the size of the workspace that is passed
+ *                   to zstd_init_dstream().
+ */
+size_t zstd_dstream_workspace_bound(size_t max_window_size);
+
+/**
+ * zstd_init_dstream() - initialize a zstd streaming decompression context
+ * @max_window_size: The maximum window size allowed for compressed frames.
+ * @workspace:       The workspace to emplace the context into. It must outlive
+ *                   the returned context.
+ * @workspaceSize:   The size of workspace.
+ *                   Use zstd_dstream_workspace_bound(max_window_size) to
+ *                   determine how large the workspace must be.
+ *
+ * Return:           The zstd streaming decompression context.
+ */
+zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
+	size_t workspace_size);
+
+/**
+ * zstd_reset_dstream() - reset the context using parameters from creation
+ * @dstream: The zstd streaming decompression context to reset.
+ *
+ * Resets the context using the parameters from creation. Skips dictionary
+ * loading, since it can be reused.
+ *
+ * Return:   Zero or an error, which can be checked using zstd_is_error().
+ */
+size_t zstd_reset_dstream(zstd_dstream *dstream);
+
+/**
+ * zstd_decompress_stream() - streaming decompress some of input into output
+ * @dstream: The zstd streaming decompression context.
+ * @output:  Destination buffer. `output.pos` is updated to indicate how much
+ *           decompressed data was written.
+ * @input:   Source buffer. `input.pos` is updated to indicate how much data was
+ *           read. Note that it may not consume the entire input, in which case
+ *           `input.pos < input.size`, and it's up to the caller to present
+ *           remaining data again.
+ *
+ * The `input` and `output` buffers may be any size. Guaranteed to make some
+ * forward progress if `input` and `output` are not empty.
+ * zstd_decompress_stream() will not consume the last byte of the frame until
+ * the entire frame is flushed.
+ *
+ * Return:   Returns 0 iff a frame is completely decoded and fully flushed.
+ *           Otherwise returns a hint for the number of bytes to use as the
+ *           input for the next function call or an error, which can be checked
+ *           using zstd_is_error(). The size hint will never load more than the
+ *           frame.
+ */
+size_t zstd_decompress_stream(zstd_dstream *dstream,
+	struct zstd_out_buffer *output, struct zstd_in_buffer *input);
+
+/* ======   Frame Inspection Functions ====== */
+
+/**
+ * zstd_find_frame_compressed_size() - returns the size of a compressed frame
+ * @src:      Source buffer. It should point to the start of a zstd encoded
+ *            frame or a skippable frame.
+ * @src_size: The size of the source buffer. It must be at least as large as the
+ *            size of the frame.
+ *
+ * Return:    The compressed size of the frame pointed to by `src` or an error,
+ *            which can be check with zstd_is_error().
+ *            Suitable to pass to ZSTD_decompress() or similar functions.
+ */
+size_t zstd_find_frame_compressed_size(const void *src, size_t src_size);
+
+/**
+ * struct zstd_frame_params - zstd frame parameters stored in the frame header
+ * @frame_content_size: The frame content size, or 0 if not present.
+ * @window_size:        The window size, or 0 if the frame is a skippable frame.
+ * @dict_id:            The dictionary id, or 0 if not present.
+ * @checksum_flag:      Whether a checksum was used.
+ */
+struct zstd_frame_params {
+	unsigned long long frame_content_size;
+	unsigned int window_size;
+	unsigned int dict_id;
+	unsigned int checksum_flag;
+};
+
+/**
+ * zstd_get_frame_params() - extracts parameters from a zstd or skippable frame
+ * @params:   On success the frame parameters are written here.
+ * @src:      The source buffer. It must point to a zstd or skippable frame.
+ * @src_size: The size of the source buffer.
+ *
+ * Return:    0 on success. If more data is required it returns how many bytes
+ *            must be provided to make forward progress. Otherwise it returns
+ *            an error, which can be checked using zstd_is_error().
+ */
+size_t zstd_get_frame_params(struct zstd_frame_params *params, const void *src,
+	size_t src_size);
+
+#endif  /* LINUX_ZSTD_H */

contrib/linux-kernel/test/Makefile

@@ -6,10 +6,11 @@ CPPFLAGS += -I$(LINUX)/include -I$(LINUX_ZSTDLIB) -Iinclude -DNDEBUG
 # Don't poison the workspace, it currently doesn't work with static allocation and workspace reuse
 CPPFLAGS += -DZSTD_ASAN_DONT_POISON_WORKSPACE
 
+LINUX_ZSTD_MODULE     := $(wildcard $(LINUX_ZSTDLIB)/*.c)
 LINUX_ZSTD_COMMON     := $(wildcard $(LINUX_ZSTDLIB)/common/*.c) 
 LINUX_ZSTD_COMPRESS   := $(wildcard $(LINUX_ZSTDLIB)/compress/*.c) 
 LINUX_ZSTD_DECOMPRESS := $(wildcard $(LINUX_ZSTDLIB)/decompress/*.c) 
-LINUX_ZSTD_FILES      := $(LINUX_ZSTD_COMMON) $(LINUX_ZSTD_COMPRESS) $(LINUX_ZSTD_DECOMPRESS)
+LINUX_ZSTD_FILES      := $(LINUX_ZSTD_MODULE) $(LINUX_ZSTD_COMMON) $(LINUX_ZSTD_COMPRESS) $(LINUX_ZSTD_DECOMPRESS)
 LINUX_ZSTD_OBJECTS    := $(LINUX_ZSTD_FILES:.c=.o)
 
 liblinuxzstd.a: $(LINUX_ZSTD_OBJECTS)

contrib/linux-kernel/test/include/linux/module.h

@@ -12,8 +12,7 @@
 
 #define EXPORT_SYMBOL(symbol)                                                  \
   void* __##symbol = symbol
-#define MODULE_LICENSE(license) static char const *const LICENSE = license
-#define MODULE_DESCRIPTION(description)                                        \
-  static char const *const DESCRIPTION = description
+#define MODULE_LICENSE(license)
+#define MODULE_DESCRIPTION(description)
 
 #endif

contrib/linux-kernel/test/static_test.c

@@ -31,13 +31,13 @@ static const char kEmptyZstdFrame[] = {
 static void test_decompress_unzstd() {
     fprintf(stderr, "Testing decompress unzstd... ");
     {
-        size_t const wkspSize = ZSTD_estimateDCtxSize();
+        size_t const wkspSize = zstd_dctx_workspace_bound();
         void* wksp = malloc(wkspSize);
         CONTROL(wksp != NULL);
-        ZSTD_DCtx* dctx = ZSTD_initStaticDCtx(wksp, wkspSize);
+        ZSTD_DCtx* dctx = zstd_init_dctx(wksp, wkspSize);
         CONTROL(dctx != NULL);
-        size_t const dSize = ZSTD_decompressDCtx(dctx, NULL, 0, kEmptyZstdFrame, sizeof(kEmptyZstdFrame));
-        CONTROL(!ZSTD_isError(dSize));
+        size_t const dSize = zstd_decompress_dctx(dctx, NULL, 0, kEmptyZstdFrame, sizeof(kEmptyZstdFrame));
+        CONTROL(!zstd_is_error(dSize));
         CONTROL(dSize == 0);
         free(wksp);
     }

contrib/linux-kernel/test/test.c

@@ -37,7 +37,7 @@ test_data_t create_test_data(void) {
   CONTROL(data.data != NULL);
   data.data2 = malloc(data.dataSize);
   CONTROL(data.data2 != NULL);
-  data.compSize = ZSTD_compressBound(data.dataSize);
+  data.compSize = zstd_compress_bound(data.dataSize);
   data.comp = malloc(data.compSize);
   CONTROL(data.comp != NULL);
   memset(data.data, 0, data.dataSize);
@@ -57,11 +57,11 @@ static void test_btrfs(test_data_t const *data) {
   fprintf(stderr, "testing btrfs use cases... ");
   size_t const size = MIN(data->dataSize, 128 * 1024);
   for (int level = -1; level < 16; ++level) {
-    ZSTD_parameters params = ZSTD_getParams(level, size, 0);
-    CONTROL(params.cParams.windowLog <= 17);
+    struct zstd_parameters params = zstd_get_params(level, size);
+    CONTROL(params.cparams.window_log <= 17);
     size_t const workspaceSize =
-        MAX(ZSTD_estimateCStreamSize_usingCParams(params.cParams),
-            ZSTD_estimateDStreamSize(size));
+        MAX(zstd_cstream_workspace_bound(&params.cparams),
+            zstd_dstream_workspace_bound(size));
     void *workspace = malloc(workspaceSize);
     CONTROL(workspace != NULL);
 
@@ -70,12 +70,10 @@ static void test_btrfs(test_data_t const *data) {
     char *op = data->comp;
     char *oend = op + data->compSize;
     {
-      ZSTD_CStream *cctx = ZSTD_initStaticCStream(workspace, workspaceSize);
+      zstd_cstream *cctx = zstd_init_cstream(&params, size, workspace, workspaceSize);
       CONTROL(cctx != NULL);
-      CONTROL(!ZSTD_isError(
-          ZSTD_initCStream_advanced(cctx, NULL, 0, params, size)));
-      ZSTD_outBuffer out = {NULL, 0, 0};
-      ZSTD_inBuffer in = {NULL, 0, 0};
+      struct zstd_out_buffer out = {NULL, 0, 0};
+      struct zstd_in_buffer in = {NULL, 0, 0};
       for (;;) {
         if (in.pos == in.size) {
           in.src = ip;
@@ -92,10 +90,10 @@ static void test_btrfs(test_data_t const *data) {
         }
 
         if (ip != iend || in.pos < in.size) {
-          CONTROL(!ZSTD_isError(ZSTD_compressStream(cctx, &out, &in)));
+          CONTROL(!zstd_is_error(zstd_compress_stream(cctx, &out, &in)));
         } else {
-          size_t const ret = ZSTD_endStream(cctx, &out);
-          CONTROL(!ZSTD_isError(ret));
+          size_t const ret = zstd_end_stream(cctx, &out);
+          CONTROL(!zstd_is_error(ret));
           if (ret == 0) {
             break;
           }
@@ -109,10 +107,10 @@ static void test_btrfs(test_data_t const *data) {
     op = data->data2;
     oend = op + size;
     {
-      ZSTD_DStream *dctx = ZSTD_initStaticDStream(workspace, workspaceSize);
+      zstd_dstream *dctx = zstd_init_dstream(1ULL << params.cparams.window_log, workspace, workspaceSize);
       CONTROL(dctx != NULL);
-      ZSTD_outBuffer out = {NULL, 0, 0};
-      ZSTD_inBuffer in = {NULL, 0, 0};
+      struct zstd_out_buffer out = {NULL, 0, 0};
+      struct zstd_in_buffer in = {NULL, 0, 0};
       for (;;) {
         if (in.pos == in.size) {
           in.src = ip;
@@ -128,8 +126,8 @@ static void test_btrfs(test_data_t const *data) {
           op += out.size;
         }
 
-        size_t const ret = ZSTD_decompressStream(dctx, &out, &in);
-        CONTROL(!ZSTD_isError(ret));
+        size_t const ret = zstd_decompress_stream(dctx, &out, &in);
+        CONTROL(!zstd_is_error(ret));
         if (ret == 0) {
           break;
         }
@@ -146,23 +144,24 @@ static void test_decompress_unzstd(test_data_t const *data) {
     fprintf(stderr, "Testing decompress unzstd... ");
     size_t cSize;
     {
-        size_t const wkspSize = ZSTD_estimateCCtxSize(19);
+        struct zstd_parameters params = zstd_get_params(19, 0);
+        size_t const wkspSize = zstd_cctx_workspace_bound(&params.cparams);
         void* wksp = malloc(wkspSize);
         CONTROL(wksp != NULL);
-        ZSTD_CCtx* cctx = ZSTD_initStaticCCtx(wksp, wkspSize);
+        zstd_cctx* cctx = zstd_init_cctx(wksp, wkspSize);
         CONTROL(cctx != NULL);
-        cSize = ZSTD_compressCCtx(cctx, data->comp, data->compSize, data->data, data->dataSize, 19);
-        CONTROL(!ZSTD_isError(cSize));
+        cSize = zstd_compress_cctx(cctx, data->comp, data->compSize, data->data, data->dataSize, &params);
+        CONTROL(!zstd_is_error(cSize));
         free(wksp);
     }
     {
-        size_t const wkspSize = ZSTD_estimateDCtxSize();
+        size_t const wkspSize = zstd_dctx_workspace_bound();
         void* wksp = malloc(wkspSize);
         CONTROL(wksp != NULL);
-        ZSTD_DCtx* dctx = ZSTD_initStaticDCtx(wksp, wkspSize);
+        zstd_dctx* dctx = zstd_init_dctx(wksp, wkspSize);
         CONTROL(dctx != NULL);
-        size_t const dSize = ZSTD_decompressDCtx(dctx, data->data2, data->dataSize, data->comp, cSize);
-        CONTROL(!ZSTD_isError(dSize));
+        size_t const dSize = zstd_decompress_dctx(dctx, data->data2, data->dataSize, data->comp, cSize);
+        CONTROL(!zstd_is_error(dSize));
         CONTROL(dSize == data->dataSize);
         CONTROL(!memcmp(data->data, data->data2, data->dataSize));
         free(wksp);

contrib/linux-kernel/zstd_compress_module.c

@@ -2,78 +2,205 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/string.h>
 #include <linux/zstd.h>
 
-EXPORT_SYMBOL(ZSTD_compressBound);
-EXPORT_SYMBOL(ZSTD_minCLevel);
-EXPORT_SYMBOL(ZSTD_maxCLevel);
-EXPORT_SYMBOL(ZSTD_freeCCtx);
-EXPORT_SYMBOL(ZSTD_compressCCtx);
-EXPORT_SYMBOL(ZSTD_cParam_getBounds);
-EXPORT_SYMBOL(ZSTD_CCtx_setParameter);
-EXPORT_SYMBOL(ZSTD_CCtx_setPledgedSrcSize);
-EXPORT_SYMBOL(ZSTD_CCtx_reset);
-EXPORT_SYMBOL(ZSTD_compress2);
-EXPORT_SYMBOL(ZSTD_freeCStream);
-EXPORT_SYMBOL(ZSTD_compressStream2);
-EXPORT_SYMBOL(ZSTD_CStreamInSize);
-EXPORT_SYMBOL(ZSTD_CStreamOutSize);
-EXPORT_SYMBOL(ZSTD_initCStream);
-EXPORT_SYMBOL(ZSTD_compressStream);
-EXPORT_SYMBOL(ZSTD_flushStream);
-EXPORT_SYMBOL(ZSTD_endStream);
-EXPORT_SYMBOL(ZSTD_compress_usingDict);
-EXPORT_SYMBOL(ZSTD_freeCDict);
-EXPORT_SYMBOL(ZSTD_compress_usingCDict);
-EXPORT_SYMBOL(ZSTD_CCtx_refCDict);
-EXPORT_SYMBOL(ZSTD_CCtx_refPrefix);
-EXPORT_SYMBOL(ZSTD_sizeof_CCtx);
-EXPORT_SYMBOL(ZSTD_sizeof_CStream);
-EXPORT_SYMBOL(ZSTD_sizeof_CDict);
-EXPORT_SYMBOL(ZSTD_getSequences);
-EXPORT_SYMBOL(ZSTD_estimateCCtxSize);
-EXPORT_SYMBOL(ZSTD_estimateCCtxSize_usingCParams);
-EXPORT_SYMBOL(ZSTD_estimateCCtxSize_usingCCtxParams);
-EXPORT_SYMBOL(ZSTD_estimateCStreamSize);
-EXPORT_SYMBOL(ZSTD_estimateCStreamSize_usingCParams);
-EXPORT_SYMBOL(ZSTD_estimateCDictSize);
-EXPORT_SYMBOL(ZSTD_estimateCDictSize_advanced);
-EXPORT_SYMBOL(ZSTD_initStaticCCtx);
-EXPORT_SYMBOL(ZSTD_initStaticCStream);
-EXPORT_SYMBOL(ZSTD_initStaticCDict);
-EXPORT_SYMBOL(ZSTD_createCCtx_advanced);
-EXPORT_SYMBOL(ZSTD_createCStream_advanced);
-EXPORT_SYMBOL(ZSTD_createCDict_advanced);
-EXPORT_SYMBOL(ZSTD_createCDict_byReference);
-EXPORT_SYMBOL(ZSTD_getCParams);
-EXPORT_SYMBOL(ZSTD_getParams);
-EXPORT_SYMBOL(ZSTD_checkCParams);
-EXPORT_SYMBOL(ZSTD_adjustCParams);
-EXPORT_SYMBOL(ZSTD_compress_advanced);
-EXPORT_SYMBOL(ZSTD_compress_usingCDict_advanced);
-EXPORT_SYMBOL(ZSTD_CCtx_loadDictionary_byReference);
-EXPORT_SYMBOL(ZSTD_CCtx_loadDictionary_advanced);
-EXPORT_SYMBOL(ZSTD_CCtx_refPrefix_advanced);
-EXPORT_SYMBOL(ZSTD_CCtx_getParameter);
-EXPORT_SYMBOL(ZSTD_compressStream2_simpleArgs);
-EXPORT_SYMBOL(ZSTD_initCStream_srcSize);
-EXPORT_SYMBOL(ZSTD_initCStream_usingDict);
-EXPORT_SYMBOL(ZSTD_initCStream_advanced);
-EXPORT_SYMBOL(ZSTD_initCStream_usingCDict);
-EXPORT_SYMBOL(ZSTD_initCStream_usingCDict_advanced);
-EXPORT_SYMBOL(ZSTD_resetCStream);
-EXPORT_SYMBOL(ZSTD_getFrameProgression);
-EXPORT_SYMBOL(ZSTD_toFlushNow);
-EXPORT_SYMBOL(ZSTD_compressBegin);
-EXPORT_SYMBOL(ZSTD_compressBegin_usingDict);
-EXPORT_SYMBOL(ZSTD_compressBegin_advanced);
-EXPORT_SYMBOL(ZSTD_compressBegin_usingCDict);
-EXPORT_SYMBOL(ZSTD_compressBegin_usingCDict_advanced);
-EXPORT_SYMBOL(ZSTD_copyCCtx);
-EXPORT_SYMBOL(ZSTD_compressContinue);
-EXPORT_SYMBOL(ZSTD_compressEnd);
-EXPORT_SYMBOL(ZSTD_getBlockSize);
-EXPORT_SYMBOL(ZSTD_compressBlock);
+#include "zstd.h"
+#include "common/zstd_deps.h"
+#include "common/zstd_internal.h"
+
+static void zstd_check_structs(void) {
+	/* Check that the structs have the same size. */
+	ZSTD_STATIC_ASSERT(sizeof(ZSTD_parameters) ==
+		sizeof(struct zstd_parameters));
+	ZSTD_STATIC_ASSERT(sizeof(ZSTD_compressionParameters) ==
+		sizeof(struct zstd_compression_parameters));
+	ZSTD_STATIC_ASSERT(sizeof(ZSTD_frameParameters) ==
+		sizeof(struct zstd_frame_parameters));
+	/* Zstd guarantees that the layout of the structs never change. Verify it. */
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, cParams) ==
+		offsetof(struct zstd_parameters, cparams));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_parameters, fParams) ==
+		offsetof(struct zstd_parameters, fparams));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, windowLog) ==
+		offsetof(struct zstd_compression_parameters, window_log));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, chainLog) ==
+		offsetof(struct zstd_compression_parameters, chain_log));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, hashLog) ==
+		offsetof(struct zstd_compression_parameters, hash_log));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, searchLog) ==
+		offsetof(struct zstd_compression_parameters, search_log));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, minMatch) ==
+		offsetof(struct zstd_compression_parameters, search_length));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, targetLength) ==
+		offsetof(struct zstd_compression_parameters, target_length));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_compressionParameters, strategy) ==
+		offsetof(struct zstd_compression_parameters, strategy));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, contentSizeFlag) ==
+		offsetof(struct zstd_frame_parameters, content_size_flag));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, checksumFlag) ==
+		offsetof(struct zstd_frame_parameters, checksum_flag));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_frameParameters, noDictIDFlag) ==
+		offsetof(struct zstd_frame_parameters, no_dict_id_flag));
+	/* Check that the strategies are the same. This can change. */
+	ZSTD_STATIC_ASSERT((int)ZSTD_fast == (int)zstd_fast);
+	ZSTD_STATIC_ASSERT((int)ZSTD_dfast == (int)zstd_dfast);
+	ZSTD_STATIC_ASSERT((int)ZSTD_greedy == (int)zstd_greedy);
+	ZSTD_STATIC_ASSERT((int)ZSTD_lazy == (int)zstd_lazy);
+	ZSTD_STATIC_ASSERT((int)ZSTD_lazy2 == (int)zstd_lazy2);
+	ZSTD_STATIC_ASSERT((int)ZSTD_btlazy2 == (int)zstd_btlazy2);
+	ZSTD_STATIC_ASSERT((int)ZSTD_btopt == (int)zstd_btopt);
+	ZSTD_STATIC_ASSERT((int)ZSTD_btultra == (int)zstd_btultra);
+	ZSTD_STATIC_ASSERT((int)ZSTD_btultra2 == (int)zstd_btultra2);
+	/* Check input buffer */
+	ZSTD_STATIC_ASSERT(sizeof(ZSTD_inBuffer) == sizeof(struct zstd_in_buffer));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, src) ==
+		offsetof(struct zstd_in_buffer, src));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, size) ==
+		offsetof(struct zstd_in_buffer, size));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_inBuffer, pos) ==
+		offsetof(struct zstd_in_buffer, pos));
+	/* Check output buffer */
+	ZSTD_STATIC_ASSERT(sizeof(ZSTD_outBuffer) ==
+		sizeof(struct zstd_out_buffer));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, dst) ==
+		offsetof(struct zstd_out_buffer, dst));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, size) ==
+		offsetof(struct zstd_out_buffer, size));
+	ZSTD_STATIC_ASSERT(offsetof(ZSTD_outBuffer, pos) ==
+		offsetof(struct zstd_out_buffer, pos));
+}
+
+size_t zstd_compress_bound(size_t src_size)
+{
+	return ZSTD_compressBound(src_size);
+}
+EXPORT_SYMBOL(zstd_compress_bound);
+
+struct zstd_parameters zstd_get_params(int level,
+	unsigned long long estimated_src_size)
+{
+	const ZSTD_parameters params = ZSTD_getParams(level, estimated_src_size, 0);
+	struct zstd_parameters out;
+
+	/* no-op */
+	zstd_check_structs();
+	ZSTD_memcpy(&out, &params, sizeof(out));
+	return out;
+}
+EXPORT_SYMBOL(zstd_get_params);
+
+size_t zstd_cctx_workspace_bound(
+	const struct zstd_compression_parameters *cparams)
+{
+	ZSTD_compressionParameters p;
+
+	ZSTD_memcpy(&p, cparams, sizeof(p));
+	return ZSTD_estimateCCtxSize_usingCParams(p);
+}
+EXPORT_SYMBOL(zstd_cctx_workspace_bound);
+
+zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size)
+{
+	if (workspace == NULL)
+		return NULL;
+	return ZSTD_initStaticCCtx(workspace, workspace_size);
+}
+EXPORT_SYMBOL(zstd_init_cctx);
+
+size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
+	const void *src, size_t src_size, const struct zstd_parameters *parameters)
+{
+	ZSTD_parameters p;
+
+	ZSTD_memcpy(&p, parameters, sizeof(p));
+	return ZSTD_compress_advanced(cctx, dst, dst_capacity, src, src_size, NULL, 0, p);
+}
+EXPORT_SYMBOL(zstd_compress_cctx);
+
+size_t zstd_cstream_workspace_bound(
+	const struct zstd_compression_parameters *cparams)
+{
+	ZSTD_compressionParameters p;
+
+	ZSTD_memcpy(&p, cparams, sizeof(p));
+	return ZSTD_estimateCStreamSize_usingCParams(p);
+}
+EXPORT_SYMBOL(zstd_cstream_workspace_bound);
+
+zstd_cstream *zstd_init_cstream(const struct zstd_parameters *parameters,
+	unsigned long long pledged_src_size, void *workspace, size_t workspace_size)
+{
+	ZSTD_parameters p;
+	zstd_cstream *cstream;
+	size_t ret;
+
+	if (workspace == NULL)
+		return NULL;
+
+	cstream = ZSTD_initStaticCStream(workspace, workspace_size);
+	if (cstream == NULL)
+		return NULL;
+
+	/* 0 means unknown in linux zstd API but means 0 in new zstd API */
+	if (pledged_src_size == 0)
+		pledged_src_size = ZSTD_CONTENTSIZE_UNKNOWN;
+
+	ZSTD_memcpy(&p, parameters, sizeof(p));
+	ret = ZSTD_initCStream_advanced(cstream, NULL, 0, p, pledged_src_size);
+	if (ZSTD_isError(ret))
+		return NULL;
+
+	return cstream;
+}
+EXPORT_SYMBOL(zstd_init_cstream);
+
+size_t zstd_reset_cstream(zstd_cstream *cstream,
+	unsigned long long pledged_src_size)
+{
+	return ZSTD_resetCStream(cstream, pledged_src_size);
+}
+EXPORT_SYMBOL(zstd_reset_cstream);
+
+size_t zstd_compress_stream(zstd_cstream *cstream,
+	struct zstd_out_buffer *output, struct zstd_in_buffer *input)
+{
+	ZSTD_outBuffer o;
+	ZSTD_inBuffer i;
+	size_t ret;
+
+	ZSTD_memcpy(&o, output, sizeof(o));
+	ZSTD_memcpy(&i, input, sizeof(i));
+	ret = ZSTD_compressStream(cstream, &o, &i);
+	ZSTD_memcpy(output, &o, sizeof(o));
+	ZSTD_memcpy(input, &i, sizeof(i));
+	return ret;
+}
+EXPORT_SYMBOL(zstd_compress_stream);
+
+size_t zstd_flush_stream(zstd_cstream *cstream, struct zstd_out_buffer *output)
+{
+	ZSTD_outBuffer o;
+	size_t ret;
+
+	ZSTD_memcpy(&o, output, sizeof(o));
+	ret = ZSTD_flushStream(cstream, &o);
+	ZSTD_memcpy(output, &o, sizeof(o));
+	return ret;
+}
+EXPORT_SYMBOL(zstd_flush_stream);
+
+size_t zstd_end_stream(zstd_cstream *cstream, struct zstd_out_buffer *output)
+{
+	ZSTD_outBuffer o;
+	size_t ret;
+
+	ZSTD_memcpy(&o, output, sizeof(o));
+	ret = ZSTD_endStream(cstream, &o);
+	ZSTD_memcpy(output, &o, sizeof(o));
+	return ret;
+}
+EXPORT_SYMBOL(zstd_end_stream);
 
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("Zstd Compressor");

contrib/linux-kernel/zstd_decompress_module.c

@@ -2,78 +2,121 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/string.h>
 #include <linux/zstd.h>
-#include <linux/zstd_errors.h>
 
-// Common symbols. zstd_compress must depend on zstd_decompress.
-EXPORT_SYMBOL(ZSTD_versionNumber);
-EXPORT_SYMBOL(ZSTD_versionString);
-EXPORT_SYMBOL(ZSTD_isError);
-EXPORT_SYMBOL(ZSTD_getErrorName);
-EXPORT_SYMBOL(ZSTD_getErrorCode);
-EXPORT_SYMBOL(ZSTD_getErrorString);
+#include "zstd.h"
+#include "common/zstd_deps.h"
+#include "common/zstd_errors.h"
 
-// Decompression symbols.
-EXPORT_SYMBOL(ZSTD_getFrameContentSize);
-EXPORT_SYMBOL(ZSTD_getDecompressedSize);
-EXPORT_SYMBOL(ZSTD_findFrameCompressedSize);
-EXPORT_SYMBOL(ZSTD_freeDCtx);
-EXPORT_SYMBOL(ZSTD_decompressDCtx);
-EXPORT_SYMBOL(ZSTD_dParam_getBounds);
-EXPORT_SYMBOL(ZSTD_DCtx_setParameter);
-EXPORT_SYMBOL(ZSTD_DCtx_reset);
-EXPORT_SYMBOL(ZSTD_freeDStream);
-EXPORT_SYMBOL(ZSTD_initDStream);
-EXPORT_SYMBOL(ZSTD_decompressStream);
-EXPORT_SYMBOL(ZSTD_DStreamInSize);
-EXPORT_SYMBOL(ZSTD_DStreamOutSize);
-EXPORT_SYMBOL(ZSTD_decompress_usingDict);
-EXPORT_SYMBOL(ZSTD_freeDDict);
-EXPORT_SYMBOL(ZSTD_decompress_usingDDict);
-EXPORT_SYMBOL(ZSTD_getDictID_fromDict);
-EXPORT_SYMBOL(ZSTD_getDictID_fromDDict);
-EXPORT_SYMBOL(ZSTD_getDictID_fromFrame);
-EXPORT_SYMBOL(ZSTD_DCtx_refDDict);
-EXPORT_SYMBOL(ZSTD_DCtx_refPrefix);
-EXPORT_SYMBOL(ZSTD_sizeof_DCtx);
-EXPORT_SYMBOL(ZSTD_sizeof_DStream);
-EXPORT_SYMBOL(ZSTD_sizeof_DDict);
-EXPORT_SYMBOL(ZSTD_findDecompressedSize);
-EXPORT_SYMBOL(ZSTD_decompressBound);
-EXPORT_SYMBOL(ZSTD_frameHeaderSize);
-EXPORT_SYMBOL(ZSTD_estimateDCtxSize);
-EXPORT_SYMBOL(ZSTD_estimateDStreamSize);
-EXPORT_SYMBOL(ZSTD_estimateDStreamSize_fromFrame);
-EXPORT_SYMBOL(ZSTD_estimateDDictSize);
-EXPORT_SYMBOL(ZSTD_initStaticDCtx);
-EXPORT_SYMBOL(ZSTD_initStaticDStream);
-EXPORT_SYMBOL(ZSTD_initStaticDDict);
-EXPORT_SYMBOL(ZSTD_createDCtx_advanced);
-EXPORT_SYMBOL(ZSTD_createDStream_advanced);
-EXPORT_SYMBOL(ZSTD_createDDict_advanced);
-EXPORT_SYMBOL(ZSTD_isFrame);
-EXPORT_SYMBOL(ZSTD_createDDict_byReference);
-EXPORT_SYMBOL(ZSTD_DCtx_loadDictionary_byReference);
-EXPORT_SYMBOL(ZSTD_DCtx_loadDictionary_advanced);
-EXPORT_SYMBOL(ZSTD_DCtx_refPrefix_advanced);
-EXPORT_SYMBOL(ZSTD_DCtx_setMaxWindowSize);
-EXPORT_SYMBOL(ZSTD_DCtx_setFormat);
-EXPORT_SYMBOL(ZSTD_decompressStream_simpleArgs);
-EXPORT_SYMBOL(ZSTD_initDStream_usingDict);
-EXPORT_SYMBOL(ZSTD_initDStream_usingDDict);
-EXPORT_SYMBOL(ZSTD_resetDStream);
-EXPORT_SYMBOL(ZSTD_getFrameHeader);
-EXPORT_SYMBOL(ZSTD_getFrameHeader_advanced);
-EXPORT_SYMBOL(ZSTD_decodingBufferSize_min);
-EXPORT_SYMBOL(ZSTD_decompressBegin);
-EXPORT_SYMBOL(ZSTD_decompressBegin_usingDict);
-EXPORT_SYMBOL(ZSTD_decompressBegin_usingDDict);
-EXPORT_SYMBOL(ZSTD_nextSrcSizeToDecompress);
-EXPORT_SYMBOL(ZSTD_decompressContinue);
-EXPORT_SYMBOL(ZSTD_copyDCtx);
-EXPORT_SYMBOL(ZSTD_nextInputType);
-EXPORT_SYMBOL(ZSTD_decompressBlock);
-EXPORT_SYMBOL(ZSTD_insertBlock);
+/* Common symbols. zstd_compress must depend on zstd_decompress. */
+
+unsigned int zstd_is_error(size_t code)
+{
+	return ZSTD_isError(code);
+}
+EXPORT_SYMBOL(zstd_is_error);
+
+int zstd_get_error_code(size_t code)
+{
+	return ZSTD_getErrorCode(code);
+}
+EXPORT_SYMBOL(zstd_get_error_code);
+
+const char *zstd_get_error_name(size_t code)
+{
+	return ZSTD_getErrorName(code);
+}
+EXPORT_SYMBOL(zstd_get_error_name);
+
+/* Decompression symbols. */
+
+size_t zstd_dctx_workspace_bound(void)
+{
+	return ZSTD_estimateDCtxSize();
+}
+EXPORT_SYMBOL(zstd_dctx_workspace_bound);
+
+zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size)
+{
+	if (workspace == NULL)
+		return NULL;
+	return ZSTD_initStaticDCtx(workspace, workspace_size);
+}
+EXPORT_SYMBOL(zstd_init_dctx);
+
+size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,
+	const void *src, size_t src_size)
+{
+	return ZSTD_decompressDCtx(dctx, dst, dst_capacity, src, src_size);
+}
+EXPORT_SYMBOL(zstd_decompress_dctx);
+
+size_t zstd_dstream_workspace_bound(size_t max_window_size)
+{
+	return ZSTD_estimateDStreamSize(max_window_size);
+}
+EXPORT_SYMBOL(zstd_dstream_workspace_bound);
+
+zstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,
+	size_t workspace_size)
+{
+	if (workspace == NULL)
+		return NULL;
+	(void)max_window_size;
+	return ZSTD_initStaticDStream(workspace, workspace_size);
+}
+EXPORT_SYMBOL(zstd_init_dstream);
+
+size_t zstd_reset_dstream(zstd_dstream *dstream)
+{
+	return ZSTD_resetDStream(dstream);
+}
+EXPORT_SYMBOL(zstd_reset_dstream);
+
+size_t zstd_decompress_stream(zstd_dstream *dstream,
+	struct zstd_out_buffer *output, struct zstd_in_buffer *input)
+{
+	ZSTD_outBuffer o;
+	ZSTD_inBuffer i;
+	size_t ret;
+
+	ZSTD_memcpy(&o, output, sizeof(o));
+	ZSTD_memcpy(&i, input, sizeof(i));
+	ret = ZSTD_decompressStream(dstream, &o, &i);
+	ZSTD_memcpy(output, &o, sizeof(o));
+	ZSTD_memcpy(input, &i, sizeof(i));
+	return ret;
+}
+EXPORT_SYMBOL(zstd_decompress_stream);
+
+size_t zstd_find_frame_compressed_size(const void *src, size_t src_size)
+{
+	return ZSTD_findFrameCompressedSize(src, src_size);
+}
+EXPORT_SYMBOL(zstd_find_frame_compressed_size);
+
+size_t zstd_get_frame_params(struct zstd_frame_params *params, const void *src,
+	size_t src_size)
+{
+	ZSTD_frameHeader h;
+	const size_t ret = ZSTD_getFrameHeader(&h, src, src_size);
+
+	if (ret != 0)
+		return ret;
+
+	if (h.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
+		params->frame_content_size = h.frameContentSize;
+	else
+		params->frame_content_size = 0;
+
+	params->window_size = h.windowSize;
+	params->dict_id = h.dictID;
+	params->checksum_flag = h.checksumFlag;
+
+	return ret;
+}
+EXPORT_SYMBOL(zstd_get_frame_params);
 
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("Zstd Decompressor");

lib/compress/zstd_compress.c

@@ -3574,7 +3574,7 @@ size_t ZSTD_compress(void* dst, size_t dstCapacity,
     ZSTD_CCtx* cctx = ZSTD_createCCtx();
     RETURN_ERROR_IF(!cctx, memory_allocation, "ZSTD_createCCtx failed");
     result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);
-    ZSTD_freeCCtx(cctx);;
+    ZSTD_freeCCtx(cctx);
 #else
     ZSTD_CCtx ctxBody;
     ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);