Skip to contentSkip to conversation

module: Introduce module unload taint tracking

PATCH Superseded Aaron Tomlin 3 participants 9 messages Apr 25, 2022 – May 2, 2022 Module support

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v4 cover module: Introduce module unload taint tracking

Hi Luis,

This iteration is still based on the latest mcgrof/modules-next branch.

I have decided still to use RCU even though no entry is ever removed from the unloaded tainted modules list. That being said, if I understand correctly, it is not safe in some instances to use 'module_mutex' in print_modules(). So instead we disable preemption to ensure list traversal with concurrent list manipulation e.g. list_add_rcu(), is safe too.

Changes since v3 [1]
- Fixed kernel build error reported by kernel test robot i.e. moved '#endif' outside 'if (!list_empty(&unloaded_tainted_modules))' statement in the context of print_modules()
- Used strncmp() instead of memcmp()
(Oleksandr Natalenko)
- Removed the additional strlen()
(Christoph Lameter)

Changes since v2 [2]
- Dropped RFC from subject
- Removed the newline i.e. "\n" in printk()
- Always include the tainted module's unload count
- Unconditionally display each unloaded tainted module

Please let me know your thoughts.

[1]: https://lore.kernel.org/all/[email protected]/
[2]: https://lore.kernel.org/all/[email protected]/

Aaron Tomlin (2):
module: Make module_flags_taint() accept a module's taints bitmap
directly
module: Introduce module unload taint tracking

 init/Kconfig         | 11 +++++++
 kernel/module/main.c | 73 +++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 80 insertions(+), 4 deletions(-)

base-commit: eeaec7801c421e17edda6e45a32d4a5596b633da

Signature · 1 line
2.34.1
#1 lore raw

PATCH v4 1/2 module: Make module_flags_taint() accept a module's taints bitmap directly

No functional change.

The purpose of this patch is to modify module_flags_taint() to accept a module's taints bitmap as a parameter and modifies all users accordingly. This is in preparation for module unload taint tracking support.

---
 kernel/module/main.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
kernel/module/main.c +4 -4
index 05a42d8fcd7a..ea78cec316dd 100644
@@ -890,13 +890,13 @@ static inline int module_unload_init(struct module *mod)
 }
 #endif /* CONFIG_MODULE_UNLOAD */
 
-static size_t module_flags_taint(struct module *mod, char *buf)
+static size_t module_flags_taint(unsigned long taints, char *buf)
 {
 	size_t l = 0;
 	int i;
 
 	for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
-		if (taint_flags[i].module && test_bit(i, &mod->taints))
+		if (taint_flags[i].module && test_bit(i, &taints))
 			buf[l++] = taint_flags[i].c_true;
 	}
 
@@ -974,7 +974,7 @@ static ssize_t show_taint(struct module_attribute *mattr,
 {
 	size_t l;
 
-	l = module_flags_taint(mk->mod, buffer);
+	l = module_flags_taint(mk->mod->taints, buffer);
 	buffer[l++] = '\n';
 	return l;
 }
@@ -2993,7 +2993,7 @@ char *module_flags(struct module *mod, char *buf)
 	    mod->state == MODULE_STATE_GOING ||
 	    mod->state == MODULE_STATE_COMING) {
 		buf[bx++] = '(';
-		bx += module_flags_taint(mod, buf + bx);
+		bx += module_flags_taint(mod->taints, buf + bx);
 		/* Show a - for module-is-being-unloaded */
 		if (mod->state == MODULE_STATE_GOING)
 			buf[bx++] = '-';
Signature · 1 line
2.34.1
#2 lore raw

PATCH v4 2/2 module: Introduce module unload taint tracking

In reply to Aaron Tomlin

Currently, only the initial module that tainted the kernel is recorded e.g. when an out-of-tree module is loaded.

The purpose of this patch is to allow the kernel to maintain a record of each unloaded module that taints the kernel. So, in addition to displaying a list of linked modules (see print_modules()) e.g. in the event of a detected bad page, unloaded modules that carried a taint/or taints are displayed too. A tainted module unload count is maintained.

The number of tracked modules is not fixed. This feature is disabled by default.

---
 init/Kconfig         | 11 ++++++++
 kernel/module/main.c | 65 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
init/Kconfig +11 -0
index ddcbefe535e9..6b30210f787d 100644
@@ -2118,6 +2118,17 @@ config MODULE_FORCE_UNLOAD
 	  rmmod).  This is mainly for kernel developers and desperate users.
 	  If unsure, say N.
 
+config MODULE_UNLOAD_TAINT_TRACKING
+	bool "Tainted module unload tracking"
+	depends on MODULE_UNLOAD
+	default n
+	help
+	  This option allows you to maintain a record of each unloaded
+	  module that tainted the kernel. In addition to displaying a
+	  list of linked (or loaded) modules e.g. on detection of a bad
+	  page (see bad_page()), the aforementioned details are also
+	  shown. If unsure, say N.
+
 config MODVERSIONS
 	bool "Module versioning support"
 	help
