Skip to contentSkip to conversation

Initial Prefixed Instruction support

PATCH Superseded Jordan Niethe 5 participants 65 messages Mar 20, 2020 – Apr 3, 2020 Page 2 of 2

Subsystems (5)
PowerPC ftrace KVM PowerPC uprobes +1 more subsystems

v4 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#52 lore raw

Re: [PATCH v4 14/16] powerpc64: Add prefixed instructions to instruction data type

In reply to Jordan Niethe

Jordan Niethe's on March 24, 2020 9:45 am:

Quoted 9 lines · Nicholas Piggin
Quoted 7 lines

Jordan Niethe's on March 20, 2020 3:18 pm:
I'm a bit against using partially constructed opaque type for things like this, even if it is in the code that knows about the type. We could modify ppc_inst_prefixed() to assert that pad is equal to zero (or some poisoned value) if it's not prefixed. Or do some validation on the suffix if it is.

Okay what about something like:

Review

Quoted 10 lines
(quoted diff) +10 -0
+static inline ppc_inst ppc_inst_read(const void *ptr)
+{
+     u32 prefix, suffix;
+     prefix = *(u32 *)ptr;
+     if (prefix >> 26 == 1)
+             suffix = *((u32 *)ptr + 1);
+     else
+             suffix = 0;
+     return PPC_INST_PREFIX(prefix, suffix);
+}

Sure, if that's the best way to test prefix.

Quoted 5 lines
Quoted 4 lines

Although there's proably no real performance or atomicity issues here, I'd be pleased if we could do a case for prefixed and a case for non prefixed, and store the non-prefixed with "std". Just for the principle of not having half-written instructions in the image.

Do you mean store the prefixed with std?

Oops, yes.

Quoted 10 lines
Quoted 10 lines

arch/powerpc/xmon/xmon.c static struct bpt *new_breakpoint(unsigned long a) · line 887

Quoted 8 lines
arch/powerpc/xmon/xmon.c +0 -1
@@ -881,7 +882,6 @@ static struct bpt *new_breakpoint(unsigned long a)
              if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
                      bp->address = a;
                      bp->instr = bpt_table + ((bp - bpts) * BPT_WORDS);
-                     patch_instruction(bp->instr + 1, PPC_INST(bpinstr));
                      return bp;
              }
      }

Why is this okay to remove?

Quoted 5 lines

When we only had word instructions the bpt was just patched in here once and that was that.
With prefixed instructions bp->instr + 1 might be the suffix. So I moved putting the breakpoint to insert_bpts():
patch_instruction(bp->instr + ppc_inst_len(instr), PPC_INST(bpinstr));

Ah okay.

Thanks,
Nick

#53 lore raw

Re: [PATCH v4 14/16] powerpc64: Add prefixed instructions to instruction data type

In reply to Jordan Niethe

<snip>

arch/powerpc/kernel/kprobes.c int kprobe_post_handler(struct pt_regs *regs) · line 490

Quoted 5 lines
arch/powerpc/kernel/kprobes.c +1 -0
@@ -487,12 +487,13 @@ int kprobe_post_handler(struct pt_regs *regs)
 {
 	struct kprobe *cur = kprobe_running();
 	struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+	int len = ppc_inst_len(ppc_inst_read(cur->ainsn.insn));

I am no kprobes expert but it seems based on the code here that in some circumstances it's ok/expected that cur == NULL, therefore the assignment needs to happen after the check below to avoid dereferencing NULL. At least this was the problem I was hitting when running some of the kernel selftests.

- Alistair

Quoted 378 lines
arch/powerpc/kernel/kprobes.c +2 -2
 	if (!cur || user_mode(regs))
 		return 0;
 
 	/* make sure we got here for instruction we have a kprobe on */
-	if (((unsigned long)cur->ainsn.insn + 4) != regs->nip)
+	if ((unsigned long)cur->ainsn.insn + len != regs->nip)
 		return 0;
 
 	if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
@@ -501,7 +502,7 @@ int kprobe_post_handler(struct pt_regs *regs)
 	}
 
 	/* Adjust nip to after the single-stepped instruction */
-	regs->nip = (unsigned long)cur->addr + 4;
+	regs->nip = (unsigned long)cur->addr + len;
 	regs->msr |= kcb->kprobe_saved_msr;
 
 	/*Restore back the original saved kprobes variables and continue. */
(quoted diff) +0 -0

b/arch/powerpc/kernel/optprobes.c index 5b53c373373b..af6761859fba 100644

arch/powerpc/kernel/optprobes.c +17 -17
@@ -158,38 +158,38 @@ void patch_imm32_load_insns(unsigned int val,
 kprobe_opcode_t *addr)
 
 /*
  * Generate instructions to load provided immediate 64-bit value
- * to register 'r3' and patch these instructions at 'addr'.
+ * to register 'reg' and patch these instructions at 'addr'.
  */
-void patch_imm64_load_insns(unsigned long val, kprobe_opcode_t *addr)
+void patch_imm64_load_insns(unsigned long val, int reg, kprobe_opcode_t
 *addr) {
-	/* lis r3,(op)@highest */
-	patch_instruction(addr, PPC_INST(PPC_INST_ADDIS | ___PPC_RT(3) |
+	/* lis reg,(op)@highest */
+	patch_instruction(addr, PPC_INST(PPC_INST_ADDIS | ___PPC_RT(reg) |
 			  ((val >> 48) & 0xffff)));
 	addr++;
 
-	/* ori r3,r3,(op)@higher */
-	patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(3) |
-			  ___PPC_RS(3) | ((val >> 32) & 0xffff)));
+	/* ori reg,reg,(op)@higher */
+	patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(reg) |
+			  ___PPC_RS(reg) | ((val >> 32) & 0xffff)));
 	addr++;
 
-	/* rldicr r3,r3,32,31 */
-	patch_instruction(addr, PPC_INST(PPC_INST_RLDICR | ___PPC_RA(3) |
-			  ___PPC_RS(3) | __PPC_SH64(32) | __PPC_ME64(31)));
+	/* rldicr reg,reg,32,31 */
+	patch_instruction(addr, PPC_INST(PPC_INST_RLDICR | ___PPC_RA(reg) |
+			  ___PPC_RS(reg) | __PPC_SH64(32) | __PPC_ME64(31)));
 	addr++;
 
-	/* oris r3,r3,(op)@h */
-	patch_instruction(addr, PPC_INST(PPC_INST_ORIS | ___PPC_RA(3) |
-			  ___PPC_RS(3) | ((val >> 16) & 0xffff)));
+	/* oris reg,reg,(op)@h */
+	patch_instruction(addr, PPC_INST(PPC_INST_ORIS | ___PPC_RA(reg) |
+			  ___PPC_RS(reg) | ((val >> 16) & 0xffff)));
 	addr++;
 
