Skip to contentSkip to conversation

kernel/module: have the callers of set_memory_*() check the return value

RFC PATCH In review Tianlin Li 4 participants 8 messages Nov 19, 2019 – Nov 20, 2019

Subsystems (7)
Arm (32-bit) x86 arm64 Tracing +3 more subsystems
lore
Share & tools
lore

Tianlin Li

author
#0 lore raw

RFC PATCH 1/1 kernel/module: have the callers of set_memory_*() check the return value

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute. They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few steps on effects architectures[1]:
1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

[1]:https://github.com/KSPP/linux/issues/7

---
 arch/arm/kernel/ftrace.c   |   8 +-
 arch/arm64/kernel/ftrace.c |   6 +-
 arch/nds32/kernel/ftrace.c |   6 +-
 arch/x86/kernel/ftrace.c   |  13 ++-
 include/linux/module.h     |  16 ++--
 kernel/livepatch/core.c    |  15 +++-
 kernel/module.c            | 170 +++++++++++++++++++++++++++----------
 kernel/trace/ftrace.c      |  15 +++-
 8 files changed, 175 insertions(+), 74 deletions(-)
arch/arm/kernel/ftrace.c +5 -3
index bda949fd84e8..7ea1338821d6 100644
@@ -59,13 +59,15 @@ static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
 
 int ftrace_arch_code_modify_prepare(void)
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
+	int ret;
+	ret = set_all_modules_text_ro();
+	if (ret)
+		return ret;
 	/* Make sure any TLB misses during machine stop are cleared. */
 	flush_tlb_all();
 	return 0;
arch/arm64/kernel/ftrace.c +4 -2
index 171773257974..97a89c38f6b9 100644
@@ -115,9 +115,11 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 			}
 
 			/* point the trampoline to our ftrace entry point */
-			module_disable_ro(mod);
+			if (module_disable_ro(mod))
+				return -EINVAL;
 			*dst = trampoline;
-			module_enable_ro(mod, true);
+			if (module_enable_ro(mod, true))
+				return -EINVAL;
 
 			/*
 			 * Ensure updated trampoline is visible to instruction
arch/nds32/kernel/ftrace.c +2 -4
index fd2a54b8cd57..e9e63e703a3e 100644
@@ -91,14 +91,12 @@ int __init ftrace_dyn_arch_init(void)
 
 int ftrace_arch_code_modify_prepare(void)
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
-	return 0;
+	return set_all_modules_text_ro();
 }
 
 static unsigned long gen_sethi_insn(unsigned long addr)
arch/x86/kernel/ftrace.c +10 -3
index 024c3053dbba..7fdee06e2a76 100644
@@ -42,19 +42,26 @@ int ftrace_arch_code_modify_prepare(void)
 	 * and live kernel patching from changing the text permissions while
 	 * ftrace has it set to "read/write".
 	 */
+	int ret;
 	mutex_lock(&text_mutex);
 	set_kernel_text_rw();
-	set_all_modules_text_rw();
+	ret = set_all_modules_text_rw();
+	if (ret) {
+		set_kernel_text_ro();
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	return 0;
 }
 
 int ftrace_arch_code_modify_post_process(void)
     __releases(&text_mutex)
 {
-	set_all_modules_text_ro();
+	int ret;
+	ret = set_all_modules_text_ro();
 	set_kernel_text_ro();
 	mutex_unlock(&text_mutex);
-	return 0;
+	return ret;
 }
 
 union ftrace_code_union {
include/linux/module.h +8 -8
index 1455812dd325..e6c7f3b719a3 100644
@@ -847,15 +847,15 @@ extern int module_sysfs_initialized;
 #define __MODULE_STRING(x) __stringify(x)
 
 #ifdef CONFIG_STRICT_MODULE_RWX
-extern void set_all_modules_text_rw(void);
-extern void set_all_modules_text_ro(void);
-extern void module_enable_ro(const struct module *mod, bool after_init);
-extern void module_disable_ro(const struct module *mod);
+extern int set_all_modules_text_rw(void);
+extern int set_all_modules_text_ro(void);
+extern int module_enable_ro(const struct module *mod, bool after_init);
+extern int module_disable_ro(const struct module *mod);
 #else
-static inline void set_all_modules_text_rw(void) { }
-static inline void set_all_modules_text_ro(void) { }
-static inline void module_enable_ro(const struct module *mod, bool after_init) { }
-static inline void module_disable_ro(const struct module *mod) { }
+static inline int set_all_modules_text_rw(void) { return 0; }
+static inline int set_all_modules_text_ro(void) { return 0; }
+static inline int module_enable_ro(const struct module *mod, bool after_init) { return 0; }
+static inline int module_disable_ro(const struct module *mod) { return 0; }
 #endif
 
 #ifdef CONFIG_GENERIC_BUG
kernel/livepatch/core.c +12 -3
index c4ce08f43bd6..39bfc0685854 100644
@@ -721,16 +721,25 @@ static int klp_init_object_loaded(struct klp_patch *patch,
 
 	mutex_lock(&text_mutex);
 
-	module_disable_ro(patch->mod);
+	ret = module_disable_ro(patch->mod);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	ret = klp_write_object_relocations(patch->mod, obj);
 	if (ret) {
-		module_enable_ro(patch->mod, true);
+		if (module_enable_ro(patch->mod, true));
+			pr_err("module_enable_ro failed.\n");
 		mutex_unlock(&text_mutex);
 		return ret;
 	}
 
 	arch_klp_init_object_loaded(patch, obj);
-	module_enable_ro(patch->mod, true);
+	ret = module_enable_ro(patch->mod, true);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 
 	mutex_unlock(&text_mutex);
 
kernel/module.c +123 -47

272 lines not on this page · raw message

kernel/trace/ftrace.c +11 -4
index f9821a3374e9..d4532bb65d1b 100644
@@ -5814,8 +5814,13 @@ void ftrace_module_enable(struct module *mod)
 	 * text to read-only, as we now need to set it back to read-write
 	 * so that we can modify the text.
 	 */
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_prepare();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_prepare();
+		if (ret) {
+			FTRACE_WARN_ON(ret);
+			goto out_unlock;
+		}
+	}
 
 	do_for_each_ftrace_rec(pg, rec) {
 		int cnt;
@@ -5854,8 +5859,10 @@ void ftrace_module_enable(struct module *mod)
 	} while_for_each_ftrace_rec();
 
  out_loop:
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_post_process();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_post_process();
+		FTRACE_WARN_ON(ret);
+	}
 
  out_unlock:
 	mutex_unlock(&ftrace_lock);
Signature · 1 line
2.17.1
#1 lore raw
Quoted 6 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute. They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few steps on effects architectures[1]:

Awesome; thanks for working on this!

A few suggestions on this patch, which will help reviewers, below...

Quoted 5 lines

1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Maybe clarify to say something like "this series is step 1"?

Quoted 17 lines

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

[1]:https://github.com/KSPP/linux/issues/7

