module: switch to execmem API for remapping as RW and restoring ROX

Instead of using writable copy for module text sections, temporarily remap the memory allocated from execmem's ROX cache as writable and restore its ROX permissions after the module is formed. This will allow removing nasty games with writable copy in alternatives patching on x86.

Mike Rapoport (Microsoft) committed 1 year ago

Commit c287c071 parent 05e555b4 files · +27 −72Browse files

Showing the changes to kernel/module (2 of 4 files). Show all

Unified · Split

2 files

kernel/module/main.c +21 −57
kernel/module/strict_rwx.c +5 −4

kernel/module/main.c+21−57

 {
 }
-void *__module_writable_address(struct module *mod, void *loc)
-{
-	for_class_mod_mem_type(type, text) {
-		struct module_memory *mem = &mod->mem[type];
-		if (loc >= mem->base && loc < mem->base + mem->size)
-			return loc + (mem->rw_copy - mem->base);
-	}
-	return loc;
-}
 static int module_memory_alloc(struct module *mod, enum mod_mem_type type)
 {
 	unsigned int size = PAGE_ALIGN(mod->mem[type].size);
 	if (!ptr)
 		return -ENOMEM;
-	mod->mem[type].base = ptr;
 	if (execmem_is_rox(execmem_type)) {
-		ptr = vzalloc(size);
+		int err = execmem_make_temp_rw(ptr, size);
-		if (!ptr) {
+		if (err) {
-			execmem_free(mod->mem[type].base);
+			execmem_free(ptr);
 			return -ENOMEM;
 		}
-		mod->mem[type].rw_copy = ptr;
 		mod->mem[type].is_rox = true;
-	} else {
-		mod->mem[type].rw_copy = mod->mem[type].base;
-		memset(mod->mem[type].base, 0, size);
 	}
 	/*
 	 */
 	kmemleak_not_leak(ptr);
+	memset(ptr, 0, size);
+	mod->mem[type].base = ptr;
 	return 0;
 }
+static void module_memory_restore_rox(struct module *mod)
+{
+	for_class_mod_mem_type(type, text) {
+		struct module_memory *mem = &mod->mem[type];
+		if (mem->is_rox)
+			execmem_restore_rox(mem->base, mem->size);
+	}
+}
 static void module_memory_free(struct module *mod, enum mod_mem_type type)
 {
 	struct module_memory *mem = &mod->mem[type];
-	if (mem->is_rox)
-		vfree(mem->rw_copy);
 	execmem_free(mem->base);
 }
 	for_each_mod_mem_type(type) {
 		if (!mod->mem[type].size) {
 			mod->mem[type].base = NULL;
-			mod->mem[type].rw_copy = NULL;
 			continue;
 		}
 		void *dest;
 		Elf_Shdr *shdr = &info->sechdrs[i];
 		const char *sname;
-		unsigned long addr;
 		if (!(shdr->sh_flags & SHF_ALLOC))
 			continue;
 				ret = PTR_ERR(dest);
 				goto out_err;
 			}
-			addr = (unsigned long)dest;
 			codetag_section_found = true;
 		} else {
 			enum mod_mem_type type = shdr->sh_entsize >> SH_ENTSIZE_TYPE_SHIFT;
 			unsigned long offset = shdr->sh_entsize & SH_ENTSIZE_OFFSET_MASK;
-			addr = (unsigned long)mod->mem[type].base + offset;
+			dest = mod->mem[type].base + offset;
-			dest = mod->mem[type].rw_copy + offset;
 		}
 		if (shdr->sh_type != SHT_NOBITS) {
 		 * users of info can keep taking advantage and using the newly
 		 * minted official memory area.
 		 */
-		shdr->sh_addr = addr;
+		shdr->sh_addr = (unsigned long)dest;
 		pr_debug("\t0x%lx 0x%.8lx %s\n", (long)shdr->sh_addr,
 			 (long)shdr->sh_size, info->secstrings + shdr->sh_name);
 	}
 	return 0;
 out_err:
+	module_memory_restore_rox(mod);
 	for (t--; t >= 0; t--)
 		module_memory_free(mod, t);
 	if (codetag_section_found)
 	return 0;
 }
-int __weak module_post_finalize(const Elf_Ehdr *hdr,
-				const Elf_Shdr *sechdrs,
-				struct module *me)
-{
-	return 0;
-}
 static int post_relocation(struct module *mod, const struct load_info *info)
 {
-	int ret;
 	/* Sort exception table now relocations are done. */
 	sort_extable(mod->extable, mod->extable + mod->num_exentries);
 	add_kallsyms(mod, info);
 	/* Arch-specific module finalizing. */
-	ret = module_finalize(info->hdr, info->sechdrs, mod);
+	return module_finalize(info->hdr, info->sechdrs, mod);
-	if (ret)
-		return ret;
-	for_each_mod_mem_type(type) {
-		struct module_memory *mem = &mod->mem[type];
-		if (mem->is_rox) {
-			if (!execmem_update_copy(mem->base, mem->rw_copy,
-						 mem->size))
-				return -ENOMEM;
-			vfree(mem->rw_copy);
-			mem->rw_copy = NULL;
-		}
-	}
-	return module_post_finalize(info->hdr, info->sechdrs, mod);
 }
 /* Call module constructors. */
 				       mod->mem[type].size);
 	}
+	module_memory_restore_rox(mod);
 	module_deallocate(mod, info);
  free_copy:
 	/*

kernel/module/strict_rwx.c+5−4

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#include <linux/mm.h>	9	#include <linux/mm.h>
10	#include <linux/vmalloc.h>	10	#include <linux/vmalloc.h>
11	#include <linux/set_memory.h>	11	#include <linux/set_memory.h>
		12	#include <linux/execmem.h>
12	#include "internal.h"	13	#include "internal.h"
13		14
14	static int module_set_memory(const struct module *mod, enum mod_mem_type type,	15	static int module_set_memory(const struct module *mod, enum mod_mem_type type,
@@ -32,12 +33,12 @@ static int module_set_memory(const struct module *mod, enum mod_mem_type type, · 17 unmodified lines
32	int module_enable_text_rox(const struct module *mod)	33	int module_enable_text_rox(const struct module *mod)
33	{	34	{
34	for_class_mod_mem_type(type, text) {	35	for_class_mod_mem_type(type, text) {
		36	const struct module_memory *mem = &mod->mem[type];
35	int ret;	37	int ret;
36		38
37	if (mod->mem[type].is_rox)	39	if (mem->is_rox)
38	continue;	40	ret = execmem_restore_rox(mem->base, mem->size);
39		41	else if (IS_ENABLED(CONFIG_STRICT_MODULE_RWX))
40	if (IS_ENABLED(CONFIG_STRICT_MODULE_RWX))
41	ret = module_set_memory(mod, type, set_memory_rox);	42	ret = module_set_memory(mod, type, set_memory_rox);
42	else	43	else
43	ret = module_set_memory(mod, type, set_memory_x);	44	ret = module_set_memory(mod, type, set_memory_x);