Commit 7dd86cf8 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'livepatching-for-6.3' of... 

Merge tag 'livepatching-for-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/livepatching/livepatching

Pull livepatching updates from Petr Mladek:

 - Allow reloading a livepatched module by clearing livepatch-specific
   relocations in the livepatch module.

   Otherwise, the repeated load would fail on consistency checks.

* tag 'livepatching-for-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/livepatching/livepatching:
  livepatch,x86: Clear relocation targets on a module removal
  x86/module: remove unused code in __apply_relocate_add
parents d8763154 0c05e7bd

arch/x86/kernel/module.c

+60 −37
Original line number Diff line number Diff line
@@ -129,22 +129,27 @@ int apply_relocate(Elf32_Shdr *sechdrs, 
	return 0;

}

#else /*X86_64*/

static int __apply_relocate_add(Elf64_Shdr *sechdrs,

static int __write_relocate_add(Elf64_Shdr *sechdrs,

		   const char *strtab,

		   unsigned int symindex,

		   unsigned int relsec,

		   struct module *me,

		   void *(*write)(void *dest, const void *src, size_t len))

		   void *(*write)(void *dest, const void *src, size_t len),

		   bool apply)

{

	unsigned int i;

	Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;

	Elf64_Sym *sym;

	void *loc;

	u64 val;

	u64 zero = 0ULL;



	DEBUGP("Applying relocate section %u to %u\n",

	DEBUGP("%s relocate section %u to %u\n",

	       apply ? "Applying" : "Clearing",

	       relsec, sechdrs[relsec].sh_info);

	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {

		size_t size;



		/* This is where to make the change */

		loc = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr

			+ rel[i].r_offset;
@@ -162,55 +167,52 @@ static int __apply_relocate_add(Elf64_Shdr *sechdrs, 


		switch (ELF64_R_TYPE(rel[i].r_info)) {

		case R_X86_64_NONE:

			break;

			continue;  /* nothing to write */

		case R_X86_64_64:

			if (*(u64 *)loc != 0)

				goto invalid_relocation;

			write(loc, &val, 8);

			size = 8;

			break;

		case R_X86_64_32:

			if (*(u32 *)loc != 0)

				goto invalid_relocation;

			write(loc, &val, 4);

			if (val != *(u32 *)loc)

			if (val != *(u32 *)&val)

				goto overflow;

			size = 4;

			break;

		case R_X86_64_32S:

			if (*(s32 *)loc != 0)

				goto invalid_relocation;

			write(loc, &val, 4);

			if ((s64)val != *(s32 *)loc)

			if ((s64)val != *(s32 *)&val)

				goto overflow;

			size = 4;

			break;

		case R_X86_64_PC32:

		case R_X86_64_PLT32:

			if (*(u32 *)loc != 0)

				goto invalid_relocation;

			val -= (u64)loc;

			write(loc, &val, 4);

#if 0

			if ((s64)val != *(s32 *)loc)

				goto overflow;

#endif

			size = 4;

			break;

		case R_X86_64_PC64:

			if (*(u64 *)loc != 0)

				goto invalid_relocation;

			val -= (u64)loc;

			write(loc, &val, 8);

			size = 8;

			break;

		default:

			pr_err("%s: Unknown rela relocation: %llu\n",

			       me->name, ELF64_R_TYPE(rel[i].r_info));

			return -ENOEXEC;

		}

	}

	return 0;



invalid_relocation:

	pr_err("x86/modules: Skipping invalid relocation target, existing value is nonzero for type %d, loc %p, val %Lx\n",

		if (apply) {

			if (memcmp(loc, &zero, size)) {

				pr_err("x86/modules: Invalid relocation target, existing value is nonzero for type %d, loc %p, val %Lx\n",

				       (int)ELF64_R_TYPE(rel[i].r_info), loc, val);

				return -ENOEXEC;

			}

			write(loc, &val, size);

		} else {

			if (memcmp(loc, &val, size)) {

				pr_warn("x86/modules: Invalid relocation target, existing value does not match expected value for type %d, loc %p, val %Lx\n",

					(int)ELF64_R_TYPE(rel[i].r_info), loc, val);

				return -ENOEXEC;

			}

			write(loc, &zero, size);

		}

	}

	return 0;



overflow:

	pr_err("overflow in relocation type %d val %Lx\n",
@@ -220,11 +222,12 @@ static int __apply_relocate_add(Elf64_Shdr *sechdrs, 
	return -ENOEXEC;

}



int apply_relocate_add(Elf64_Shdr *sechdrs,

static int write_relocate_add(Elf64_Shdr *sechdrs,

			      const char *strtab,

			      unsigned int symindex,

			      unsigned int relsec,

		   struct module *me)

			      struct module *me,

			      bool apply)

{

	int ret;

	bool early = me->state == MODULE_STATE_UNFORMED;
@@ -235,8 +238,8 @@ int apply_relocate_add(Elf64_Shdr *sechdrs, 
		mutex_lock(&text_mutex);

	}



	ret = __apply_relocate_add(sechdrs, strtab, symindex, relsec, me,

				   write);

	ret = __write_relocate_add(sechdrs, strtab, symindex, relsec, me,

				   write, apply);



	if (!early) {

		text_poke_sync();
@@ -246,6 +249,26 @@ int apply_relocate_add(Elf64_Shdr *sechdrs, 
	return ret;

}



int apply_relocate_add(Elf64_Shdr *sechdrs,

		   const char *strtab,

		   unsigned int symindex,

		   unsigned int relsec,

		   struct module *me)

{

	return write_relocate_add(sechdrs, strtab, symindex, relsec, me, true);

}



#ifdef CONFIG_LIVEPATCH

void clear_relocate_add(Elf64_Shdr *sechdrs,

			const char *strtab,

			unsigned int symindex,

			unsigned int relsec,

			struct module *me)

{

	write_relocate_add(sechdrs, strtab, symindex, relsec, me, false);

}

#endif



#endif



int module_finalize(const Elf_Ehdr *hdr,

include/linux/moduleloader.h

+17 −0
Original line number Diff line number Diff line
@@ -75,6 +75,23 @@ int apply_relocate_add(Elf_Shdr *sechdrs, 
		       unsigned int symindex,

		       unsigned int relsec,

		       struct module *mod);

#ifdef CONFIG_LIVEPATCH

/*

 * Some architectures (namely x86_64 and ppc64) perform sanity checks when

 * applying relocations.  If a patched module gets unloaded and then later

 * reloaded (and re-patched), klp re-applies relocations to the replacement

 * function(s).  Any leftover relocations from the previous loading of the

 * patched module might trigger the sanity checks.

 *

 * To prevent that, when unloading a patched module, clear out any relocations

 * that might trigger arch-specific sanity checks on a future module reload.

 */

void clear_relocate_add(Elf_Shdr *sechdrs,

		   const char *strtab,

		   unsigned int symindex,

		   unsigned int relsec,

		   struct module *me);

#endif

#else

static inline int apply_relocate_add(Elf_Shdr *sechdrs,

				     const char *strtab,

kernel/livepatch/core.c

+49 −13
Original line number Diff line number Diff line
@@ -260,6 +260,14 @@ static int klp_resolve_symbols(Elf_Shdr *sechdrs, const char *strtab, 
	return 0;

}



void __weak clear_relocate_add(Elf_Shdr *sechdrs,

		   const char *strtab,

		   unsigned int symindex,

		   unsigned int relsec,

		   struct module *me)

{

}



/*

 * At a high-level, there are two types of klp relocation sections: those which

 * reference symbols which live in vmlinux; and those which reference symbols
@@ -283,10 +291,10 @@ static int klp_resolve_symbols(Elf_Shdr *sechdrs, const char *strtab, 
 *    the to-be-patched module to be loaded and patched sometime *after* the

 *    klp module is loaded.

 */

int klp_apply_section_relocs(struct module *pmod, Elf_Shdr *sechdrs,

static int klp_write_section_relocs(struct module *pmod, Elf_Shdr *sechdrs,

				    const char *shstrtab, const char *strtab,

				    unsigned int symndx, unsigned int secndx,

			     const char *objname)

				    const char *objname, bool apply)

{

	int cnt, ret;

	char sec_objname[MODULE_NAME_LEN];
@@ -308,13 +316,28 @@ int klp_apply_section_relocs(struct module *pmod, Elf_Shdr *sechdrs, 
	if (strcmp(objname ? objname : "vmlinux", sec_objname))

		return 0;



	ret = klp_resolve_symbols(sechdrs, strtab, symndx, sec, sec_objname);

	if (apply) {

		ret = klp_resolve_symbols(sechdrs, strtab, symndx,

					  sec, sec_objname);

		if (ret)

			return ret;



		return apply_relocate_add(sechdrs, strtab, symndx, secndx, pmod);

	}



	clear_relocate_add(sechdrs, strtab, symndx, secndx, pmod);

	return 0;

}



int klp_apply_section_relocs(struct module *pmod, Elf_Shdr *sechdrs,

			     const char *shstrtab, const char *strtab,

			     unsigned int symndx, unsigned int secndx,

			     const char *objname)

{

	return klp_write_section_relocs(pmod, sechdrs, shstrtab, strtab, symndx,

					secndx, objname, true);

}



/*

 * Sysfs Interface

 *
@@ -761,8 +784,9 @@ static int klp_init_func(struct klp_object *obj, struct klp_func *func) 
			   func->old_sympos ? func->old_sympos : 1);

}



static int klp_apply_object_relocs(struct klp_patch *patch,

				   struct klp_object *obj)

static int klp_write_object_relocs(struct klp_patch *patch,

				   struct klp_object *obj,

				   bool apply)

{

	int i, ret;

	struct klp_modinfo *info = patch->mod->klp_info;
@@ -773,10 +797,10 @@ static int klp_apply_object_relocs(struct klp_patch *patch, 
		if (!(sec->sh_flags & SHF_RELA_LIVEPATCH))

			continue;



		ret = klp_apply_section_relocs(patch->mod, info->sechdrs,

		ret = klp_write_section_relocs(patch->mod, info->sechdrs,

					       info->secstrings,

					       patch->mod->core_kallsyms.strtab,

					       info->symndx, i, obj->name);

					       info->symndx, i, obj->name, apply);

		if (ret)

			return ret;

	}
@@ -784,6 +808,18 @@ static int klp_apply_object_relocs(struct klp_patch *patch, 
	return 0;

}



static int klp_apply_object_relocs(struct klp_patch *patch,

				   struct klp_object *obj)

{

	return klp_write_object_relocs(patch, obj, true);

}



static void klp_clear_object_relocs(struct klp_patch *patch,

				    struct klp_object *obj)

{

	klp_write_object_relocs(patch, obj, false);

}



/* parts of the initialization that is done only when the object is loaded */

static int klp_init_object_loaded(struct klp_patch *patch,

				  struct klp_object *obj)
@@ -1171,7 +1207,7 @@ static void klp_cleanup_module_patches_limited(struct module *mod, 
			klp_unpatch_object(obj);



			klp_post_unpatch_callback(obj);



			klp_clear_object_relocs(patch, obj);

			klp_free_object_loaded(obj);

			break;

		}