From: Andreas Gruenbacher <agruen@suse.de>
Subject: SUSE/external support flag in modules
Patch-mainline: Never, SLES feature
References: bsc#148091 bsc#974406
Upon module load, check if a module is supported, and set the
N (TAINT_NO_SUPPORT) or X (TAINT_EXTERNAL_SUPPORT) tail flags
for unsupported or externally suported modules.
Contributions by:
Michal Marek, Michal Suchanek, Jeff Mahoney
Signed-off-by: Andreas Gruenbacher <agruen@suse.de>
---
Documentation/admin-guide/kernel-parameters.txt | 8 +
Documentation/admin-guide/sysctl/kernel.rst | 41 +++----
Makefile | 5
include/linux/module.h | 3
include/linux/panic.h | 18 +++
init/Kconfig.suse | 18 +++
kernel/ksysfs.c | 27 ++++
kernel/module.c | 84 +++++++++++++++
kernel/panic.c | 3
kernel/sysctl.c | 9 +
scripts/Makefile.modpost | 6 +
scripts/mod/modpost.c | 132 +++++++++++++++++++++++-
12 files changed, 333 insertions(+), 21 deletions(-)
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -5854,6 +5854,14 @@
unknown_nmi_panic
[X86] Cause panic on unknown NMI.
+ unsupported Allow loading of unsupported kernel modules:
+ 0 = only allow supported modules,
+ 1 = warn when loading unsupported modules,
+ 2 = don't warn.
+
+ CONFIG_SUSE_KERNEL_SUPPORTED must be enabled for this
+ to have any effect.
+
usbcore.authorized_default=
[USB] Default USB device authorization:
(default -1 = authorized except for wireless USB,
--- a/Documentation/admin-guide/sysctl/kernel.rst
+++ b/Documentation/admin-guide/sysctl/kernel.rst
@@ -1348,26 +1348,27 @@ tainted
Non-zero if the kernel has been tainted. Numeric values, which can be
ORed together. The letters are seen in "Tainted" line of Oops reports.
-====== ===== ==============================================================
- 1 `(P)` proprietary module was loaded
- 2 `(F)` module was force loaded
- 4 `(S)` kernel running on an out of specification system
- 8 `(R)` module was force unloaded
- 16 `(M)` processor reported a Machine Check Exception (MCE)
- 32 `(B)` bad page referenced or some unexpected page flags
- 64 `(U)` taint requested by userspace application
- 128 `(D)` kernel died recently, i.e. there was an OOPS or BUG
- 256 `(A)` an ACPI table was overridden by user
- 512 `(W)` kernel issued warning
- 1024 `(C)` staging driver was loaded
- 2048 `(I)` workaround for bug in platform firmware applied
- 4096 `(O)` externally-built ("out-of-tree") module was loaded
- 8192 `(E)` unsigned module was loaded
- 16384 `(L)` soft lockup occurred
- 32768 `(K)` kernel has been live patched
- 65536 `(X)` Auxiliary taint, defined and used by for distros
-131072 `(T)` The kernel was built with the struct randomization plugin
-====== ===== ==============================================================
+========== ===== ==========================================================
+ 1 `(P)` proprietary module was loaded
+ 2 `(F)` module was force loaded
+ 4 `(S)` kernel running on an out of specification system
+ 8 `(R)` module was force unloaded
+ 16 `(M)` processor reported a Machine Check Exception (MCE)
+ 32 `(B)` bad page referenced or some unexpected page flags
+ 64 `(U)` taint requested by userspace application
+ 128 `(D)` kernel died recently, i.e. there was an OOPS or BUG
+ 256 `(A)` an ACPI table was overridden by user
+ 512 `(W)` kernel issued warning
+ 1024 `(C)` staging driver was loaded
+ 2048 `(I)` workaround for bug in platform firmware applied
+ 4096 `(O)` externally-built ("out-of-tree") module was loaded
+ 8192 `(E)` unsigned module was loaded
+ 16384 `(L)` soft lockup occurred
+ 32768 `(K)` kernel has been live patched
+ 65536 `(X)` A kernel module with external support was loaded
+ 131072 `(T)` The kernel was built with the struct randomization plugin
+2147483648 `(N)` An unsupported kernel module was loaded
+========== ===== ==========================================================
See Documentation/admin-guide/tainted-kernels.rst for more information.
--- a/Makefile
+++ b/Makefile
@@ -357,6 +357,11 @@ else # !mixed-build
include $(srctree)/scripts/Kbuild.include
+# Warn about unsupported modules in kernels built inside Autobuild
+ifneq ($(wildcard /.buildenv),)
+CFLAGS += -DUNSUPPORTED_MODULES=2
+endif
+
# Read KERNELRELEASE from include/config/kernel.release (if it exists)
KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)
KERNELVERSION = $(VERSION)$(if $(PATCHLEVEL),.$(PATCHLEVEL)$(if $(SUBLEVEL),.$(SUBLEVEL)))$(EXTRAVERSION)
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -559,6 +559,9 @@ bool is_module_address(unsigned long add
bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
bool is_module_percpu_address(unsigned long addr);
bool is_module_text_address(unsigned long addr);
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+const char *supported_printable(int taint);
+#endif
static inline bool within_module_core(unsigned long addr,
const struct module *mod)
--- a/include/linux/panic.h
+++ b/include/linux/panic.h
@@ -37,6 +37,10 @@ extern int sysctl_panic_on_stackoverflow
extern bool crash_kexec_post_notifiers;
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+extern int suse_unsupported;
+#endif
+
/*
* panic_cpu is used for synchronizing panic() and crash_kexec() execution. It
* holds a CPU number which is executing panic() currently. A value of
@@ -77,6 +81,20 @@ static inline void set_arch_panic_timeou
#define TAINT_FLAGS_COUNT 18
#define TAINT_FLAGS_MAX ((1UL << TAINT_FLAGS_COUNT) - 1)
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+/*
+ * Take the upper bits to hopefully allow them
+ * to stay the same for more than one release.
+ */
+# define TAINT_EXTERNAL_SUPPORT TAINT_AUX
+# define TAINT_NO_SUPPORT 31
+# if TAINT_FLAGS_COUNT >= TAINT_NO_SUPPORT
+# error Upstream taint flags overlap with SUSE flags
+# endif
+# undef TAINT_FLAGS_COUNT
+# define TAINT_FLAGS_COUNT 32
+#endif
+
struct taint_flag {
char c_true; /* character printed when tainted */
char c_false; /* character printed when not tainted */
--- a/init/Kconfig.suse
+++ b/init/Kconfig.suse
@@ -1,2 +1,20 @@
config SUSE_KERNEL
def_bool y
+
+config SUSE_KERNEL_SUPPORTED
+ bool "Enable enterprise support facility"
+ depends on SUSE_KERNEL
+ help
+ This feature enables the handling of the "supported" module flag.
+ This flag can be used to report unsupported module loads or even
+ refuse them entirely. It is useful when ensuring that the kernel
+ remains in a state that SUSE, or its technical partners, is
+ prepared to support.
+
+ Modules in the list of supported modules will be marked supported
+ on build. The default enforcement mode is to report, but not
+ deny, loading of unsupported modules.
+
+ If you aren't building a kernel for an enterprise distribution,
+ say n.
+
--- a/kernel/ksysfs.c
+++ b/kernel/ksysfs.c
@@ -208,6 +208,30 @@ static struct bin_attribute notes_attr _
struct kobject *kernel_kobj;
EXPORT_SYMBOL_GPL(kernel_kobj);
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+const char *supported_printable(int taint)
+{
+ int mask = (1 << TAINT_PROPRIETARY_MODULE) | (1 << TAINT_NO_SUPPORT);
+ if ((taint & mask) == mask)
+ return "No, Proprietary and Unsupported modules are loaded";
+ else if (taint & (1 << TAINT_PROPRIETARY_MODULE))
+ return "No, Proprietary modules are loaded";
+ else if (taint & (1 << TAINT_NO_SUPPORT))
+ return "No, Unsupported modules are loaded";
+ else if (taint & (1 << TAINT_EXTERNAL_SUPPORT))
+ return "Yes, External";
+ else
+ return "Yes";
+}
+
+static ssize_t supported_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return sprintf(buf, "%s\n", supported_printable(get_taint()));
+}
+KERNEL_ATTR_RO(supported);
+#endif
+
static struct attribute * kernel_attrs[] = {
&fscaps_attr.attr,
&uevent_seqnum_attr.attr,
@@ -229,6 +253,9 @@ static struct attribute * kernel_attrs[]
&rcu_expedited_attr.attr,
&rcu_normal_attr.attr,
#endif
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ &supported_attr.attr,
+#endif
NULL
};
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -81,6 +81,22 @@
/* If this is set, the section belongs in the init part of the module */
#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+/* Allow unsupported modules switch. */
+#ifdef UNSUPPORTED_MODULES
+int suse_unsupported = UNSUPPORTED_MODULES;
+#else
+int suse_unsupported = 2; /* don't warn when loading unsupported modules. */
+#endif
+
+static int __init unsupported_setup(char *str)
+{
+ get_option(&str, &suse_unsupported);
+ return 1;
+}
+__setup("unsupported=", unsupported_setup);
+#endif
+
/*
* Mutex protects:
* 1) List of modules (also safely readable with preempt_disable),
@@ -1202,6 +1224,33 @@ static ssize_t show_taint(struct module_
static struct module_attribute modinfo_taint =
__ATTR(taint, 0444, show_taint, NULL);
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+static void setup_modinfo_supported(struct module *mod, const char *s)
+{
+ if (!s) {
+ mod->taints |= (1 << TAINT_NO_SUPPORT);
+ return;
+ }
+
+ if (strcmp(s, "external") == 0)
+ mod->taints |= (1 << TAINT_EXTERNAL_SUPPORT);
+ else if (strcmp(s, "yes"))
+ mod->taints |= (1 << TAINT_NO_SUPPORT);
+}
+
+static ssize_t show_modinfo_supported(struct module_attribute *mattr,
+ struct module_kobject *mk, char *buffer)
+{
+ return sprintf(buffer, "%s\n", supported_printable(mk->mod->taints));
+}
+
+static struct module_attribute modinfo_supported = {
+ .attr = { .name = "supported", .mode = 0444 },
+ .show = show_modinfo_supported,
+ .setup = setup_modinfo_supported,
+};
+#endif
+
static struct module_attribute *modinfo_attrs[] = {
&module_uevent,
&modinfo_version,
@@ -1210,6 +1259,9 @@ static struct module_attribute *modinfo_
&modinfo_coresize,
&modinfo_initsize,
&modinfo_taint,
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ &modinfo_supported,
+#endif
#ifdef CONFIG_MODULE_UNLOAD
&modinfo_refcnt,
#endif
@@ -1874,8 +1926,37 @@ static int mod_sysfs_setup(struct module
add_sect_attrs(mod, info);
add_notes_attrs(mod, info);
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ if (mod->taints & (1 << TAINT_EXTERNAL_SUPPORT)) {
+ pr_notice("%s: externally supported module, "
+ "setting X kernel taint flag.\n", mod->name);
+ add_taint(TAINT_EXTERNAL_SUPPORT, LOCKDEP_STILL_OK);
+ } else if (mod->taints & (1 << TAINT_NO_SUPPORT)) {
+ if (suse_unsupported == 0) {
+ printk(KERN_WARNING "%s: module not supported by "
+ "SUSE, refusing to load. To override, echo "
+ "1 > /proc/sys/kernel/unsupported\n", mod->name);
+ err = -ENOEXEC;
+ goto out_remove_attrs;
+ }
+ add_taint(TAINT_NO_SUPPORT, LOCKDEP_STILL_OK);
+ if (suse_unsupported == 1) {
+ printk(KERN_WARNING "%s: module is not supported by "
+ "SUSE. Our support organization may not be "
+ "able to address your support request if it "
+ "involves a kernel fault.\n", mod->name);
+ }
+ }
+#endif
+
return 0;
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+out_remove_attrs:
+ remove_notes_attrs(mod);
+ remove_sect_attrs(mod);
+ del_usage_links(mod);
+#endif
out_unreg_modinfo_attrs:
module_remove_modinfo_attrs(mod, -1);
out_unreg_param:
@@ -4748,6 +4829,9 @@ void print_modules(void)
if (last_unloaded_module[0])
pr_cont(" [last unloaded: %s]", last_unloaded_module);
pr_cont("\n");
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ printk("Supported: %s\n", supported_printable(get_taint()));
+#endif
}
#ifdef CONFIG_MODVERSIONS
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -387,6 +387,9 @@ const struct taint_flag taint_flags[TAIN
[ TAINT_LIVEPATCH ] = { 'K', ' ', true },
[ TAINT_AUX ] = { 'X', ' ', true },
[ TAINT_RANDSTRUCT ] = { 'T', ' ', true },
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ [ TAINT_NO_SUPPORT ] = { 'N', ' ', true },
+#endif
};
/**
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -2195,6 +2195,15 @@ static struct ctl_table kern_table[] = {
.extra1 = &pid_max_min,
.extra2 = &pid_max_max,
},
+#if defined(CONFIG_MODULES) && defined(CONFIG_SUSE_KERNEL_SUPPORTED)
+ {
+ .procname = "unsupported",
+ .data = &suse_unsupported,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = &proc_dointvec,
+ },
+#endif
{
.procname = "panic_on_oops",
.data = &panic_on_oops,
--- a/scripts/Makefile.modpost
+++ b/scripts/Makefile.modpost
@@ -141,6 +141,12 @@ ifneq ($(KBUILD_MODPOST_WARN)$(filter-ou
MODPOST += -w
endif
+MODVERDIR := $(if $(KBUILD_EXTMOD),$(firstword $(KBUILD_EXTMOD))/).tmp_versions
+
+MODPOST += $(if $(CONFIG_SUSE_KERNEL_SUPPORTED), \
+ -S $(firstword $(wildcard $(dir $(MODVERDIR))/Module.supported \
+ $(if $(KBUILD_EXTMOD),,$(srctree)/Module.supported) /dev/null)))
+
# Read out modules.order to pass in modpost.
# Otherwise, allmodconfig would fail with "Argument list too long".
quiet_cmd_modpost = MODPOST $@
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -16,9 +16,11 @@
#include <stdio.h>
#include <ctype.h>
#include <string.h>
+#include <fnmatch.h>
#include <limits.h>
#include <errno.h>
#include "modpost.h"
+#include "../../include/generated/autoconf.h"
#include "../../include/linux/license.h"
/* Are we using CONFIG_MODVERSIONS? */
@@ -2006,6 +2008,99 @@ static char *remove_dot(char *s)
return s;
}
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+/*
+ * Replace dashes with underscores.
+ * Dashes inside character range patterns (e.g. [0-9]) are left unchanged.
+ * (copied from module-init-tools/util.c)
+ */
+static char *underscores(char *string)
+{
+ unsigned int i;
+
+ if (!string)
+ return NULL;
+
+ for (i = 0; string[i]; i++) {
+ switch (string[i]) {
+ case '-':
+ string[i] = '_';
+ break;
+
+ case ']':
+ warn("Unmatched bracket in %s\n", string);
+ break;
+
+ case '[':
+ i += strcspn(&string[i], "]");
+ if (!string[i])
+ warn("Unmatched bracket in %s\n", string);
+ break;
+ }
+ }
+ return string;
+}
+
+char *supported_file;
+unsigned long supported_size;
+
+static const char *supported(const char *modname)
+{
+ unsigned long pos = 0;
+ char *line;
+
+ /* In a first shot, do a simple linear scan. */
+ while ((line = get_next_line(&pos, supported_file,
+ supported_size))) {
+ const char *how = "yes";
+ char *l = line;
+ char *pat_basename, *mod, *orig_mod, *mod_basename;
+
+ /* optional type-of-support flag */
+ for (l = line; *l != '\0'; l++) {
+ if (*l == ' ' || *l == '\t') {
+ *l = '\0';
+ how = l + 1;
+ break;
+ }
+ }
+ /* strip .ko extension */
+ l = line + strlen(line);
+ if (l - line > 3 && !strcmp(l-3, ".ko"))
+ *(l-3) = '\0';
+
+ /*
+ * convert dashes to underscores in the last path component
+ * of line and mod
+ */
+ if ((pat_basename = strrchr(line, '/')))
+ pat_basename++;
+ else
+ pat_basename = line;
+ underscores(pat_basename);
+
+ orig_mod = mod = strdup(modname);
+ if ((mod_basename = strrchr(mod, '/')))
+ mod_basename++;
+ else
+ mod_basename = mod;
+ underscores(mod_basename);
+
+ /* only compare the last component if no wildcards are used */
+ if (strcspn(line, "[]*?") == strlen(line)) {
+ line = pat_basename;
+ mod = mod_basename;
+ }
+ if (!fnmatch(line, mod, 0)) {
+ free(orig_mod);
+ return how;
+ }
+ free(orig_mod);
+ }
+ return NULL;
+}
+#endif
+
static void read_symbols(const char *modname)
{
const char *symname;
@@ -2273,6 +2368,15 @@ static void add_staging_flag(struct buff
buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
}
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+static void add_supported_flag(struct buffer *b, struct module *mod)
+{
+ const char *how = supported(mod->name);
+ if (how)
+ buf_printf(b, "\nMODULE_INFO(supported, \"%s\");\n", how);
+}
+#endif
+
/**
* Record CRCs for unresolved symbols
**/
@@ -2411,6 +2515,17 @@ static void write_if_changed(struct buff
write_buf(b, fname);
}
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+static void read_supported(const char *fname)
+{
+ if (fname) {
+ supported_file = grab_file(fname, &supported_size);
+ if (!supported_file)
+ ; /* ignore error */
+ }
+}
+#endif
+
/* parse Module.symvers file. line format:
* 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
**/
@@ -2523,12 +2638,15 @@ int main(int argc, char **argv)
struct buffer buf = { };
char *missing_namespace_deps = NULL;
char *dump_write = NULL, *files_source = NULL;
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ const char *supported = NULL;
+#endif
int opt;
int n;
struct dump_list *dump_read_start = NULL;
struct dump_list **dump_read_iter = &dump_read_start;
- while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
+ while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:S:")) != -1) {
switch (opt) {
case 'e':
external_module = 1;
@@ -2566,11 +2684,20 @@ int main(int argc, char **argv)
case 'd':
missing_namespace_deps = optarg;
break;
+ case 'S':
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ supported = optarg;
+#endif
+ break;
default:
exit(1);
}
}
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ read_supported(supported);
+#endif
+
while (dump_read_start) {
struct dump_list *tmp;
@@ -2601,6 +2728,9 @@ int main(int argc, char **argv)
add_intree_flag(&buf, !external_module);
add_retpoline(&buf);
add_staging_flag(&buf, mod->name);
+#ifdef CONFIG_SUSE_KERNEL_SUPPORTED
+ add_supported_flag(&buf, mod);
+#endif
add_versions(&buf, mod);
add_depends(&buf, mod);
add_moddevtable(&buf, mod);