From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 1EDB61382C5 for ; Tue, 16 Jun 2020 18:22:08 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 35274E0937; Tue, 16 Jun 2020 18:22:07 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id D565EE0937 for ; Tue, 16 Jun 2020 18:22:06 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 4D96034ED9E for ; Tue, 16 Jun 2020 18:22:05 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 7855F1EF for ; Tue, 16 Jun 2020 18:22:01 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1592331682.88a265090e58371f7c1081152ef04d991c59cd9b.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.8 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1500_XATTR_USER_PREFIX.patch 1510_fs-enable-link-security-restrictions-by-default.patch 2000_BT-Check-key-sizes-only-if-Secure-Simple-Pairing-enabled.patch 2900_tmp513-Fix-build-issue-by-selecting-CONFIG_REG.patch 2910_TVP5150-Fix-build-issue-by-selecting-REGMAP-I2C.patch 2920_sign-file-patch-for-libressl.patch 5000_ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch 5001_ZSTD-v5-2-8-prepare-xxhash-for-preboot-env.patch 5002_ZSTD-v5-3-8-add-zstd-support-to-decompress.patch 5003_ZSTD-v5-4-8-add-support-for-zstd-compres-kern.patch 5004_ZSTD-v5-5-8-add-support-for-zstd-compressed-initramfs.patch 5005_ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch 5006_ZSTD-v5-7-8-support-for-ZSTD-compressed-kernel.patch 5007_ZSTD-v5-8-8-gitignore-add-ZSTD-compressed-files.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: 88a265090e58371f7c1081152ef04d991c59cd9b X-VCS-Branch: 5.8 Date: Tue, 16 Jun 2020 18:22:01 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: efdf974b-292a-4f29-9431-bf0701bd3b00 X-Archives-Hash: 8c7e97832714d60a9f0939965e173ac3 commit: 88a265090e58371f7c1081152ef04d991c59cd9b Author: Mike Pagano gentoo org> AuthorDate: Tue Jun 16 18:21:22 2020 +0000 Commit: Mike Pagano gentoo org> CommitDate: Tue Jun 16 18:21:22 2020 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=88a26509 Genpatches initial commit: Support for namespace user.pax.* on tmpfs. Enable link security restrictions by default. Bluetooth: Check key sizes only when Secure Simple Pairing is enabled. See bug #686758 tmp513 requies REGMAP_I2C to build. Select it by default in Kconfig. See bug #710790. Thanks to Phil Stracchino VIDEO_TVP5150 requies REGMAP_I2C to build. Select it by default in Kconfig. See bug #721096. Thanks to Max Steel sign-file: full functionality with modern LibreSSL Add Gentoo Linux support config settings and defaults. Support for ZSTD compressed kernel Signed-off-by: Mike Pagano gentoo.org> 0000_README | 56 +++ 1500_XATTR_USER_PREFIX.patch | 67 ++++ ...ble-link-security-restrictions-by-default.patch | 20 + ...zes-only-if-Secure-Simple-Pairing-enabled.patch | 37 ++ ...3-Fix-build-issue-by-selecting-CONFIG_REG.patch | 30 ++ ...0-Fix-build-issue-by-selecting-REGMAP-I2C.patch | 10 + 2920_sign-file-patch-for-libressl.patch | 16 + ..._ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch | 82 ++++ ...STD-v5-2-8-prepare-xxhash-for-preboot-env.patch | 94 +++++ ...STD-v5-3-8-add-zstd-support-to-decompress.patch | 422 +++++++++++++++++++++ ...-v5-4-8-add-support-for-zstd-compres-kern.patch | 65 ++++ ...add-support-for-zstd-compressed-initramfs.patch | 50 +++ ..._ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch | 20 + ...v5-7-8-support-for-ZSTD-compressed-kernel.patch | 92 +++++ ...5-8-8-gitignore-add-ZSTD-compressed-files.patch | 12 + 15 files changed, 1073 insertions(+) diff --git a/0000_README b/0000_README index 9018993..8373b37 100644 --- a/0000_README +++ b/0000_README @@ -43,6 +43,62 @@ EXPERIMENTAL Individual Patch Descriptions: -------------------------------------------------------------------------- +Patch: 1500_XATTR_USER_PREFIX.patch +From: https://bugs.gentoo.org/show_bug.cgi?id=470644 +Desc: Support for namespace user.pax.* on tmpfs. + +Patch: 1510_fs-enable-link-security-restrictions-by-default.patch +From: http://sources.debian.net/src/linux/3.16.7-ckt4-3/debian/patches/debian/fs-enable-link-security-restrictions-by-default.patch/ +Desc: Enable link security restrictions by default. + +Patch: 2000_BT-Check-key-sizes-only-if-Secure-Simple-Pairing-enabled.patch +From: https://lore.kernel.org/linux-bluetooth/20190522070540.48895-1-marcel@holtmann.org/raw +Desc: Bluetooth: Check key sizes only when Secure Simple Pairing is enabled. See bug #686758 + +Patch: 2900_tmp513-Fix-build-issue-by-selecting-CONFIG_REG.patch +From: https://bugs.gentoo.org/710790 +Desc: tmp513 requies REGMAP_I2C to build. Select it by default in Kconfig. See bug #710790. Thanks to Phil Stracchino + +Patch: 2910_TVP5150-Fix-build-issue-by-selecting-REGMAP-I2C.patch +From: https://bugs.gentoo.org/721096 +Desc: VIDEO_TVP5150 requies REGMAP_I2C to build. Select it by default in Kconfig. See bug #721096. Thanks to Max Steel + +Patch: 2920_sign-file-patch-for-libressl.patch +From: https://bugs.gentoo.org/717166 +Desc: sign-file: full functionality with modern LibreSSL + Patch: 4567_distro-Gentoo-Kconfig.patch From: Tom Wijsman Desc: Add Gentoo Linux support config settings and defaults. + +Patch: 5000_ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: lib: prepare zstd for preboot environment + +Patch: 5001_ZSTD-v5-2-8-prepare-xxhash-for-preboot-env.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: lib: prepare xxhash for preboot environment + +Patch: 5002_ZSTD-v5-3-8-add-zstd-support-to-decompress.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: lib: add zstd support to decompress + +Patch: 5003_ZSTD-v5-4-8-add-support-for-zstd-compres-kern.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: init: add support for zstd compressed kernel + +Patch: 5004_ZSTD-v5-5-8-add-support-for-zstd-compressed-initramfs.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: usr: add support for zstd compressed initramfs + +Patch: 5005_ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: x86: bump ZO_z_extra_bytes margin for zstd + +Patch: 5006_ZSTD-v5-7-8-support-for-ZSTD-compressed-kernel.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: x86: Add support for ZSTD compressed kernel + +Patch: 5007_ZSTD-v5-8-8-gitignore-add-ZSTD-compressed-files.patch +From: https://lkml.org/lkml/2020/4/1/29 +Desc: .gitignore: add ZSTD-compressed files diff --git a/1500_XATTR_USER_PREFIX.patch b/1500_XATTR_USER_PREFIX.patch new file mode 100644 index 0000000..245dcc2 --- /dev/null +++ b/1500_XATTR_USER_PREFIX.patch @@ -0,0 +1,67 @@ +From: Anthony G. Basile + +This patch adds support for a restricted user-controlled namespace on +tmpfs filesystem used to house PaX flags. The namespace must be of the +form user.pax.* and its value cannot exceed a size of 8 bytes. + +This is needed even on all Gentoo systems so that XATTR_PAX flags +are preserved for users who might build packages using portage on +a tmpfs system with a non-hardened kernel and then switch to a +hardened kernel with XATTR_PAX enabled. + +The namespace is added to any user with Extended Attribute support +enabled for tmpfs. Users who do not enable xattrs will not have +the XATTR_PAX flags preserved. + +diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h +index 1590c49..5eab462 100644 +--- a/include/uapi/linux/xattr.h ++++ b/include/uapi/linux/xattr.h +@@ -73,5 +73,9 @@ + #define XATTR_POSIX_ACL_DEFAULT "posix_acl_default" + #define XATTR_NAME_POSIX_ACL_DEFAULT XATTR_SYSTEM_PREFIX XATTR_POSIX_ACL_DEFAULT + ++/* User namespace */ ++#define XATTR_PAX_PREFIX XATTR_USER_PREFIX "pax." ++#define XATTR_PAX_FLAGS_SUFFIX "flags" ++#define XATTR_NAME_PAX_FLAGS XATTR_PAX_PREFIX XATTR_PAX_FLAGS_SUFFIX + + #endif /* _UAPI_LINUX_XATTR_H */ +--- a/mm/shmem.c 2020-05-04 15:30:27.042035334 -0400 ++++ b/mm/shmem.c 2020-05-04 15:34:57.013881725 -0400 +@@ -3238,6 +3238,14 @@ static int shmem_xattr_handler_set(const + struct shmem_inode_info *info = SHMEM_I(inode); + + name = xattr_full_name(handler, name); ++ ++ if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) { ++ if (strcmp(name, XATTR_NAME_PAX_FLAGS)) ++ return -EOPNOTSUPP; ++ if (size > 8) ++ return -EINVAL; ++ } ++ + return simple_xattr_set(&info->xattrs, name, value, size, flags, NULL); + } + +@@ -3253,6 +3261,12 @@ static const struct xattr_handler shmem_ + .set = shmem_xattr_handler_set, + }; + ++static const struct xattr_handler shmem_user_xattr_handler = { ++ .prefix = XATTR_USER_PREFIX, ++ .get = shmem_xattr_handler_get, ++ .set = shmem_xattr_handler_set, ++}; ++ + static const struct xattr_handler *shmem_xattr_handlers[] = { + #ifdef CONFIG_TMPFS_POSIX_ACL + &posix_acl_access_xattr_handler, +@@ -3260,6 +3274,7 @@ static const struct xattr_handler *shmem + #endif + &shmem_security_xattr_handler, + &shmem_trusted_xattr_handler, ++ &shmem_user_xattr_handler, + NULL + }; + diff --git a/1510_fs-enable-link-security-restrictions-by-default.patch b/1510_fs-enable-link-security-restrictions-by-default.patch new file mode 100644 index 0000000..f0ed144 --- /dev/null +++ b/1510_fs-enable-link-security-restrictions-by-default.patch @@ -0,0 +1,20 @@ +From: Ben Hutchings +Subject: fs: Enable link security restrictions by default +Date: Fri, 02 Nov 2012 05:32:06 +0000 +Bug-Debian: https://bugs.debian.org/609455 +Forwarded: not-needed +This reverts commit 561ec64ae67ef25cac8d72bb9c4bfc955edfd415 +('VFS: don't do protected {sym,hard}links by default'). +--- a/fs/namei.c 2018-09-28 07:56:07.770005006 -0400 ++++ b/fs/namei.c 2018-09-28 07:56:43.370349204 -0400 +@@ -885,8 +885,8 @@ static inline void put_link(struct namei + path_put(&last->link); + } + +-int sysctl_protected_symlinks __read_mostly = 0; +-int sysctl_protected_hardlinks __read_mostly = 0; ++int sysctl_protected_symlinks __read_mostly = 1; ++int sysctl_protected_hardlinks __read_mostly = 1; + int sysctl_protected_fifos __read_mostly; + int sysctl_protected_regular __read_mostly; + diff --git a/2000_BT-Check-key-sizes-only-if-Secure-Simple-Pairing-enabled.patch b/2000_BT-Check-key-sizes-only-if-Secure-Simple-Pairing-enabled.patch new file mode 100644 index 0000000..394ad48 --- /dev/null +++ b/2000_BT-Check-key-sizes-only-if-Secure-Simple-Pairing-enabled.patch @@ -0,0 +1,37 @@ +The encryption is only mandatory to be enforced when both sides are using +Secure Simple Pairing and this means the key size check makes only sense +in that case. + +On legacy Bluetooth 2.0 and earlier devices like mice the encryption was +optional and thus causing an issue if the key size check is not bound to +using Secure Simple Pairing. + +Fixes: d5bb334a8e17 ("Bluetooth: Align minimum encryption key size for LE and BR/EDR connections") +Signed-off-by: Marcel Holtmann +Cc: stable@vger.kernel.org +--- + net/bluetooth/hci_conn.c | 9 +++++++-- + 1 file changed, 7 insertions(+), 2 deletions(-) + +diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c +index 3cf0764d5793..7516cdde3373 100644 +--- a/net/bluetooth/hci_conn.c ++++ b/net/bluetooth/hci_conn.c +@@ -1272,8 +1272,13 @@ int hci_conn_check_link_mode(struct hci_conn *conn) + return 0; + } + +- if (hci_conn_ssp_enabled(conn) && +- !test_bit(HCI_CONN_ENCRYPT, &conn->flags)) ++ /* If Secure Simple Pairing is not enabled, then legacy connection ++ * setup is used and no encryption or key sizes can be enforced. ++ */ ++ if (!hci_conn_ssp_enabled(conn)) ++ return 1; ++ ++ if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags)) + return 0; + + /* The minimum encryption key size needs to be enforced by the +-- +2.20.1 diff --git a/2900_tmp513-Fix-build-issue-by-selecting-CONFIG_REG.patch b/2900_tmp513-Fix-build-issue-by-selecting-CONFIG_REG.patch new file mode 100644 index 0000000..4335685 --- /dev/null +++ b/2900_tmp513-Fix-build-issue-by-selecting-CONFIG_REG.patch @@ -0,0 +1,30 @@ +From dc328d75a6f37f4ff11a81ae16b1ec88c3197640 Mon Sep 17 00:00:00 2001 +From: Mike Pagano +Date: Mon, 23 Mar 2020 08:20:06 -0400 +Subject: [PATCH 1/1] This driver requires REGMAP_I2C to build. Select it by + default in Kconfig. Reported at gentoo bugzilla: + https://bugs.gentoo.org/710790 +Cc: mpagano@gentoo.org + +Reported-by: Phil Stracchino + +Signed-off-by: Mike Pagano +--- + drivers/hwmon/Kconfig | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig +index 47ac20aee06f..530b4f29ba85 100644 +--- a/drivers/hwmon/Kconfig ++++ b/drivers/hwmon/Kconfig +@@ -1769,6 +1769,7 @@ config SENSORS_TMP421 + config SENSORS_TMP513 + tristate "Texas Instruments TMP513 and compatibles" + depends on I2C ++ select REGMAP_I2C + help + If you say yes here you get support for Texas Instruments TMP512, + and TMP513 temperature and power supply sensor chips. +-- +2.24.1 + diff --git a/2910_TVP5150-Fix-build-issue-by-selecting-REGMAP-I2C.patch b/2910_TVP5150-Fix-build-issue-by-selecting-REGMAP-I2C.patch new file mode 100644 index 0000000..1bc058e --- /dev/null +++ b/2910_TVP5150-Fix-build-issue-by-selecting-REGMAP-I2C.patch @@ -0,0 +1,10 @@ +--- a/drivers/media/i2c/Kconfig 2020-05-13 12:38:05.102903309 -0400 ++++ b/drivers/media/i2c/Kconfig 2020-05-13 12:38:51.283171977 -0400 +@@ -378,6 +378,7 @@ config VIDEO_TVP514X + config VIDEO_TVP5150 + tristate "Texas Instruments TVP5150 video decoder" + depends on VIDEO_V4L2 && I2C ++ select REGMAP_I2C + select V4L2_FWNODE + help + Support for the Texas Instruments TVP5150 video decoder. diff --git a/2920_sign-file-patch-for-libressl.patch b/2920_sign-file-patch-for-libressl.patch new file mode 100644 index 0000000..e6ec017 --- /dev/null +++ b/2920_sign-file-patch-for-libressl.patch @@ -0,0 +1,16 @@ +--- a/scripts/sign-file.c 2020-05-20 18:47:21.282820662 -0400 ++++ b/scripts/sign-file.c 2020-05-20 18:48:37.991081899 -0400 +@@ -41,9 +41,10 @@ + * signing with anything other than SHA1 - so we're stuck with that if such is + * the case. + */ +-#if defined(LIBRESSL_VERSION_NUMBER) || \ +- OPENSSL_VERSION_NUMBER < 0x10000000L || \ +- defined(OPENSSL_NO_CMS) ++#if defined(OPENSSL_NO_CMS) || \ ++ ( defined(LIBRESSL_VERSION_NUMBER) \ ++ && (LIBRESSL_VERSION_NUMBER < 0x3010000fL) ) || \ ++ OPENSSL_VERSION_NUMBER < 0x10000000L + #define USE_PKCS7 + #endif + #ifndef USE_PKCS7 diff --git a/5000_ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch b/5000_ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch new file mode 100644 index 0000000..297a8d4 --- /dev/null +++ b/5000_ZSTD-v5-1-8-prepare-zstd-for-preboot-env.patch @@ -0,0 +1,82 @@ +diff --git a/lib/zstd/decompress.c b/lib/zstd/decompress.c +index 269ee9a796c1..73ded63278cf 100644 +--- a/lib/zstd/decompress.c ++++ b/lib/zstd/decompress.c +@@ -2490,6 +2490,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream *zds, ZSTD_outBuffer *output, ZSTD_inB + } + } + ++#ifndef ZSTD_PREBOOT + EXPORT_SYMBOL(ZSTD_DCtxWorkspaceBound); + EXPORT_SYMBOL(ZSTD_initDCtx); + EXPORT_SYMBOL(ZSTD_decompressDCtx); +@@ -2529,3 +2530,4 @@ EXPORT_SYMBOL(ZSTD_insertBlock); + + MODULE_LICENSE("Dual BSD/GPL"); + MODULE_DESCRIPTION("Zstd Decompressor"); ++#endif +diff --git a/lib/zstd/fse_decompress.c b/lib/zstd/fse_decompress.c +index a84300e5a013..0b353530fb3f 100644 +--- a/lib/zstd/fse_decompress.c ++++ b/lib/zstd/fse_decompress.c +@@ -47,6 +47,7 @@ + ****************************************************************/ + #include "bitstream.h" + #include "fse.h" ++#include "zstd_internal.h" + #include + #include + #include /* memcpy, memset */ +@@ -60,14 +61,6 @@ + enum { FSE_static_assert = 1 / (int)(!!(c)) }; \ + } /* use only *after* variable declarations */ + +-/* check and forward error code */ +-#define CHECK_F(f) \ +- { \ +- size_t const e = f; \ +- if (FSE_isError(e)) \ +- return e; \ +- } +- + /* ************************************************************** + * Templates + ****************************************************************/ +diff --git a/lib/zstd/zstd_internal.h b/lib/zstd/zstd_internal.h +index 1a79fab9e13a..dac753397f86 100644 +--- a/lib/zstd/zstd_internal.h ++++ b/lib/zstd/zstd_internal.h +@@ -127,7 +127,14 @@ static const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG; + * Shared functions to include for inlining + *********************************************/ + ZSTD_STATIC void ZSTD_copy8(void *dst, const void *src) { +- memcpy(dst, src, 8); ++ /* ++ * zstd relies heavily on gcc being able to analyze and inline this ++ * memcpy() call, since it is called in a tight loop. Preboot mode ++ * is compiled in freestanding mode, which stops gcc from analyzing ++ * memcpy(). Use __builtin_memcpy() to tell gcc to analyze this as a ++ * regular memcpy(). ++ */ ++ __builtin_memcpy(dst, src, 8); + } + /*! ZSTD_wildcopy() : + * custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */ +@@ -137,13 +144,16 @@ ZSTD_STATIC void ZSTD_wildcopy(void *dst, const void *src, ptrdiff_t length) + const BYTE* ip = (const BYTE*)src; + BYTE* op = (BYTE*)dst; + BYTE* const oend = op + length; +- /* Work around https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81388. ++#if defined(GCC_VERSION) && GCC_VERSION >= 70000 && GCC_VERSION < 70200 ++ /* ++ * Work around https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81388. + * Avoid the bad case where the loop only runs once by handling the + * special case separately. This doesn't trigger the bug because it + * doesn't involve pointer/integer overflow. + */ + if (length <= 8) + return ZSTD_copy8(dst, src); ++#endif + do { + ZSTD_copy8(op, ip); + op += 8; diff --git a/5001_ZSTD-v5-2-8-prepare-xxhash-for-preboot-env.patch b/5001_ZSTD-v5-2-8-prepare-xxhash-for-preboot-env.patch new file mode 100644 index 0000000..88e4674 --- /dev/null +++ b/5001_ZSTD-v5-2-8-prepare-xxhash-for-preboot-env.patch @@ -0,0 +1,94 @@ +diff --git a/lib/xxhash.c b/lib/xxhash.c +index aa61e2a3802f..b4364e011392 100644 +--- a/lib/xxhash.c ++++ b/lib/xxhash.c +@@ -80,13 +80,11 @@ void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src) + { + memcpy(dst, src, sizeof(*dst)); + } +-EXPORT_SYMBOL(xxh32_copy_state); + + void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src) + { + memcpy(dst, src, sizeof(*dst)); + } +-EXPORT_SYMBOL(xxh64_copy_state); + + /*-*************************** + * Simple Hash Functions +@@ -151,7 +149,6 @@ uint32_t xxh32(const void *input, const size_t len, const uint32_t seed) + + return h32; + } +-EXPORT_SYMBOL(xxh32); + + static uint64_t xxh64_round(uint64_t acc, const uint64_t input) + { +@@ -234,7 +231,6 @@ uint64_t xxh64(const void *input, const size_t len, const uint64_t seed) + + return h64; + } +-EXPORT_SYMBOL(xxh64); + + /*-************************************************** + * Advanced Hash Functions +@@ -251,7 +247,6 @@ void xxh32_reset(struct xxh32_state *statePtr, const uint32_t seed) + state.v4 = seed - PRIME32_1; + memcpy(statePtr, &state, sizeof(state)); + } +-EXPORT_SYMBOL(xxh32_reset); + + void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed) + { +@@ -265,7 +260,6 @@ void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed) + state.v4 = seed - PRIME64_1; + memcpy(statePtr, &state, sizeof(state)); + } +-EXPORT_SYMBOL(xxh64_reset); + + int xxh32_update(struct xxh32_state *state, const void *input, const size_t len) + { +@@ -334,7 +328,6 @@ int xxh32_update(struct xxh32_state *state, const void *input, const size_t len) + + return 0; + } +-EXPORT_SYMBOL(xxh32_update); + + uint32_t xxh32_digest(const struct xxh32_state *state) + { +@@ -372,7 +365,6 @@ uint32_t xxh32_digest(const struct xxh32_state *state) + + return h32; + } +-EXPORT_SYMBOL(xxh32_digest); + + int xxh64_update(struct xxh64_state *state, const void *input, const size_t len) + { +@@ -439,7 +431,6 @@ int xxh64_update(struct xxh64_state *state, const void *input, const size_t len) + + return 0; + } +-EXPORT_SYMBOL(xxh64_update); + + uint64_t xxh64_digest(const struct xxh64_state *state) + { +@@ -494,7 +485,19 @@ uint64_t xxh64_digest(const struct xxh64_state *state) + + return h64; + } ++ ++#ifndef XXH_PREBOOT ++EXPORT_SYMBOL(xxh32_copy_state); ++EXPORT_SYMBOL(xxh64_copy_state); ++EXPORT_SYMBOL(xxh32); ++EXPORT_SYMBOL(xxh64); ++EXPORT_SYMBOL(xxh32_reset); ++EXPORT_SYMBOL(xxh64_reset); ++EXPORT_SYMBOL(xxh32_update); ++EXPORT_SYMBOL(xxh32_digest); ++EXPORT_SYMBOL(xxh64_update); + EXPORT_SYMBOL(xxh64_digest); + + MODULE_LICENSE("Dual BSD/GPL"); + MODULE_DESCRIPTION("xxHash"); ++#endif diff --git a/5002_ZSTD-v5-3-8-add-zstd-support-to-decompress.patch b/5002_ZSTD-v5-3-8-add-zstd-support-to-decompress.patch new file mode 100644 index 0000000..1c22fa3 --- /dev/null +++ b/5002_ZSTD-v5-3-8-add-zstd-support-to-decompress.patch @@ -0,0 +1,422 @@ +diff --git a/include/linux/decompress/unzstd.h b/include/linux/decompress/unzstd.h +new file mode 100644 +index 000000000000..56d539ae880f +--- /dev/null ++++ b/include/linux/decompress/unzstd.h +@@ -0,0 +1,11 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++#ifndef LINUX_DECOMPRESS_UNZSTD_H ++#define LINUX_DECOMPRESS_UNZSTD_H ++ ++int unzstd(unsigned char *inbuf, long len, ++ long (*fill)(void*, unsigned long), ++ long (*flush)(void*, unsigned long), ++ unsigned char *output, ++ long *pos, ++ void (*error_fn)(char *x)); ++#endif +diff --git a/lib/Kconfig b/lib/Kconfig +index 5d53f9609c25..e883aecb9279 100644 +--- a/lib/Kconfig ++++ b/lib/Kconfig +@@ -336,6 +336,10 @@ config DECOMPRESS_LZ4 + select LZ4_DECOMPRESS + tristate + ++config DECOMPRESS_ZSTD ++ select ZSTD_DECOMPRESS ++ tristate ++ + # + # Generic allocator support is selected if needed + # +diff --git a/lib/Makefile b/lib/Makefile +index ab68a8674360..3ce4ac296611 100644 +--- a/lib/Makefile ++++ b/lib/Makefile +@@ -166,6 +166,7 @@ lib-$(CONFIG_DECOMPRESS_LZMA) += decompress_unlzma.o + lib-$(CONFIG_DECOMPRESS_XZ) += decompress_unxz.o + lib-$(CONFIG_DECOMPRESS_LZO) += decompress_unlzo.o + lib-$(CONFIG_DECOMPRESS_LZ4) += decompress_unlz4.o ++lib-$(CONFIG_DECOMPRESS_ZSTD) += decompress_unzstd.o + + obj-$(CONFIG_TEXTSEARCH) += textsearch.o + obj-$(CONFIG_TEXTSEARCH_KMP) += ts_kmp.o +diff --git a/lib/decompress.c b/lib/decompress.c +index 857ab1af1ef3..ab3fc90ffc64 100644 +--- a/lib/decompress.c ++++ b/lib/decompress.c +@@ -13,6 +13,7 @@ + #include + #include + #include ++#include + + #include + #include +@@ -37,6 +38,9 @@ + #ifndef CONFIG_DECOMPRESS_LZ4 + # define unlz4 NULL + #endif ++#ifndef CONFIG_DECOMPRESS_ZSTD ++# define unzstd NULL ++#endif + + struct compress_format { + unsigned char magic[2]; +@@ -52,6 +56,7 @@ static const struct compress_format compressed_formats[] __initconst = { + { {0xfd, 0x37}, "xz", unxz }, + { {0x89, 0x4c}, "lzo", unlzo }, + { {0x02, 0x21}, "lz4", unlz4 }, ++ { {0x28, 0xb5}, "zstd", unzstd }, + { {0, 0}, NULL, NULL } + }; + +diff --git a/lib/decompress_unzstd.c b/lib/decompress_unzstd.c +new file mode 100644 +index 000000000000..f317afab502f +--- /dev/null ++++ b/lib/decompress_unzstd.c +@@ -0,0 +1,342 @@ ++// SPDX-License-Identifier: GPL-2.0 ++ ++/* ++ * Important notes about in-place decompression ++ * ++ * At least on x86, the kernel is decompressed in place: the compressed data ++ * is placed to the end of the output buffer, and the decompressor overwrites ++ * most of the compressed data. There must be enough safety margin to ++ * guarantee that the write position is always behind the read position. ++ * ++ * The safety margin for ZSTD with a 128 KB block size is calculated below. ++ * Note that the margin with ZSTD is bigger than with GZIP or XZ! ++ * ++ * The worst case for in-place decompression is that the beginning of ++ * the file is compressed extremely well, and the rest of the file is ++ * uncompressible. Thus, we must look for worst-case expansion when the ++ * compressor is encoding uncompressible data. ++ * ++ * The structure of the .zst file in case of a compresed kernel is as follows. ++ * Maximum sizes (as bytes) of the fields are in parenthesis. ++ * ++ * Frame Header: (18) ++ * Blocks: (N) ++ * Checksum: (4) ++ * ++ * The frame header and checksum overhead is at most 22 bytes. ++ * ++ * ZSTD stores the data in blocks. Each block has a header whose size is ++ * a 3 bytes. After the block header, there is up to 128 KB of payload. ++ * The maximum uncompressed size of the payload is 128 KB. The minimum ++ * uncompressed size of the payload is never less than the payload size ++ * (excluding the block header). ++ * ++ * The assumption, that the uncompressed size of the payload is never ++ * smaller than the payload itself, is valid only when talking about ++ * the payload as a whole. It is possible that the payload has parts where ++ * the decompressor consumes more input than it produces output. Calculating ++ * the worst case for this would be tricky. Instead of trying to do that, ++ * let's simply make sure that the decompressor never overwrites any bytes ++ * of the payload which it is currently reading. ++ * ++ * Now we have enough information to calculate the safety margin. We need ++ * - 22 bytes for the .zst file format headers; ++ * - 3 bytes per every 128 KiB of uncompressed size (one block header per ++ * block); and ++ * - 128 KiB (biggest possible zstd block size) to make sure that the ++ * decompressor never overwrites anything from the block it is currently ++ * reading. ++ * ++ * We get the following formula: ++ * ++ * safety_margin = 22 + uncompressed_size * 3 / 131072 + 131072 ++ * <= 22 + (uncompressed_size >> 15) + 131072 ++ */ ++ ++/* ++ * Preboot environments #include "path/to/decompress_unzstd.c". ++ * All of the source files we depend on must be #included. ++ * zstd's only source dependeny is xxhash, which has no source ++ * dependencies. ++ * ++ * zstd and xxhash avoid declaring themselves as modules ++ * when ZSTD_PREBOOT and XXH_PREBOOT are defined. ++ */ ++#ifdef STATIC ++# define ZSTD_PREBOOT ++# define XXH_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" ++#endif ++ ++#include ++#include ++#include ++ ++/* 128MB is the maximum window size supported by zstd. */ ++#define ZSTD_WINDOWSIZE_MAX (1 << ZSTD_WINDOWLOG_MAX) ++/* Size of the input and output buffers in multi-call mode. ++ * Pick a larger size because it isn't used during kernel decompression, ++ * since that is single pass, and we have to allocate a large buffer for ++ * zstd's window anyways. The larger size speeds up initramfs decompression. ++ */ ++#define ZSTD_IOBUF_SIZE (1 << 17) ++ ++static int INIT handle_zstd_error(size_t ret, void (*error)(char *x)) ++{ ++ const int err = ZSTD_getErrorCode(ret); ++ ++ if (!ZSTD_isError(ret)) ++ return 0; ++ ++ switch (err) { ++ case ZSTD_error_memory_allocation: ++ error("ZSTD decompressor ran out of memory"); ++ break; ++ case ZSTD_error_prefix_unknown: ++ error("Input is not in the ZSTD format (wrong magic bytes)"); ++ break; ++ case ZSTD_error_dstSize_tooSmall: ++ case ZSTD_error_corruption_detected: ++ case ZSTD_error_checksum_wrong: ++ error("ZSTD-compressed data is corrupt"); ++ break; ++ default: ++ error("ZSTD-compressed data is probably corrupt"); ++ break; ++ } ++ return -1; ++} ++ ++/* ++ * Handle the case where we have the entire input and output in one segment. ++ * We can allocate less memory (no circular buffer for the sliding window), ++ * and avoid some memcpy() calls. ++ */ ++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(); ++ void *wksp = large_malloc(wksp_size); ++ ZSTD_DCtx *dctx = ZSTD_initDCtx(wksp, wksp_size); ++ int err; ++ size_t ret; ++ ++ if (dctx == NULL) { ++ 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. ++ */ ++ ret = ZSTD_findFrameCompressedSize(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); ++ err = handle_zstd_error(ret, error); ++ if (err) ++ goto out; ++ ++ if (in_pos != NULL) ++ *in_pos = in_len; ++ ++ err = 0; ++out: ++ if (wksp != NULL) ++ large_free(wksp); ++ return err; ++} ++ ++static int INIT __unzstd(unsigned char *in_buf, long in_len, ++ long (*fill)(void*, unsigned long), ++ long (*flush)(void*, unsigned long), ++ unsigned char *out_buf, long out_len, ++ long *in_pos, ++ void (*error)(char *x)) ++{ ++ ZSTD_inBuffer in; ++ ZSTD_outBuffer out; ++ ZSTD_frameParams params; ++ void *in_allocated = NULL; ++ void *out_allocated = NULL; ++ void *wksp = NULL; ++ size_t wksp_size; ++ ZSTD_DStream *dstream; ++ int err; ++ size_t ret; ++ ++ if (out_len == 0) ++ out_len = LONG_MAX; /* no limit */ ++ ++ if (fill == NULL && flush == NULL) ++ /* ++ * We can decompress faster and with less memory when we have a ++ * single chunk. ++ */ ++ return decompress_single(in_buf, in_len, out_buf, out_len, ++ in_pos, error); ++ ++ /* ++ * If in_buf is not provided, we must be using fill(), so allocate ++ * a large enough buffer. If it is provided, it must be at least ++ * ZSTD_IOBUF_SIZE large. ++ */ ++ if (in_buf == NULL) { ++ in_allocated = large_malloc(ZSTD_IOBUF_SIZE); ++ if (in_allocated == NULL) { ++ error("Out of memory while allocating input buffer"); ++ err = -1; ++ goto out; ++ } ++ in_buf = in_allocated; ++ in_len = 0; ++ } ++ /* Read the first chunk, since we need to decode the frame header. */ ++ if (fill != NULL) ++ in_len = fill(in_buf, ZSTD_IOBUF_SIZE); ++ if (in_len < 0) { ++ error("ZSTD-compressed data is truncated"); ++ err = -1; ++ goto out; ++ } ++ /* Set the first non-empty input buffer. */ ++ in.src = in_buf; ++ in.pos = 0; ++ in.size = in_len; ++ /* Allocate the output buffer if we are using flush(). */ ++ if (flush != NULL) { ++ out_allocated = large_malloc(ZSTD_IOBUF_SIZE); ++ if (out_allocated == NULL) { ++ error("Out of memory while allocating output buffer"); ++ err = -1; ++ goto out; ++ } ++ out_buf = out_allocated; ++ out_len = ZSTD_IOBUF_SIZE; ++ } ++ /* Set the output buffer. */ ++ out.dst = out_buf; ++ out.pos = 0; ++ out.size = out_len; ++ ++ /* ++ * 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(¶ms, in.src, in.size); ++ err = handle_zstd_error(ret, error); ++ if (err) ++ goto out; ++ if (ret != 0) { ++ error("ZSTD-compressed data has an incomplete frame header"); ++ err = -1; ++ goto out; ++ } ++ if (params.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 ++ * required. ++ */ ++ wksp_size = ZSTD_DStreamWorkspaceBound(params.windowSize); ++ wksp = large_malloc(wksp_size); ++ dstream = ZSTD_initDStream(params.windowSize, wksp, wksp_size); ++ if (dstream == NULL) { ++ error("Out of memory while allocating ZSTD_DStream"); ++ err = -1; ++ goto out; ++ } ++ ++ /* ++ * Decompression loop: ++ * Read more data if necessary (error if no more data can be read). ++ * Call the decompression function, which returns 0 when finished. ++ * Flush any data produced if using flush(). ++ */ ++ if (in_pos != NULL) ++ *in_pos = 0; ++ do { ++ /* ++ * If we need to reload data, either we have fill() and can ++ * try to get more data, or we don't and the input is truncated. ++ */ ++ if (in.pos == in.size) { ++ if (in_pos != NULL) ++ *in_pos += in.pos; ++ in_len = fill ? fill(in_buf, ZSTD_IOBUF_SIZE) : -1; ++ if (in_len < 0) { ++ error("ZSTD-compressed data is truncated"); ++ err = -1; ++ goto out; ++ } ++ in.pos = 0; ++ in.size = in_len; ++ } ++ /* Returns zero when the frame is complete. */ ++ ret = ZSTD_decompressStream(dstream, &out, &in); ++ err = handle_zstd_error(ret, error); ++ if (err) ++ goto out; ++ /* Flush all of the data produced if using flush(). */ ++ if (flush != NULL && out.pos > 0) { ++ if (out.pos != flush(out.dst, out.pos)) { ++ error("Failed to flush()"); ++ err = -1; ++ goto out; ++ } ++ out.pos = 0; ++ } ++ } while (ret != 0); ++ ++ if (in_pos != NULL) ++ *in_pos += in.pos; ++ ++ err = 0; ++out: ++ if (in_allocated != NULL) ++ large_free(in_allocated); ++ if (out_allocated != NULL) ++ large_free(out_allocated); ++ if (wksp != NULL) ++ large_free(wksp); ++ return err; ++} ++ ++#ifndef ZSTD_PREBOOT ++STATIC int INIT unzstd(unsigned char *buf, long len, ++ long (*fill)(void*, unsigned long), ++ long (*flush)(void*, unsigned long), ++ unsigned char *out_buf, ++ long *pos, ++ void (*error)(char *x)) ++{ ++ return __unzstd(buf, len, fill, flush, out_buf, 0, pos, error); ++} ++#else ++STATIC int INIT __decompress(unsigned char *buf, long len, ++ long (*fill)(void*, unsigned long), ++ long (*flush)(void*, unsigned long), ++ unsigned char *out_buf, long out_len, ++ long *pos, ++ void (*error)(char *x)) ++{ ++ return __unzstd(buf, len, fill, flush, out_buf, out_len, pos, error); ++} ++#endif diff --git a/5003_ZSTD-v5-4-8-add-support-for-zstd-compres-kern.patch b/5003_ZSTD-v5-4-8-add-support-for-zstd-compres-kern.patch new file mode 100644 index 0000000..d9dc79e --- /dev/null +++ b/5003_ZSTD-v5-4-8-add-support-for-zstd-compres-kern.patch @@ -0,0 +1,65 @@ +diff --git a/init/Kconfig b/init/Kconfig +index 492bb7000aa4..806874fdd663 100644 +--- a/init/Kconfig ++++ b/init/Kconfig +@@ -176,13 +176,16 @@ config HAVE_KERNEL_LZO + config HAVE_KERNEL_LZ4 + bool + ++config HAVE_KERNEL_ZSTD ++ bool ++ + config HAVE_KERNEL_UNCOMPRESSED + bool + + choice + prompt "Kernel compression mode" + default KERNEL_GZIP +- depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO || HAVE_KERNEL_LZ4 || HAVE_KERNEL_UNCOMPRESSED ++ depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO || HAVE_KERNEL_LZ4 || HAVE_KERNEL_ZSTD || HAVE_KERNEL_UNCOMPRESSED + help + The linux kernel is a kind of self-extracting executable. + Several compression algorithms are available, which differ +@@ -261,6 +264,16 @@ config KERNEL_LZ4 + is about 8% bigger than LZO. But the decompression speed is + faster than LZO. + ++config KERNEL_ZSTD ++ bool "ZSTD" ++ depends on HAVE_KERNEL_ZSTD ++ help ++ ZSTD is a compression algorithm targeting intermediate compression ++ with fast decompression speed. It will compress better than GZIP and ++ decompress around the same speed as LZO, but slower than LZ4. You ++ will need at least 192 KB RAM or more for booting. The zstd command ++ line tools is required for compression. ++ + config KERNEL_UNCOMPRESSED + bool "None" + depends on HAVE_KERNEL_UNCOMPRESSED +diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib +index b12dd5ba4896..efe69b78d455 100644 +--- a/scripts/Makefile.lib ++++ b/scripts/Makefile.lib +@@ -405,6 +405,21 @@ quiet_cmd_xzkern = XZKERN $@ + quiet_cmd_xzmisc = XZMISC $@ + cmd_xzmisc = cat $(real-prereqs) | xz --check=crc32 --lzma2=dict=1MiB > $@ + ++# ZSTD ++# --------------------------------------------------------------------------- ++# Appends the uncompressed size of the data using size_append. The .zst ++# format has the size information available at the beginning of the file too, ++# but it's in a more complex format and it's good to avoid changing the part ++# of the boot code that reads the uncompressed size. ++# Note that the bytes added by size_append will make the zstd tool think that ++# the file is corrupt. This is expected. ++ ++quiet_cmd_zstd = ZSTD $@ ++cmd_zstd = (cat $(filter-out FORCE,$^) | \ ++ zstd -19 && \ ++ $(call size_append, $(filter-out FORCE,$^))) > $@ || \ ++ (rm -f $@ ; false) ++ + # ASM offsets + # --------------------------------------------------------------------------- + diff --git a/5004_ZSTD-v5-5-8-add-support-for-zstd-compressed-initramfs.patch b/5004_ZSTD-v5-5-8-add-support-for-zstd-compressed-initramfs.patch new file mode 100644 index 0000000..0096db1 --- /dev/null +++ b/5004_ZSTD-v5-5-8-add-support-for-zstd-compressed-initramfs.patch @@ -0,0 +1,50 @@ +diff --git a/usr/Kconfig b/usr/Kconfig +index 96afb03b65f9..2599bc21c1b2 100644 +--- a/usr/Kconfig ++++ b/usr/Kconfig +@@ -100,6 +100,15 @@ config RD_LZ4 + Support loading of a LZ4 encoded initial ramdisk or cpio buffer + If unsure, say N. + ++config RD_ZSTD ++ bool "Support initial ramdisk/ramfs compressed using ZSTD" ++ default y ++ depends on BLK_DEV_INITRD ++ select DECOMPRESS_ZSTD ++ help ++ Support loading of a ZSTD encoded initial ramdisk or cpio buffer. ++ If unsure, say N. ++ + choice + prompt "Built-in initramfs compression mode" + depends on INITRAMFS_SOURCE != "" +@@ -196,6 +205,17 @@ config INITRAMFS_COMPRESSION_LZ4 + If you choose this, keep in mind that most distros don't provide lz4 + by default which could cause a build failure. + ++config INITRAMFS_COMPRESSION_ZSTD ++ bool "ZSTD" ++ depends on RD_ZSTD ++ help ++ ZSTD is a compression algorithm targeting intermediate compression ++ with fast decompression speed. It will compress better than GZIP and ++ decompress around the same speed as LZO, but slower than LZ4. ++ ++ If you choose this, keep in mind that you may need to install the zstd ++ tool to be able to compress the initram. ++ + config INITRAMFS_COMPRESSION_NONE + bool "None" + help +diff --git a/usr/Makefile b/usr/Makefile +index c12e6b15ce72..b1a81a40eab1 100644 +--- a/usr/Makefile ++++ b/usr/Makefile +@@ -15,6 +15,7 @@ compress-$(CONFIG_INITRAMFS_COMPRESSION_LZMA) := lzma + compress-$(CONFIG_INITRAMFS_COMPRESSION_XZ) := xzmisc + compress-$(CONFIG_INITRAMFS_COMPRESSION_LZO) := lzo + compress-$(CONFIG_INITRAMFS_COMPRESSION_LZ4) := lz4 ++compress-$(CONFIG_INITRAMFS_COMPRESSION_ZSTD) := zstd + + obj-$(CONFIG_BLK_DEV_INITRD) := initramfs_data.o + diff --git a/5005_ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch b/5005_ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch new file mode 100644 index 0000000..4e86d56 --- /dev/null +++ b/5005_ZSTD-v5-6-8-bump-ZO-z-extra-bytes-margin.patch @@ -0,0 +1,20 @@ +diff --git a/arch/x86/boot/header.S b/arch/x86/boot/header.S +index 735ad7f21ab0..6dbd7e9f74c9 100644 +--- a/arch/x86/boot/header.S ++++ b/arch/x86/boot/header.S +@@ -539,8 +539,14 @@ pref_address: .quad LOAD_PHYSICAL_ADDR # preferred load addr + # the size-dependent part now grows so fast. + # + # extra_bytes = (uncompressed_size >> 8) + 65536 ++# ++# ZSTD compressed data grows by at most 3 bytes per 128K, and only has a 22 ++# byte fixed overhead but has a maximum block size of 128K, so it needs a ++# larger margin. ++# ++# extra_bytes = (uncompressed_size >> 8) + 131072 + +-#define ZO_z_extra_bytes ((ZO_z_output_len >> 8) + 65536) ++#define ZO_z_extra_bytes ((ZO_z_output_len >> 8) + 131072) + #if ZO_z_output_len > ZO_z_input_len + # define ZO_z_extract_offset (ZO_z_output_len + ZO_z_extra_bytes - \ + ZO_z_input_len) diff --git a/5006_ZSTD-v5-7-8-support-for-ZSTD-compressed-kernel.patch b/5006_ZSTD-v5-7-8-support-for-ZSTD-compressed-kernel.patch new file mode 100644 index 0000000..6147136 --- /dev/null +++ b/5006_ZSTD-v5-7-8-support-for-ZSTD-compressed-kernel.patch @@ -0,0 +1,92 @@ +diff --git a/Documentation/x86/boot.rst b/Documentation/x86/boot.rst +index fa7ddc0428c8..0404e99dc1d4 100644 +--- a/Documentation/x86/boot.rst ++++ b/Documentation/x86/boot.rst +@@ -782,9 +782,9 @@ Protocol: 2.08+ + uncompressed data should be determined using the standard magic + numbers. The currently supported compression formats are gzip + (magic numbers 1F 8B or 1F 9E), bzip2 (magic number 42 5A), LZMA +- (magic number 5D 00), XZ (magic number FD 37), and LZ4 (magic number +- 02 21). The uncompressed payload is currently always ELF (magic +- number 7F 45 4C 46). ++ (magic number 5D 00), XZ (magic number FD 37), LZ4 (magic number ++ 02 21) and ZSTD (magic number 28 B5). The uncompressed payload is ++ currently always ELF (magic number 7F 45 4C 46). + + ============ ============== + Field name: payload_length +diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig +index 886fa8368256..912f783bc01a 100644 +--- a/arch/x86/Kconfig ++++ b/arch/x86/Kconfig +@@ -185,6 +185,7 @@ config X86 + select HAVE_KERNEL_LZMA + select HAVE_KERNEL_LZO + select HAVE_KERNEL_XZ ++ select HAVE_KERNEL_ZSTD + select HAVE_KPROBES + select HAVE_KPROBES_ON_FTRACE + select HAVE_FUNCTION_ERROR_INJECTION +diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile +index 7619742f91c9..471e61400a2e 100644 +--- a/arch/x86/boot/compressed/Makefile ++++ b/arch/x86/boot/compressed/Makefile +@@ -26,7 +26,7 @@ OBJECT_FILES_NON_STANDARD := y + KCOV_INSTRUMENT := n + + targets := vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2 vmlinux.bin.lzma \ +- vmlinux.bin.xz vmlinux.bin.lzo vmlinux.bin.lz4 ++ vmlinux.bin.xz vmlinux.bin.lzo vmlinux.bin.lz4 vmlinux.bin.zst + + KBUILD_CFLAGS := -m$(BITS) -O2 + KBUILD_CFLAGS += -fno-strict-aliasing $(call cc-option, -fPIE, -fPIC) +@@ -145,6 +145,8 @@ $(obj)/vmlinux.bin.lzo: $(vmlinux.bin.all-y) FORCE + $(call if_changed,lzo) + $(obj)/vmlinux.bin.lz4: $(vmlinux.bin.all-y) FORCE + $(call if_changed,lz4) ++$(obj)/vmlinux.bin.zst: $(vmlinux.bin.all-y) FORCE ++ $(call if_changed,zstd) + + suffix-$(CONFIG_KERNEL_GZIP) := gz + suffix-$(CONFIG_KERNEL_BZIP2) := bz2 +@@ -152,6 +154,7 @@ suffix-$(CONFIG_KERNEL_LZMA) := lzma + suffix-$(CONFIG_KERNEL_XZ) := xz + suffix-$(CONFIG_KERNEL_LZO) := lzo + suffix-$(CONFIG_KERNEL_LZ4) := lz4 ++suffix-$(CONFIG_KERNEL_ZSTD) := zst + + quiet_cmd_mkpiggy = MKPIGGY $@ + cmd_mkpiggy = $(obj)/mkpiggy $< > $@ +diff --git a/arch/x86/boot/compressed/misc.c b/arch/x86/boot/compressed/misc.c +index 9652d5c2afda..39e592d0e0b4 100644 +--- a/arch/x86/boot/compressed/misc.c ++++ b/arch/x86/boot/compressed/misc.c +@@ -77,6 +77,10 @@ static int lines, cols; + #ifdef CONFIG_KERNEL_LZ4 + #include "../../../../lib/decompress_unlz4.c" + #endif ++ ++#ifdef CONFIG_KERNEL_ZSTD ++#include "../../../../lib/decompress_unzstd.c" ++#endif + /* + * NOTE: When adding a new decompressor, please update the analysis in + * ../header.S. +diff --git a/arch/x86/include/asm/boot.h b/arch/x86/include/asm/boot.h +index 680c320363db..d6dd43d25d9f 100644 +--- a/arch/x86/include/asm/boot.h ++++ b/arch/x86/include/asm/boot.h +@@ -24,9 +24,11 @@ + # error "Invalid value for CONFIG_PHYSICAL_ALIGN" + #endif + +-#ifdef CONFIG_KERNEL_BZIP2 ++#if defined(CONFIG_KERNEL_BZIP2) + # define BOOT_HEAP_SIZE 0x400000 +-#else /* !CONFIG_KERNEL_BZIP2 */ ++#elif defined(CONFIG_KERNEL_ZSTD) ++# define BOOT_HEAP_SIZE 0x30000 ++#else + # define BOOT_HEAP_SIZE 0x10000 + #endif + diff --git a/5007_ZSTD-v5-8-8-gitignore-add-ZSTD-compressed-files.patch b/5007_ZSTD-v5-8-8-gitignore-add-ZSTD-compressed-files.patch new file mode 100644 index 0000000..adf8578 --- /dev/null +++ b/5007_ZSTD-v5-8-8-gitignore-add-ZSTD-compressed-files.patch @@ -0,0 +1,12 @@ +diff --git a/.gitignore b/.gitignore +index 2258e906f01c..23871de69072 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -44,6 +44,7 @@ + *.tab.[ch] + *.tar + *.xz ++*.zst + Module.symvers + modules.builtin + modules.order