Ticket #13742: 0001-Package-Kit-add-Zstd-compression.patch

Jamfile

@@ -23 +23 @@
 # Include required packages:
 # primary architecture
 AddHaikuImagePackages [ FFilterByBuildFeatures
-    bash bc coreutils curl freetype icu libsolv zlib
+    bash bc coreutils curl freetype icu libsolv zlib zstd
 
     regular_image @{
         bzip2 ctags diffutils expat ffmpeg findutils gawk glu grep gutenprint

build/jam/BuildFeatures

@@ -677 +677 @@
     }
 }
 
+
+# zstd
+if [ IsPackageAvailable zstd_devel ] {
+    ExtractBuildFeatureArchives zstd :
+        file: base zstd
+            runtime: lib
+        file: devel zstd_devel
+            depends: base
+            library: $(developLibDir)/libzstd.so
+            headers: $(developHeadersDir)
+        # sources are required for the primary architecture only
+        primary @{
+            file: source zstd_source
+                sources: develop/sources/%portRevisionedName%/sources
+        }@
+        ;
+
+    EnableBuildFeatures zstd ;
+} else {
+    Echo "zstd support not available on $(TARGET_PACKAGING_ARCH)" ;
+}
+
+
 # ATA Drivers + Bus
 EnableBuildFeatures ata ;

new file headers/build/private/support/ZstdCompressionAlgorithm.h

@@ +1 @@
+#include <../private/support/ZstdCompressionAlgorithm.h>

headers/os/package/hpkg/HPKGDefs.h

@@ -98 +98 @@
 // compression types
 enum {
     B_HPKG_COMPRESSION_NONE = 0,
-    B_HPKG_COMPRESSION_ZLIB = 1
+    B_HPKG_COMPRESSION_ZLIB = 1,
+    B_HPKG_COMPRESSION_ZSTD = 2
 };
 
 

new file headers/private/support/ZstdCompressionAlgorithm.h

