kernel-5.17-0.rc2.20220204gitdcb85f85fa6f.86

* Fri Feb 04 2022 Fedora Kernel Team <kernel-team@fedoraproject.org> [5.17-0.rc2.20220204gitdcb85f85fa6f.86]
- mm/sparsemem: Fix 'mem_section' will never be NULL gcc 12 warning (Waiman Long)
- Workaround for gcc12 compile issues in ubcmd-util.h (Justin M. Forbes)
Resolves: rhbz#

Signed-off-by: Justin M. Forbes <jforbes@fedoraproject.org>

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 = {                    \