Unverified Commit d4b539ad authored by Palmer Dabbelt's avatar Palmer Dabbelt
Browse files

Merge patch series "riscv: Various text patching improvements" 

Samuel Holland <samuel.holland@sifive.com> says:

Here are a few changes to minimize calls to stop_machine() and
flush_icache_*() in the various text patching functions, as well as
to simplify the code.

* b4-shazam-merge:
  riscv: Remove extra variable in patch_text_nosync()
  riscv: Use offset_in_page() in text patching functions
  riscv: Pass patch_text() the length in bytes
  riscv: Simplify text patching loops
  riscv: kprobes: Use patch_text_nosync() for insn slots
  riscv: jump_label: Simplify assembly syntax
  riscv: jump_label: Batch icache maintenance

Link: https://lore.kernel.org/r/20240327160520.791322-1-samuel.holland@sifive.com


Signed-off-by: default avatarPalmer Dabbelt <palmer@rivosinc.com>
parents c74f037d 47742484

arch/riscv/include/asm/jump_label.h

+3 −1
Original line number Diff line number Diff line
@@ -12,6 +12,8 @@ 
#include <linux/types.h>

#include <asm/asm.h>



#define HAVE_JUMP_LABEL_BATCH



#define JUMP_LABEL_NOP_SIZE 4



