diff options
Diffstat (limited to 'patch-5.17-redhat.patch')
| -rw-r--r-- | patch-5.17-redhat.patch | 507 |
1 files changed, 375 insertions, 132 deletions
diff --git a/patch-5.17-redhat.patch b/patch-5.17-redhat.patch index f733277f9..0055f7ffb 100644 --- a/patch-5.17-redhat.patch +++ b/patch-5.17-redhat.patch @@ -1,6 +1,6 @@ Documentation/admin-guide/kernel-parameters.txt | 9 + Kconfig | 2 + - Kconfig.redhat | 17 ++ + Kconfig.redhat | 17 + Makefile | 12 +- arch/arm/Kconfig | 4 +- arch/arm64/Kconfig | 3 +- @@ -9,22 +9,22 @@ arch/s390/kernel/ipl.c | 5 + arch/s390/kernel/setup.c | 4 + arch/x86/kernel/cpu/common.c | 1 + - arch/x86/kernel/setup.c | 70 ++++- - crypto/rng.c | 73 ++++- + arch/x86/kernel/setup.c | 70 ++- + crypto/rng.c | 73 ++- drivers/acpi/apei/hest.c | 8 + drivers/acpi/irq.c | 17 +- drivers/acpi/scan.c | 9 + - drivers/ata/libahci.c | 18 ++ - drivers/char/ipmi/ipmi_dmi.c | 15 ++ + drivers/ata/libahci.c | 18 + + drivers/char/ipmi/ipmi_dmi.c | 15 + drivers/char/ipmi/ipmi_msghandler.c | 16 +- - drivers/char/random.c | 115 ++++++++ + drivers/char/random.c | 115 +++++ drivers/firmware/efi/Makefile | 1 + - drivers/firmware/efi/efi.c | 124 ++++++--- - drivers/firmware/efi/secureboot.c | 38 +++ - drivers/hid/hid-rmi.c | 64 ----- - drivers/hwtracing/coresight/coresight-etm4x-core.c | 19 ++ - drivers/input/rmi4/rmi_driver.c | 124 +++++---- - drivers/iommu/iommu.c | 22 ++ + drivers/firmware/efi/efi.c | 124 +++-- + drivers/firmware/efi/secureboot.c | 38 ++ + drivers/hid/hid-rmi.c | 64 --- + drivers/hwtracing/coresight/coresight-etm4x-core.c | 19 + + drivers/input/rmi4/rmi_driver.c | 124 +++-- + drivers/iommu/iommu.c | 22 + drivers/message/fusion/mptsas.c | 10 + drivers/message/fusion/mptspi.c | 11 + drivers/net/ethernet/intel/e1000/e1000_main.c | 2 + @@ -33,8 +33,8 @@ drivers/nvme/host/core.c | 22 +- drivers/nvme/host/multipath.c | 19 +- drivers/nvme/host/nvme.h | 4 + - drivers/pci/pci-driver.c | 78 ++++++ - drivers/pci/quirks.c | 24 ++ + drivers/pci/pci-driver.c | 78 ++++ + drivers/pci/quirks.c | 24 + drivers/scsi/aacraid/linit.c | 2 + drivers/scsi/be2iscsi/be_main.c | 2 + drivers/scsi/hpsa.c | 4 + @@ -44,27 +44,28 @@ drivers/scsi/qla2xxx/qla_os.c | 6 + drivers/scsi/qla4xxx/ql4_os.c | 2 + drivers/usb/core/hub.c | 7 + + drivers/virtio/virtio_mem.c | 13 + fs/ext4/super.c | 5 + fs/xfs/xfs_super.c | 5 + include/linux/efi.h | 22 +- - include/linux/kernel.h | 19 ++ + include/linux/kernel.h | 19 + include/linux/lsm_hook_defs.h | 2 + include/linux/lsm_hooks.h | 6 + include/linux/mmzone.h | 4 +- include/linux/module.h | 1 + include/linux/panic.h | 19 +- - include/linux/pci.h | 16 ++ + include/linux/pci.h | 16 + include/linux/random.h | 7 + - include/linux/rh_kabi.h | 297 +++++++++++++++++++++ + include/linux/rh_kabi.h | 515 +++++++++++++++++++++ include/linux/rmi.h | 1 + include/linux/security.h | 5 + init/Kconfig | 2 +- kernel/Makefile | 1 + - kernel/bpf/syscall.c | 18 ++ + kernel/bpf/syscall.c | 18 + kernel/module.c | 2 + kernel/module_signing.c | 9 +- kernel/panic.c | 14 + - kernel/rh_messages.c | 179 +++++++++++++ + kernel/rh_messages.c | 179 +++++++ kernel/sysctl.c | 5 + mm/cma.c | 10 + scripts/mod/modpost.c | 8 + @@ -75,7 +76,7 @@ security/security.c | 6 + tools/lib/subcmd/subcmd-util.h | 9 +- tools/objtool/check.c | 2 +- - 77 files changed, 1518 insertions(+), 197 deletions(-) + 78 files changed, 1749 insertions(+), 197 deletions(-) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index f5a27f067db9..f4dc42f2f82a 100644 @@ -2097,6 +2098,30 @@ index 47a1c8bddf86..e309d992e2ad 100644 /* Lock the device, then check to see if we were * disconnected while waiting for the lock to succeed. */ usb_lock_device(hdev); +diff --git a/drivers/virtio/virtio_mem.c b/drivers/virtio/virtio_mem.c +index 38becd8d578c..f4ec685879cf 100644 +--- a/drivers/virtio/virtio_mem.c ++++ b/drivers/virtio/virtio_mem.c +@@ -2792,6 +2792,19 @@ static int virtio_mem_probe(struct virtio_device *vdev) + + /* trigger a config update to start processing the requested_size */ + if (!vm->in_kdump) { ++#ifdef CONFIG_RHEL_DIFFERENCES ++ static bool printed; ++ ++ /* ++ * virtio-mem, and especially its memory hot(un)plug ++ * functionality, is tech-preview. ++ */ ++ if (!printed) { ++ printed = true; ++ mark_tech_preview("virtio_mem", THIS_MODULE); ++ } ++#endif /* CONFIG_RHEL_DIFFERENCES */ ++ + atomic_set(&vm->config_changed, 1); + queue_work(system_freezable_wq, &vm->wq); + } diff --git a/fs/ext4/super.c b/fs/ext4/super.c index ce60b5026bde..95211f35dae8 100644 --- a/fs/ext4/super.c @@ -2378,15 +2403,15 @@ index c45b2693e51f..4edfdb3e44a9 100644 extern const struct file_operations random_fops, urandom_fops; diff --git a/include/linux/rh_kabi.h b/include/linux/rh_kabi.h new file mode 100644 -index 000000000000..ea9c136bf884 +index 000000000000..c7b42c1f1681 --- /dev/null +++ b/include/linux/rh_kabi.h -@@ -0,0 +1,297 @@ +@@ -0,0 +1,515 @@ +/* + * rh_kabi.h - Red Hat kABI abstraction header + * + * Copyright (c) 2014 Don Zickus -+ * Copyright (c) 2015-2018 Jiri Benc ++ * Copyright (c) 2015-2020 Jiri Benc + * Copyright (c) 2015 Sabrina Dubroca, Hannes Frederic Sowa + * Copyright (c) 2016-2018 Prarit Bhargava + * Copyright (c) 2017 Paolo Abeni, Larry Woodman @@ -2410,24 +2435,48 @@ index 000000000000..ea9c136bf884 +#ifndef _LINUX_RH_KABI_H +#define _LINUX_RH_KABI_H + ++#include <linux/kconfig.h> +#include <linux/compiler.h> +#include <linux/stringify.h> + +/* ++ * NOTE ++ * Unless indicated otherwise, don't use ';' after these macros as it ++ * messes up the kABI checker by changing what the resulting token string ++ * looks like. Instead let the macros add the ';' so it can be properly ++ * hidden from the kABI checker (mainly for RH_KABI_EXTEND, but applied to ++ * most macros for uniformity). ++ * ++ * + * RH_KABI_CONST + * Adds a new const modifier to a function parameter preserving the old + * checksum. + * ++ * RH_KABI_ADD_MODIFIER ++ * Adds a new modifier to a function parameter or a typedef, preserving ++ * the old checksum. Useful e.g. for adding rcu annotations or changing ++ * int to unsigned. Beware that this may change the semantics; if you're ++ * sure this is safe, always explain why binary compatibility with 3rd ++ * party modules is retained. ++ * + * RH_KABI_DEPRECATE -+ * Mark the element as deprecated and make it unusable by modules while -+ * preserving kABI checksums. ++ * Marks the element as deprecated and make it unusable by modules while ++ * keeping a hole in its place to preserve binary compatibility. + * + * RH_KABI_DEPRECATE_FN -+ * Mark the function pointer as deprecated and make it unusable by modules -+ * while preserving kABI checksums. ++ * Marks the function pointer as deprecated and make it unusable by modules ++ * while keeping a hole in its place to preserve binary compatibility. + * + * RH_KABI_EXTEND -+ * Simple macro for adding a new element to a struct. ++ * Adds a new field to a struct. This must always be added to the end of ++ * the struct. Before using this macro, make sure this is actually safe ++ * to do - there is a number of conditions under which it is *not* safe. ++ * In particular (but not limited to), this macro cannot be used: ++ * - if the struct in question is embedded in another struct, or ++ * - if the struct is allocated by drivers either statically or ++ * dynamically, or ++ * - if the struct is allocated together with driver data (an example of ++ * such behavior is struct net_device or struct request). + * + * RH_KABI_EXTEND_WITH_SIZE + * Adds a new element (usually a struct) to a struct and reserves extra @@ -2443,28 +2492,195 @@ index 000000000000..ea9c136bf884 + * guarantee. + * + * RH_KABI_FILL_HOLE -+ * Simple macro for filling a hole in a struct. ++ * Fills a hole in a struct. + * + * Warning: only use if a hole exists for _all_ arches. Use pahole to verify. + * + * RH_KABI_RENAME -+ * Simple macro for renaming an element without changing its type. This -+ * macro can be used in bitfields, for example. ++ * Renames an element without changing its type. This macro can be used in ++ * bitfields, for example. + * -+ * NOTE: does not include the final ';' ++ * NOTE: this macro does not add the final ';' + * + * RH_KABI_REPLACE -+ * Simple replacement of _orig with a union of _orig and _new. ++ * Replaces the _orig field by the _new field. The size of the occupied ++ * space is preserved, it's fine if the _new field is smaller than the ++ * _orig field. If a _new field is larger or has a different alignment, ++ * compilation will abort. ++ * ++ * RH_KABI_REPLACE_SPLIT ++ * Works the same as RH_KABI_REPLACE but replaces a single _orig field by ++ * multiple new fields. The checks for size and alignment done by ++ * RH_KABI_REPLACE are still applied. ++ * ++ * RH_KABI_HIDE_INCLUDE ++ * Hides the given include file from kABI checksum computations. This is ++ * used when a newly added #include makes a previously opaque struct ++ * visible. ++ * ++ * Example usage: ++ * #include RH_KABI_HIDE_INCLUDE(<linux/poll.h>) ++ * ++ * RH_KABI_FAKE_INCLUDE ++ * Pretends inclusion of the given file for kABI checksum computations. ++ * This is used when upstream removed a particular #include but that made ++ * some structures opaque that were previously visible and is causing kABI ++ * checker failures. ++ * ++ * Example usage: ++ * #include RH_KABI_FAKE_INCLUDE(<linux/rhashtable.h>) ++ * ++ * RH_KABI_RESERVE ++ * Adds a reserved field to a struct. This is done prior to kABI freeze ++ * for structs that cannot be expanded later using RH_KABI_EXTEND (for ++ * example because they are embedded in another struct or because they are ++ * allocated by drivers or because they use unusual memory layout). The ++ * size of the reserved field is 'unsigned long' and is assumed to be ++ * 8 bytes. ++ * ++ * The argument is a number unique for the given struct; usually, multiple ++ * RH_KABI_RESERVE macros are added to a struct with numbers starting from ++ * one. ++ * ++ * Example usage: ++ * struct foo { ++ * int a; ++ * RH_KABI_RESERVE(1) ++ * RH_KABI_RESERVE(2) ++ * RH_KABI_RESERVE(3) ++ * RH_KABI_RESERVE(4) ++ * }; ++ * ++ * RH_KABI_USE ++ * Uses a previously reserved field or multiple fields. The arguments are ++ * one or more numbers assigned to RH_KABI_RESERVE, followed by a field to ++ * be put in their place. The compiler ensures that the new field is not ++ * larger than the reserved area. ++ * ++ * Example usage: ++ * struct foo { ++ * int a; ++ * RH_KABI_USE(1, int b) ++ * RH_KABI_USE(2, 3, int c[3]) ++ * RH_KABI_RESERVE(4) ++ * }; ++ * ++ * RH_KABI_USE_SPLIT ++ * Works the same as RH_KABI_USE but replaces a single reserved field by ++ * multiple new fields. ++ * ++ * RH_KABI_AUX_EMBED ++ * RH_KABI_AUX_PTR ++ * Adds an extenstion of a struct in the form of "auxiliary structure". ++ * This is done prior to kABI freeze for structs that cannot be expanded ++ * later using RH_KABI_EXTEND. See also RH_KABI_RESERVED, these two ++ * approaches can (and often are) combined. ++ * ++ * To use this for 'struct foo' (the "base structure"), define a new ++ * structure called 'struct foo_rh'; this new struct is called "auxiliary ++ * structure". Then add RH_KABI_AUX_EMBED or RH_KABI_AUX_PTR to the end ++ * of the base structure. The argument is the name of the base structure, ++ * without the 'struct' keyword. ++ * ++ * RH_KABI_AUX_PTR stores a pointer to the aux structure in the base ++ * struct. The lifecycle of the aux struct needs to be properly taken ++ * care of. ++ * ++ * RH_KABI_AUX_EMBED embeds the aux struct into the base struct. This ++ * cannot be used when the base struct is itself embedded into another ++ * struct, allocated in an array, etc. ++ * ++ * Both approaches (ptr and embed) work correctly even when the aux struct ++ * is allocated by modules. To ensure this, the code responsible for ++ * allocation/assignment of the aux struct has to properly set the size of ++ * the aux struct; see the RH_KABI_AUX_SET_SIZE and RH_KABI_AUX_INIT_SIZE ++ * macros. ++ * ++ * New fields can be later added to the auxiliary structure, always to its ++ * end. Note the auxiliary structure cannot be shrunk in size later (i.e., ++ * fields cannot be removed, only deprecated). Any code accessing fields ++ * from the aux struct must guard the access using the RH_KABI_AUX macro. ++ * The access itself is then done via a '_rh' field in the base struct. ++ * ++ * The auxiliary structure is not guaranteed for access by modules unless ++ * explicitly commented as such in the declaration of the aux struct ++ * itself or some of its elements. ++ * ++ * Example: ++ * ++ * struct foo_rh { ++ * int newly_added; ++ * }; ++ * ++ * struct foo { ++ * bool big_hammer; ++ * RH_KABI_AUX_PTR(foo) ++ * }; ++ * ++ * void use(struct foo *f) ++ * { ++ * if (RH_KABI_AUX(f, foo, newly_added)) ++ * f->_rh->newly_added = 123; ++ * else ++ * // the field 'newly_added' is not present in the passed ++ * // struct, fall back to old behavior ++ * f->big_hammer = true; ++ * } ++ * ++ * static struct foo_rh my_foo_rh { ++ * .newly_added = 0; ++ * } ++ * ++ * static struct foo my_foo = { ++ * .big_hammer = false, ++ * ._rh = &my_foo_rh, ++ * RH_KABI_AUX_INIT_SIZE(foo) ++ * }; ++ * ++ * RH_KABI_USE_AUX_PTR ++ * Creates an auxiliary structure post kABI freeze. This works by using ++ * two reserved fields (thus there has to be two reserved fields still ++ * available) and converting them to RH_KABI_AUX_PTR. ++ * ++ * Example: ++ * ++ * struct foo_rh { ++ * }; ++ * ++ * struct foo { ++ * int a; ++ * RH_KABI_RESERVE(1) ++ * RH_KABI_USE_AUX_PTR(2, 3, foo) ++ * }; ++ * ++ * RH_KABI_AUX_SET_SIZE ++ * RH_KABI_AUX_INIT_SIZE ++ * Calculates and stores the size of the auxiliary structure. + * -+ * The RH_KABI_REPLACE* macros attempt to add the ability to use the '_new' -+ * element while preserving size alignment with the '_orig' element. ++ * RH_KABI_AUX_SET_SIZE is for dynamically allocated base structs, ++ * RH_KABI_AUX_INIT_SIZE is for statically allocated case structs. + * -+ * The #ifdef __GENKSYMS__ preserves the kABI agreement, while the anonymous -+ * union structure preserves the size alignment (assuming the '_new' element -+ * is not bigger than the '_orig' element). ++ * These macros must be called from the allocation (RH_KABI_AUX_SET_SIZE) ++ * or declaration (RH_KABI_AUX_INIT_SIZE) site, regardless of whether ++ * that happens in the kernel or in a module. Without calling one of ++ * these macros, the aux struct will appear to have no fields to the ++ * kernel. + * -+ * RH_KABI_REPLACE_UNSAFE -+ * Unsafe version of RH_KABI_REPLACE. Only use for typedefs. ++ * Note: since RH_KABI_AUX_SET_SIZE is intended to be invoked outside of ++ * a struct definition, it does not add the semicolon and must be ++ * terminated by semicolon by the caller. ++ * ++ * RH_KABI_AUX ++ * Verifies that the given field exists in the given auxiliary structure. ++ * This MUST be called prior to accessing that field; failing to do that ++ * may lead to invalid memory access. ++ * ++ * The first argument is a pointer to the base struct, the second argument ++ * is the name of the base struct (without the 'struct' keyword), the ++ * third argument is the field name. ++ * ++ * This macro works for structs extended by either of RH_KABI_AUX_EMBED, ++ * RH_KABI_AUX_PTR and RH_KABI_USE_AUX_PTR. + * + * RH_KABI_FORCE_CHANGE + * Force change of the symbol checksum. The argument of the macro is a @@ -2499,25 +2715,75 @@ index 000000000000..ea9c136bf884 + * of the size is not allowed and would constitute a silent kABI breakage. + * Beware that the RH_KABI_EXCLUDE macro does not do any size checks. + * -+ * NOTE -+ * Don't use ';' after these macros as it messes up the kABI checker by -+ * changing what the resulting token string looks like. Instead let this -+ * macro add the ';' so it can be properly hidden from the kABI checker -+ * (mainly for RH_KABI_EXTEND, but applied to all macros for uniformity). ++ * RH_KABI_BROKEN_INSERT ++ * RH_KABI_BROKEN_REMOVE ++ * Insert a field to the middle of a struct / delete a field from a struct. ++ * Note that this breaks kABI! It can be done only when it's certain that ++ * no 3rd party driver can validly reach into the struct. A typical ++ * example is a struct that is: both (a) referenced only through a long ++ * chain of pointers from another struct that is part of a whitelisted ++ * symbol and (b) kernel internal only, it should have never been visible ++ * to genksyms in the first place. ++ * ++ * Another example are structs that are explicitly exempt from kABI ++ * guarantee but we did not have enough foresight to use RH_KABI_EXCLUDE. ++ * In this case, the warning for RH_KABI_EXCLUDE applies. ++ * ++ * A detailed explanation of correctness of every RH_KABI_BROKEN_* macro ++ * use is especially important. + * ++ * RH_KABI_BROKEN_INSERT_BLOCK ++ * RH_KABI_BROKEN_REMOVE_BLOCK ++ * A version of RH_KABI_BROKEN_INSERT / REMOVE that allows multiple fields ++ * to be inserted or removed together. All fields need to be terminated ++ * by ';' inside(!) the macro parameter. The macro itself must not be ++ * terminated by ';'. ++ * ++ * RH_KABI_BROKEN_REPLACE ++ * Replace a field by a different one without doing any checking. This ++ * allows replacing a field by another with a different size. Similarly ++ * to other RH_KABI_BROKEN macros, use of this indicates a kABI breakage. ++ * ++ * RH_KABI_BROKEN_INSERT_ENUM ++ * RH_KABI_BROKEN_REMOVE_ENUM ++ * Insert a field to the middle of an enumaration type / delete a field from ++ * an enumaration type. Note that this can break kABI especially if the ++ * number of enum fields is used in an array within a structure. It can be ++ * done only when it is certain that no 3rd party driver will use the ++ * enumeration type or a structure that embeds an array with size determined ++ * by an enumeration type. ++ * ++ * RH_KABI_EXTEND_ENUM ++ * Adds a new field to an enumeration type. This must always be added to ++ * the end of the enum. Before using this macro, make sure this is actually ++ * safe to do. + */ ++ ++#undef linux ++#define linux linux ++ +#ifdef __GENKSYMS__ + +# define RH_KABI_CONST ++# define RH_KABI_ADD_MODIFIER(_new) +# define RH_KABI_EXTEND(_new) +# define RH_KABI_FILL_HOLE(_new) +# define RH_KABI_FORCE_CHANGE(ver) __attribute__((rh_kabi_change ## ver)) +# define RH_KABI_RENAME(_orig, _new) _orig ++# define RH_KABI_HIDE_INCLUDE(_file) <linux/rh_kabi.h> ++# define RH_KABI_FAKE_INCLUDE(_file) _file ++# define RH_KABI_BROKEN_INSERT(_new) ++# define RH_KABI_BROKEN_REMOVE(_orig) _orig; ++# define RH_KABI_BROKEN_INSERT_BLOCK(_new) ++# define RH_KABI_BROKEN_REMOVE_BLOCK(_orig) _orig ++# define RH_KABI_BROKEN_REPLACE(_orig, _new) _orig; ++# define RH_KABI_BROKEN_INSERT_ENUM(_new) ++# define RH_KABI_BROKEN_REMOVE_ENUM(_orig) _orig, ++# define RH_KABI_EXTEND_ENUM(_new) + +# define _RH_KABI_DEPRECATE(_type, _orig) _type _orig +# define _RH_KABI_DEPRECATE_FN(_type, _orig, _args...) _type (*_orig)(_args) +# define _RH_KABI_REPLACE(_orig, _new) _orig -+# define _RH_KABI_REPLACE_UNSAFE(_orig, _new) _orig +# define _RH_KABI_EXCLUDE(_elem) + +#else @@ -2525,11 +2791,21 @@ index 000000000000..ea9c136bf884 +# define RH_KABI_ALIGN_WARNING ". Disable CONFIG_RH_KABI_SIZE_ALIGN_CHECKS if debugging." + +# define RH_KABI_CONST const ++# define RH_KABI_ADD_MODIFIER(_new) _new +# define RH_KABI_EXTEND(_new) _new; +# define RH_KABI_FILL_HOLE(_new) _new; +# define RH_KABI_FORCE_CHANGE(ver) +# define RH_KABI_RENAME(_orig, _new) _new -+ ++# define RH_KABI_HIDE_INCLUDE(_file) _file ++# define RH_KABI_FAKE_INCLUDE(_file) <linux/rh_kabi.h> ++# define RH_KABI_BROKEN_INSERT(_new) _new; ++# define RH_KABI_BROKEN_REMOVE(_orig) ++# define RH_KABI_BROKEN_INSERT_BLOCK(_new) _new ++# define RH_KABI_BROKEN_REMOVE_BLOCK(_orig) ++# define RH_KABI_BROKEN_REPLACE(_orig, _new) _new; ++# define RH_KABI_BROKEN_INSERT_ENUM(_new) _new, ++# define RH_KABI_BROKEN_REMOVE_ENUM(_orig) ++# define RH_KABI_EXTEND_ENUM(_new) _new, + +#if IS_BUILTIN(CONFIG_RH_KABI_SIZE_ALIGN_CHECKS) +# define __RH_KABI_CHECK_SIZE_ALIGN(_orig, _new) \ @@ -2560,47 +2836,56 @@ index 000000000000..ea9c136bf884 + } RH_KABI_UNIQUE_ID; \ + __RH_KABI_CHECK_SIZE_ALIGN(_orig, _new); \ + } -+# define _RH_KABI_REPLACE_UNSAFE(_orig, _new) _new + +# define _RH_KABI_EXCLUDE(_elem) _elem + +#endif /* __GENKSYMS__ */ + -+/* semicolon added wrappers for the RH_KABI_REPLACE macros */ +# define RH_KABI_DEPRECATE(_type, _orig) _RH_KABI_DEPRECATE(_type, _orig); +# define RH_KABI_DEPRECATE_FN(_type, _orig, _args...) \ + _RH_KABI_DEPRECATE_FN(_type, _orig, _args); +# define RH_KABI_REPLACE(_orig, _new) _RH_KABI_REPLACE(_orig, _new); -+# define RH_KABI_REPLACE_UNSAFE(_orig, _new) _RH_KABI_REPLACE_UNSAFE(_orig, _new); -+/* -+ * Macro for breaking up a random element into two smaller chunks using an -+ * anonymous struct inside an anonymous union. -+ */ -+# define RH_KABI_REPLACE2(orig, _new1, _new2) RH_KABI_REPLACE(orig, struct{ _new1; _new2;}) ++ ++#define _RH_KABI_REPLACE1(_new) _new; ++#define _RH_KABI_REPLACE2(_new, ...) _new; _RH_KABI_REPLACE1(__VA_ARGS__) ++#define _RH_KABI_REPLACE3(_new, ...) _new; _RH_KABI_REPLACE2(__VA_ARGS__) ++#define _RH_KABI_REPLACE4(_new, ...) _new; _RH_KABI_REPLACE3(__VA_ARGS__) ++#define _RH_KABI_REPLACE5(_new, ...) _new; _RH_KABI_REPLACE4(__VA_ARGS__) ++#define _RH_KABI_REPLACE6(_new, ...) _new; _RH_KABI_REPLACE5(__VA_ARGS__) ++#define _RH_KABI_REPLACE7(_new, ...) _new; _RH_KABI_REPLACE6(__VA_ARGS__) ++#define _RH_KABI_REPLACE8(_new, ...) _new; _RH_KABI_REPLACE7(__VA_ARGS__) ++#define _RH_KABI_REPLACE9(_new, ...) _new; _RH_KABI_REPLACE8(__VA_ARGS__) ++#define _RH_KABI_REPLACE10(_new, ...) _new; _RH_KABI_REPLACE9(__VA_ARGS__) ++#define _RH_KABI_REPLACE11(_new, ...) _new; _RH_KABI_REPLACE10(__VA_ARGS__) ++#define _RH_KABI_REPLACE12(_new, ...) _new; _RH_KABI_REPLACE11(__VA_ARGS__) ++ ++#define RH_KABI_REPLACE_SPLIT(_orig, ...) _RH_KABI_REPLACE(_orig, \ ++ struct { __PASTE(_RH_KABI_REPLACE, COUNT_ARGS(__VA_ARGS__))(__VA_ARGS__) }); + +# define RH_KABI_RESERVE(n) _RH_KABI_RESERVE(n); -+/* -+ * Simple wrappers to replace standard Red Hat reserved elements. -+ */ -+# define RH_KABI_USE(n, _new) RH_KABI_REPLACE(_RH_KABI_RESERVE(n), _new) -+/* -+ * Macros for breaking up a reserved element into two smaller chunks using -+ * an anonymous struct inside an anonymous union. -+ */ -+# define RH_KABI_USE2(n, _new1, _new2) RH_KABI_REPLACE(_RH_KABI_RESERVE(n), struct{ _new1; _new2; }) + -+/* -+ * We tried to standardize on Red Hat reserved names. These wrappers -+ * leverage those common names making it easier to read and find in the -+ * code. -+ */ ++#define _RH_KABI_USE1(n, _new) _RH_KABI_RESERVE(n), _new ++#define _RH_KABI_USE2(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE1(__VA_ARGS__) ++#define _RH_KABI_USE3(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE2(__VA_ARGS__) ++#define _RH_KABI_USE4(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE3(__VA_ARGS__) ++#define _RH_KABI_USE5(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE4(__VA_ARGS__) ++#define _RH_KABI_USE6(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE5(__VA_ARGS__) ++#define _RH_KABI_USE7(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE6(__VA_ARGS__) ++#define _RH_KABI_USE8(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE7(__VA_ARGS__) ++#define _RH_KABI_USE9(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE8(__VA_ARGS__) ++#define _RH_KABI_USE10(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE9(__VA_ARGS__) ++#define _RH_KABI_USE11(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE10(__VA_ARGS__) ++#define _RH_KABI_USE12(n, ...) _RH_KABI_RESERVE(n); _RH_KABI_USE11(__VA_ARGS__) ++ ++#define _RH_KABI_USE(...) _RH_KABI_REPLACE(__VA_ARGS__) ++#define RH_KABI_USE(n, ...) _RH_KABI_USE(__PASTE(_RH_KABI_USE, COUNT_ARGS(__VA_ARGS__))(n, __VA_ARGS__)); ++ ++# define RH_KABI_USE_SPLIT(n, ...) RH_KABI_REPLACE_SPLIT(_RH_KABI_RESERVE(n), __VA_ARGS__) ++ +# define _RH_KABI_RESERVE(n) unsigned long rh_reserved##n + +#define RH_KABI_EXCLUDE(_elem) _RH_KABI_EXCLUDE(_elem); + -+/* -+ * Extending a struct while reserving extra space. -+ */ +#define RH_KABI_EXTEND_WITH_SIZE(_new, _size) \ + RH_KABI_EXTEND(union { \ + _new; \ @@ -2608,74 +2893,32 @@ index 000000000000..ea9c136bf884 + __RH_KABI_CHECK_SIZE(_new, 8 * (_size)); \ + }) + -+/* -+ * RHEL macros to extend structs. -+ * -+ * base struct: The struct being extended. For example, pci_dev. -+ * extended struct: The Red Hat struct being added to the base struct. -+ * For example, pci_dev_rh. -+ * -+ * These macros should be used to extend structs before KABI freeze. -+ * They can be used post-KABI freeze in the limited case of the base -+ * struct not being embedded in another struct. -+ * -+ * Extended structs cannot be shrunk in size as changes will break -+ * the size & offset comparison. -+ * -+ * Extended struct elements are not guaranteed for access by modules unless -+ * explicitly commented as such in the declaration of the extended struct or -+ * the element in the extended struct. -+ */ -+ -+/* -+ * RH_KABI_SIZE_AND_EXTEND|_PTR() extends a struct by embedding or adding -+ * a pointer in a base struct. The name of the new struct is the name -+ * of the base struct appended with _rh. -+ */ -+#define _RH_KABI_SIZE_AND_EXTEND_PTR(_struct) \ ++#define _RH_KABI_AUX_PTR(_struct) \ + size_t _struct##_size_rh; \ -+ RH_KABI_EXCLUDE(struct _struct##_rh *_struct##_rh) -+#define RH_KABI_SIZE_AND_EXTEND_PTR(_struct) \ -+ _RH_KABI_SIZE_AND_EXTEND_PTR(_struct) ++ _RH_KABI_EXCLUDE(struct _struct##_rh *_rh) ++#define RH_KABI_AUX_PTR(_struct) \ ++ _RH_KABI_AUX_PTR(_struct); + -+#define _RH_KABI_SIZE_AND_EXTEND(_struct) \ ++#define _RH_KABI_AUX_EMBED(_struct) \ + size_t _struct##_size_rh; \ -+ RH_KABI_EXCLUDE(struct _struct##_rh _struct##_rh) -+#define RH_KABI_SIZE_AND_EXTEND(_struct) \ -+ _RH_KABI_SIZE_AND_EXTEND(_struct) ++ _RH_KABI_EXCLUDE(struct _struct##_rh _rh) ++#define RH_KABI_AUX_EMBED(_struct) \ ++ _RH_KABI_AUX_EMBED(_struct); + -+/* -+ * RH_KABI_SET_SIZE calculates and sets the size of the extended struct and -+ * stores it in the size_rh field for structs that are dynamically allocated. -+ * This macro MUST be called when expanding a base struct with -+ * RH_KABI_SIZE_AND_EXTEND, and it MUST be called from the allocation site -+ * regardless of being allocated in the kernel or a module. -+ * Note: since this macro is intended to be invoked outside of a struct, -+ * a semicolon is necessary at the end of the line where it is invoked. -+ */ -+#define RH_KABI_SET_SIZE(_name, _struct) ({ \ -+ _name->_struct##_size_rh = sizeof(struct _struct##_rh); \ ++#define RH_KABI_USE_AUX_PTR(n1, n2, _struct) \ ++ RH_KABI_USE(n1, n2, \ ++ struct { RH_KABI_AUX_PTR(_struct) }) ++ ++#define RH_KABI_AUX_SET_SIZE(_name, _struct) ({ \ ++ (_name)->_struct##_size_rh = sizeof(struct _struct##_rh); \ +}) + -+/* -+ * RH_KABI_INIT_SIZE calculates and sets the size of the extended struct and -+ * stores it in the size_rh field for structs that are statically allocated. -+ * This macro MUST be called when expanding a base struct with -+ * RH_KABI_SIZE_AND_EXTEND, and it MUST be called from the declaration site -+ * regardless of being allocated in the kernel or a module. -+ */ -+#define RH_KABI_INIT_SIZE(_struct) \ ++#define RH_KABI_AUX_INIT_SIZE(_struct) \ + ._struct##_size_rh = sizeof(struct _struct##_rh), + -+/* -+ * RH_KABI_CHECK_EXT verifies allocated memory exists. This MUST be called to -+ * verify that memory in the _rh struct is valid, and can be called -+ * regardless if RH_KABI_SIZE_AND_EXTEND or RH_KABI_SIZE_AND_EXTEND_PTR is -+ * used. -+ */ -+#define RH_KABI_CHECK_EXT(_ptr, _struct, _field) ({ \ ++#define RH_KABI_AUX(_ptr, _struct, _field) ({ \ + size_t __off = offsetof(struct _struct##_rh, _field); \ -+ _ptr->_struct##_size_rh > __off ? true : false; \ ++ (_ptr)->_struct##_size_rh > __off ? true : false; \ +}) + +#endif /* _LINUX_RH_KABI_H */ @@ -2776,7 +3019,7 @@ index fa4505f9b611..1955a6f41b7b 100644 IS_BUILTIN(CONFIG_BPF_UNPRIV_DEFAULT_OFF) ? 2 : 0; diff --git a/kernel/module.c b/kernel/module.c -index 24dab046e16c..0501ad302769 100644 +index 46a5c2ed1928..92c2306651ce 100644 --- a/kernel/module.c +++ b/kernel/module.c @@ -743,6 +743,7 @@ static struct module_attribute modinfo_##field = { \ |