Quoted 10 lines
---
 arch/arm/kernel/ftrace.c   |   8 +-
 arch/arm64/kernel/ftrace.c |   6 +-
 arch/nds32/kernel/ftrace.c |   6 +-
 arch/x86/kernel/ftrace.c   |  13 ++-
 include/linux/module.h     |  16 ++--
 kernel/livepatch/core.c    |  15 +++-
 kernel/module.c            | 170 +++++++++++++++++++++++++++----------
 kernel/trace/ftrace.c      |  15 +++-
 8 files changed, 175 insertions(+), 74 deletions(-)

- Can you break this patch into 3 separate patches, by "subsystem":
- ftrace
- module
- livepatch (unless Jessica thinks maybe livepatch should go with module?)
- Please run patches through scripts/checkpatch.pl to catch common coding style issues (e.g. blank line between variable declarations and function body).
- These changes look pretty straight forward, so I think it'd be fine to drop the "RFC" tag and include [email protected] in the Cc list for the v2. For lots of detail, see:
https://www.kernel.org/doc/html/latest/process/submitting-patches.html

More below...

Quoted 8 lines
arch/arm/kernel/ftrace.c +0 -0
index bda949fd84e8..7ea1338821d6 100644
@@ -59,13 +59,15 @@ static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
 
 int ftrace_arch_code_modify_prepare(void)

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 67

Quoted 10 lines
arch/arm/kernel/ftrace.c +2 -3
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
+	int ret;

Blank line here...

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 73

Quoted 6 lines
arch/arm/kernel/ftrace.c +3 -0
+	ret = set_all_modules_text_ro();
+	if (ret)
+		return ret;
 	/* Make sure any TLB misses during machine stop are cleared. */
 	flush_tlb_all();
 	return 0;

Are callers of these ftrace functions checking return values too?

Quoted 44 lines
arch/arm64/kernel/ftrace.c +4 -2
index 171773257974..97a89c38f6b9 100644
@@ -115,9 +115,11 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 			}
 
 			/* point the trampoline to our ftrace entry point */
-			module_disable_ro(mod);
+			if (module_disable_ro(mod))
+				return -EINVAL;
 			*dst = trampoline;
-			module_enable_ro(mod, true);
+			if (module_enable_ro(mod, true))
+				return -EINVAL;
 
 			/*
 			 * Ensure updated trampoline is visible to instruction
arch/nds32/kernel/ftrace.c +2 -4
index fd2a54b8cd57..e9e63e703a3e 100644
@@ -91,14 +91,12 @@ int __init ftrace_dyn_arch_init(void)
 
 int ftrace_arch_code_modify_prepare(void)
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
-	return 0;
+	return set_all_modules_text_ro();
 }
 
 static unsigned long gen_sethi_insn(unsigned long addr)
arch/x86/kernel/ftrace.c +0 -0
index 024c3053dbba..7fdee06e2a76 100644

arch/x86/kernel/ftrace.c int ftrace_arch_code_modify_prepare(void) · line 50

Quoted 10 lines
arch/x86/kernel/ftrace.c +4 -1
@@ -42,19 +42,26 @@ int ftrace_arch_code_modify_prepare(void)
 	 * and live kernel patching from changing the text permissions while
 	 * ftrace has it set to "read/write".
 	 */
+	int ret;
 	mutex_lock(&text_mutex);
 	set_kernel_text_rw();