@@ +1 @@
+/*
+ * Copyright 2017, Jérôme Duval.
+ * Copyright 2014, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _ZSTD_COMPRESSION_ALGORITHM_H_
+#define _ZSTD_COMPRESSION_ALGORITHM_H_
+
+
+#include <CompressionAlgorithm.h>
+
+
+// compression level
+enum {
+    B_ZSTD_COMPRESSION_NONE     = 0,
+    B_ZSTD_COMPRESSION_FASTEST  = 1,
+    B_ZSTD_COMPRESSION_BEST     = 19,
+    B_ZSTD_COMPRESSION_DEFAULT  = 2,
+};
+
+
+class BZstdCompressionParameters : public BCompressionParameters {
+public:
+                                BZstdCompressionParameters(
+                                    int compressionLevel
+                                        = B_ZSTD_COMPRESSION_DEFAULT);
+    virtual                     ~BZstdCompressionParameters();
+
+            int32               CompressionLevel() const;
+            void                SetCompressionLevel(int32 level);
+
+            size_t              BufferSize() const;
+            void                SetBufferSize(size_t size);
+
+private:
+            int32               fCompressionLevel;
+            size_t              fBufferSize;
+};
+
+
+class BZstdDecompressionParameters : public BDecompressionParameters {
+public:
+                                BZstdDecompressionParameters();
+    virtual                     ~BZstdDecompressionParameters();
+
+            size_t              BufferSize() const;
+            void                SetBufferSize(size_t size);
+
+private:
+            size_t              fBufferSize;
+};
+
+
+class BZstdCompressionAlgorithm : public BCompressionAlgorithm {
+public:
+                                BZstdCompressionAlgorithm();
+    virtual                     ~BZstdCompressionAlgorithm();
+
+    virtual status_t            CreateCompressingInputStream(BDataIO* input,
+                                    const BCompressionParameters* parameters,
+                                    BDataIO*& _stream);
+    virtual status_t            CreateCompressingOutputStream(BDataIO* output,
+                                    const BCompressionParameters* parameters,
+                                    BDataIO*& _stream);
+    virtual status_t            CreateDecompressingInputStream(BDataIO* input,
+                                    const BDecompressionParameters* parameters,
+                                    BDataIO*& _stream);
+    virtual status_t            CreateDecompressingOutputStream(BDataIO* output,
+                                    const BDecompressionParameters* parameters,
+                                    BDataIO*& _stream);
+
+    virtual status_t            CompressBuffer(const void* input,
+                                    size_t inputSize, void* output,
+                                    size_t outputSize, size_t& _compressedSize,
+                                    const BCompressionParameters* parameters
+                                        = NULL);
+    virtual status_t            DecompressBuffer(const void* input,
+                                    size_t inputSize, void* output,
+                                    size_t outputSize,
+                                    size_t& _uncompressedSize,
+                                    const BDecompressionParameters* parameters
+                                        = NULL);
+
+private:
+            struct CompressionStrategy;
+            struct DecompressionStrategy;
+
+            template<typename BaseClass, typename Strategy, typename StreamType> struct Stream;
+            template<typename BaseClass, typename Strategy, typename StreamType>
+                friend struct Stream;
+
+private:
+    static  status_t            _TranslateZstdError(size_t error);
+};
+
+
+#endif  // _ZSTD_COMPRESSION_ALGORITHM_H_

src/add-ons/kernel/file_systems/packagefs/Jamfile

@@ -5 +5 @@
 UsePrivateKernelHeaders ;
 UsePrivateHeaders package shared storage support ;
 
+local zstdSources ;
+local zstdKernelLib ;
+
+if [ FIsBuildFeatureEnabled zstd ] {
+    zstdSources = ZstdCompressionAlgorithm.cpp ;
+    zstdKernelLib = kernel_libzstd.a ;
+    UseBuildFeatureHeaders zstd ;
+    Includes [ FGristFiles $(zstdSources) ]
+        : [ BuildFeatureAttribute zstd : headers ] ;
+    SubDirC++Flags -DZSTD_ENABLED ;
+}
+
 
 local subDirs =
     indices
@@ -117 +129 @@
 local supportKitSources =
     CompressionAlgorithm.cpp
     ZlibCompressionAlgorithm.cpp
+    $(zstdSources)
 ;
 
 KernelAddon packagefs
@@ -129 +142 @@
     $(storageKitSources)
     $(supportKitSources)
 
-    : kernel_libz.a
+    : kernel_libz.a $(zstdKernelLib)
 ;
 
 

src/bin/package/command_create.cpp

@@ -39 +39 @@
     bool quiet = false;
     bool verbose = false;
     int32 compressionLevel = BPackageKit::BHPKG::B_HPKG_COMPRESSION_LEVEL_BEST;
+    int32 compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_ZLIB;
 
     while (true) {
         static struct option sLongOptions[] = {
@@ -49 +50 @@
         };
 
         opterr = 0; // don't print errors
-        int c = getopt_long(argc, (char**)argv, "+b0123456789C:hi:I:qv",
+        int c = getopt_long(argc, (char**)argv, "+b0123456789C:hi:I:qvz",
             sLongOptions, NULL);
         if (c == -1)
             break;
@@ -96 +97 @@
                 verbose = true;
                 break;
 
+            case 'z':
+                compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_ZSTD;
+                break;
+
             default:
                 print_usage_and_exit(true);
                 break;
@@ -118 +123 @@
     // create package
     BPackageWriterParameters writerParameters;
     writerParameters.SetCompressionLevel(compressionLevel);
-    if (compressionLevel == 0) {
-        writerParameters.SetCompression(
-            BPackageKit::BHPKG::B_HPKG_COMPRESSION_NONE);
-    }
+    if (compressionLevel == 0)
+        compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_NONE;
+    writerParameters.SetCompression(compression);
 
     PackageWriterListener listener(verbose, quiet);
     BPackageWriter packageWriter(&listener);

src/bin/package/command_recompress.cpp

@@ -45 +45 @@
     bool quiet = false;
     bool verbose = false;
     int32 compressionLevel = BPackageKit::BHPKG::B_HPKG_COMPRESSION_LEVEL_BEST;
+    int32 compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_ZLIB;
 
     while (true) {
         static struct option sLongOptions[] = {
@@ -55 +56 @@
         };
 
         opterr = 0; // don't print errors
-        int c = getopt_long(argc, (char**)argv, "+0123456789:hqv",
+        int c = getopt_long(argc, (char**)argv, "+0123456789:hqvz",
             sLongOptions, NULL);
         if (c == -1)
             break;
@@ -86 +87 @@
                 verbose = true;
                 break;
 
+            case 'z':
+                compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_ZSTD;
+                break;
+
             default:
                 print_usage_and_exit(true);
                 break;
@@ -119 +124 @@
     // write the output package
     BPackageWriterParameters writerParameters;
     writerParameters.SetCompressionLevel(compressionLevel);
-    if (compressionLevel == 0) {
-        writerParameters.SetCompression(
-            BPackageKit::BHPKG::B_HPKG_COMPRESSION_NONE);
-    }
+    if (compressionLevel == 0)
+        compression = BPackageKit::BHPKG::B_HPKG_COMPRESSION_NONE;
+    writerParameters.SetCompression(compression);
 
     PackageWriterListener listener(verbose, quiet);
     BPackageWriter packageWriter(&listener);

src/bin/package/package.cpp

@@ -72 +72 @@
     "                 to redirect a \"make install\". Only allowed with -b.\n"
     "    -q         - Be quiet (don't show any output except for errors).\n"
     "    -v         - Be verbose (show more info about created package).\n"
+    "    -z         - Use Zstd compression.\n"
     "\n"
     "  dump [ <options> ] <package>\n"
     "    Dumps the TOC section of package file <package>. For debugging only.\n"
@@ -120 +121 @@
     "                 Defaults to 9.\n"
     "    -q         - Be quiet (don't show any output except for errors).\n"
     "    -v         - Be verbose (show more info about created package).\n"
+    "    -z         - Use Zstd compression.\n"
     "\n"
     "Common Options:\n"
     "  -h, --help   - Print this usage info.\n"

src/kits/Jamfile

@@ -48 +48 @@
             [ TargetLibstdc++ ]
             [ BuildFeatureAttribute icu : libraries ]
             [ BuildFeatureAttribute zlib : library ]
+            [ BuildFeatureAttribute zstd : library ]
             ;
     }
 }

src/kits/package/Jamfile

@@ -62 +62 @@
 for architectureObject in [ MultiArchSubDirSetup ] {
     on $(architectureObject) {
         UseBuildFeatureHeaders curl ;
-
+        if [ FIsBuildFeatureEnabled zstd ] {
+            SubDirC++Flags -DZSTD_ENABLED ;
+        }
         SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg ] ;
         SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg v1 ] ;
         SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package manager ] ;

src/kits/package/hpkg/ReaderImplBase.cpp

@@ -20 +20 @@
 #include <DataIO.h>
 
 #include <ZlibCompressionAlgorithm.h>
+#include <ZstdCompressionAlgorithm.h>
 
 #include <package/hpkg/HPKGDefsPrivate.h>
 #include <package/hpkg/PackageFileHeapReader.h>
@@ -824 +825 @@
                 return B_NO_MEMORY;
             }
             break;
+#ifdef ZSTD_ENABLED
+        case B_HPKG_COMPRESSION_ZSTD:
+            decompressionAlgorithm = DecompressionAlgorithmOwner::Create(
+                new(std::nothrow) BZstdCompressionAlgorithm,
+                new(std::nothrow) BZstdDecompressionParameters);
+            decompressionAlgorithmReference.SetTo(decompressionAlgorithm, true);
+            if (decompressionAlgorithm == NULL
+                || decompressionAlgorithm->algorithm == NULL
+                || decompressionAlgorithm->parameters == NULL) {
+                return B_NO_MEMORY;
+            }
+            break;
+#endif
         default:
             fErrorOutput->PrintError("Error: Invalid heap compression\n");
             return B_BAD_DATA;

src/kits/package/hpkg/WriterImplBase.cpp

@@ -20 +20 @@
 
 #include <AutoDeleter.h>
 #include <ZlibCompressionAlgorithm.h>
+#include <ZstdCompressionAlgorithm.h>
 
 #include <package/hpkg/DataReader.h>
 #include <package/hpkg/ErrorOutput.h>
@@ -326 +327 @@
                 throw std::bad_alloc();
             }
             break;
+#ifdef ZSTD_ENABLED
+        case B_HPKG_COMPRESSION_ZSTD:
+            compressionAlgorithm = CompressionAlgorithmOwner::Create(
+                new(std::nothrow) BZstdCompressionAlgorithm,
+                new(std::nothrow) BZstdCompressionParameters(
+                    fParameters.CompressionLevel()));
+            compressionAlgorithmReference.SetTo(compressionAlgorithm, true);
+
+            decompressionAlgorithm = DecompressionAlgorithmOwner::Create(
+                new(std::nothrow) BZstdCompressionAlgorithm,
+                new(std::nothrow) BZstdDecompressionParameters);
+            decompressionAlgorithmReference.SetTo(decompressionAlgorithm, true);
+
+            if (compressionAlgorithm == NULL
+                || compressionAlgorithm->algorithm == NULL
+                || compressionAlgorithm->parameters == NULL
+                || decompressionAlgorithm == NULL
+                || decompressionAlgorithm->algorithm == NULL
+                || decompressionAlgorithm->parameters == NULL) {
+                throw std::bad_alloc();
+            }
+            break;
+#endif
         default:
             fErrorOutput->PrintError("Error: Invalid heap compression\n");
             return B_BAD_VALUE;

src/kits/support/Jamfile

@@ -8 +8 @@
 for architectureObject in [ MultiArchSubDirSetup ] {
     on $(architectureObject) {
         local architecture = $(TARGET_PACKAGING_ARCH) ;
+        local zstdSources ;
 
         UseBuildFeatureHeaders zlib ;
 
         Includes [ FGristFiles ZlibCompressionAlgorithm.cpp ]
             : [ BuildFeatureAttribute zlib : headers ] ;
 
+        if [ FIsBuildFeatureEnabled zstd ] {
+            UseBuildFeatureHeaders zstd ;
+            zstdSources = ZstdCompressionAlgorithm.cpp ;
+
+            Includes [ FGristFiles ZstdCompressionAlgorithm.cpp ]
+                : [ BuildFeatureAttribute zstd : headers ] ;
+        }
+
         # BUrl uses ICU to perform IDNA conversions (unicode domain names)
         UseBuildFeatureHeaders icu ;
         Includes [ FGristFiles Url.cpp ]
@@ -46 +55 @@
             Url.cpp
             Uuid.cpp
             ZlibCompressionAlgorithm.cpp
+            $(zstdSources)
             ;
 
         StaticLibrary [ MultiArchDefaultGristFiles libreferenceable.a ]

new file src/kits/support/ZstdCompressionAlgorithm.cpp

@@ +1 @@
+/*
+ * Copyright 2017, Jérôme Duval.
+ * Copyright 2014, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <ZstdCompressionAlgorithm.h>
+
+#include <errno.h>
+#include <string.h>
+
+#include <algorithm>
+#include <new>
+
+#include <zstd.h>
+#include <zstd_errors.h>
+
+#include <DataIO.h>
+
+
+// build compression support only for userland
+#if !defined(_KERNEL_MODE) && !defined(_BOOT_MODE)
+#   define B_ZSTD_COMPRESSION_SUPPORT 1
+#endif
+
+
+static const size_t kMinBufferSize      = 1024;
+static const size_t kMaxBufferSize      = 1024 * 1024;
+static const size_t kDefaultBufferSize  = 4 * 1024;
+
+
+static size_t
+sanitize_buffer_size(size_t size)
+{
+    if (size < kMinBufferSize)
+        return kMinBufferSize;
+    return std::min(size, kMaxBufferSize);
+}
+
+
+// #pragma mark - BZstdCompressionParameters
+
+
+BZstdCompressionParameters::BZstdCompressionParameters(
+    int compressionLevel)
+    :
+    BCompressionParameters(),
+    fCompressionLevel(compressionLevel),
+    fBufferSize(kDefaultBufferSize)
+{
+}
+
+
+BZstdCompressionParameters::~BZstdCompressionParameters()
+{
+}
+
+
+int32
+BZstdCompressionParameters::CompressionLevel() const
+{
+    return fCompressionLevel;
+}
+
+
+void
+BZstdCompressionParameters::SetCompressionLevel(int32 level)
+{
+    fCompressionLevel = level;
+}
+
+
+size_t
+BZstdCompressionParameters::BufferSize() const
+{
+    return fBufferSize;
+}
+
+
+void
+BZstdCompressionParameters::SetBufferSize(size_t size)
+{
+    fBufferSize = sanitize_buffer_size(size);
+}
+
+
+// #pragma mark - BZstdDecompressionParameters
+
+
+BZstdDecompressionParameters::BZstdDecompressionParameters()
+    :
+    BDecompressionParameters(),
+    fBufferSize(kDefaultBufferSize)
+{
+}
+
+
+BZstdDecompressionParameters::~BZstdDecompressionParameters()
+{
+}
+
+
+size_t
+BZstdDecompressionParameters::BufferSize() const
+{
+    return fBufferSize;
+}
+
+
+void
+BZstdDecompressionParameters::SetBufferSize(size_t size)
+{
+    fBufferSize = sanitize_buffer_size(size);
+}
+
+
+// #pragma mark - CompressionStrategy
+
+
+#ifdef B_ZSTD_COMPRESSION_SUPPORT
+
+
+struct BZstdCompressionAlgorithm::CompressionStrategy {
+    typedef BZstdCompressionParameters Parameters;
+
+    static const bool kNeedsFinalFlush = true;
+
+    static size_t Init(ZSTD_CStream **stream,
+        const BZstdCompressionParameters* parameters)
+    {
+        int32 compressionLevel = B_ZSTD_COMPRESSION_DEFAULT;
+        if (parameters != NULL) {
+            compressionLevel = parameters->CompressionLevel();
+        }
+
+        *stream = ZSTD_createCStream();
+        return ZSTD_initCStream(*stream, compressionLevel);
+    }
+
+    static void Uninit(ZSTD_CStream *stream)
+    {
+        ZSTD_freeCStream(stream);
+    }
+
+    static size_t Process(ZSTD_CStream *stream, ZSTD_inBuffer *input,
+        ZSTD_outBuffer *output, bool flush)
+    {
+        return ZSTD_compressStream(stream, output, input);
+    }
+};
+
+
+#endif  // B_ZSTD_COMPRESSION_SUPPORT
+
+
+// #pragma mark - DecompressionStrategy
+
+
+struct BZstdCompressionAlgorithm::DecompressionStrategy {
+    typedef BZstdDecompressionParameters Parameters;
+
+    static size_t Init(ZSTD_DStream **stream,
+        const BZstdDecompressionParameters* /*parameters*/)
+    {
+        *stream = ZSTD_createDStream();
+        return ZSTD_initDStream(*stream);
+    }
+
+    static void Uninit(ZSTD_DStream *stream)
+    {
+        ZSTD_freeDStream(stream);
+    }
+
+    static size_t Process(ZSTD_DStream *stream, ZSTD_inBuffer *input,
+        ZSTD_outBuffer *output, bool flush)
+    {
+        return ZSTD_decompressStream(stream, output, input);
+    }
+
+};
+
+
+// #pragma mark - Stream
+
+
+template<typename BaseClass, typename Strategy, typename StreamType>
+struct BZstdCompressionAlgorithm::Stream : BaseClass {
+    Stream(BDataIO* io)
+        :
+        BaseClass(io),
+        fStreamInitialized(false)
+    {
+    }
+
+    ~Stream()
+    {
+        if (fStreamInitialized) {
+            Strategy::Uninit(fStream);
+        }
+    }
+
+    status_t Init(const typename Strategy::Parameters* parameters)
+    {
+        status_t error = this->BaseClass::Init(
+            parameters != NULL ? parameters->BufferSize() : kDefaultBufferSize);
+        if (error != B_OK)
+            return error;
+
+        size_t zstdError = Strategy::Init(&fStream, parameters);
+        if (ZSTD_getErrorCode(zstdError) != ZSTD_error_no_error)
+            return _TranslateZstdError(zstdError);
+
+        fStreamInitialized = true;
+        return B_OK;
+    }
+
+    virtual status_t ProcessData(const void* input, size_t inputSize,
+        void* output, size_t outputSize, size_t& bytesConsumed,
+        size_t& bytesProduced)
+    {
+        return _ProcessData(input, inputSize, output, outputSize,
+            bytesConsumed, bytesProduced, false);
+    }
+
+    virtual status_t FlushPendingData(void* output, size_t outputSize,
+        size_t& bytesProduced)
+    {
+        size_t bytesConsumed;
+        return _ProcessData(NULL, 0, output, outputSize,
+            bytesConsumed, bytesProduced, true);
+    }
+
+    template<typename BaseParameters>
+    static status_t Create(BDataIO* io, BaseParameters* _parameters,
+        BDataIO*& _stream)
+    {
+        const typename Strategy::Parameters* parameters
+#ifdef _BOOT_MODE
+            = static_cast<const typename Strategy::Parameters*>(_parameters);
+#else
+            = dynamic_cast<const typename Strategy::Parameters*>(_parameters);
+#endif
+        Stream* stream = new(std::nothrow) Stream(io);
+        if (stream == NULL)
+            return B_NO_MEMORY;
+
+        status_t error = stream->Init(parameters);
+        if (error != B_OK) {
+            delete stream;
+            return error;
+        }
+
+        _stream = stream;
+        return B_OK;
+    }
+
+private:
+    status_t _ProcessData(const void* input, size_t inputSize,
+        void* output, size_t outputSize, size_t& bytesConsumed,
+        size_t& bytesProduced, bool flush)
+    {
+        inBuffer.src = input;
+        inBuffer.size = inputSize;
+        outBuffer.dst = output;
+        outBuffer.size = outputSize;
+
+        size_t zstdError = Strategy::Process(fStream, &inBuffer, &outBuffer, flush);
+        if (ZSTD_getErrorCode(zstdError) != ZSTD_error_no_error) {
+            /*if (zstdError == Z_STREAM_END) {
+                if (fStream.avail_in != 0)
+                    return B_BAD_DATA;
+            } else*/
+                return _TranslateZstdError(zstdError);
+        }
+
+        bytesConsumed = inBuffer.pos;
+        bytesProduced = outBuffer.pos;
+        return B_OK;
+    }
+
+private:
+    bool        fStreamInitialized;
+    StreamType  *fStream;
+    ZSTD_inBuffer inBuffer;
+    ZSTD_outBuffer outBuffer;
+};
+
+
+// #pragma mark - BZstdCompressionAlgorithm
+
+
+BZstdCompressionAlgorithm::BZstdCompressionAlgorithm()
+    :
+    BCompressionAlgorithm()
+{
+}
+
+
+BZstdCompressionAlgorithm::~BZstdCompressionAlgorithm()
+{
+}
+
+
+status_t
+BZstdCompressionAlgorithm::CreateCompressingInputStream(BDataIO* input,
+    const BCompressionParameters* parameters, BDataIO*& _stream)
+{
+#ifdef B_ZSTD_COMPRESSION_SUPPORT
+    return Stream<BAbstractInputStream, CompressionStrategy, ZSTD_CStream>::Create(
+        input, parameters, _stream);
+#else
+    return B_NOT_SUPPORTED;
+#endif
+}
+
+
+status_t
+BZstdCompressionAlgorithm::CreateCompressingOutputStream(BDataIO* output,
+    const BCompressionParameters* parameters, BDataIO*& _stream)
+{
+#ifdef B_ZSTD_COMPRESSION_SUPPORT
+    return Stream<BAbstractOutputStream, CompressionStrategy, ZSTD_CStream>::Create(
+        output, parameters, _stream);
+#else
+    return B_NOT_SUPPORTED;
+#endif
+}
+
+
+status_t
+BZstdCompressionAlgorithm::CreateDecompressingInputStream(BDataIO* input,
+    const BDecompressionParameters* parameters, BDataIO*& _stream)
+{
+    return Stream<BAbstractInputStream, DecompressionStrategy, ZSTD_DStream>::Create(
+        input, parameters, _stream);
+}
+
+
+status_t
+BZstdCompressionAlgorithm::CreateDecompressingOutputStream(BDataIO* output,
+    const BDecompressionParameters* parameters, BDataIO*& _stream)
+{
+    return Stream<BAbstractOutputStream, DecompressionStrategy, ZSTD_DStream>::Create(
+        output, parameters, _stream);
+}
+
+
+status_t
+BZstdCompressionAlgorithm::CompressBuffer(const void* input,
+    size_t inputSize, void* output, size_t outputSize, size_t& _compressedSize,
+    const BCompressionParameters* parameters)
+{
+#ifdef B_ZSTD_COMPRESSION_SUPPORT
+    const BZstdCompressionParameters* zstdParameters
+        = dynamic_cast<const BZstdCompressionParameters*>(parameters);
+    int compressionLevel = zstdParameters != NULL
+        ? zstdParameters->CompressionLevel()
+        : B_ZSTD_COMPRESSION_DEFAULT;
+
+    size_t zstdError = ZSTD_compress(output, outputSize, input,
+        inputSize, compressionLevel);
+    if (ZSTD_isError(zstdError))
+        return _TranslateZstdError(zstdError);
+
+    _compressedSize = zstdError;
+    return B_OK;
+#else
+    return B_NOT_SUPPORTED;
+#endif
+}
+
+
+status_t
+BZstdCompressionAlgorithm::DecompressBuffer(const void* input,
+    size_t inputSize, void* output, size_t outputSize,
+    size_t& _uncompressedSize, const BDecompressionParameters* parameters)
+{
+    size_t zstdError = ZSTD_decompress(output, outputSize, input,
+        inputSize);
+    if (ZSTD_isError(zstdError))
+        return _TranslateZstdError(zstdError);
+
+    _uncompressedSize = zstdError;
+    return B_OK;
+}
+
+
+/*static*/ status_t
+BZstdCompressionAlgorithm::_TranslateZstdError(size_t error)
+{
+    switch (ZSTD_getErrorCode(error)) {
+        case ZSTD_error_no_error:
+            return B_OK;
+        case ZSTD_error_seekableIO:
+            return B_BAD_VALUE;
+        case ZSTD_error_corruption_detected:
+        case ZSTD_error_checksum_wrong:
+            return B_BAD_DATA;
+        case ZSTD_error_version_unsupported:
+            return B_BAD_VALUE;
+        default:
+            return B_ERROR;
+    }
+}

