Initial Prefixed Instruction support
Subsystems (5)
Nicholas Piggin
reviewerRe: [PATCH v4 14/16] powerpc64: Add prefixed instructions to instruction data type
In reply to Jordan NietheJordan 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 modifyppc_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 instructionsbp->instr+ 1 might be the suffix. So I moved putting the breakpoint toinsert_bpts():patch_instruction(bp->instr + ppc_inst_len(instr), PPC_INST(bpinstr));
Ah okay.
Thanks,
Nick
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
-2if (!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.cindex5b53c373373b..af6761859fba100644arch/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
-0unsigned 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.Sindexcf383520843f..ff8ba4d3824d100644arch/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.cindexad451205f268..3b8655f57b4a100644arch/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_instarch/powerpc/kernel/uprobes.c +0
-0@@ -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.cindexfa7f32adf029..3b8277a64b8f100644arch/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
-3if (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@@ -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@@ -110,7 +110,7 @@ struct bpt {#define BP_DABR 4#define NBPTS 256 -#define BPT_WORDS 2 +#define BPT_WORDS 4static 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 intcmds(struct pt_regs *);
static intmread(unsigned long, void *, int);
static intmwrite(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[] = {"--" ,"**" ,"##" };
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
-0if (!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.cindex5b53c373373b..af6761859fba100644arch/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.Sindexcf383520843f..ff8ba4d3824d100644arch/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.cindexad451205f268..3b8655f57b4a100644arch/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_instarch/powerpc/kernel/uprobes.c +0
-0@@ -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.cindexfa7f32adf029..3b8277a64b8f100644arch/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@@ -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@@ -110,7 +110,7 @@ struct bpt {#define BP_DABR 4#define NBPTS 256 -#define BPT_WORDS 2 +#define BPT_WORDS 4static 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 intcmds(struct pt_regs *);
static intmread(unsigned long, void *, int);
static intmwrite(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[] = {"--" ,"**" ,"##" };
PATCH v4 15/16 powerpc sstep: Add support for prefixed load/stores
In reply to Jordan NietheThis 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
@@ -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
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
Signed-off-by Jordan Niethe <[email protected]>
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@@ -187,6 +187,44 @@ static nokprobe_inline unsigned long xform_ea(unsignedint 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
-0unsigned int mb, me, sh;@@ -2652,6 +2691,126 @@ int analyse_instr(struct instruction_op *op, conststruct 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__ */ }
PATCH v4 16/16 powerpc sstep: Add support for prefixed fixed-point arithmetic
In reply to Jordan NietheThis 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
@@ -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
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)Signed-off-by Jordan Niethe <[email protected]>
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@@ -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;
Nicholas Piggin
reviewerJordan 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
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 powerpcThanks 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
Nicholas Piggin
reviewerJordan 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 ofppc_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 #defineINST_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
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 powerpcThanks 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 ofppc_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 #defineINST_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
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 powerpcThanks 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 ofppc_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 #defineINST_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
Nicholas Piggin
reviewerJordan 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 powerpcThanks 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 ofppc_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,0Quoted 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