static __always_inline bool arch_static_branch(struct static_key * const key,
@@ -44,7 +46,7 @@ static __always_inline bool arch_static_branch_jump(struct static_key * const ke 
		"	.option push				\n\t"

		"	.option norelax				\n\t"

		"	.option norvc				\n\t"

		"1:	jal		zero, %l[label]		\n\t"

		"1:	j		%l[label]		\n\t"

		"	.option pop				\n\t"

		"	.pushsection	__jump_table, \"aw\"	\n\t"

		"	.align		" RISCV_LGPTR "		\n\t"

arch/riscv/include/asm/patch.h

+1 −1
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 
int patch_insn_write(void *addr, const void *insn, size_t len);

int patch_text_nosync(void *addr, const void *insns, size_t len);

int patch_text_set_nosync(void *addr, u8 c, size_t len);

int patch_text(void *addr, u32 *insns, int ninsns);

int patch_text(void *addr, u32 *insns, size_t len);



extern int riscv_patch_in_stop_machine;

arch/riscv/kernel/jump_label.c

+12 −4
Original line number Diff line number Diff line
@@ -9,12 +9,13 @@ 
#include <linux/memory.h>

#include <linux/mutex.h>

#include <asm/bug.h>

#include <asm/cacheflush.h>

#include <asm/patch.h>



#define RISCV_INSN_NOP 0x00000013U

#define RISCV_INSN_JAL 0x0000006fU



void arch_jump_label_transform(struct jump_entry *entry,

bool arch_jump_label_transform_queue(struct jump_entry *entry,

				     enum jump_label_type type)

{

	void *addr = (void *)jump_entry_code(entry);
@@ -24,7 +25,7 @@ void arch_jump_label_transform(struct jump_entry *entry, 
		long offset = jump_entry_target(entry) - jump_entry_code(entry);



		if (WARN_ON(offset & 1 || offset < -524288 || offset >= 524288))

			return;

			return true;



		insn = RISCV_INSN_JAL |

			(((u32)offset & GENMASK(19, 12)) << (12 - 12)) |
@@ -36,6 +37,13 @@ void arch_jump_label_transform(struct jump_entry *entry, 
	}



	mutex_lock(&text_mutex);

	patch_text_nosync(addr, &insn, sizeof(insn));

	patch_insn_write(addr, &insn, sizeof(insn));

	mutex_unlock(&text_mutex);



	return true;

}



void arch_jump_label_transform_apply(void)

{

	flush_icache_all();

}

arch/riscv/kernel/patch.c

+33 −36
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
struct patch_insn {

	void *addr;

	u32 *insns;

	int ninsns;

	size_t len;

	atomic_t cpu_count;

};
@@ -54,7 +54,7 @@ static __always_inline void *patch_map(void *addr, const unsigned int fixmap) 
	BUG_ON(!page);



	return (void *)set_fixmap_offset(fixmap, page_to_phys(page) +

					 (uintaddr & ~PAGE_MASK));

					 offset_in_page(addr));

}



static void patch_unmap(int fixmap)
@@ -65,8 +65,8 @@ NOKPROBE_SYMBOL(patch_unmap); 


static int __patch_insn_set(void *addr, u8 c, size_t len)

{

	bool across_pages = (offset_in_page(addr) + len) > PAGE_SIZE;

	void *waddr = addr;

	bool across_pages = (((uintptr_t)addr & ~PAGE_MASK) + len) > PAGE_SIZE;



	/*

	 * Only two pages can be mapped at a time for writing.
@@ -102,8 +102,8 @@ NOKPROBE_SYMBOL(__patch_insn_set); 


static int __patch_insn_write(void *addr, const void *insn, size_t len)

{

	bool across_pages = (offset_in_page(addr) + len) > PAGE_SIZE;

	void *waddr = addr;

	bool across_pages = (((uintptr_t) addr & ~PAGE_MASK) + len) > PAGE_SIZE;

	int ret;



	/*
@@ -163,34 +163,34 @@ NOKPROBE_SYMBOL(__patch_insn_write); 


static int patch_insn_set(void *addr, u8 c, size_t len)

{

	size_t patched = 0;

	size_t size;

	int ret = 0;

	int ret;



	/*

	 * __patch_insn_set() can only work on 2 pages at a time so call it in a

	 * loop with len <= 2 * PAGE_SIZE.

	 */

	while (patched < len && !ret) {

		size = min_t(size_t, PAGE_SIZE * 2 - offset_in_page(addr + patched), len - patched);

		ret = __patch_insn_set(addr + patched, c, size);

	while (len) {

		size = min(len, PAGE_SIZE * 2 - offset_in_page(addr));

		ret = __patch_insn_set(addr, c, size);

		if (ret)

			return ret;



		patched += size;

		addr += size;

		len -= size;

	}



	return ret;

	return 0;

}

NOKPROBE_SYMBOL(patch_insn_set);



int patch_text_set_nosync(void *addr, u8 c, size_t len)

{

	u32 *tp = addr;

	int ret;



	ret = patch_insn_set(tp, c, len);



	ret = patch_insn_set(addr, c, len);

	if (!ret)

		flush_icache_range((uintptr_t)tp, (uintptr_t)tp + len);

		flush_icache_range((uintptr_t)addr, (uintptr_t)addr + len);



	return ret;

}
@@ -198,34 +198,35 @@ NOKPROBE_SYMBOL(patch_text_set_nosync); 


int patch_insn_write(void *addr, const void *insn, size_t len)

{

	size_t patched = 0;

	size_t size;

	int ret = 0;

	int ret;



	/*

	 * Copy the instructions to the destination address, two pages at a time

	 * because __patch_insn_write() can only handle len <= 2 * PAGE_SIZE.

	 */

	while (patched < len && !ret) {

		size = min_t(size_t, PAGE_SIZE * 2 - offset_in_page(addr + patched), len - patched);

		ret = __patch_insn_write(addr + patched, insn + patched, size);

	while (len) {

		size = min(len, PAGE_SIZE * 2 - offset_in_page(addr));

		ret = __patch_insn_write(addr, insn, size);

		if (ret)

			return ret;



		patched += size;

		addr += size;

		insn += size;

		len -= size;

	}



	return ret;

	return 0;

}

NOKPROBE_SYMBOL(patch_insn_write);



int patch_text_nosync(void *addr, const void *insns, size_t len)

{

	u32 *tp = addr;

	int ret;



	ret = patch_insn_write(tp, insns, len);



	ret = patch_insn_write(addr, insns, len);

	if (!ret)

		flush_icache_range((uintptr_t) tp, (uintptr_t) tp + len);

		flush_icache_range((uintptr_t)addr, (uintptr_t)addr + len);



	return ret;

}
@@ -234,14 +235,10 @@ NOKPROBE_SYMBOL(patch_text_nosync); 
static int patch_text_cb(void *data)

{

	struct patch_insn *patch = data;

	unsigned long len;

	int i, ret = 0;

	int ret = 0;



	if (atomic_inc_return(&patch->cpu_count) == num_online_cpus()) {

		for (i = 0; ret == 0 && i < patch->ninsns; i++) {

			len = GET_INSN_LENGTH(patch->insns[i]);

			ret = patch_insn_write(patch->addr + i * len, &patch->insns[i], len);

		}

		ret = patch_insn_write(patch->addr, patch->insns, patch->len);

		/*

		 * Make sure the patching store is effective *before* we

		 * increment the counter which releases all waiting CPUs
@@ -261,13 +258,13 @@ static int patch_text_cb(void *data) 
}

NOKPROBE_SYMBOL(patch_text_cb);



int patch_text(void *addr, u32 *insns, int ninsns)

int patch_text(void *addr, u32 *insns, size_t len)

{

	int ret;

	struct patch_insn patch = {

		.addr = addr,

		.insns = insns,

		.ninsns = ninsns,

		.len = len,

		.cpu_count = ATOMIC_INIT(0),

	};

arch/riscv/kernel/probes/kprobes.c

+10 −9
Original line number Diff line number Diff line
@@ -24,14 +24,13 @@ post_kprobe_handler(struct kprobe *, struct kprobe_ctlblk *, struct pt_regs *); 


static void __kprobes arch_prepare_ss_slot(struct kprobe *p)

{

	size_t len = GET_INSN_LENGTH(p->opcode);

	u32 insn = __BUG_INSN_32;

	unsigned long offset = GET_INSN_LENGTH(p->opcode);



	p->ainsn.api.restore = (unsigned long)p->addr + offset;

	p->ainsn.api.restore = (unsigned long)p->addr + len;



	patch_text(p->ainsn.api.insn, &p->opcode, 1);

	patch_text((void *)((unsigned long)(p->ainsn.api.insn) + offset),

		   &insn, 1);

	patch_text_nosync(p->ainsn.api.insn, &p->opcode, len);

	patch_text_nosync(p->ainsn.api.insn + len, &insn, GET_INSN_LENGTH(insn));

}



static void __kprobes arch_prepare_simulate(struct kprobe *p)
@@ -108,16 +107,18 @@ int __kprobes arch_prepare_kprobe(struct kprobe *p) 
/* install breakpoint in text */

void __kprobes arch_arm_kprobe(struct kprobe *p)

{

	u32 insn = (p->opcode & __INSN_LENGTH_MASK) == __INSN_LENGTH_32 ?

		   __BUG_INSN_32 : __BUG_INSN_16;

	size_t len = GET_INSN_LENGTH(p->opcode);

	u32 insn = len == 4 ? __BUG_INSN_32 : __BUG_INSN_16;



	patch_text(p->addr, &insn, 1);

	patch_text(p->addr, &insn, len);

}



/* remove breakpoint from text */

void __kprobes arch_disarm_kprobe(struct kprobe *p)

{

	patch_text(p->addr, &p->opcode, 1);

	size_t len = GET_INSN_LENGTH(p->opcode);



	patch_text(p->addr, &p->opcode, len);

}



void __kprobes arch_remove_kprobe(struct kprobe *p)