kernel/module/main.c +65 -0

95 lines not on this page · raw message

Signature · 1 line
2.34.1
#3 lore raw

Le 25/04/2022 à 11:08, Aaron Tomlin a écrit :

Quoted 65 lines

Currently, only the initial module that tainted the kernel is recorded e.g. when an out-of-tree module is loaded.

The purpose of this patch is to allow the kernel to maintain a record of each unloaded module that taints the kernel. So, in addition to displaying a list of linked modules (see print_modules()) e.g. in the event of a detected bad page, unloaded modules that carried a taint/or taints are displayed too. A tainted module unload count is maintained.

The number of tracked modules is not fixed. This feature is disabled by default.

---
  init/Kconfig         | 11 ++++++++
  kernel/module/main.c | 65 ++++++++++++++++++++++++++++++++++++++++++++
  2 files changed, 76 insertions(+)
init/Kconfig +11 -0
index ddcbefe535e9..6b30210f787d 100644
@@ -2118,6 +2118,17 @@ config MODULE_FORCE_UNLOAD
  	  rmmod).  This is mainly for kernel developers and desperate users.
  	  If unsure, say N.
 
+config MODULE_UNLOAD_TAINT_TRACKING
+	bool "Tainted module unload tracking"
+	depends on MODULE_UNLOAD
+	default n
+	help
+	  This option allows you to maintain a record of each unloaded
+	  module that tainted the kernel. In addition to displaying a
+	  list of linked (or loaded) modules e.g. on detection of a bad
+	  page (see bad_page()), the aforementioned details are also
+	  shown. If unsure, say N.
+
  config MODVERSIONS
  	bool "Module versioning support"
  	help
kernel/module/main.c +10 -0
index ea78cec316dd..35686e63b32f 100644
@@ -68,6 +68,16 @@
   */
  DEFINE_MUTEX(module_mutex);
  LIST_HEAD(modules);
+#ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
+static LIST_HEAD(unloaded_tainted_modules);
+
+struct mod_unload_taint {
+	struct list_head list;
+	char name[MODULE_NAME_LEN];
+	unsigned long taints;
+	u64 count;
+};
+#endif
 
  /* Work queue for freeing init sections in success case */
  static void do_free_init(struct work_struct *w);
@@ -150,6 +160,41 @@ int unregister_module_notifier(struct notifier_block *nb)
  }
  EXPORT_SYMBOL(unregister_module_notifier);
 

kernel/module/main.c int unregister_module_notifier(struct notifier_block *nb) · line 172

Quoted 10 lines
kernel/module/main.c +10 -0
+#ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
+static int try_add_tainted_module(struct module *mod)
+{
+	struct mod_unload_taint *mod_taint;
+
+	module_assert_mutex_or_preempt();
+
+	list_for_each_entry_rcu(mod_taint, &unloaded_tainted_modules, list,
+				lockdep_is_held(&module_mutex)) {
+		size_t len = strlen(mod_taint->name);

Why do you need that strlen() at all, can't you just use strcmp() ?

With strncmp() what happens if for instance mod_taint->name is "dead" and mod->name is "deadbeef" ?

Quoted 69 lines
kernel/module/main.c +45 -0
+
+		if (!strncmp(mod_taint->name, mod->name, len) &&
+		    mod_taint->taints & mod->taints) {
+			mod_taint->count++;
+			goto out;
+		}
+	}
+
+	mod_taint = kmalloc(sizeof(*mod_taint), GFP_KERNEL);
+	if (unlikely(!mod_taint))
+		return -ENOMEM;
+	strscpy(mod_taint->name, mod->name, MODULE_NAME_LEN);
+	mod_taint->taints = mod->taints;
+	list_add_rcu(&mod_taint->list, &unloaded_tainted_modules);
+	mod_taint->count = 1;
+out:
+	return 0;
+}
+#else /* MODULE_UNLOAD_TAINT_TRACKING */
+static int try_add_tainted_module(struct module *mod)
+{
+	return 0;
+}
+#endif
+
  /*
   * We require a truly strong try_module_get(): 0 means success.
   * Otherwise an error is returned due to ongoing or failed
@@ -1201,6 +1246,9 @@ static void free_module(struct module *mod)
  	module_bug_cleanup(mod);
  	/* Wait for RCU-sched synchronizing before releasing mod->list and buglist. */
  	synchronize_rcu();
+	if (try_add_tainted_module(mod))
+		pr_err("%s: adding tainted module to the unloaded tainted modules list failed.\n",
+		       mod->name);
  	mutex_unlock(&module_mutex);
 
  	/* Clean up CFI for the module. */