-	/* ori r3,r3,(op)@l */
-	patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(3) |
-			  ___PPC_RS(3) | (val & 0xffff)));
+	/* ori reg,reg,(op)@l */
+	patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(reg) |
+			  ___PPC_RS(reg) | (val & 0xffff)));
 }
 
 int arch_prepare_optimized_kprobe(struct optimized_kprobe *op, struct
 kprobe *p) {
-	ppc_inst branch_op_callback, branch_emulate_step;
+	ppc_inst branch_op_callback, branch_emulate_step, temp;
 	kprobe_opcode_t *op_callback_addr, *emulate_step_addr, *buff;
 	long b_offset;
arch/powerpc/kernel/optprobes.c +0 -0
 	unsigned long nip, size;
@@ -239,7 +239,7 @@ int arch_prepare_optimized_kprobe(struct

optimized_kprobe *op, struct kprobe *p) * Fixup the template with instructions to:

arch/powerpc/kernel/optprobes.c +1 -1
 	 * 1. load the address of the actual probepoint
 	 */
-	patch_imm64_load_insns((unsigned long)op, buff + TMPL_OP_IDX);
+	patch_imm64_load_insns((unsigned long)op, 3, buff + TMPL_OP_IDX);
 
 	/*
 	 * 2. branch to optimized_callback() and emulate_step()
@@ -268,7 +268,11 @@ int arch_prepare_optimized_kprobe(struct

optimized_kprobe *op, struct kprobe *p) /*

arch/powerpc/kernel/optprobes.c +0 -1
 	 * 3. load instruction to be emulated into relevant register, and
 	 */
-	patch_imm32_load_insns(*(unsigned int *)p->ainsn.insn, buff +

TMPL_INSN_IDX); + temp = ppc_inst_read(p->ainsn.insn);

arch/powerpc/kernel/optprobes.c +4 -0
+	patch_imm64_load_insns(ppc_inst_word(temp) |
+			       ((u64)ppc_inst_suffix(temp) << 32),
+			       4,
+			       buff + TMPL_INSN_IDX);
 
 	/*
 	 * 4. branch back from trampoline
(quoted diff) +0 -0

b/arch/powerpc/kernel/optprobes_head.S index cf383520843f..ff8ba4d3824d 100644

arch/powerpc/kernel/optprobes_head.S +3 -0
@@ -94,6 +94,9 @@ optprobe_template_insn:
 	/* 2, Pass instruction to be emulated in r4 */
 	nop
 	nop
+	nop
+	nop
+	nop
 
 	.global optprobe_template_call_emulate
 optprobe_template_call_emulate:
(quoted diff) +0 -0

b/arch/powerpc/kernel/trace/ftrace.c index ad451205f268..3b8655f57b4a 100644

arch/powerpc/kernel/trace/ftrace.c +17 -2
@@ -42,9 +42,24 @@
 static unsigned long ftrace_tramps[NUM_FTRACE_TRAMPS];
 
 static long
-read_inst(ppc_inst *inst, const void *src)
+read_inst(ppc_inst *p, const void *src)
 {
-	return probe_kernel_read((void *)inst, src, MCOUNT_INSN_SIZE);
+	ppc_inst inst;
+	long err;
+
+	err = probe_kernel_read((void *)&inst.prefix,
+				src, MCOUNT_INSN_SIZE);
+	if (err)
+		return err;
+
+	if (ppc_inst_prefixed(inst))
+		err = probe_kernel_read((void *)&inst.suffix,
+					src + 4, MCOUNT_INSN_SIZE);
+	if (err)
+		return err;
+
+	ppc_inst_write(p, inst);
+	return 0;
 }
 
 static ppc_inst
arch/powerpc/kernel/uprobes.c +0 -0
index d1dff1dc3a11..3e4fbb5c1b1e 100644
@@ -111,7 +111,7 @@ int arch_uprobe_post_xol(struct arch_uprobe *auprobe,

struct pt_regs *regs) * support doesn't exist and have to fix-up the next instruction * to be executed.

arch/powerpc/kernel/uprobes.c +1 -1
 	 */
-	regs->nip = utask->vaddr + MAX_UINSN_BYTES;
+	regs->nip = utask->vaddr + ppc_inst_len(ppc_inst_read(auprobe->insn));
 
 	user_disable_single_step(current);
 	return 0;
(quoted diff) +0 -0

b/arch/powerpc/lib/code-patching.c index fa7f32adf029..3b8277a64b8f 100644

arch/powerpc/lib/code-patching.c +13 -3
@@ -24,17 +24,27 @@ static int __patch_instruction(ppc_inst *exec_addr,
 ppc_inst instr, {
 	int err = 0;
 
-	__put_user_asm(instr, patch_addr, err, "stw");
+	__put_user_asm(ppc_inst_word(instr), patch_addr, err, "stw");
 	if (err)
 		return err;
 
 	asm ("dcbst 0, %0; sync; icbi 0,%1; sync; isync" :: "r" (patch_addr),
 							    "r" (exec_addr));
 
+	if (!ppc_inst_prefixed(instr))
+		return 0;
+
+	__put_user_asm(ppc_inst_suffix(instr), patch_addr + 4, err, "stw");
+	if (err)
+		return err;
+
+	asm ("dcbst 0, %0; sync; icbi 0,%1; sync; isync" :: "r" (patch_addr + 4),
+							    "r" (exec_addr + 4));
+
 	return 0;
 }
 
-int raw_patch_instruction(ppc_inst *addr, ppc_inst instr)
+int raw_patch_instruction(void *addr, ppc_inst instr)
 {
 	return __patch_instruction(addr, instr, addr);
 }
@@ -184,7 +194,7 @@ static int do_patch_instruction(ppc_inst *addr, ppc_inst
 instr)
 
 #endif /* CONFIG_STRICT_KERNEL_RWX */
 
-int patch_instruction(unsigned int *addr, unsigned int instr)
+int patch_instruction(void *addr, ppc_inst instr)
 {
 	/* Make sure we aren't patching a freed init section */
arch/powerpc/lib/code-patching.c +3 -3
 	if (init_mem_is_free && init_section_contains(addr, 4)) {
@@ -195,7 +205,7 @@ int patch_instruction(unsigned int *addr, unsigned int
 instr) }
 NOKPROBE_SYMBOL(patch_instruction);
 
-int patch_branch(ppc_inst *addr, unsigned long target, int flags)
+int patch_branch(void *addr, unsigned long target, int flags)
 {
 	return patch_instruction(addr, create_branch(addr, target, flags));
 }
@@ -264,7 +274,7 @@ ppc_inst create_branch(const ppc_inst *addr,
 	return instruction;
 }
 
-unsigned int create_cond_branch(const unsigned int *addr,
+ppc_inst create_cond_branch(const void *addr,
 				unsigned long target, int flags)
 {
 	ppc_inst instruction;
@@ -344,7 +354,7 @@ static unsigned long branch_bform_target(const ppc_inst
 *instr) return (unsigned long)imm;
 }
 
-unsigned long branch_target(const ppc_inst *instr)
+unsigned long branch_target(const void *instr)
 {
 	if (instr_is_branch_iform(ppc_inst_read(instr)))
 		return branch_iform_target(instr);
arch/powerpc/lib/sstep.c +3 -1
index bae878a83fa5..ab4c71c43c8c 100644
@@ -1169,10 +1169,12 @@ int analyse_instr(struct instruction_op *op, const
 struct pt_regs *regs, unsigned long int imm;
 	unsigned long int val, val2;
 	unsigned int mb, me, sh;
-	unsigned int word;
+	unsigned int word, suffix;
 	long ival;
 
 	word = ppc_inst_word(instr);
+	suffix = ppc_inst_suffix(instr);
+
 	op->type = COMPUTE;
 
 	opcode = word >> 26;
arch/powerpc/xmon/xmon.c +1 -2
index ee084411f2f5..c5536e1a3356 100644
@@ -110,7 +110,7 @@ struct bpt {
 #define BP_DABR		4
 
 #define NBPTS	256
-#define BPT_WORDS	2
+#define BPT_WORDS	4
 static struct bpt bpts[NBPTS];
 static struct bpt dabr;
 static struct bpt *iabr;
@@ -118,12 +118,13 @@ static unsigned bpinstr = 0x7fe00008;	/* trap */
 
 #define BP_NUM(bp)	((bp) - bpts + 1)
 
-static unsigned int __section(.text.xmon_bpts) bpt_table[NBPTS *

BPT_WORDS]; +static unsigned int __section(.text.xmon_bpts) bpt_table[NBPTS
* BPT_WORDS] __aligned(64);

/* Prototypes */
static int cmds(struct pt_regs *);
static int mread(unsigned long, void *, int);
static int mwrite(unsigned long, void *, int);

arch/powerpc/xmon/xmon.c +25 -9
+static int mread_instr(unsigned long, ppc_inst *);
 static int handle_fault(struct pt_regs *);
 static void byterev(unsigned char *, int);
 static void memex(void);
@@ -759,8 +760,8 @@ static int xmon_bpt(struct pt_regs *regs)
 
 	/* Are we at the trap at bp->instr[1] for some bp? */
 	bp = in_breakpoint_table(regs->nip, &offset);
-	if (bp != NULL && offset == 4) {
-		regs->nip = bp->address + 4;
+	if (bp != NULL && (offset == 4 || offset == 8)) {
+		regs->nip = bp->address + offset;
 		atomic_dec(&bp->ref_count);
 		return 1;
 	}
@@ -862,7 +863,7 @@ static struct bpt *in_breakpoint_table(unsigned long
 nip, unsigned long *offp) if (off >= sizeof(bpt_table))
 		return NULL;
 	bp_off = off % (sizeof(unsigned int) * BPT_WORDS);
-	if (bp_off != 0 && bp_off != 4)
+	if (bp_off != 0 && bp_off != 4 && bp_off != 8)
 		return NULL;
 	*offp = bp_off;
 	return bpts + ((off - bp_off) / (sizeof(unsigned int) * BPT_WORDS));
@@ -881,7 +882,6 @@ static struct bpt *new_breakpoint(unsigned long a)
 		if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
 			bp->address = a;
 			bp->instr = bpt_table + ((bp - bpts) * BPT_WORDS);
-			patch_instruction(bp->instr + 1, PPC_INST(bpinstr));
 			return bp;
 		}
 	}
@@ -900,7 +900,7 @@ static void insert_bpts(void)
 	for (i = 0; i < NBPTS; ++i, ++bp) {
 		if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
 			continue;
-		if (mread(bp->address, &instr, 4) != 4) {
+		if (!mread_instr(bp->address, &instr)) {
 			printf("Couldn't read instruction at %lx, "
 			       "disabling breakpoint there\n", bp->address);
 			bp->enabled = 0;
@@ -913,9 +913,10 @@ static void insert_bpts(void)
 			continue;
 		}
 		patch_instruction(bp->instr, instr);
+		patch_instruction(bp->instr + ppc_inst_len(instr), PPC_INST(bpinstr));
 		if (bp->enabled & BP_CIABR)
 			continue;
-		if (patch_instruction((ppc_inst *)bp->address,
+		if (patch_instruction((void *)bp->address,
 							PPC_INST(bpinstr)) != 0) {
 			printf("Couldn't write instruction at %lx, "
 			       "disabling breakpoint there\n", bp->address);
@@ -950,7 +951,7 @@ static void remove_bpts(void)
 	for (i = 0; i < NBPTS; ++i, ++bp) {
 		if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
 			continue;
-		if (mread(bp->address, &instr, 4) == 4
+		if (mread_instr(bp->address, &instr)
 		    && ppc_inst_equal(instr, PPC_INST(bpinstr))
 		    && patch_instruction(
 			(ppc_inst *)bp->address, ppc_inst_read(bp->instr)) != 0)
@@ -1166,7 +1167,7 @@ static int do_step(struct pt_regs *regs)
 	force_enable_xmon();
 	/* check we are in 64-bit kernel mode, translation enabled */
 	if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
-		if (mread(regs->nip, &instr, 4) == 4) {
+		if (mread_instr(regs->nip, &instr)) {
 			stepped = emulate_step(regs, instr);
 			if (stepped < 0) {
 				printf("Couldn't single-step %s instruction\n",
@@ -1333,7 +1334,7 @@ static long check_bp_loc(unsigned long addr)
 		printf("Breakpoints may only be placed at kernel addresses\n");
 		return 0;
 	}
-	if (!mread(addr, &instr, sizeof(instr))) {
+	if (!mread_instr(addr, &instr)) {
 		printf("Can't read instruction at address %lx\n", addr);
 		return 0;
 	}
@@ -2126,6 +2127,21 @@ mwrite(unsigned long adrs, void *buf, int size)
 	return n;
 }
 
+static int
+mread_instr(unsigned long adrs, ppc_inst *instr)
+{
+	if (setjmp(bus_error_jmp) == 0) {
+		catch_memory_errors = 1;
+		sync();
+		*instr = ppc_inst_read((void *)adrs);
+		sync();
+		/* wait a little while to see if we get a machine check */
+		__delay(200);
+	}
+	catch_memory_errors = 0;
+	return ppc_inst_len(*instr);
+}
+
 static int fault_type;
 static int fault_except;
 static char *fault_chars[] = { "--", "**", "##" };
#54 lore raw

Re: [PATCH v4 14/16] powerpc64: Add prefixed instructions to instruction data type

Quoted 14 lines · Alistair Popple

<snip>

arch/powerpc/kernel/kprobes.c int kprobe_post_handler(struct pt_regs *regs) · line 490

Quoted 5 lines
arch/powerpc/kernel/kprobes.c +1 -0
@@ -487,12 +487,13 @@ int kprobe_post_handler(struct pt_regs *regs)
 {
      struct kprobe *cur = kprobe_running();
      struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+     int len = ppc_inst_len(ppc_inst_read(cur->ainsn.insn));

I am no kprobes expert but it seems based on the code here that in some circumstances it's ok/expected that cur == NULL, therefore the assignment needs to happen after the check below to avoid dereferencing NULL. At least this was the problem I was hitting when running some of the kernel selftests.

Quoted 4 lines

- Alistair

Quoted 2 lines
(quoted diff) +0 -0
      if (!cur || user_mode(regs))
              return 0;

Thank you for pointing that out. I'll move the assignment down here.

Quoted 379 lines
Quoted 376 lines
arch/powerpc/kernel/kprobes.c +2 -2
      /* make sure we got here for instruction we have a kprobe on */
-     if (((unsigned long)cur->ainsn.insn + 4) != regs->nip)
+     if ((unsigned long)cur->ainsn.insn + len != regs->nip)
              return 0;
 
      if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
@@ -501,7 +502,7 @@ int kprobe_post_handler(struct pt_regs *regs)
      }
 
      /* Adjust nip to after the single-stepped instruction */
-     regs->nip = (unsigned long)cur->addr + 4;
+     regs->nip = (unsigned long)cur->addr + len;
      regs->msr |= kcb->kprobe_saved_msr;
 
      /*Restore back the original saved kprobes variables and continue. */
(quoted diff) +0 -0

b/arch/powerpc/kernel/optprobes.c index 5b53c373373b..af6761859fba 100644

arch/powerpc/kernel/optprobes.c +17 -17
@@ -158,38 +158,38 @@ void patch_imm32_load_insns(unsigned int val,
 kprobe_opcode_t *addr)
 
 /*
  * Generate instructions to load provided immediate 64-bit value
- * to register 'r3' and patch these instructions at 'addr'.
+ * to register 'reg' and patch these instructions at 'addr'.
  */
-void patch_imm64_load_insns(unsigned long val, kprobe_opcode_t *addr)
+void patch_imm64_load_insns(unsigned long val, int reg, kprobe_opcode_t
 *addr) {
-     /* lis r3,(op)@highest */
-     patch_instruction(addr, PPC_INST(PPC_INST_ADDIS | ___PPC_RT(3) |
+     /* lis reg,(op)@highest */
+     patch_instruction(addr, PPC_INST(PPC_INST_ADDIS | ___PPC_RT(reg) |
                        ((val >> 48) & 0xffff)));
      addr++;
 
-     /* ori r3,r3,(op)@higher */
-     patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(3) |
-                       ___PPC_RS(3) | ((val >> 32) & 0xffff)));
+     /* ori reg,reg,(op)@higher */
+     patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(reg) |
+                       ___PPC_RS(reg) | ((val >> 32) & 0xffff)));
      addr++;
 
-     /* rldicr r3,r3,32,31 */
-     patch_instruction(addr, PPC_INST(PPC_INST_RLDICR | ___PPC_RA(3) |
-                       ___PPC_RS(3) | __PPC_SH64(32) | __PPC_ME64(31)));
+     /* rldicr reg,reg,32,31 */
+     patch_instruction(addr, PPC_INST(PPC_INST_RLDICR | ___PPC_RA(reg) |
+                       ___PPC_RS(reg) | __PPC_SH64(32) | __PPC_ME64(31)));
      addr++;
 
-     /* oris r3,r3,(op)@h */
-     patch_instruction(addr, PPC_INST(PPC_INST_ORIS | ___PPC_RA(3) |
-                       ___PPC_RS(3) | ((val >> 16) & 0xffff)));
+     /* oris reg,reg,(op)@h */
+     patch_instruction(addr, PPC_INST(PPC_INST_ORIS | ___PPC_RA(reg) |
+                       ___PPC_RS(reg) | ((val >> 16) & 0xffff)));
      addr++;
 
-     /* ori r3,r3,(op)@l */
-     patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(3) |
-                       ___PPC_RS(3) | (val & 0xffff)));
+     /* ori reg,reg,(op)@l */
+     patch_instruction(addr, PPC_INST(PPC_INST_ORI | ___PPC_RA(reg) |
+                       ___PPC_RS(reg) | (val & 0xffff)));
 }
 
 int arch_prepare_optimized_kprobe(struct optimized_kprobe *op, struct
 kprobe *p) {
-     ppc_inst branch_op_callback, branch_emulate_step;
+     ppc_inst branch_op_callback, branch_emulate_step, temp;
      kprobe_opcode_t *op_callback_addr, *emulate_step_addr, *buff;
      long b_offset;
      unsigned long nip, size;
arch/powerpc/kernel/optprobes.c +0 -0
@@ -239,7 +239,7 @@ int arch_prepare_optimized_kprobe(struct

optimized_kprobe *op, struct kprobe *p) * Fixup the template with instructions to:
* 1. load the address of the actual probepoint */

arch/powerpc/kernel/optprobes.c +1 -1
-     patch_imm64_load_insns((unsigned long)op, buff + TMPL_OP_IDX);
+     patch_imm64_load_insns((unsigned long)op, 3, buff + TMPL_OP_IDX);
 
      /*
       * 2. branch to optimized_callback() and emulate_step()
@@ -268,7 +268,11 @@ int arch_prepare_optimized_kprobe(struct

optimized_kprobe *op, struct kprobe *p) /*
* 3. load instruction to be emulated into relevant register, and */
- patch_imm32_load_insns(*(unsigned int *)p->ainsn.insn, buff +
TMPL_INSN_IDX); + temp = ppc_inst_read(p->ainsn.insn);

arch/powerpc/kernel/optprobes.c +4 -0
+     patch_imm64_load_insns(ppc_inst_word(temp) |
+                            ((u64)ppc_inst_suffix(temp) << 32),
+                            4,
+                            buff + TMPL_INSN_IDX);
 
      /*
       * 4. branch back from trampoline
(quoted diff) +0 -0

b/arch/powerpc/kernel/optprobes_head.S index cf383520843f..ff8ba4d3824d 100644

arch/powerpc/kernel/optprobes_head.S +3 -0
@@ -94,6 +94,9 @@ optprobe_template_insn:
      /* 2, Pass instruction to be emulated in r4 */
      nop
      nop
+     nop
+     nop
+     nop
 
      .global optprobe_template_call_emulate
 optprobe_template_call_emulate:
(quoted diff) +0 -0

b/arch/powerpc/kernel/trace/ftrace.c index ad451205f268..3b8655f57b4a 100644

arch/powerpc/kernel/trace/ftrace.c +17 -2
@@ -42,9 +42,24 @@
 static unsigned long ftrace_tramps[NUM_FTRACE_TRAMPS];
 
 static long
-read_inst(ppc_inst *inst, const void *src)
+read_inst(ppc_inst *p, const void *src)
 {
-     return probe_kernel_read((void *)inst, src, MCOUNT_INSN_SIZE);
+     ppc_inst inst;
+     long err;
+
+     err = probe_kernel_read((void *)&inst.prefix,
+                             src, MCOUNT_INSN_SIZE);
+     if (err)
+             return err;
+
+     if (ppc_inst_prefixed(inst))
+             err = probe_kernel_read((void *)&inst.suffix,
+                                     src + 4, MCOUNT_INSN_SIZE);
+     if (err)
+             return err;
+
+     ppc_inst_write(p, inst);
+     return 0;
 }
 
 static ppc_inst
arch/powerpc/kernel/uprobes.c +0 -0
index d1dff1dc3a11..3e4fbb5c1b1e 100644
@@ -111,7 +111,7 @@ int arch_uprobe_post_xol(struct arch_uprobe *auprobe,

struct pt_regs *regs) * support doesn't exist and have to fix-up the next instruction * to be executed.

       */
arch/powerpc/kernel/uprobes.c +1 -1
-     regs->nip = utask->vaddr + MAX_UINSN_BYTES;
+     regs->nip = utask->vaddr + ppc_inst_len(ppc_inst_read(auprobe->insn));
 
      user_disable_single_step(current);
      return 0;
(quoted diff) +0 -0

b/arch/powerpc/lib/code-patching.c index fa7f32adf029..3b8277a64b8f 100644

arch/powerpc/lib/code-patching.c +13 -3
@@ -24,17 +24,27 @@ static int __patch_instruction(ppc_inst *exec_addr,
 ppc_inst instr, {
      int err = 0;
 
-     __put_user_asm(instr, patch_addr, err, "stw");
+     __put_user_asm(ppc_inst_word(instr), patch_addr, err, "stw");
      if (err)
              return err;
 
      asm ("dcbst 0, %0; sync; icbi 0,%1; sync; isync" :: "r" (patch_addr),
                                                          "r" (exec_addr));
 
+     if (!ppc_inst_prefixed(instr))
+             return 0;
+
+     __put_user_asm(ppc_inst_suffix(instr), patch_addr + 4, err, "stw");
+     if (err)
+             return err;
+
+     asm ("dcbst 0, %0; sync; icbi 0,%1; sync; isync" :: "r" (patch_addr + 4),
+                                                         "r" (exec_addr + 4));
+
      return 0;
 }
 
-int raw_patch_instruction(ppc_inst *addr, ppc_inst instr)
+int raw_patch_instruction(void *addr, ppc_inst instr)
 {
      return __patch_instruction(addr, instr, addr);
 }
@@ -184,7 +194,7 @@ static int do_patch_instruction(ppc_inst *addr, ppc_inst
 instr)
 
 #endif /* CONFIG_STRICT_KERNEL_RWX */
 
-int patch_instruction(unsigned int *addr, unsigned int instr)
+int patch_instruction(void *addr, ppc_inst instr)
 {
      /* Make sure we aren't patching a freed init section */
      if (init_mem_is_free && init_section_contains(addr, 4)) {
arch/powerpc/lib/code-patching.c +3 -3
@@ -195,7 +205,7 @@ int patch_instruction(unsigned int *addr, unsigned int
 instr) }
 NOKPROBE_SYMBOL(patch_instruction);
 
-int patch_branch(ppc_inst *addr, unsigned long target, int flags)
+int patch_branch(void *addr, unsigned long target, int flags)
 {
      return patch_instruction(addr, create_branch(addr, target, flags));
 }
@@ -264,7 +274,7 @@ ppc_inst create_branch(const ppc_inst *addr,
      return instruction;
 }
 
-unsigned int create_cond_branch(const unsigned int *addr,
+ppc_inst create_cond_branch(const void *addr,
                              unsigned long target, int flags)
 {
      ppc_inst instruction;
@@ -344,7 +354,7 @@ static unsigned long branch_bform_target(const ppc_inst
 *instr) return (unsigned long)imm;
 }
 
-unsigned long branch_target(const ppc_inst *instr)
+unsigned long branch_target(const void *instr)
 {
      if (instr_is_branch_iform(ppc_inst_read(instr)))
              return branch_iform_target(instr);
arch/powerpc/lib/sstep.c +3 -1
index bae878a83fa5..ab4c71c43c8c 100644
@@ -1169,10 +1169,12 @@ int analyse_instr(struct instruction_op *op, const
 struct pt_regs *regs, unsigned long int imm;
      unsigned long int val, val2;
      unsigned int mb, me, sh;
-     unsigned int word;
+     unsigned int word, suffix;
      long ival;
 
      word = ppc_inst_word(instr);
+     suffix = ppc_inst_suffix(instr);
+
      op->type = COMPUTE;
 
      opcode = word >> 26;
arch/powerpc/xmon/xmon.c +1 -2
index ee084411f2f5..c5536e1a3356 100644
@@ -110,7 +110,7 @@ struct bpt {
 #define BP_DABR              4
 
 #define NBPTS        256
-#define BPT_WORDS    2
+#define BPT_WORDS    4
 static struct bpt bpts[NBPTS];
 static struct bpt dabr;
 static struct bpt *iabr;
@@ -118,12 +118,13 @@ static unsigned bpinstr = 0x7fe00008;   /* trap */
 
 #define BP_NUM(bp)   ((bp) - bpts + 1)
 
-static unsigned int __section(.text.xmon_bpts) bpt_table[NBPTS *

BPT_WORDS]; +static unsigned int __section(.text.xmon_bpts) bpt_table[NBPTS
* BPT_WORDS] __aligned(64);

/* Prototypes */
static int cmds(struct pt_regs *);
static int mread(unsigned long, void *, int);
static int mwrite(unsigned long, void *, int);

arch/powerpc/xmon/xmon.c +25 -9
+static int mread_instr(unsigned long, ppc_inst *);
 static int handle_fault(struct pt_regs *);
 static void byterev(unsigned char *, int);
 static void memex(void);
@@ -759,8 +760,8 @@ static int xmon_bpt(struct pt_regs *regs)
 
      /* Are we at the trap at bp->instr[1] for some bp? */
      bp = in_breakpoint_table(regs->nip, &offset);
-     if (bp != NULL && offset == 4) {
-             regs->nip = bp->address + 4;
+     if (bp != NULL && (offset == 4 || offset == 8)) {
+             regs->nip = bp->address + offset;
              atomic_dec(&bp->ref_count);
              return 1;
      }
@@ -862,7 +863,7 @@ static struct bpt *in_breakpoint_table(unsigned long
 nip, unsigned long *offp) if (off >= sizeof(bpt_table))
              return NULL;
      bp_off = off % (sizeof(unsigned int) * BPT_WORDS);
-     if (bp_off != 0 && bp_off != 4)
+     if (bp_off != 0 && bp_off != 4 && bp_off != 8)
              return NULL;
      *offp = bp_off;
      return bpts + ((off - bp_off) / (sizeof(unsigned int) * BPT_WORDS));
@@ -881,7 +882,6 @@ static struct bpt *new_breakpoint(unsigned long a)
              if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
                      bp->address = a;
                      bp->instr = bpt_table + ((bp - bpts) * BPT_WORDS);
-                     patch_instruction(bp->instr + 1, PPC_INST(bpinstr));
                      return bp;
              }
      }
@@ -900,7 +900,7 @@ static void insert_bpts(void)
      for (i = 0; i < NBPTS; ++i, ++bp) {
              if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
                      continue;
-             if (mread(bp->address, &instr, 4) != 4) {
+             if (!mread_instr(bp->address, &instr)) {
                      printf("Couldn't read instruction at %lx, "
                             "disabling breakpoint there\n", bp->address);
                      bp->enabled = 0;
@@ -913,9 +913,10 @@ static void insert_bpts(void)
                      continue;
              }
              patch_instruction(bp->instr, instr);
+             patch_instruction(bp->instr + ppc_inst_len(instr), PPC_INST(bpinstr));
              if (bp->enabled & BP_CIABR)
                      continue;
-             if (patch_instruction((ppc_inst *)bp->address,
+             if (patch_instruction((void *)bp->address,
                                                      PPC_INST(bpinstr)) != 0) {
                      printf("Couldn't write instruction at %lx, "
                             "disabling breakpoint there\n", bp->address);
@@ -950,7 +951,7 @@ static void remove_bpts(void)
      for (i = 0; i < NBPTS; ++i, ++bp) {
              if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
                      continue;
-             if (mread(bp->address, &instr, 4) == 4
+             if (mread_instr(bp->address, &instr)
                  && ppc_inst_equal(instr, PPC_INST(bpinstr))
                  && patch_instruction(
                      (ppc_inst *)bp->address, ppc_inst_read(bp->instr)) != 0)
@@ -1166,7 +1167,7 @@ static int do_step(struct pt_regs *regs)
      force_enable_xmon();
      /* check we are in 64-bit kernel mode, translation enabled */
      if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
-             if (mread(regs->nip, &instr, 4) == 4) {
+             if (mread_instr(regs->nip, &instr)) {
                      stepped = emulate_step(regs, instr);
                      if (stepped < 0) {
                              printf("Couldn't single-step %s instruction\n",
@@ -1333,7 +1334,7 @@ static long check_bp_loc(unsigned long addr)
              printf("Breakpoints may only be placed at kernel addresses\n");
              return 0;
      }
-     if (!mread(addr, &instr, sizeof(instr))) {
+     if (!mread_instr(addr, &instr)) {
              printf("Can't read instruction at address %lx\n", addr);
              return 0;
      }
@@ -2126,6 +2127,21 @@ mwrite(unsigned long adrs, void *buf, int size)
      return n;
 }
 
+static int
+mread_instr(unsigned long adrs, ppc_inst *instr)
+{
+     if (setjmp(bus_error_jmp) == 0) {
+             catch_memory_errors = 1;
+             sync();
+             *instr = ppc_inst_read((void *)adrs);
+             sync();
+             /* wait a little while to see if we get a machine check */
+             __delay(200);
+     }
+     catch_memory_errors = 0;
+     return ppc_inst_len(*instr);
+}
+
 static int fault_type;
 static int fault_except;
 static char *fault_chars[] = { "--", "**", "##" };
#55 lore raw

PATCH v4 15/16 powerpc sstep: Add support for prefixed load/stores

In reply to Jordan Niethe

This adds emulation support for the following prefixed integer load/stores:
* Prefixed Load Byte and Zero (plbz)
* Prefixed Load Halfword and Zero (plhz)
* Prefixed Load Halfword Algebraic (plha)
* Prefixed Load Word and Zero (plwz)
* Prefixed Load Word Algebraic (plwa)
* Prefixed Load Doubleword (pld)
* Prefixed Store Byte (pstb)
* Prefixed Store Halfword (psth)
* Prefixed Store Word (pstw)
* Prefixed Store Doubleword (pstd)
* Prefixed Load Quadword (plq)
* Prefixed Store Quadword (pstq)

the follow prefixed floating-point load/stores:
* Prefixed Load Floating-Point Single (plfs)
* Prefixed Load Floating-Point Double (plfd)
* Prefixed Store Floating-Point Single (pstfs)
* Prefixed Store Floating-Point Double (pstfd)

and for the following prefixed VSX load/stores:
* Prefixed Load VSX Scalar Doubleword (plxsd)
* Prefixed Load VSX Scalar Single-Precision (plxssp)
* Prefixed Load VSX Vector [0|1] (plxv, plxv0, plxv1)
* Prefixed Store VSX Scalar Doubleword (pstxsd)
* Prefixed Store VSX Scalar Single-Precision (pstxssp)
* Prefixed Store VSX Vector [0|1] (pstxv, pstxv0, pstxv1)

---
v2: - Combine all load/store patches
- Fix the name of Type 01 instructions
- Remove sign extension flag from pstd/pld
- Rename sufx -> suffix
v3: - Move prefixed loads and stores into the switch statement

---
 arch/powerpc/lib/sstep.c | 159 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
arch/powerpc/lib/sstep.c +159 -0
index ab4c71c43c8c..daef70eb8e22 100644
@@ -187,6 +187,44 @@ static nokprobe_inline unsigned long xform_ea(unsigned int instr,
 	return ea;
 }
 
+/*
+ * Calculate effective address for a MLS:D-form / 8LS:D-form
+ * prefixed instruction
+ */
+static nokprobe_inline unsigned long mlsd_8lsd_ea(unsigned int instr,
+						  unsigned int suffix,
+						  const struct pt_regs *regs)
+{
+	int ra, prefix_r;
+	unsigned int  dd;
+	unsigned long ea, d0, d1, d;
+
+	prefix_r = instr & (1ul << 20);
+	ra = (suffix >> 16) & 0x1f;
+
+	d0 = instr & 0x3ffff;
+	d1 = suffix & 0xffff;
+	d = (d0 << 16) | d1;
+
+	/*
+	 * sign extend a 34 bit number
+	 */
+	dd = (unsigned int)(d >> 2);
+	ea = (signed int)dd;
+	ea = (ea << 2) | (d & 0x3);
+
+	if (!prefix_r && ra)
+		ea += regs->gpr[ra];
+	else if (!prefix_r && !ra)
+		; /* Leave ea as is */
+	else if (prefix_r && !ra)
+		ea += regs->nip;
+	else if (prefix_r && ra)
+		; /* Invalid form. Should already be checked for by caller! */
+
+	return ea;
+}
+
 /*
  * Return the largest power of 2, not greater than sizeof(unsigned long),
  * such that x is a multiple of it.
@@ -1166,6 +1204,7 @@ int analyse_instr(struct instruction_op *op, const struct pt_regs *regs,
 		  ppc_inst instr)
 {
 	unsigned int opcode, ra, rb, rc, rd, spr, u;
+	unsigned int suffixopcode, prefixtype, prefix_r;
 	unsigned long int imm;
 	unsigned long int val, val2;
 	unsigned int mb, me, sh;
@@ -2652,6 +2691,126 @@ int analyse_instr(struct instruction_op *op, const struct pt_regs *regs,
 			break;
 		}
 		break;
+	case 1: /* Prefixed instructions */
+		prefix_r = word & (1ul << 20);
+		ra = (suffix >> 16) & 0x1f;
+		op->update_reg = ra;
+		rd = (suffix >> 21) & 0x1f;
+		op->reg = rd;
+		op->val = regs->gpr[rd];
+
+		suffixopcode = suffix >> 26;
+		prefixtype = (word >> 24) & 0x3;
+		switch (prefixtype) {
+		case 0: /* Type 00  Eight-Byte Load/Store */
+			if (prefix_r && ra)
+				break;
+			op->ea = mlsd_8lsd_ea(word, suffix, regs);
+			switch (suffixopcode) {
+			case 41:	/* plwa */
+				op->type = MKOP(LOAD, PREFIXED | SIGNEXT, 4);
+				break;
+			case 42:        /* plxsd */
+				op->reg = rd + 32;
+				op->type = MKOP(LOAD_VSX, PREFIXED, 8);
+				op->element_size = 8;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 43:	/* plxssp */
+				op->reg = rd + 32;
+				op->type = MKOP(LOAD_VSX, PREFIXED, 4);
+				op->element_size = 8;
+				op->vsx_flags = VSX_FPCONV | VSX_CHECK_VEC;
+				break;
+			case 46:	/* pstxsd */
+				op->reg = rd + 32;
+				op->type = MKOP(STORE_VSX, PREFIXED, 8);
+				op->element_size = 8;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 47:	/* pstxssp */
+				op->reg = rd + 32;
+				op->type = MKOP(STORE_VSX, PREFIXED, 4);
+				op->element_size = 8;
+				op->vsx_flags = VSX_FPCONV | VSX_CHECK_VEC;
+				break;
+			case 51:	/* plxv1 */
+				op->reg += 32;
+
+				/* fallthru */
+			case 50:	/* plxv0 */
+				op->type = MKOP(LOAD_VSX, PREFIXED, 16);
+				op->element_size = 16;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 55:	/* pstxv1 */
+				op->reg = rd + 32;
+
+				/* fallthru */
+			case 54:	/* pstxv0 */
+				op->type = MKOP(STORE_VSX, PREFIXED, 16);
+				op->element_size = 16;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 56:        /* plq */
+				op->type = MKOP(LOAD, PREFIXED, 16);
+				break;
+			case 57:	/* pld */
+				op->type = MKOP(LOAD, PREFIXED, 8);
+				break;
+			case 60:        /* stq */
+				op->type = MKOP(STORE, PREFIXED, 16);
+				break;
+			case 61:	/* pstd */
+				op->type = MKOP(STORE, PREFIXED, 8);
+				break;
+			}
+			break;
+		case 1: /* Type 01 Eight-Byte Register-to-Register */
+			break;
+		case 2: /* Type 10 Modified Load/Store */
+			if (prefix_r && ra)
+				break;
+			op->ea = mlsd_8lsd_ea(word, suffix, regs);
+			switch (suffixopcode) {
+			case 32:	/* plwz */
+				op->type = MKOP(LOAD, PREFIXED, 4);
+				break;
+			case 34:	/* plbz */
+				op->type = MKOP(LOAD, PREFIXED, 1);
+				break;
+			case 36:	/* pstw */
+				op->type = MKOP(STORE, PREFIXED, 4);
+				break;
+			case 38:	/* pstb */
+				op->type = MKOP(STORE, PREFIXED, 1);
+				break;
+			case 40:	/* plhz */
+				op->type = MKOP(LOAD, PREFIXED, 2);
+				break;
+			case 42:	/* plha */
+				op->type = MKOP(LOAD, PREFIXED | SIGNEXT, 2);
+				break;
+			case 44:	/* psth */
+				op->type = MKOP(STORE, PREFIXED, 2);
+				break;
+			case 48:        /* plfs */
+				op->type = MKOP(LOAD_FP, PREFIXED | FPCONV, 4);
+				break;
+			case 50:        /* plfd */
+				op->type = MKOP(LOAD_FP, PREFIXED, 8);
+				break;
+			case 52:        /* pstfs */
+				op->type = MKOP(STORE_FP, PREFIXED | FPCONV, 4);
+				break;
+			case 54:        /* pstfd */
+				op->type = MKOP(STORE_FP, PREFIXED, 8);
+				break;
+			}
+			break;
+		case 3: /* Type 11 Modified Register-to-Register */
+			break;
+		}
 #endif /* __powerpc64__ */
 
 	}
Signature · 1 line
2.17.1
Reviewed-by on v4 15/16
#56 lore raw

Re: [PATCH v4 15/16] powerpc sstep: Add support for prefixed load/stores

Quoted 29 lines · Jordan Niethe

This adds emulation support for the following prefixed integer load/stores:
* Prefixed Load Byte and Zero (plbz)
* Prefixed Load Halfword and Zero (plhz)
* Prefixed Load Halfword Algebraic (plha)
* Prefixed Load Word and Zero (plwz)
* Prefixed Load Word Algebraic (plwa)
* Prefixed Load Doubleword (pld)
* Prefixed Store Byte (pstb)
* Prefixed Store Halfword (psth)
* Prefixed Store Word (pstw)
* Prefixed Store Doubleword (pstd)
* Prefixed Load Quadword (plq)
* Prefixed Store Quadword (pstq)

the follow prefixed floating-point load/stores:
* Prefixed Load Floating-Point Single (plfs)
* Prefixed Load Floating-Point Double (plfd)
* Prefixed Store Floating-Point Single (pstfs)
* Prefixed Store Floating-Point Double (pstfd)

and for the following prefixed VSX load/stores:
* Prefixed Load VSX Scalar Doubleword (plxsd)
* Prefixed Load VSX Scalar Single-Precision (plxssp)
* Prefixed Load VSX Vector [0|1] (plxv, plxv0, plxv1)
* Prefixed Store VSX Scalar Doubleword (pstxsd)
* Prefixed Store VSX Scalar Single-Precision (pstxssp)
* Prefixed Store VSX Vector [0|1] (pstxv, pstxv0, pstxv1)

Quoted 1 line

LGTM,

Quoted 198 lines

---
v2: - Combine all load/store patches
- Fix the name of Type 01 instructions
- Remove sign extension flag from pstd/pld
- Rename sufx -> suffix
v3: - Move prefixed loads and stores into the switch statement

---
 arch/powerpc/lib/sstep.c | 159 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
arch/powerpc/lib/sstep.c +38 -0
index ab4c71c43c8c..daef70eb8e22 100644
@@ -187,6 +187,44 @@ static nokprobe_inline unsigned long xform_ea(unsigned
 int instr,
 	return ea;
 }
 
+/*
+ * Calculate effective address for a MLS:D-form / 8LS:D-form
+ * prefixed instruction
+ */
+static nokprobe_inline unsigned long mlsd_8lsd_ea(unsigned int instr,
+						  unsigned int suffix,
+						  const struct pt_regs *regs)
+{
+	int ra, prefix_r;
+	unsigned int  dd;
+	unsigned long ea, d0, d1, d;
+
+	prefix_r = instr & (1ul << 20);
+	ra = (suffix >> 16) & 0x1f;
+
+	d0 = instr & 0x3ffff;
+	d1 = suffix & 0xffff;
+	d = (d0 << 16) | d1;
+
+	/*
+	 * sign extend a 34 bit number
+	 */
+	dd = (unsigned int)(d >> 2);
+	ea = (signed int)dd;
+	ea = (ea << 2) | (d & 0x3);
+
+	if (!prefix_r && ra)
+		ea += regs->gpr[ra];
+	else if (!prefix_r && !ra)
+		; /* Leave ea as is */
+	else if (prefix_r && !ra)
+		ea += regs->nip;
+	else if (prefix_r && ra)
+		; /* Invalid form. Should already be checked for by caller! */
+
+	return ea;
+}
+
 /*
  * Return the largest power of 2, not greater than sizeof(unsigned long),

* such that x is a multiple of it.

arch/powerpc/lib/sstep.c +1 -0
@@ -1166,6 +1204,7 @@ int analyse_instr(struct instruction_op *op, const
 struct pt_regs *regs,
 		  ppc_inst instr)
 {
 	unsigned int opcode, ra, rb, rc, rd, spr, u;
+	unsigned int suffixopcode, prefixtype, prefix_r;
 	unsigned long int imm;
 	unsigned long int val, val2;
arch/powerpc/lib/sstep.c +120 -0
 	unsigned int mb, me, sh;
@@ -2652,6 +2691,126 @@ int analyse_instr(struct instruction_op *op, const
 struct pt_regs *regs,
 			break;
 		}
 		break;
+	case 1: /* Prefixed instructions */
+		prefix_r = word & (1ul << 20);
+		ra = (suffix >> 16) & 0x1f;
+		op->update_reg = ra;
+		rd = (suffix >> 21) & 0x1f;
+		op->reg = rd;
+		op->val = regs->gpr[rd];
+
+		suffixopcode = suffix >> 26;
+		prefixtype = (word >> 24) & 0x3;
+		switch (prefixtype) {
+		case 0: /* Type 00  Eight-Byte Load/Store */
+			if (prefix_r && ra)
+				break;
+			op->ea = mlsd_8lsd_ea(word, suffix, regs);
+			switch (suffixopcode) {
+			case 41:	/* plwa */
+				op->type = MKOP(LOAD, PREFIXED | SIGNEXT, 4);
+				break;
+			case 42:        /* plxsd */
+				op->reg = rd + 32;
+				op->type = MKOP(LOAD_VSX, PREFIXED, 8);
+				op->element_size = 8;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 43:	/* plxssp */
+				op->reg = rd + 32;
+				op->type = MKOP(LOAD_VSX, PREFIXED, 4);
+				op->element_size = 8;
+				op->vsx_flags = VSX_FPCONV | VSX_CHECK_VEC;
+				break;
+			case 46:	/* pstxsd */
+				op->reg = rd + 32;
+				op->type = MKOP(STORE_VSX, PREFIXED, 8);
+				op->element_size = 8;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 47:	/* pstxssp */
+				op->reg = rd + 32;
+				op->type = MKOP(STORE_VSX, PREFIXED, 4);
+				op->element_size = 8;
+				op->vsx_flags = VSX_FPCONV | VSX_CHECK_VEC;
+				break;
+			case 51:	/* plxv1 */
+				op->reg += 32;
+
+				/* fallthru */
+			case 50:	/* plxv0 */
+				op->type = MKOP(LOAD_VSX, PREFIXED, 16);
+				op->element_size = 16;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 55:	/* pstxv1 */
+				op->reg = rd + 32;
+
+				/* fallthru */
+			case 54:	/* pstxv0 */
+				op->type = MKOP(STORE_VSX, PREFIXED, 16);
+				op->element_size = 16;
+				op->vsx_flags = VSX_CHECK_VEC;
+				break;
+			case 56:        /* plq */
+				op->type = MKOP(LOAD, PREFIXED, 16);
+				break;
+			case 57:	/* pld */
+				op->type = MKOP(LOAD, PREFIXED, 8);
+				break;
+			case 60:        /* stq */
+				op->type = MKOP(STORE, PREFIXED, 16);
+				break;
+			case 61:	/* pstd */
+				op->type = MKOP(STORE, PREFIXED, 8);
+				break;
+			}
+			break;
+		case 1: /* Type 01 Eight-Byte Register-to-Register */
+			break;
+		case 2: /* Type 10 Modified Load/Store */
+			if (prefix_r && ra)
+				break;
+			op->ea = mlsd_8lsd_ea(word, suffix, regs);
+			switch (suffixopcode) {
+			case 32:	/* plwz */
+				op->type = MKOP(LOAD, PREFIXED, 4);
+				break;
+			case 34:	/* plbz */
+				op->type = MKOP(LOAD, PREFIXED, 1);
+				break;
+			case 36:	/* pstw */
+				op->type = MKOP(STORE, PREFIXED, 4);
+				break;
+			case 38:	/* pstb */
+				op->type = MKOP(STORE, PREFIXED, 1);
+				break;
+			case 40:	/* plhz */
+				op->type = MKOP(LOAD, PREFIXED, 2);
+				break;
+			case 42:	/* plha */
+				op->type = MKOP(LOAD, PREFIXED | SIGNEXT, 2);
+				break;
+			case 44:	/* psth */
+				op->type = MKOP(STORE, PREFIXED, 2);
+				break;
+			case 48:        /* plfs */
+				op->type = MKOP(LOAD_FP, PREFIXED | FPCONV, 4);
+				break;
+			case 50:        /* plfd */
+				op->type = MKOP(LOAD_FP, PREFIXED, 8);
+				break;
+			case 52:        /* pstfs */
+				op->type = MKOP(STORE_FP, PREFIXED | FPCONV,
 4);
+				break;
+			case 54:        /* pstfd */
+				op->type = MKOP(STORE_FP, PREFIXED, 8);
+				break;
+			}
+			break;
+		case 3: /* Type 11 Modified Register-to-Register */
+			break;
+		}
 #endif /* __powerpc64__ */

}

#57 lore raw

PATCH v4 16/16 powerpc sstep: Add support for prefixed fixed-point arithmetic

In reply to Jordan Niethe

This adds emulation support for the following prefixed Fixed-Point Arithmetic instructions:
* Prefixed Add Immediate (paddi)

---
v3: Since we moved the prefixed loads/stores into the load/store switch statement it no longer makes sense to have paddi in there, so move it out.

---
 arch/powerpc/lib/sstep.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
arch/powerpc/lib/sstep.c +20 -0
index daef70eb8e22..6862fc019258 100644
@@ -1335,6 +1335,26 @@ int analyse_instr(struct instruction_op *op, const struct pt_regs *regs,
 
 	switch (opcode) {
 #ifdef __powerpc64__
+	case 1:
+		prefix_r = word & (1ul << 20);
+		ra = (suffix >> 16) & 0x1f;
+		rd = (suffix >> 21) & 0x1f;
+		op->reg = rd;
+		op->val = regs->gpr[rd];
+		suffixopcode = suffix >> 26;
+		prefixtype = (word >> 24) & 0x3;
+		switch (prefixtype) {
+		case 2:
+			if (prefix_r && ra)
+				return 0;
+			switch (suffixopcode) {
+			case 14:	/* paddi */
+				op->type = COMPUTE | PREFIXED;
+				op->val = mlsd_8lsd_ea(word, suffix, regs);
+				goto compute_done;
+			}
+		}
+		break;
 	case 2:		/* tdi */
 		if (rd & trap_compare(regs->gpr[ra], (short) word))
 			goto trap;
Signature · 1 line
2.17.1
Reviewed-by on v4 16/16
#58 lore raw

Re: [PATCH v4 16/16] powerpc sstep: Add support for prefixed fixed-point arithmetic

Quoted 5 lines · Jordan Niethe

This adds emulation support for the following prefixed Fixed-Point Arithmetic instructions:
* Prefixed Add Immediate (paddi)

Quoted 40 lines

---
v3: Since we moved the prefixed loads/stores into the load/store switch statement it no longer makes sense to have paddi in there, so move it out.

---
 arch/powerpc/lib/sstep.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
arch/powerpc/lib/sstep.c +20 -0
index daef70eb8e22..6862fc019258 100644
@@ -1335,6 +1335,26 @@ int analyse_instr(struct instruction_op *op, const
 struct pt_regs *regs,
 
 	switch (opcode) {
 #ifdef __powerpc64__
+	case 1:
+		prefix_r = word & (1ul << 20);
+		ra = (suffix >> 16) & 0x1f;
+		rd = (suffix >> 21) & 0x1f;
+		op->reg = rd;
+		op->val = regs->gpr[rd];
+		suffixopcode = suffix >> 26;
+		prefixtype = (word >> 24) & 0x3;
+		switch (prefixtype) {
+		case 2:
+			if (prefix_r && ra)
+				return 0;
+			switch (suffixopcode) {
+			case 14:	/* paddi */
+				op->type = COMPUTE | PREFIXED;
+				op->val = mlsd_8lsd_ea(word, suffix, regs);
+				goto compute_done;
+			}
+		}
+		break;
 	case 2:		/* tdi */
 		if (rd & trap_compare(regs->gpr[ra], (short) word))

goto trap;

#59 lore raw
In reply to Jordan Niethe

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 12 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

Quoted 8 lines

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Thanks for doing this, looks like a lot of work, I hope it works out :)

Thanks,
Nick

#60 lore raw
Quoted 18 lines · Nicholas Piggin

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 16 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

Quoted 7 lines
Quoted 4 lines

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Thanks for doing this, looks like a lot of work, I hope it works out :)

Yes it did end up touching a lot of places. I started thinking that that maybe it would be simpler to just use a u64 instead of the struct for instructions.
If we always keep the word instruction / prefix in the lower bytes, all of the current masking should still work and we can use operators again instead of ppc_inst_equal(), etc.
It also makes printing easier. We could just #define INST_FMT %llx or #define INST_FMT %x on powerpc32 and use that for printing out instructions.

Quoted 2 lines

Thanks,
Nick

#61 lore raw

Jordan Niethe's on March 23, 2020 7:25 pm:

Quoted 24 lines · Nicholas Piggin
Quoted 23 lines

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 20 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Quoted 8 lines
Quoted 2 lines

Thanks for doing this, looks like a lot of work, I hope it works out :)

Yes it did end up touching a lot of places. I started thinking that that maybe it would be simpler to just use a u64 instead of the struct for instructions.
If we always keep the word instruction / prefix in the lower bytes, all of the current masking should still work and we can use operators again instead of ppc_inst_equal(), etc.

Yeah.. I think now that you've done it, I prefer it this way.

Quoted 3 lines

It also makes printing easier. We could just #define INST_FMT %llx or #define INST_FMT %x on powerpc32 and use that for printing out instructions.

Well, not sure about that. Would it make endian concerns more complicated? Print format for prefix might be '%016llx', but we don't want that for all instructions only prefixed ones, and I don't know if that is the way to go either.

We'll want to adopt some convention for displaying prefixed instruction bytes, but I don't know what what works best. I wonder if binutils or any userspace tools have a convention.

Which reminds me, you might have missed show_instructions()? Although maybe you don't need that until we start using them in the kernel.

Thanks,
Nick

#62 lore raw
Quoted 28 lines · Nicholas Piggin

Jordan Niethe's on March 23, 2020 7:25 pm:

Quoted 26 lines · Nicholas Piggin
Quoted 25 lines

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 12 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

Quoted 8 lines

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Thanks for doing this, looks like a lot of work, I hope it works out :)

Quoted 8 lines
Quoted 6 lines

Yes it did end up touching a lot of places. I started thinking that that maybe it would be simpler to just use a u64 instead of the struct for instructions.
If we always keep the word instruction / prefix in the lower bytes, all of the current masking should still work and we can use operators again instead of ppc_inst_equal(), etc.

Yeah.. I think now that you've done it, I prefer it this way.

Sorry, just to be clear which way do you mean?

Quoted 9 lines
Quoted 4 lines

It also makes printing easier. We could just #define INST_FMT %llx or #define INST_FMT %x on powerpc32 and use that for printing out instructions.

Well, not sure about that. Would it make endian concerns more complicated? Print format for prefix might be '%016llx', but we don't want that for all instructions only prefixed ones, and I don't know if that is the way to go either.

Hm yeah that is true.

Quoted 4 lines

We'll want to adopt some convention for displaying prefixed instruction bytes, but I don't know what what works best. I wonder if binutils or any userspace tools have a convention.

binutils-gdb upstream has supports disassembling prefixed instructions. Here is what objdump looks like:

  44:    00 00 00 60     nop
  48:    00 00 00 07     pnop
  4c:    00 00 00 00
  50:    01 00 20 39     li      r9,1
  54:    00 00 00 06     paddi   r4,r9,3
  58:    03 00 89 38
  5c:    00 00 62 3c     addis   r3,r2,0
Quoted 4 lines

Which reminds me, you might have missed show_instructions()? Although maybe you don't need that until we start using them in the kernel.

You are right I missed that here.

Quoted 3 lines

Thanks,
Nick

#63 lore raw
Quoted 55 lines · Jordan Niethe
Quoted 28 lines · Nicholas Piggin

Jordan Niethe's on March 23, 2020 7:25 pm:

Quoted 26 lines · Nicholas Piggin
Quoted 25 lines

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 12 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

Quoted 8 lines

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Thanks for doing this, looks like a lot of work, I hope it works out :)

Quoted 8 lines
Quoted 6 lines

Yes it did end up touching a lot of places. I started thinking that that maybe it would be simpler to just use a u64 instead of the struct for instructions.
If we always keep the word instruction / prefix in the lower bytes, all of the current masking should still work and we can use operators again instead of ppc_inst_equal(), etc.

Yeah.. I think now that you've done it, I prefer it this way.

Sorry, just to be clear which way do you mean?

Quoted 9 lines
Quoted 4 lines

It also makes printing easier. We could just #define INST_FMT %llx or #define INST_FMT %x on powerpc32 and use that for printing out instructions.

Well, not sure about that. Would it make endian concerns more complicated? Print format for prefix might be '%016llx', but we don't want that for all instructions only prefixed ones, and I don't know if that is the way to go either.

Hm yeah that is true.

Quoted 4 lines

We'll want to adopt some convention for displaying prefixed instruction bytes, but I don't know what what works best. I wonder if binutils or any userspace tools have a convention.

binutils-gdb upstream has supports disassembling prefixed instructions. Here is what objdump looks like:

Quoted 7 lines
  44:    00 00 00 60     nop
  48:    00 00 00 07     pnop
  4c:    00 00 00 00
  50:    01 00 20 39     li      r9,1
  54:    00 00 00 06     paddi   r4,r9,3
  58:    03 00 89 38
  5c:    00 00 62 3c     addis   r3,r2,0

And this is what it looks like if you use objdump with -w

  44:    00 00 00 60     nop
  48:    00 00 00 07 00 00 00 00     pnop
  50:    01 00 20 39                 li      r9,1
  54:    00 00 00 06 03 00 89 38     paddi   r4,r9,3
  5c:    00 00 62 3c                 addis   r3,r2,0    5c:

R_PPC64_TOC16_HA .toc+0x10

Quoted 8 lines
Quoted 4 lines

Which reminds me, you might have missed show_instructions()? Although maybe you don't need that until we start using them in the kernel.

You are right I missed that here.

Quoted 3 lines

Thanks,
Nick

#64 lore raw
In reply to Jordan Niethe

Jordan Niethe's on March 24, 2020 12:54 pm:

Quoted 36 lines · Nicholas Piggin
Quoted 35 lines

Jordan Niethe's on March 23, 2020 7:25 pm:

Quoted 32 lines · Nicholas Piggin
Quoted 18 lines

Jordan Niethe's on March 20, 2020 3:17 pm:

Quoted 16 lines

A future revision of the ISA will introduce prefixed instructions. A prefixed instruction is composed of a 4-byte prefix followed by a 4-byte suffix.

All prefixes have the major opcode 1. A prefix will never be a valid word instruction. A suffix may be an existing word instruction or a new instruction.

This series enables prefixed instructions and extends the instruction emulation to support them. Then the places where prefixed instructions might need to be emulated are updated.

The series is based on top of:
https://patchwork.ozlabs.org/patch/1232619/ as this will effect kprobes.

Quoted 7 lines
Quoted 4 lines

v4 is based on feedback from Nick Piggins, Christophe Leroy and Daniel Axtens. The major changes:
- Move xmon breakpoints from data section to text section
- Introduce a data type for instructions on powerpc

Thanks for doing this, looks like a lot of work, I hope it works out :)

Yes it did end up touching a lot of places. I started thinking that that maybe it would be simpler to just use a u64 instead of the struct for instructions.
If we always keep the word instruction / prefix in the lower bytes, all of the current masking should still work and we can use operators again instead of ppc_inst_equal(), etc.

Quoted 2 lines
Quoted 1 line

Yeah.. I think now that you've done it, I prefer it this way.

Sorry, just to be clear which way do you mean?

With the struct, not u64 scalar. mpe's preferred way is fine by me.

Quoted 13 lines
Quoted 3 lines

We'll want to adopt some convention for displaying prefixed instruction bytes, but I don't know what what works best. I wonder if binutils or any userspace tools have a convention.

binutils-gdb upstream has supports disassembling prefixed instructions. Here is what objdump looks like:

  44:    00 00 00 60     nop
  48:    00 00 00 07     pnop
  4c:    00 00 00 00
  50:    01 00 20 39     li      r9,1
  54:    00 00 00 06     paddi   r4,r9,3
  58:    03 00 89 38
  5c:    00 00 62 3c     addis   r3,r2,0
Quoted 1 line
Quoted 4 lines
Quoted 3 lines

Which reminds me, you might have missed show_instructions()? Although maybe you don't need that until we start using them in the kernel.

You are right I missed that here.

So binutils doesn't do anything special, I guess you can make something up.

Thanks,
Nick