src/system/kernel/lib/Jamfile

@@ -141 +141 @@
 
 HaikuSubInclude arch $(TARGET_ARCH) ;
 HaikuSubInclude zlib ;
+if [ FIsBuildFeatureEnabled zstd ] {
+    HaikuSubInclude zstd ;
+}

new file src/system/kernel/lib/zstd/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src system kernel lib zstd ;
+
+local zstdSourceDirectory = [ BuildFeatureAttribute zstd : sources : path ] ;
+UseHeaders [ FDirName $(zstdSourceDirectory) lib ] ;
+UseHeaders [ FDirName $(zstdSourceDirectory) lib common ] ;
+
+local zstdCommonSources =
+    error_private.c
+    entropy_common.c fse_decompress.c zstd_common.c
+    xxhash.c
+    ;
+local zstdDecSources =
+    huf_decompress.c zstd_decompress.c
+    ;
+
+LOCATE on [ FGristFiles $(zstdCommonSources) ] =
+    [ FDirName $(zstdSourceDirectory) lib common ] ;
+LOCATE on [ FGristFiles $(zstdDecSources) ] =
+    [ FDirName $(zstdSourceDirectory) lib decompress ] ;
+Depends [ FGristFiles $(zstdCommonSources) $(zstdDecSources) ]
+    : [ BuildFeatureAttribute zstd : sources ] ;
+
+# Build zstd with PIC, such that it can be used by kernel add-ons (filesystems).
+KernelStaticLibrary kernel_libzstd.a :
+    $(zstdCommonSources) $(zstdDecSources)
+    ;