@@ -3126,6 +3174,9 @@ struct module *__module_text_address(unsigned long addr)
  void print_modules(void)
  {
  	struct module *mod;
+#ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
+	struct mod_unload_taint *mod_taint;
+#endif
  	char buf[MODULE_FLAGS_BUF_SIZE];
 
  	printk(KERN_DEFAULT "Modules linked in:");
@@ -3136,6 +3187,20 @@ void print_modules(void)
  			continue;
  		pr_cont(" %s%s", mod->name, module_flags(mod, buf));
  	}
+#ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
+	if (!list_empty(&unloaded_tainted_modules)) {
+		printk(KERN_DEFAULT "Unloaded tainted modules:");
+		list_for_each_entry_rcu(mod_taint, &unloaded_tainted_modules,
+					list) {
+			size_t l;
+
+			l = module_flags_taint(mod_taint->taints, buf);
+			buf[l++] = '\0';
+			pr_cont(" %s(%s):%llu", mod_taint->name, buf,
+				mod_taint->count);
+		}
+	}
+#endif
  	preempt_enable();
  	if (last_unloaded_module[0])
  		pr_cont(" [last unloaded: %s]", last_unloaded_module);
#4 lore raw
Quoted 4 lines · Christophe Leroy
Quoted 4 lines
kernel/module/main.c +0 -0
@@ -150,6 +160,41 @@ int unregister_module_notifier(struct notifier_block *nb)
  }
  EXPORT_SYMBOL(unregister_module_notifier);
 
Quoted 14 lines

kernel/module/main.c int unregister_module_notifier(struct notifier_block *nb) · line 172

Quoted 10 lines
kernel/module/main.c +10 -0
+#ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
+static int try_add_tainted_module(struct module *mod)
+{
+	struct mod_unload_taint *mod_taint;
+
+	module_assert_mutex_or_preempt();
+
+	list_for_each_entry_rcu(mod_taint, &unloaded_tainted_modules, list,
+				lockdep_is_held(&module_mutex)) {
+		size_t len = strlen(mod_taint->name);

Why do you need that strlen() at all, can't you just use strcmp() ? With strncmp() what happens if for instance mod_taint->name is "dead" and mod->name is "deadbeef" ?

Hi Christophe,

Thanks for your feedback.

I see that. Furthermore, the length of a module's name is fixed. Hence strcmp() should be fine.

Kind regards,

Signature · 1 line
Aaron Tomlin
maintainer
#5 lore raw
In reply to Aaron Tomlin
Quoted 19 lines · Aaron Tomlin

Hi Luis,

This iteration is still based on the latest mcgrof/modules-next branch.

I have decided still to use RCU even though no entry is ever removed from the unloaded tainted modules list. That being said, if I understand correctly, it is not safe in some instances to use 'module_mutex' in print_modules(). So instead we disable preemption to ensure list traversal with concurrent list manipulation e.g. list_add_rcu(), is safe too.

Changes since v3 [1]
- Fixed kernel build error reported by kernel test robot i.e. moved '#endif' outside 'if (!list_empty(&unloaded_tainted_modules))' statement in the context of print_modules()
- Used strncmp() instead of memcmp()
(Oleksandr Natalenko)
- Removed the additional strlen()
(Christoph Lameter)

Quoted 7 lines

Changes since v2 [2]
- Dropped RFC from subject
- Removed the newline i.e. "\n" in printk()
- Always include the tainted module's unload count
- Unconditionally display each unloaded tainted module

Please let me know your thoughts.

This all looks good except with all the work you did to remove #ifdef hell, it gets me wondering why not just use a new file for this?

What does that look like?

Luis

#6 lore raw
Quoted 4 lines · Luis Chamberlain

This all looks good except with all the work you did to remove #ifdef hell, it gets me wondering why not just use a new file for this?

What does that look like?

Hi Luis,

I thought about it. It is indeed possible. Yet, I do not think it is worth it, for such a small change; albeit, what do you prefer?

Kind regards,

Signature · 1 line
Aaron Tomlin
maintainer
#7 lore raw
Quoted 10 lines · Aaron Tomlin
Quoted 4 lines · Luis Chamberlain

This all looks good except with all the work you did to remove #ifdef hell, it gets me wondering why not just use a new file for this?

What does that look like?

Hi Luis,

I thought about it. It is indeed possible. Yet, I do not think it is worth it, for such a small change; albeit, what do you prefer?

I'd rather see the effort than not, given all the effort to already split things. I think it keeps things pretty tidy and it can scale / and its easier to review.

Luis

#8 lore raw
Quoted 2 lines · Luis Chamberlain

I'd rather see the effort than not, given all the effort to already split things. I think it keeps things pretty tidy and it can scale / and its easier to review.

Fair enough. I'll create another iteration of the series.

Signature · 1 line
Aaron Tomlin