-	set_all_modules_text_rw();
+	ret = set_all_modules_text_rw();
+	if (ret) {
+		set_kernel_text_ro();

Is the set_kernel_text_ro() here is an atomicity fix? Also, won't a future patch need to check the result of that function call? (i.e. should it be left out of this series and should atomicity fixes happen inside the set_memory_*() functions? Can they happen there?)

arch/x86/kernel/ftrace.c int ftrace_arch_code_modify_prepare(void) · line 60

Quoted 11 lines
arch/x86/kernel/ftrace.c +4 -1
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	return 0;
 }
 
 int ftrace_arch_code_modify_post_process(void)
     __releases(&text_mutex)
 {
-	set_all_modules_text_ro();
+	int ret;

blank line needed...

Quoted 22 lines
arch/x86/kernel/ftrace.c +2 -1
+	ret = set_all_modules_text_ro();
 	set_kernel_text_ro();
 	mutex_unlock(&text_mutex);
-	return 0;
+	return ret;
 }
 
 union ftrace_code_union {
include/linux/module.h +2 -4
index 1455812dd325..e6c7f3b719a3 100644
@@ -847,15 +847,15 @@ extern int module_sysfs_initialized;
 #define __MODULE_STRING(x) __stringify(x)
 
 #ifdef CONFIG_STRICT_MODULE_RWX
-extern void set_all_modules_text_rw(void);
-extern void set_all_modules_text_ro(void);
-extern void module_enable_ro(const struct module *mod, bool after_init);
-extern void module_disable_ro(const struct module *mod);
+extern int set_all_modules_text_rw(void);
+extern int set_all_modules_text_ro(void);

include/linux/module.h extern int module_sysfs_initialized; · line 857

Quoted 10 lines
include/linux/module.h +5 -4
+extern int module_enable_ro(const struct module *mod, bool after_init);
+extern int module_disable_ro(const struct module *mod);
 #else
-static inline void set_all_modules_text_rw(void) { }
-static inline void set_all_modules_text_ro(void) { }
-static inline void module_enable_ro(const struct module *mod, bool after_init) { }
-static inline void module_disable_ro(const struct module *mod) { }
+static inline int set_all_modules_text_rw(void) { return 0; }
+static inline int set_all_modules_text_ro(void) { return 0; }
+static inline int module_enable_ro(const struct module *mod, bool after_init) { return 0; }

Please wrap this line (yes, the old one wasn't...)

Quoted 13 lines
include/linux/module.h +1 -0
+static inline int module_disable_ro(const struct module *mod) { return 0; }
 #endif
 
 #ifdef CONFIG_GENERIC_BUG
kernel/livepatch/core.c +0 -1
index c4ce08f43bd6..39bfc0685854 100644
@@ -721,16 +721,25 @@ static int klp_init_object_loaded(struct klp_patch *patch,
 
 	mutex_lock(&text_mutex);
 
-	module_disable_ro(patch->mod);

kernel/livepatch/core.c static int klp_init_object_loaded(struct klp_patch *patch, · line 732

Quoted 10 lines
kernel/livepatch/core.c +7 -1
+	ret = module_disable_ro(patch->mod);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	ret = klp_write_object_relocations(patch->mod, obj);
 	if (ret) {
-		module_enable_ro(patch->mod, true);
+		if (module_enable_ro(patch->mod, true));
+			pr_err("module_enable_ro failed.\n");

Why the pr_err() here and not in other failure cases? (Also, should it instead be a WARN_ONCE() inside the set_memory_*() functions instead?)

Quoted 188 lines
kernel/livepatch/core.c +5 -1
 		mutex_unlock(&text_mutex);
 		return ret;
 	}
 
 	arch_klp_init_object_loaded(patch, obj);
-	module_enable_ro(patch->mod, true);
+	ret = module_enable_ro(patch->mod, true);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 
 	mutex_unlock(&text_mutex);
 
kernel/module.c +72 -33
index 9ee93421269c..87125b5e315c 100644
@@ -1900,111 +1900,162 @@ static void mod_sysfs_teardown(struct module *mod)
  *
  * These values are always page-aligned (as is base)
  */
-static void frob_text(const struct module_layout *layout,
+static int frob_text(const struct module_layout *layout,
 		      int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->text_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base,
+	return set_memory((unsigned long)layout->base,
 		   layout->text_size >> PAGE_SHIFT);
 }
 
 #ifdef CONFIG_STRICT_MODULE_RWX
-static void frob_rodata(const struct module_layout *layout,
+static int frob_rodata(const struct module_layout *layout,
 			int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->text_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->text_size,
+	return set_memory((unsigned long)layout->base + layout->text_size,
 		   (layout->ro_size - layout->text_size) >> PAGE_SHIFT);
 }
 
-static void frob_ro_after_init(const struct module_layout *layout,
+static int frob_ro_after_init(const struct module_layout *layout,
 				int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_after_init_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->ro_size,
+	return set_memory((unsigned long)layout->base + layout->ro_size,
 		   (layout->ro_after_init_size - layout->ro_size) >> PAGE_SHIFT);
 }
 
-static void frob_writable_data(const struct module_layout *layout,
+static int frob_writable_data(const struct module_layout *layout,
 			       int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_after_init_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->ro_after_init_size,
+	return set_memory((unsigned long)layout->base + layout->ro_after_init_size,
 		   (layout->size - layout->ro_after_init_size) >> PAGE_SHIFT);
 }
 
 /* livepatching wants to disable read-only so it can frob module. */
-void module_disable_ro(const struct module *mod)
+int module_disable_ro(const struct module *mod)
 {
+	int ret;
 	if (!rodata_enabled)
-		return;
+		return 0;
 
-	frob_text(&mod->core_layout, set_memory_rw);
-	frob_rodata(&mod->core_layout, set_memory_rw);
-	frob_ro_after_init(&mod->core_layout, set_memory_rw);
-	frob_text(&mod->init_layout, set_memory_rw);
-	frob_rodata(&mod->init_layout, set_memory_rw);
+	ret = frob_text(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_ro_after_init(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_rw);
+	if (ret)
+		return ret;
+
+	return 0;
 }
 
-void module_enable_ro(const struct module *mod, bool after_init)
+int module_enable_ro(const struct module *mod, bool after_init)
 {
+	int ret;
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	set_vm_flush_reset_perms(mod->core_layout.base);
 	set_vm_flush_reset_perms(mod->init_layout.base);
-	frob_text(&mod->core_layout, set_memory_ro);
+	ret = frob_text(&mod->core_layout, set_memory_ro);
+	if (ret)
+		return ret;
 
-	frob_rodata(&mod->core_layout, set_memory_ro);
-	frob_text(&mod->init_layout, set_memory_ro);
-	frob_rodata(&mod->init_layout, set_memory_ro);
+	ret = frob_rodata(&mod->core_layout, set_memory_ro);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_ro);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_ro);
+	if (ret)
+		return ret;
 
-	if (after_init)
-		frob_ro_after_init(&mod->core_layout, set_memory_ro);
+	if (after_init) {
+		ret = frob_ro_after_init(&mod->core_layout, set_memory_ro);
+		if (ret)
+			return ret;
+	}
+	return 0;
 }
 
-static void module_enable_nx(const struct module *mod)
+static int module_enable_nx(const struct module *mod)
 {
-	frob_rodata(&mod->core_layout, set_memory_nx);
-	frob_ro_after_init(&mod->core_layout, set_memory_nx);
-	frob_writable_data(&mod->core_layout, set_memory_nx);
-	frob_rodata(&mod->init_layout, set_memory_nx);
-	frob_writable_data(&mod->init_layout, set_memory_nx);
+	int ret;
+
+	ret = frob_rodata(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_ro_after_init(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_writable_data(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_writable_data(&mod->init_layout, set_memory_nx);
+	if (ret)
+		return ret;
+
+	return 0;
 }
 
 /* Iterate through all modules and set each module's text as RW */
-void set_all_modules_text_rw(void)
+int set_all_modules_text_rw(void)
 {
 	struct module *mod;
+	int ret;
 
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	mutex_lock(&module_mutex);
 	list_for_each_entry_rcu(mod, &modules, list) {
 		if (mod->state == MODULE_STATE_UNFORMED)
 			continue;
 
-		frob_text(&mod->core_layout, set_memory_rw);
-		frob_text(&mod->init_layout, set_memory_rw);

kernel/module.c static void mod_sysfs_teardown(struct module *mod) · line 2045

Quoted 10 lines
kernel/module.c +10 -0
+		ret = frob_text(&mod->core_layout, set_memory_rw);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
+		ret = frob_text(&mod->init_layout, set_memory_rw);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}

This pattern feels like it might be better with a "goto out" style:

	mutex_lock...
	list_for_each... {
		ret = frob_...
		if (ret)
			goto out;
		ret = frob_...
		if (ret)
			goto out;
	}
	ret = 0;
out:
	mutex_unlock...
	return ret;
Quoted 102 lines
kernel/module.c +41 -14
 	}
 	mutex_unlock(&module_mutex);
+	return 0;
 }
 
 /* Iterate through all modules and set each module's text as RO */
-void set_all_modules_text_ro(void)
+int set_all_modules_text_ro(void)
 {
 	struct module *mod;
+	int ret;
 
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	mutex_lock(&module_mutex);
 	list_for_each_entry_rcu(mod, &modules, list) {
@@ -2017,22 +2068,37 @@ void set_all_modules_text_ro(void)
 			mod->state == MODULE_STATE_GOING)
 			continue;
 
-		frob_text(&mod->core_layout, set_memory_ro);
-		frob_text(&mod->init_layout, set_memory_ro);
+		ret = frob_text(&mod->core_layout, set_memory_ro);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
+		ret = frob_text(&mod->init_layout, set_memory_ro);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
 	}
 	mutex_unlock(&module_mutex);
+	return 0;
 }
 #else /* !CONFIG_STRICT_MODULE_RWX */
-static void module_enable_nx(const struct module *mod) { }
+static int module_enable_nx(const struct module *mod) { return 0; }
 #endif /*  CONFIG_STRICT_MODULE_RWX */
-static void module_enable_x(const struct module *mod)
+static int module_enable_x(const struct module *mod)
 {
-	frob_text(&mod->core_layout, set_memory_x);
-	frob_text(&mod->init_layout, set_memory_x);
+	int ret;
+	ret = frob_text(&mod->core_layout, set_memory_x);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_x);
+	if (ret)
+		return ret;
+	return 0;
 }
 #else /* !CONFIG_ARCH_HAS_STRICT_MODULE_RWX */
-static void module_enable_nx(const struct module *mod) { }
-static void module_enable_x(const struct module *mod) { }
+static int module_enable_nx(const struct module *mod) { return 0; }
+static int module_enable_x(const struct module *mod) { return 0; }
 #endif /* CONFIG_ARCH_HAS_STRICT_MODULE_RWX */
 
 
@@ -3534,7 +3600,11 @@ static noinline int do_init_module(struct module *mod)
 	/* Switch to core kallsyms now init is done: kallsyms may be walking! */
 	rcu_assign_pointer(mod->kallsyms, &mod->core_kallsyms);
 #endif
-	module_enable_ro(mod, true);
+	ret = module_enable_ro(mod, true);
+	if (ret) {
+		mutex_unlock(&module_mutex);
+		goto fail_free_freeinit;
+	}
 	mod_tree_remove_init(mod);
 	module_arch_freeing_init(mod);
 	mod->init_layout.base = NULL;
@@ -3640,9 +3710,15 @@ static int complete_formation(struct module *mod, struct load_info *info)
 	/* This relies on module_mutex for list integrity. */
 	module_bug_finalize(info->hdr, info->sechdrs, mod);
 
-	module_enable_ro(mod, false);
-	module_enable_nx(mod);
-	module_enable_x(mod);
+	err = module_enable_ro(mod, false);
+	if (err)
+		goto out;
+	err = module_enable_nx(mod);
+	if (err)
+		goto out;
+	err = module_enable_x(mod);
+	if (err)
+		goto out;
 
 	/* Mark state as coming so strong_try_module_get() ignores us,
 	 * but kallsyms etc. can see us. */
kernel/trace/ftrace.c +0 -0
index f9821a3374e9..d4532bb65d1b 100644
@@ -5814,8 +5814,13 @@ void ftrace_module_enable(struct module *mod)
 	 * text to read-only, as we now need to set it back to read-write

kernel/trace/ftrace.c void ftrace_module_enable(struct module *mod) · line 5822

Quoted 10 lines
kernel/trace/ftrace.c +6 -2
 	 * so that we can modify the text.
 	 */
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_prepare();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_prepare();
+		if (ret) {
+			FTRACE_WARN_ON(ret);
+			goto out_unlock;
+		}

Can FTRACE_WARN_ON() be used in an "if" like WARN_ON? This could maybe look like:

ret = ftrace_arch...
if (FTRACE_WARN_ON(ret))
goto out_unlock

Though I not this doesn't result in an error getting passed up? i.e. ftrace_module_enable() is still "void". Does that matter here?

Quoted 20 lines
kernel/trace/ftrace.c +5 -2
+	}
 
 	do_for_each_ftrace_rec(pg, rec) {
 		int cnt;
@@ -5854,8 +5859,10 @@ void ftrace_module_enable(struct module *mod)
 	} while_for_each_ftrace_rec();
 
  out_loop:
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_post_process();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_post_process();
+		FTRACE_WARN_ON(ret);
+	}
 
  out_unlock:
 	mutex_unlock(&ftrace_lock);
Signature · 1 line
2.17.1

Thanks!

Signature · 1 line
Kees Cook
#2 lore raw
Quoted 20 lines · Kees Cook
Quoted 7 lines
arch/arm/kernel/ftrace.c +0 -0
index bda949fd84e8..7ea1338821d6 100644
@@ -59,13 +59,15 @@ static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
 
 int ftrace_arch_code_modify_prepare(void)

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 67

Quoted 10 lines
arch/arm/kernel/ftrace.c +2 -3
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
+	int ret;

Blank line here...

Quoted 8 lines

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 73

Quoted 6 lines
arch/arm/kernel/ftrace.c +3 -0
+	ret = set_all_modules_text_ro();
+	if (ret)
+		return ret;
 	/* Make sure any TLB misses during machine stop are cleared. */
 	flush_tlb_all();
 	return 0;

Are callers of these ftrace functions checking return values too?

Aside from the fact that I just deleted the set_all_modules_text_*() functions, ftrace actually does check the return value. It prvides a nice WARN and kills ftrace dead.

Quoted 16 lines
Quoted 16 lines
arch/arm64/kernel/ftrace.c +4 -2
index 171773257974..97a89c38f6b9 100644
@@ -115,9 +115,11 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 			}
 
 			/* point the trampoline to our ftrace entry point */
-			module_disable_ro(mod);
+			if (module_disable_ro(mod))
+				return -EINVAL;
 			*dst = trampoline;
-			module_enable_ro(mod, true);
+			if (module_enable_ro(mod, true))
+				return -EINVAL;
 
Quoted 2 lines

arch/arm64/kernel/ftrace.c int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr) · line 125

Quoted 2 lines
arch/arm64/kernel/ftrace.c +0 -0
 			/*
 			 * Ensure updated trampoline is visible to instruction

Patching dead code again:

https://lkml.kernel.org/r/[email protected]

author
#3 lore raw
In reply to Kees Cook
Quoted 15 lines · Kees Cook
Quoted 6 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute. They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few steps on effects architectures[1]:

Awesome; thanks for working on this!

A few suggestions on this patch, which will help reviewers, below...

Quoted 7 lines
Quoted 5 lines

1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Maybe clarify to say something like "this series is step 1”?

ok. Will add the clarification. Thanks!

Quoted 29 lines
Quoted 19 lines

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

[1]:https://github.com/KSPP/linux/issues/7

---

Quoted 9 lines
arch/arm/kernel/ftrace.c   |   8 +-
arch/arm64/kernel/ftrace.c |   6 +-
arch/nds32/kernel/ftrace.c |   6 +-
arch/x86/kernel/ftrace.c   |  13 ++-
include/linux/module.h     |  16 ++--
kernel/livepatch/core.c    |  15 +++-
kernel/module.c            | 170 +++++++++++++++++++++++++++----------
kernel/trace/ftrace.c      |  15 +++-
8 files changed, 175 insertions(+), 74 deletions(-)
Quoted 12 lines

- Can you break this patch into 3 separate patches, by "subsystem":
- ftrace
- module
- livepatch (unless Jessica thinks maybe livepatch should go
with module?)
- Please run patches through scripts/checkpatch.pl to catch common
coding style issues (e.g. blank line between variable declarations
and function body).
- These changes look pretty straight forward, so I think it'd be fine
to drop the "RFC" tag and include [email protected] <mailto:[email protected]> in the
Cc list for the v2. For lots of detail, see:
https://www.kernel.org/doc/html/latest/process/submitting-patches.html <https://www.kernel.org/doc/html/latest/process/submitting-patches.html>

ok. I will fix them in v2. Thanks a lot!

Quoted 23 lines

More below...

Quoted 8 lines
arch/arm/kernel/ftrace.c +0 -0
index bda949fd84e8..7ea1338821d6 100644
@@ -59,13 +59,15 @@ static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
 
 int ftrace_arch_code_modify_prepare(void)

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 67

Quoted 10 lines
arch/arm/kernel/ftrace.c +2 -3
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
+	int ret;

Blank line here...

Quoted 8 lines

arch/arm/kernel/ftrace.c static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr) · line 73

Quoted 6 lines
arch/arm/kernel/ftrace.c +3 -0
+	ret = set_all_modules_text_ro();
+	if (ret)
+		return ret;
 	/* Make sure any TLB misses during machine stop are cleared. */
 	flush_tlb_all();
 	return 0;

Are callers of these ftrace functions checking return values too?

ftrace_arch_code_modify_prepare is called in ftrace_run_update_code and ftrace_module_enable. ftrace_run_update_code is checking the return value of ftrace_arch_code_modify_prepare already. ftrace_module_enable didn’t check. (I modifies this function in this patch to check the return value of ftrace_arch_code_modify_prepare ). Same for ftrace_arch_code_modify_post_process.

Quoted 51 lines
Quoted 51 lines
arch/arm64/kernel/ftrace.c +4 -2
index 171773257974..97a89c38f6b9 100644
@@ -115,9 +115,11 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 			}
 
 			/* point the trampoline to our ftrace entry point */
-			module_disable_ro(mod);
+			if (module_disable_ro(mod))
+				return -EINVAL;
 			*dst = trampoline;
-			module_enable_ro(mod, true);
+			if (module_enable_ro(mod, true))
+				return -EINVAL;
 
 			/*
 			 * Ensure updated trampoline is visible to instruction
arch/nds32/kernel/ftrace.c +2 -4
index fd2a54b8cd57..e9e63e703a3e 100644
@@ -91,14 +91,12 @@ int __init ftrace_dyn_arch_init(void)
 
 int ftrace_arch_code_modify_prepare(void)
 {
-	set_all_modules_text_rw();
-	return 0;
+	return set_all_modules_text_rw();
 }
 
 int ftrace_arch_code_modify_post_process(void)
 {
-	set_all_modules_text_ro();
-	return 0;
+	return set_all_modules_text_ro();
 }
 
 static unsigned long gen_sethi_insn(unsigned long addr)
arch/x86/kernel/ftrace.c +1 -1
index 024c3053dbba..7fdee06e2a76 100644
@@ -42,19 +42,26 @@ int ftrace_arch_code_modify_prepare(void)
 	 * and live kernel patching from changing the text permissions while
 	 * ftrace has it set to "read/write".
 	 */
+	int ret;
 	mutex_lock(&text_mutex);
 	set_kernel_text_rw();
-	set_all_modules_text_rw();
Quoted 8 lines

arch/x86/kernel/ftrace.c int ftrace_arch_code_modify_prepare(void) · line 50

Quoted 3 lines
arch/x86/kernel/ftrace.c +3 -0
+	ret = set_all_modules_text_rw();
+	if (ret) {
+		set_kernel_text_ro();

Is the set_kernel_text_ro() here is an atomicity fix? Also, won't a future patch need to check the result of that function call? (i.e. should it be left out of this series and should atomicity fixes happen inside the set_memory_*() functions? Can they happen there?)

set_kernel_text_tro() here was not for an atomicity fix in step 3, it was just for reverting the status in ftrace_arch_code_modify_prepare, because set_kernel_text_rw() is called.
Thanks for pointing it out. I will check it.

Quoted 62 lines

arch/x86/kernel/ftrace.c int ftrace_arch_code_modify_prepare(void) · line 60

Quoted 12 lines
arch/x86/kernel/ftrace.c +4 -1
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	return 0;
 }
 
 int ftrace_arch_code_modify_post_process(void)
    __releases(&text_mutex)
 {
-	set_all_modules_text_ro();
+	int ret;

blank line needed...

Quoted 22 lines
arch/x86/kernel/ftrace.c +2 -1
+	ret = set_all_modules_text_ro();
 	set_kernel_text_ro();
 	mutex_unlock(&text_mutex);
-	return 0;
+	return ret;
 }
 
 union ftrace_code_union {
include/linux/module.h +2 -4
index 1455812dd325..e6c7f3b719a3 100644
@@ -847,15 +847,15 @@ extern int module_sysfs_initialized;
 #define __MODULE_STRING(x) __stringify(x)
 
 #ifdef CONFIG_STRICT_MODULE_RWX
-extern void set_all_modules_text_rw(void);
-extern void set_all_modules_text_ro(void);
-extern void module_enable_ro(const struct module *mod, bool after_init);
-extern void module_disable_ro(const struct module *mod);
+extern int set_all_modules_text_rw(void);
+extern int set_all_modules_text_ro(void);

include/linux/module.h extern int module_sysfs_initialized; · line 857

Quoted 10 lines
include/linux/module.h +5 -4
+extern int module_enable_ro(const struct module *mod, bool after_init);
+extern int module_disable_ro(const struct module *mod);
 #else
-static inline void set_all_modules_text_rw(void) { }
-static inline void set_all_modules_text_ro(void) { }
-static inline void module_enable_ro(const struct module *mod, bool after_init) { }
-static inline void module_disable_ro(const struct module *mod) { }
+static inline int set_all_modules_text_rw(void) { return 0; }
+static inline int set_all_modules_text_ro(void) { return 0; }
+static inline int module_enable_ro(const struct module *mod, bool after_init) { return 0; }

Please wrap this line (yes, the old one wasn't...)

Quoted 12 lines
include/linux/module.h +1 -0
+static inline int module_disable_ro(const struct module *mod) { return 0; }
 #endif
 
 #ifdef CONFIG_GENERIC_BUG
kernel/livepatch/core.c +0 -0
index c4ce08f43bd6..39bfc0685854 100644
@@ -721,16 +721,25 @@ static int klp_init_object_loaded(struct klp_patch *patch,
 
 	mutex_lock(&text_mutex);
 
Quoted 14 lines

kernel/livepatch/core.c static int klp_init_object_loaded(struct klp_patch *patch, · line 732

Quoted 11 lines
kernel/livepatch/core.c +7 -2
-	module_disable_ro(patch->mod);
+	ret = module_disable_ro(patch->mod);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	ret = klp_write_object_relocations(patch->mod, obj);
 	if (ret) {
-		module_enable_ro(patch->mod, true);
+		if (module_enable_ro(patch->mod, true));
+			pr_err("module_enable_ro failed.\n");

Why the pr_err() here and not in other failure cases? (Also, should it instead be a WARN_ONCE() inside the set_memory_*() functions instead?)

Because module_enable_ro() is called in the checking of another return value. I can not return the value, so I print the error. Similar to the previous question, should it be fixed by atomicity patches later?

Quoted 202 lines
Quoted 189 lines
kernel/livepatch/core.c +5 -1
 		mutex_unlock(&text_mutex);
 		return ret;
 	}
 
 	arch_klp_init_object_loaded(patch, obj);
-	module_enable_ro(patch->mod, true);
+	ret = module_enable_ro(patch->mod, true);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 
 	mutex_unlock(&text_mutex);
 
kernel/module.c +72 -33
index 9ee93421269c..87125b5e315c 100644
@@ -1900,111 +1900,162 @@ static void mod_sysfs_teardown(struct module *mod)
 *
 * These values are always page-aligned (as is base)
 */
-static void frob_text(const struct module_layout *layout,
+static int frob_text(const struct module_layout *layout,
 		      int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->text_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base,
+	return set_memory((unsigned long)layout->base,
 		   layout->text_size >> PAGE_SHIFT);
 }
 
 #ifdef CONFIG_STRICT_MODULE_RWX
-static void frob_rodata(const struct module_layout *layout,
+static int frob_rodata(const struct module_layout *layout,
 			int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->text_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->text_size,
+	return set_memory((unsigned long)layout->base + layout->text_size,
 		   (layout->ro_size - layout->text_size) >> PAGE_SHIFT);
 }
 
-static void frob_ro_after_init(const struct module_layout *layout,
+static int frob_ro_after_init(const struct module_layout *layout,
 				int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_after_init_size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->ro_size,
+	return set_memory((unsigned long)layout->base + layout->ro_size,
 		   (layout->ro_after_init_size - layout->ro_size) >> PAGE_SHIFT);
 }
 
-static void frob_writable_data(const struct module_layout *layout,
+static int frob_writable_data(const struct module_layout *layout,
 			       int (*set_memory)(unsigned long start, int num_pages))
 {
 	BUG_ON((unsigned long)layout->base & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->ro_after_init_size & (PAGE_SIZE-1));
 	BUG_ON((unsigned long)layout->size & (PAGE_SIZE-1));
-	set_memory((unsigned long)layout->base + layout->ro_after_init_size,
+	return set_memory((unsigned long)layout->base + layout->ro_after_init_size,
 		   (layout->size - layout->ro_after_init_size) >> PAGE_SHIFT);
 }
 
 /* livepatching wants to disable read-only so it can frob module. */
-void module_disable_ro(const struct module *mod)
+int module_disable_ro(const struct module *mod)
 {
+	int ret;
 	if (!rodata_enabled)
-		return;
+		return 0;
 
-	frob_text(&mod->core_layout, set_memory_rw);
-	frob_rodata(&mod->core_layout, set_memory_rw);
-	frob_ro_after_init(&mod->core_layout, set_memory_rw);
-	frob_text(&mod->init_layout, set_memory_rw);
-	frob_rodata(&mod->init_layout, set_memory_rw);
+	ret = frob_text(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_ro_after_init(&mod->core_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_rw);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_rw);
+	if (ret)
+		return ret;
+
+	return 0;
 }
 
-void module_enable_ro(const struct module *mod, bool after_init)
+int module_enable_ro(const struct module *mod, bool after_init)
 {
+	int ret;
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	set_vm_flush_reset_perms(mod->core_layout.base);
 	set_vm_flush_reset_perms(mod->init_layout.base);
-	frob_text(&mod->core_layout, set_memory_ro);
+	ret = frob_text(&mod->core_layout, set_memory_ro);
+	if (ret)
+		return ret;
 
-	frob_rodata(&mod->core_layout, set_memory_ro);
-	frob_text(&mod->init_layout, set_memory_ro);
-	frob_rodata(&mod->init_layout, set_memory_ro);
+	ret = frob_rodata(&mod->core_layout, set_memory_ro);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_ro);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_ro);
+	if (ret)
+		return ret;
 
-	if (after_init)
-		frob_ro_after_init(&mod->core_layout, set_memory_ro);
+	if (after_init) {
+		ret = frob_ro_after_init(&mod->core_layout, set_memory_ro);
+		if (ret)
+			return ret;
+	}
+	return 0;
 }
 
-static void module_enable_nx(const struct module *mod)
+static int module_enable_nx(const struct module *mod)
 {
-	frob_rodata(&mod->core_layout, set_memory_nx);
-	frob_ro_after_init(&mod->core_layout, set_memory_nx);
-	frob_writable_data(&mod->core_layout, set_memory_nx);
-	frob_rodata(&mod->init_layout, set_memory_nx);
-	frob_writable_data(&mod->init_layout, set_memory_nx);
+	int ret;
+
+	ret = frob_rodata(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_ro_after_init(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_writable_data(&mod->core_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_rodata(&mod->init_layout, set_memory_nx);
+	if (ret)
+		return ret;
+	ret = frob_writable_data(&mod->init_layout, set_memory_nx);
+	if (ret)
+		return ret;
+
+	return 0;
 }
 
 /* Iterate through all modules and set each module's text as RW */
-void set_all_modules_text_rw(void)
+int set_all_modules_text_rw(void)
 {
 	struct module *mod;
+	int ret;
 
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	mutex_lock(&module_mutex);
 	list_for_each_entry_rcu(mod, &modules, list) {
 		if (mod->state == MODULE_STATE_UNFORMED)
 			continue;
 
-		frob_text(&mod->core_layout, set_memory_rw);
-		frob_text(&mod->init_layout, set_memory_rw);

kernel/module.c static void mod_sysfs_teardown(struct module *mod) · line 2045

Quoted 10 lines
kernel/module.c +10 -0
+		ret = frob_text(&mod->core_layout, set_memory_rw);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
+		ret = frob_text(&mod->init_layout, set_memory_rw);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}

This pattern feels like it might be better with a "goto out" style:

Quoted 13 lines
	mutex_lock...
	list_for_each... {
		ret = frob_...
		if (ret)
			goto out;
		ret = frob_...
		if (ret)
			goto out;
	}
	ret = 0;
out:
	mutex_unlock...
	return ret;

Thanks! Will fix it in v2.

Quoted 117 lines
Quoted 103 lines
kernel/module.c +41 -14
 	}
 	mutex_unlock(&module_mutex);
+	return 0;
 }
 
 /* Iterate through all modules and set each module's text as RO */
-void set_all_modules_text_ro(void)
+int set_all_modules_text_ro(void)
 {
 	struct module *mod;
+	int ret;
 
 	if (!rodata_enabled)
-		return;
+		return 0;
 
 	mutex_lock(&module_mutex);
 	list_for_each_entry_rcu(mod, &modules, list) {
@@ -2017,22 +2068,37 @@ void set_all_modules_text_ro(void)
 			mod->state == MODULE_STATE_GOING)
 			continue;
 
-		frob_text(&mod->core_layout, set_memory_ro);
-		frob_text(&mod->init_layout, set_memory_ro);
+		ret = frob_text(&mod->core_layout, set_memory_ro);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
+		ret = frob_text(&mod->init_layout, set_memory_ro);
+		if (ret) {
+			mutex_unlock(&module_mutex);
+			return ret;
+		}
 	}
 	mutex_unlock(&module_mutex);
+	return 0;
 }
 #else /* !CONFIG_STRICT_MODULE_RWX */
-static void module_enable_nx(const struct module *mod) { }
+static int module_enable_nx(const struct module *mod) { return 0; }
 #endif /*  CONFIG_STRICT_MODULE_RWX */
-static void module_enable_x(const struct module *mod)
+static int module_enable_x(const struct module *mod)
 {
-	frob_text(&mod->core_layout, set_memory_x);
-	frob_text(&mod->init_layout, set_memory_x);
+	int ret;
+	ret = frob_text(&mod->core_layout, set_memory_x);
+	if (ret)
+		return ret;
+	ret = frob_text(&mod->init_layout, set_memory_x);
+	if (ret)
+		return ret;
+	return 0;
 }
 #else /* !CONFIG_ARCH_HAS_STRICT_MODULE_RWX */
-static void module_enable_nx(const struct module *mod) { }
-static void module_enable_x(const struct module *mod) { }
+static int module_enable_nx(const struct module *mod) { return 0; }
+static int module_enable_x(const struct module *mod) { return 0; }
 #endif /* CONFIG_ARCH_HAS_STRICT_MODULE_RWX */
 
 
@@ -3534,7 +3600,11 @@ static noinline int do_init_module(struct module *mod)
 	/* Switch to core kallsyms now init is done: kallsyms may be walking! */
 	rcu_assign_pointer(mod->kallsyms, &mod->core_kallsyms);
 #endif
-	module_enable_ro(mod, true);
+	ret = module_enable_ro(mod, true);
+	if (ret) {
+		mutex_unlock(&module_mutex);
+		goto fail_free_freeinit;
+	}
 	mod_tree_remove_init(mod);
 	module_arch_freeing_init(mod);
 	mod->init_layout.base = NULL;
@@ -3640,9 +3710,15 @@ static int complete_formation(struct module *mod, struct load_info *info)
 	/* This relies on module_mutex for list integrity. */
 	module_bug_finalize(info->hdr, info->sechdrs, mod);
 
-	module_enable_ro(mod, false);
-	module_enable_nx(mod);
-	module_enable_x(mod);
+	err = module_enable_ro(mod, false);
+	if (err)
+		goto out;
+	err = module_enable_nx(mod);
+	if (err)
+		goto out;
+	err = module_enable_x(mod);
+	if (err)
+		goto out;
 
 	/* Mark state as coming so strong_try_module_get() ignores us,
 	 * but kallsyms etc. can see us. */
kernel/trace/ftrace.c +0 -0
index f9821a3374e9..d4532bb65d1b 100644
@@ -5814,8 +5814,13 @@ void ftrace_module_enable(struct module *mod)
 	 * text to read-only, as we now need to set it back to read-write

kernel/trace/ftrace.c void ftrace_module_enable(struct module *mod) · line 5822

Quoted 10 lines
kernel/trace/ftrace.c +6 -2
 	 * so that we can modify the text.
 	 */
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_prepare();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_prepare();
+		if (ret) {
+			FTRACE_WARN_ON(ret);
+			goto out_unlock;
+		}

Can FTRACE_WARN_ON() be used in an "if" like WARN_ON? This could maybe look like:

Quoted 6 lines

ret = ftrace_arch...
if (FTRACE_WARN_ON(ret))
goto out_unlock

Though I not this doesn't result in an error getting passed up? i.e. ftrace_module_enable() is still "void". Does that matter here?

Thanks. I will fix it in v2.

Quoted 15 lines
Quoted 15 lines
kernel/trace/ftrace.c +5 -2
+	}
 
 	do_for_each_ftrace_rec(pg, rec) {
 		int cnt;
@@ -5854,8 +5859,10 @@ void ftrace_module_enable(struct module *mod)
 	} while_for_each_ftrace_rec();
 
 out_loop:
-	if (ftrace_start_up)
-		ftrace_arch_code_modify_post_process();
+	if (ftrace_start_up) {
+		int ret = ftrace_arch_code_modify_post_process();
+		FTRACE_WARN_ON(ret);
+	}
 
Quoted 7 lines
Quoted 5 lines
kernel/trace/ftrace.c +0 -0
 out_unlock:
 	mutex_unlock(&ftrace_lock);
Signature · 1 line
2.17.1

Thanks,

Thanks for all detail suggestions!

Quoted 2 lines
Signature · 1 line
Kees Cook
#4 lore raw
In reply to Tianlin Li
Quoted 16 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute. They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few steps on effects architectures[1]:
1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

Quoted 8 lines

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

Please have a look here:

https://lkml.kernel.org/r/[email protected]

Much of the code you're patching is slated for removal.

Josh also has patches reworking KLP and there's some ARM64 patches pending at which point we can also delete module_disable_ro().

author
#5 lore raw
Quoted 30 lines · Peter Zijlstra
Quoted 16 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute. They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few steps on effects architectures[1]:
1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

Quoted 8 lines

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

Quoted 8 lines

Please have a look here:

https://lkml.kernel.org/r/[email protected] <https://lkml.kernel.org/r/[email protected]>

Much of the code you're patching is slated for removal.

Josh also has patches reworking KLP and there's some ARM64 patches pending at which point we can also delete module_disable_ro().

Thanks for the information. I will check the code.

maintainer
#6 lore raw
In reply to Tianlin Li
Quoted 3 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute.

Please formulate commit messages in passive tone. "we" is ambiguous.

From Documentation/process/submitting-patches.rst:

"Describe your changes in imperative mood, e.g. "make xyzzy do frotz"
instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy to do frotz", as if you are giving orders to the codebase to change its behaviour."

Also, you could add a high-level summary of the failure case from:

https://lore.kernel.org/netdev/[email protected]/

as a more real-life, convincing justification for this.

Quoted 6 lines

They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few
steps on effects architectures[1]:
1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not

__must_check

Quoted 20 lines

ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

[1]:https://github.com/KSPP/linux/issues/7

Quoted 10 lines
---
 arch/arm/kernel/ftrace.c   |   8 +-
 arch/arm64/kernel/ftrace.c |   6 +-
 arch/nds32/kernel/ftrace.c |   6 +-
 arch/x86/kernel/ftrace.c   |  13 ++-
 include/linux/module.h     |  16 ++--
 kernel/livepatch/core.c    |  15 +++-
 kernel/module.c            | 170 +++++++++++++++++++++++++++----------
 kernel/trace/ftrace.c      |  15 +++-
 8 files changed, 175 insertions(+), 74 deletions(-)

Yeah, general idea makes sense but you'd need to redo your patch ontop of linux-next because there are some changes in flight in ftrace-land at least and your patch won't apply anymore after next week, when the merge window opens.

Also, you should use checkpatch before sending a patch as sometimes it makes sense what it complains about:

WARNING: Missing a blank line after declarations
#79: FILE: arch/arm/kernel/ftrace.c:68:
+ int ret;
+ ret = set_all_modules_text_ro();

WARNING: Missing a blank line after declarations
#150: FILE: arch/x86/kernel/ftrace.c:61:
+ int ret;
+ ret = set_all_modules_text_ro();

WARNING: trailing semicolon indicates no statements, indent implies otherwise #203: FILE: kernel/livepatch/core.c:731:
+ if (module_enable_ro(patch->mod, true));
+ pr_err("module_enable_ro failed.\n");

ERROR: trailing statements should be on next line
#203: FILE: kernel/livepatch/core.c:731:
+ if (module_enable_ro(patch->mod, true));

WARNING: Missing a blank line after declarations
#451: FILE: kernel/module.c:2091:
+ int ret;
+ ret = frob_text(&mod->core_layout, set_memory_x);

WARNING: Missing a blank line after declarations
#511: FILE: kernel/trace/ftrace.c:5819:
+ int ret = ftrace_arch_code_modify_prepare();
+ if (ret) {

WARNING: Missing a blank line after declarations
#527: FILE: kernel/trace/ftrace.c:5864:
+ int ret = ftrace_arch_code_modify_post_process();
+ FTRACE_WARN_ON(ret);

Quoted 8 lines
kernel/livepatch/core.c +0 -0
index c4ce08f43bd6..39bfc0685854 100644
@@ -721,16 +721,25 @@ static int klp_init_object_loaded(struct klp_patch *patch,
 
 	mutex_lock(&text_mutex);
 

kernel/livepatch/core.c static int klp_init_object_loaded(struct klp_patch *patch, · line 731

Quoted 10 lines
kernel/livepatch/core.c +6 -2
-	module_disable_ro(patch->mod);
+	ret = module_disable_ro(patch->mod);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	ret = klp_write_object_relocations(patch->mod, obj);
 	if (ret) {
-		module_enable_ro(patch->mod, true);
+		if (module_enable_ro(patch->mod, true));
		^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

and if you look at its output above closely, it might even help you catch the bug you've added.

[ Don't worry, happens to the best of us. :-) ]

Also, what would help review is if you split your patch:

patch 1: Change functions to return a retval patch 2-n: Change call sites to handle retval properly

Thx.

Signature · 4 lines
Regards/Gruss,
    Boris.

https://people.kernel.org/tglx/notes-about-netiquette
author
#7 lore raw
Quoted 18 lines · Borislav Petkov
Quoted 3 lines · Tianlin Li

Right now several architectures allow their set_memory_*() family of functions to fail, but callers may not be checking the return values. We need to fix the callers and add the __must_check attribute.

Please formulate commit messages in passive tone. "we" is ambiguous.

From Documentation/process/submitting-patches.rst:

"Describe your changes in imperative mood, e.g. "make xyzzy do frotz"
instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy to do frotz", as if you are giving orders to the codebase to change its behaviour."

Quoted 5 lines

Also, you could add a high-level summary of the failure case from:

https://lore.kernel.org/netdev/[email protected]/ <https://lore.kernel.org/netdev/[email protected]/>

as a more real-life, convincing justification for this.

Thanks for pointing it out. I will fix them in v2.

Quoted 105 lines
Quoted 6 lines

They also may not provide any level of atomicity, in the sense that the memory protections may be left incomplete on failure. This issue likely has a few
steps on effects architectures[1]:
1)Have all callers of set_memory_*() helpers check the return value. 2)Add __much_check to all set_memory_*() helpers so that new uses do not

__must_check

Quoted 21 lines

ignore the return value.
3)Add atomicity to the calls so that the memory protections aren't left in a partial state.

Ideally, the failure of set_memory_*() should be passed up the call stack, and callers should examine the failure and deal with it. But currently, some callers just have void return type.

We need to fix the callers to handle the return all the way to the top of stack, and it will require a large series of patches to finish all the three steps mentioned above. I start with kernel/module, and will move onto other subsystems. I am not entirely sure about the failure modes for each caller. So I would like to get some comments before I move forward. This single patch is just for fixing the return value of set_memory_*() function in kernel/module, and also the related callers. Any feedback would be greatly appreciated.

[1]:https://github.com/KSPP/linux/issues/7

---

Quoted 9 lines
arch/arm/kernel/ftrace.c   |   8 +-
arch/arm64/kernel/ftrace.c |   6 +-
arch/nds32/kernel/ftrace.c |   6 +-
arch/x86/kernel/ftrace.c   |  13 ++-
include/linux/module.h     |  16 ++--
kernel/livepatch/core.c    |  15 +++-
kernel/module.c            | 170 +++++++++++++++++++++++++++----------
kernel/trace/ftrace.c      |  15 +++-
8 files changed, 175 insertions(+), 74 deletions(-)

Yeah, general idea makes sense but you'd need to redo your patch ontop of linux-next because there are some changes in flight in ftrace-land at least and your patch won't apply anymore after next week, when the merge window opens.

Also, you should use checkpatch before sending a patch as sometimes it makes sense what it complains about:

WARNING: Missing a blank line after declarations
#79: FILE: arch/arm/kernel/ftrace.c:68:

(quoted diff) +2 -0
+       int ret;
+       ret = set_all_modules_text_ro();

WARNING: Missing a blank line after declarations
#150: FILE: arch/x86/kernel/ftrace.c:61:

(quoted diff) +2 -0
+       int ret;
+       ret = set_all_modules_text_ro();

WARNING: trailing semicolon indicates no statements, indent implies otherwise #203: FILE: kernel/livepatch/core.c:731:

kernel/livepatch/core.c +2 -0
+               if (module_enable_ro(patch->mod, true));
+                       pr_err("module_enable_ro failed.\n");

ERROR: trailing statements should be on next line
#203: FILE: kernel/livepatch/core.c:731:
+ if (module_enable_ro(patch->mod, true));

WARNING: Missing a blank line after declarations
#451: FILE: kernel/module.c:2091:

kernel/module.c +2 -0
+       int ret;
+       ret = frob_text(&mod->core_layout, set_memory_x);

WARNING: Missing a blank line after declarations
#511: FILE: kernel/trace/ftrace.c:5819:

kernel/trace/ftrace.c +2 -0
+               int ret = ftrace_arch_code_modify_prepare();
+               if (ret) {

WARNING: Missing a blank line after declarations
#527: FILE: kernel/trace/ftrace.c:5864:

kernel/trace/ftrace.c +2 -0
+               int ret = ftrace_arch_code_modify_post_process();
+               FTRACE_WARN_ON(ret);
Quoted 9 lines
kernel/livepatch/core.c +0 -0
index c4ce08f43bd6..39bfc0685854 100644
@@ -721,16 +721,25 @@ static int klp_init_object_loaded(struct klp_patch *patch,
 
 	mutex_lock(&text_mutex);
 

kernel/livepatch/core.c static int klp_init_object_loaded(struct klp_patch *patch, · line 731

Quoted 10 lines
kernel/livepatch/core.c +6 -2
-	module_disable_ro(patch->mod);
+	ret = module_disable_ro(patch->mod);
+	if (ret) {
+		mutex_unlock(&text_mutex);
+		return ret;
+	}
 	ret = klp_write_object_relocations(patch->mod, obj);
 	if (ret) {
-		module_enable_ro(patch->mod, true);
+		if (module_enable_ro(patch->mod, true));
		^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

and if you look at its output above closely, it might even help you catch the bug you've added.

Quoted 6 lines

[ Don't worry, happens to the best of us. :-) ]

Also, what would help review is if you split your patch:

patch 1: Change functions to return a retval patch 2-n: Change call sites to handle retval properly

ok. I will redo the patch on top of linux-next. I will use checkpatch and split the patch properly in v2. Thanks for all valuable comments. Really appreciate it.

Quoted 7 lines

Thx.

Signature · 4 lines
Regards/Gruss,
   Boris.

https://people.kernel.org/tglx/notes-about-netiquette <https://people.kernel.org/tglx/notes-about-netiquette>