mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Nick Terrell](/assets/img/avatar_default.png)
Upgrade to the latest upstream zstd version 1.4.10. This patch is 100% generated from upstream zstd commit 20821a46f412 [0]. This patch is very large because it is transitioning from the custom kernel zstd to using upstream directly. The new zstd follows upstreams file structure which is different. Future update patches will be much smaller because they will only contain the changes from one upstream zstd release. As an aid for review I've created a commit [1] that shows the diff between upstream zstd as-is (which doesn't compile), and the zstd code imported in this patch. The verion of zstd in this patch is generated from upstream with changes applied by automation to replace upstreams libc dependencies, remove unnecessary portability macros, replace `/**` comments with `/*` comments, and use the kernel's xxhash instead of bundling it. The benefits of this patch are as follows: 1. Using upstream directly with automated script to generate kernel code. This allows us to update the kernel every upstream release, so the kernel gets the latest bug fixes and performance improvements, and doesn't get 3 years out of date again. The automation and the translated code are tested every upstream commit to ensure it continues to work. 2. Upgrades from a custom zstd based on 1.3.1 to 1.4.10, getting 3 years of performance improvements and bug fixes. On x86_64 I've measured 15% faster BtrFS and SquashFS decompression+read speeds, 35% faster kernel decompression, and 30% faster ZRAM decompression+read speeds. 3. Zstd-1.4.10 supports negative compression levels, which allow zstd to match or subsume lzo's performance. 4. Maintains the same kernel-specific wrapper API, so no callers have to be modified with zstd version updates. One concern that was brought up was stack usage. Upstream zstd had already removed most of its heavy stack usage functions, but I just removed the last functions that allocate arrays on the stack. I've measured the high water mark for both compression and decompression before and after this patch. Decompression is approximately neutral, using about 1.2KB of stack space. Compression levels up to 3 regressed from 1.4KB -> 1.6KB, and higher compression levels regressed from 1.5KB -> 2KB. We've added unit tests upstream to prevent further regression. I believe that this is a reasonable increase, and if it does end up causing problems, this commit can be cleanly reverted, because it only touches zstd. I chose the bulk update instead of replaying upstream commits because there have been ~3500 upstream commits since the 1.3.1 release, zstd wasn't ready to be used in the kernel as-is before a month ago, and not all upstream zstd commits build. The bulk update preserves bisectablity because bugs can be bisected to the zstd version update. At that point the update can be reverted, and we can work with upstream to find and fix the bug. Note that upstream zstd release 1.4.10 doesn't exist yet. I have cut a staging branch at 20821a46f412 [0] and will apply any changes requested to the staging branch. Once we're ready to merge this update I will cut a zstd release at the commit we merge, so we have a known zstd release in the kernel. The implementation of the kernel API is contained in zstd_compress_module.c and zstd_decompress_module.c. [0]20821a46f4
[1]e0fa481d0e
Signed-off-by: Nick Terrell <terrelln@fb.com> Tested By: Paul Jones <paul@pauljones.id.au> Tested-by: Oleksandr Natalenko <oleksandr@natalenko.name> Tested-by: Sedat Dilek <sedat.dilek@gmail.com> # LLVM/Clang v13.0.0 on x86-64 Tested-by: Jean-Denis Girard <jd.girard@sysnux.pf>
160 lines
4.7 KiB
C
160 lines
4.7 KiB
C
// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
|
|
/*
|
|
* Copyright (c) Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under both the BSD-style license (found in the
|
|
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
|
|
* in the COPYING file in the root directory of this source tree).
|
|
* You may select, at your option, one of the above-listed licenses.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/string.h>
|
|
#include <linux/zstd.h>
|
|
|
|
#include "common/zstd_deps.h"
|
|
#include "common/zstd_internal.h"
|
|
|
|
#define ZSTD_FORWARD_IF_ERR(ret) \
|
|
do { \
|
|
size_t const __ret = (ret); \
|
|
if (ZSTD_isError(__ret)) \
|
|
return __ret; \
|
|
} while (0)
|
|
|
|
static size_t zstd_cctx_init(zstd_cctx *cctx, const zstd_parameters *parameters,
|
|
unsigned long long pledged_src_size)
|
|
{
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_reset(
|
|
cctx, ZSTD_reset_session_and_parameters));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setPledgedSrcSize(
|
|
cctx, pledged_src_size));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_windowLog, parameters->cParams.windowLog));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_hashLog, parameters->cParams.hashLog));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_chainLog, parameters->cParams.chainLog));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_searchLog, parameters->cParams.searchLog));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_minMatch, parameters->cParams.minMatch));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_targetLength, parameters->cParams.targetLength));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_strategy, parameters->cParams.strategy));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_contentSizeFlag, parameters->fParams.contentSizeFlag));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_checksumFlag, parameters->fParams.checksumFlag));
|
|
ZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(
|
|
cctx, ZSTD_c_dictIDFlag, !parameters->fParams.noDictIDFlag));
|
|
return 0;
|
|
}
|
|
|
|
int zstd_min_clevel(void)
|
|
{
|
|
return ZSTD_minCLevel();
|
|
}
|
|
EXPORT_SYMBOL(zstd_min_clevel);
|
|
|
|
int zstd_max_clevel(void)
|
|
{
|
|
return ZSTD_maxCLevel();
|
|
}
|
|
EXPORT_SYMBOL(zstd_max_clevel);
|
|
|
|
size_t zstd_compress_bound(size_t src_size)
|
|
{
|
|
return ZSTD_compressBound(src_size);
|
|
}
|
|
EXPORT_SYMBOL(zstd_compress_bound);
|
|
|
|
zstd_parameters zstd_get_params(int level,
|
|
unsigned long long estimated_src_size)
|
|
{
|
|
return ZSTD_getParams(level, estimated_src_size, 0);
|
|
}
|
|
EXPORT_SYMBOL(zstd_get_params);
|
|
|
|
size_t zstd_cctx_workspace_bound(const zstd_compression_parameters *cparams)
|
|
{
|
|
return ZSTD_estimateCCtxSize_usingCParams(*cparams);
|
|
}
|
|
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 zstd_parameters *parameters)
|
|
{
|
|
ZSTD_FORWARD_IF_ERR(zstd_cctx_init(cctx, parameters, src_size));
|
|
return ZSTD_compress2(cctx, dst, dst_capacity, src, src_size);
|
|
}
|
|
EXPORT_SYMBOL(zstd_compress_cctx);
|
|
|
|
size_t zstd_cstream_workspace_bound(const zstd_compression_parameters *cparams)
|
|
{
|
|
return ZSTD_estimateCStreamSize_usingCParams(*cparams);
|
|
}
|
|
EXPORT_SYMBOL(zstd_cstream_workspace_bound);
|
|
|
|
zstd_cstream *zstd_init_cstream(const zstd_parameters *parameters,
|
|
unsigned long long pledged_src_size, void *workspace, size_t workspace_size)
|
|
{
|
|
zstd_cstream *cstream;
|
|
|
|
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;
|
|
|
|
if (ZSTD_isError(zstd_cctx_init(cstream, parameters, pledged_src_size)))
|
|
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, zstd_out_buffer *output,
|
|
zstd_in_buffer *input)
|
|
{
|
|
return ZSTD_compressStream(cstream, output, input);
|
|
}
|
|
EXPORT_SYMBOL(zstd_compress_stream);
|
|
|
|
size_t zstd_flush_stream(zstd_cstream *cstream, zstd_out_buffer *output)
|
|
{
|
|
return ZSTD_flushStream(cstream, output);
|
|
}
|
|
EXPORT_SYMBOL(zstd_flush_stream);
|
|
|
|
size_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output)
|
|
{
|
|
return ZSTD_endStream(cstream, output);
|
|
}
|
|
EXPORT_SYMBOL(zstd_end_stream);
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_DESCRIPTION("Zstd Compressor");
|