kprobes for s390 architecture
PATCH 1/1 kprobes for s390 architecture
Hi Folks -
This patch provides kprobes support for s390 architecture
Thanks
Mike
--
arch/s390/Kconfig | 14 arch/s390/kernel/Makefile | 1 arch/s390/kernel/entry.S | 4 arch/s390/kernel/entry64.S | 18 + arch/s390/kernel/kprobes.c | 648 +++++++++++++++++++++++++++++++++++++++++ arch/s390/kernel/traps.c | 42 ++ arch/s390/kernel/vmlinux.lds.S | 1 arch/s390/mm/fault.c | 8 include/asm-s390/kdebug.h | 57 +++ include/asm-s390/kprobes.h | 208 +++++++++++++ 10 files changed, 995 insertions(+), 6 deletions(-)
arch/s390/Kconfig +14 -0
@@ -474,8 +474,22 @@ source "drivers/net/Kconfig" source "fs/Kconfig" +menu "Instrumentation Support" + depends on EXPERIMENTAL + source "arch/s390/oprofile/Kconfig" +config KPROBES + bool "Kprobes (EXPERIMENTAL)" + depends on EXPERIMENTAL && MODULES + help + Kprobes allows you to trap at almost any kernel address and + execute a callback function. register_kprobe() establishes + a probepoint and specifies the callback. Kprobes is useful + for kernel debugging, non-intrusive instrumentation and testing. + If in doubt, say "N". +endmenu + source "arch/s390/Kconfig.debug" source "security/Kconfig"
arch/s390/kernel/entry64.S +18 -0
@@ -478,6 +478,8 @@ pgm_per: clc __LC_PGM_OLD_PSW(16),__LC_SVC_NEW_PSW je pgm_svcper # no interesting special case, ignore PER event + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per lmg %r12,%r15,__LC_SAVE_AREA lpswe __LC_PGM_OLD_PSW
@@ -497,6 +499,8 @@ pgm_no_vtime2: #endif lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct lg %r1,__TI_task(%r9) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
@@ -531,6 +535,20 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts j sysc_do_svc +# +# per was called from kernel, must be kprobes +# +kernel_per: + lgf %r3,__LC_PGM_ILC # load program interruption code + lghi %r8,0x7f + ngr %r8,%r3 # clear per-event-bit and ilc + j sysc_singlestep + lhi %r0,__LC_PGM_OLD_PSW + sth %r0,SP_TRAP(%r15) # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + larl %r14,sysc_leave # load adr. of system ret, no work + brcl 15,do_single_step # branch to do_single_step + /* * IO interrupt handler routine */
arch/s390/kernel/entry.S +4 -0
@@ -456,6 +456,8 @@ pgm_per: # ok its one of the special cases, now we need to find out which one clc __LC_PGM_OLD_PSW(8),__LC_SVC_NEW_PSW be BASED(pgm_svcper) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz BASED(sysc_singlestep) # no interesting special case, ignore PER event lm %r12,%r15,__LC_SAVE_AREA lpsw 0x28
@@ -480,6 +482,8 @@ pgm_no_vtime2: mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz BASED(sysc_singlestep) l %r3,__LC_PGM_ILC # load program interruption code la %r8,0x7f nr %r8,%r3 # clear per-event-bit and ilc
arch/s390/kernel/kprobes.c +648 -0
648 lines not on this page · raw message
arch/s390/kernel/Makefile +1 -0
@@ -21,6 +21,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o obj-$(CONFIG_BINFMT_ELF32) += binfmt_elf32.o obj-$(CONFIG_VIRT_TIMER) += vtime.o +obj-$(CONFIG_KPROBES) += kprobes.o # Kexec part S390_KEXEC_OBJS := machine_kexec.o crash.o
arch/s390/kernel/traps.c +37 -5
85 lines not on this page · raw message
arch/s390/kernel/vmlinux.lds.S +1 -0
@@ -25,6 +25,7 @@ SECTIONS *(.text) SCHED_TEXT LOCK_TEXT + KPROBES_TEXT *(.fixup) *(.gnu.warning) } = 0x0700
arch/s390/mm/fault.c +7 -1
@@ -26,10 +26,12 @@#include <linux/console.h> #include <linux/module.h> #include <linux/hardirq.h> +#include <linux/kprobes.h> #include <asm/system.h> #include <asm/uaccess.h> #include <asm/pgtable.h> +#include <asm/kdebug.h> #ifndef CONFIG_64BIT #define __FAIL_ADDR_MASK 0x7ffff000
@@ -160,7 +162,7 @@ static void do_sigsegv(struct pt_regs *r* 11 Page translation -> Not present (nullification) * 3b Region third trans. -> Not present (nullification) */ -static inline void +static inline void __kprobes do_exception (struct pt_regs *regs,unsigned long error_code,int is_protection) {struct task_struct *tsk;
@@ -174,6 +176,10 @@ do_exception(struct pt_regs *regs, unsig tsk = current; mm = tsk->mm; +if (notify_die (DIE_PAGE_FAULT ,"page fault" , regs, error_code,14 , +SIGSEGV ) ==NOTIFY_STOP ) +return ; +/* * Check for low-address protection. This needs to be treated * as a special case because the translation exception code
include/asm-s390/kdebug.h +57 -0
57 lines not on this page · raw message
include/asm-s390/kprobes.h +208 -0
208 lines not on this page · raw message
Quoted 1 line · Mike Grundy
This patch provides kprobes support for s390 architecture
Looks like a good start. There are some bugs though and I have a few suggestions:
arch/s390/kernel/entry64.S pgm_per: · line 485
Quoted 12 lines
diff -urNp
linux-2.6.17-rc6/arch/s390/kernel/entry64.Slinux-2.6.17-rc6-kp390/arch/s390/kernel/entry64.Sarch/s390/kernel/entry64.S +2
-0@@ -478,6 +478,8 @@ pgm_per: clc __LC_PGM_OLD_PSW(16),__LC_SVC_NEW_PSW je pgm_svcper # no interesting special case, ignore PER event + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per lmg %r12,%r15,__LC_SAVE_AREA lpswe __LC_PGM_OLD_PSW
If this branch is ever taken it will crash at least the currently running process. The program check handler will branch to pgm_per after having done SAVE_ALL_BASE and if the per bit in the psw is set. SAVE_ALL_SYNC and CRETE_STACK_FRAME have not been called yet and neither kernel_per nor sysc_singlestep will do it. That means that no stack frame for the kernel per event has been generated which will crash.
arch/s390/kernel/entry64.S pgm_no_vtime2: · line 506
Quoted 9 lines
arch/s390/kernel/entry64.S +2
-0@@ -497,6 +499,8 @@ pgm_no_vtime2: #endif lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct lg %r1,__TI_task(%r9) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
This branch is ok and is imho the only one we need.
Quoted 11 lines
arch/s390/kernel/entry64.S +7
-0@@ -531,6 +535,20 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts j sysc_do_svc +# +# per was called from kernel, must be kprobes +# +kernel_per: + lgf %r3,__LC_PGM_ILC # load program interruption code + lghi %r8,0x7f + ngr %r8,%r3 # clear per-event-bit and ilc
arch/s390/kernel/entry64.S pgm_no_vtime3: · line 554
Quoted 10 lines
arch/s390/kernel/entry64.S +7
-0+ j sysc_singlestep + lhi %r0,__LC_PGM_OLD_PSW + sth %r0,SP_TRAP(%r15) # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + larl %r14,sysc_leave # load adr. of system ret, no work + brcl 15,do_single_step # branch to do_single_step + /* * IO interrupt handler routine */
The code after "j sysc_singlestep" is unreachable. Either you can remove it or there is a branch missing.
arch/s390/kernel/entry.S pgm_per: · line 463
Quoted 12 lines
diff -urNp
linux-2.6.17-rc6/arch/s390/kernel/entry.Slinux-2.6.17-rc6-kp390/arch/s390/kernel/entry.Sarch/s390/kernel/entry.S +2
-0@@ -456,6 +456,8 @@ pgm_per: # ok its one of the special cases, now we need to find out which one clc __LC_PGM_OLD_PSW(8),__LC_SVC_NEW_PSW be BASED(pgm_svcper) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz BASED(sysc_singlestep) # no interesting special case, ignore PER event lm %r12,%r15,__LC_SAVE_AREA lpsw 0x28
Same as for 64 bit, if the branch is taken it will crash.
arch/s390/kernel/entry.S pgm_no_vtime2: · line 489
Quoted 9 lines
arch/s390/kernel/entry.S +2
-0@@ -480,6 +482,8 @@ pgm_no_vtime2: mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz BASED(sysc_singlestep) l %r3,__LC_PGM_ILC # load program interruption code la %r8,0x7f nr %r8,%r3 # clear per-event-bit and ilc
The 31 bit code branches to sysc_singlestep directly. Why is kernel_per only needed for 64 bit? I think 31 bit needs kernel_per as well.
Quoted 53 lines
diff -urNp
linux-2.6.17-rc6/arch/s390/kernel/kprobes.clinux-2.6.17-rc6-kp390/arch/s390/kernel/kprobes.carch/s390/kernel/kprobes.c +49
-0@@ -0,0 +1,648 @@ +/* +* Kernel Probes (KProbes) +* arch/s390/kernel/kprobes.c +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* Copyright (C) IBM Corporation, 2002, 2006 +* +* s390 port, used ppc64 as template. Mike Grundy <[email protected]> +*/ + +#include <linux/config.h> +#include <linux/kprobes.h> +#include <linux/ptrace.h> +#include <linux/preempt.h> +#include <asm/cacheflush.h> +#include <asm/kdebug.h> +#include <asm/sections.h> + +DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL; +DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk); + +int __kprobes arch_prepare_kprobe (struct kprobe *p) +{ +int ret =0 ; + +/* Make sure the probe isn't going on a difficult instruction */ +if (is_prohibited_opcode ((kprobe_opcode_t *) p->addr)) + ret = -EINVAL ; + +/* Use the get_insn_slot() facility for correctness */ +if (!ret) { + p->ainsn.insn =get_insn_slot (); +if (!p->ainsn.insn) { + ret = -ENOMEM ; + }else { +/* this should only happen if you got the slot */
arch/s390/kernel/kprobes.c line 59
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+memcpy (p->ainsn.insn, p->addr, +MAX_INSN_SIZE *sizeof (kprobe_opcode_t)); + p->ainsn.inst_type = +get_instruction_type (p->ainsn.insn); + } + } + p->opcode = *p->addr; +return ret; +} +
Hmm, you are assigning to p->opcode even if the function returns an error. I have the vague feeling that this is not a good idea. And I suggest that you use early returns, that way you get rid of two levels of indention.
Quoted 23 lines
arch/s390/kernel/kprobes.c +23
-0+int __kprobes is_prohibited_opcode (kprobe_opcode_t *instruction) +{ +__u8 opcode[6 ]; +int ret =0 ; + +memcpy (opcode, instruction,6 *sizeof (__u8)); + +switch (opcode[0 ]) { +case OPCODE_BASSM : +case OPCODE_BSM : +case OPCODE_DIAG : +case OPCODE_EX : + ret = -EINVAL ; +break ; +case OPCODE_PR : +if (opcode[1 ] ==OPCODE_PR ) + ret = -EINVAL ; +break ; +case 0xB2 : +switch (opcode[1 ]) { +case OPCODE_BSA : +case OPCODE_BAKR : +case OPCODE_BSG :
arch/s390/kernel/kprobes.c line 92
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+case OPCODE_PC : +case OPCODE_PT : + ret = -EINVAL ; +break ; + } +break ; + } +return ret; +} +
I would write the function like this:
int __kprobes is_prohibited_opcode(kprobe_opcode_t *instruction)
{
switch (*(__u8 *) instruction) {
case 0x0c: /* bassm */
case 0x0b: /* bsm */
case 0x83: /* diag */
case 0x44: /* ex */
return -EINVAL;
}
switch (*(__u16 *) instruction) {
case 0x0101: /* pr */
case 0xb25a: /* bsa */
case 0xb240: /* bakr */
case 0xb258: /* bsg */
case 0xb218: /* pc */
case 0xb228: /* pt */
return -EINVAL;
}
return 0;
}Remove the OPCODE_xxx #defines. To have one-byte opcode defines for 2, 4 and 6 bytes instructions is quite confusing. The full blown opcode masking solution as implemented e.g. in the binutils would be overkill. A "stand-alone" function like the above is preferable because it is simple and you don't have to look at several files to figure out what it does.
arch/s390/kernel/kprobes.c line 104
Quoted 12 lines
arch/s390/kernel/kprobes.c +12
-0+/* get_instruction type will return 0 if only the regular offset adjustments +* after out of line singlestep are required. If a register needs to be fixed, +* bits 16-23 will contain the register number, bits 24-31 contain the length +* of the instruction unit. If fixup is only required when the branch is not +* taken, bits 0-16 will all be set. +*/ +int __kprobes get_instruction_type (kprobe_opcode_t * instruction) +{ +__u8 opcode[6 ]; +int ret =0 ; + +memcpy (opcode, instruction,6 *sizeof (__u8));
Again that memcpy. Why don't you just cast the instruction pointer to __u8 and __u16 and deference it?
The following switch deals with all the instructions that need special handling. Please get rid of the BALR/BASR/BCR/BCTR/... defines and use the opcode number directly. Add a comment which instruction it is like in the new is_prohibited_opcode. All these defines are only used in get_instruction_type and the opcodes will certainly not change, only new ones will get added. No point in all those #defines.
Quoted 4 lines
arch/s390/kernel/kprobes.c +4
-0+ +switch (opcode[0 ]) { +/* RR Format - instruction unit length = 2 +* ________ ____ ____
arch/s390/kernel/kprobes.c line 118
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+* |Op Code | R1 | R2 | +* |________|_M1_|____| +* 0 8 12 15 +*/ +case BALR :/* PSW addr saved in R1, branch address in R2 */ + ret = (opcode[1 ] &0xf0 ) +2 ; +/* Special non branching use of BALR */ +if ((opcode[1 ] &0x0f ) ==0 ) + ret &=FIXUP_NOBRANCH ; +break ;
((opcode[1] & 0xf0) + 2) & FIXUP_NOBRANCH is always 0. If the target register is 0 no branch takes place but R1 still needs fixup. resume_execution will just fixup the psw address in that case. I think you meant "ret |= FIXUP_NOBRANCH".
arch/s390/kernel/kprobes.c line 124
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+case BASR :/* PSW addr saved in R1, branch address in R2 */ + ret = (opcode[1 ] &0xf0 ) +2 ; +/* Special non branching use of BASR */ +if ((opcode[1 ] &0x0f ) ==0 ) + ret &=FIXUP_NOBRANCH ; +break ;
Same here..
arch/s390/kernel/kprobes.c line 127
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCR :/* M1 is mask val (condition), branch addr in R2 */ + ret =FIXUP_NOBRANCH &2 ; +break ;
..here..
arch/s390/kernel/kprobes.c line 130
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCTR :/* R1 is count down, R2 is branch addr until R1 = 0 */ + ret =FIXUP_NOBRANCH &2 ; +break ;
..here..
Quoted 5 lines
arch/s390/kernel/kprobes.c +5
-0+/* RX Format - instruction unit length = 4 +* ________ ____ ____ ____ ____________ +* |Op Code | R1 | X2 | B2 | D2 | +* |________|_M1_|____|____|____________| +* 0 8 12 16 20 31
arch/s390/kernel/kprobes.c line 145
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+*/ +case BAL :/* PSW addr saved in R1, branch addr D2(X2,B2) */ + ret = (opcode[1 ] &0xf0 ) +4 ; +break ; +case BAS :/* PSW addr saved in R1, branch addr D2(X2,B2) */ + ret = (opcode[1 ] &0xf0 ) +4 ; +break ; +case BC :/* M1 is mask val (condition), branch addr D2(X2,B2) */ + ret =FIXUP_NOBRANCH &4 ; +break ;
..here..
arch/s390/kernel/kprobes.c line 148
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCT :/* R1 is count down, D2(X2,B2) is branch addr */ + ret =FIXUP_NOBRANCH &4 ; +break ;
..here..
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+/* RI Format - instruction unit length = 4 +* ________ ____ ____ _________________ +* |Op Code | R1 |OpCd| I2 | +* |________|____|____|_________________| +* 0 8 12 16 31 +*/ +case 0xA7 :/* first byte (multiple ops have same 1st byte) */ +if ((opcode[1 ] &0x0f ) ==BRAS ) { + ret = (opcode[1 ] &0xf0 ) +4 ; + }
arch/s390/kernel/kprobes.c line 168
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+break ; +/* RS Format - instruction unit length = 4 +* ________ ____ ____ ____ ____________ +* |Op Code | R1 | R3 | B2 | D2 | +* |________|____|_M3_|____|____________| +* 0 8 12 16 20 31 +*/ +case BXH : + ret =FIXUP_NOBRANCH &4 ; +break ;
..here..
arch/s390/kernel/kprobes.c line 171
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BXLE : + ret =FIXUP_NOBRANCH &4 ; +break ;
..here..
arch/s390/kernel/kprobes.c line 184
Quoted 13 lines
arch/s390/kernel/kprobes.c +13
-0+/* RIL Format - instruction unit length = 6 +* ________ ____ ____ _____________/______________ +* |Op Code | R1 |OpCd| I2 | +* |________|_M1_|____|_____________/______________| +* 0 8 12 16 47 +*/ +case 0xC0 : +if ((opcode[1 ] &0x0f ) ==BRASL ) { + ret = (opcode[1 ] &0xf0 ) +6 ; + }else if ((opcode[1 ] &0x0f ) ==BRCL ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;
..here..
arch/s390/kernel/kprobes.c line 195
Quoted 11 lines
arch/s390/kernel/kprobes.c +11
-0+/* RSY Format - instruction unit length = 6 +* ________ ____ ____ ____ __/__ ________ ________ +* |Op Code | R1 | R3 | B2 | DL2 | DH2 |Op Code | +* |________|____|_M3_|____|__/__|________|________| +* 0 8 12 16 20 32 40 47 +*/ +case 0xEB : +if (opcode[5 ] ==BXHG || opcode[5 ] ==BXLEG ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;
..here..
arch/s390/kernel/kprobes.c line 206
Quoted 11 lines
arch/s390/kernel/kprobes.c +11
-0+/* RXY Format - instruction unit length = 6 +* ________ ____ ____ ____ __/__ ________ ________ +* |Op Code | R1 | X2 | B2 | DL2 | DH2 |Op Code | +* |________|____|____|____|__/__|________|________| +* 0 8 12 16 20 32 40 47 +*/ +case 0xE3 : +if (opcode[5 ] ==BCTG ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;
..and here.
arch/s390/kernel/kprobes.c line 212
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+default : +break ; + } +return ret; +} +
There are some more instructions missing that need fixup:
"brxh" 0x84??????, "brxle" 0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr" 0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.
A suggestion: I think the code would be easier to understand if you'd use three bits for the three actions that are needed after single stepping the out-of-line instruction:
1) fixup psw.addr to point to the instruction after the breakpoint (FIXUP_PSW_NORMAL 0x80000000)
2) fixup psw.addr to point to the instruction after the breakpoint if the branch has not been taken (FIXUP_PSW_BRANCH 0x40000000)
3) update register with the return address (FIXUP_RETURN_REGISTER).
1) and 2) are mutual exclusive, 3) can be combined with either 1) or 2). In addition a structure instead of an int for inst_type might improve readability.
arch/s390/kernel/kprobes.c line 222
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+void __kprobes arch_arm_kprobe (struct kprobe *p) +{ + *p->addr =BREAKPOINT_INSTRUCTION ; +} + +void __kprobes arch_disarm_kprobe (struct kprobe *p) +{ + *p->addr = p->opcode; +} +
I would feel better if the kernel code is changed in a more controlled manner. Do an smp_call_function to avoid concurrent execution of the instruction you are changing.
Quoted 7 lines
arch/s390/kernel/kprobes.c +7
-0+void __kprobes arch_remove_kprobe (struct kprobe *p) +{ +mutex_lock (&kprobe_mutex); +free_insn_slot (p->ainsn.insn); +mutex_unlock (&kprobe_mutex); +} +
arch/s390/kernel/kprobes.c line 239
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+static void __kprobes prepare_singlestep (struct kprobe *p,struct pt_regs *regs) +{ +per_cr_bits kprobe_per_regs[1 ]; + +memset (kprobe_per_regs,0 ,sizeof (per_cr_bits)); + regs->psw.addr = (unsigned long )p->ainsn.insn; + +/* Just make sure this gets done */ + regs->psw.addr |=PSW_ADDR_AMODE ; +
Just make sure this gets done... I don't think that comment helps much. Please collapse the two regs->psw.addr lines into a single one and remove the comment.
arch/s390/kernel/kprobes.c line 244
Quoted 5 lines
arch/s390/kernel/kprobes.c +5
-0+/* Set up the per control reg info, will pass to lctl */ + kprobe_per_regs[0 ].em_instruction_fetch =1 ; + kprobe_per_regs[0 ].starting_addr = regs->psw.addr; + kprobe_per_regs[0 ].ending_addr = regs->psw.addr +4 ; +
"ending_addr = regs->psw.addr + 1" is enough, see pop 4-31:
an instruction-fetching event occurs if the first byte of the instruction is within the storage area designated by control registers 10 and 11.
arch/s390/kernel/kprobes.c line 250
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+/* Set the PER control regs, turns on single step for this address */ +__ctl_load (kprobe_per_regs,9 ,11 ); + regs->psw.mask |=PSW_MASK_PER ; + regs->psw.mask &= ~(PSW_MASK_IO |PSW_MASK_EXT |PSW_MASK_MCHECK ); +} +
Why do you disable the interrupts and the machine checks?
arch/s390/kernel/kprobes.c line 620
Quoted 5 lines
arch/s390/kernel/kprobes.c +5
-0+void __kprobes jprobe_return (void ) +{ + asmvolatile (".long 0x00020000" ); +} +
0x0002 is a two bytes instruction, any specific reason why you use .long ?
So much for now. I skipped over a lot of code quite quickly and can't comment on it yet. Hope I will find some more time tomorrow to review these parts as well.
Signature · 8 lines
blue skies, Martin. Martin Schwidefsky Linux for zSeries Development & Services IBM Deutschland Entwicklung GmbH "Reality continues to ruin my life." - Calvin.
Hi Martin - This patch implements the suggestions from your review. There were a couple points I wanted to go over:
Quoted 4 lines
There are some more instructions missing that need fixup:
"brxh"0x84??????, "brxle"0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr"0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.
Since all of these are relative branches, and they don't save the psw, the standard clean up of adjusting the original psw by the offset from the out of line address after single step. Unless I'm just being dense :-)
Quoted 6 lines
Quoted 6 lines
(quoted diff) +6
-0+void __kprobes arch_arm_kprobe(struct kprobe *p) +{ + *p->addr = BREAKPOINT_INSTRUCTION; +} + +void __kprobes arch_disarm_kprobe(struct kprobe *p)
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+{ + *p->addr = p->opcode; +} +I would feel better if the kernel code is changed in a more controlled manner. Do an
smp_call_functionto avoid concurrent execution of the instruction you are changing.
I'm not sure that repeatedly executing the same operation on the same area of memory on multiple CPUs is the answer. I'm not sure there is a right answer:
If the instruction is brought into the pipeline while it is being changed on another cpu it will either execute the original instruction and that probe opportunity will be missed, execute the modified opcode and cause a probe hit (which is ok, everything is ready for it), or stall the pipeline while it figures out why the heck someone is modifying something in the I-cache (IIRC that will slow things down a tad. (I'd really like to plead "all the other architectures do it this way", but instead I'll read every paper I can find on I-cache operations and zseries processors over diner)
Quoted 1 line
Why do you disable the interrupts and the machine checks?
No longer sure if it is necessary. Originally it was so that an interrupt wouldn't cause recursion on a probe point (e.g. you are handling a probe that was in the machine check code and you get a machine check interrupt). So, now I wonder, will get back to you on that one.
Thanks
Mike
arch/s390/Kconfig | 14 + arch/s390/kernel/Makefile | 1 arch/s390/kernel/entry.S | 15 + arch/s390/kernel/entry64.S | 16 + arch/s390/kernel/kprobes.c | 543 +++++++++++++++++++++++++++++++++++++++++ arch/s390/kernel/traps.c | 42 ++- arch/s390/kernel/vmlinux.lds.S | 1 arch/s390/mm/fault.c | 8 include/asm-s390/kdebug.h | 57 ++++ include/asm-s390/kprobes.h | 105 +++++++ 10 files changed, 796 insertions(+), 6 deletions(-)
arch/s390/Kconfig +14 -0
@@ -474,8 +474,22 @@ source "drivers/net/Kconfig" source "fs/Kconfig" +menu "Instrumentation Support" + depends on EXPERIMENTAL + source "arch/s390/oprofile/Kconfig" +config KPROBES + bool "Kprobes (EXPERIMENTAL)" + depends on EXPERIMENTAL && MODULES + help + Kprobes allows you to trap at almost any kernel address and + execute a callback function. register_kprobe() establishes + a probepoint and specifies the callback. Kprobes is useful + for kernel debugging, non-intrusive instrumentation and testing. + If in doubt, say "N". +endmenu + source "arch/s390/Kconfig.debug" source "security/Kconfig"
arch/s390/kernel/entry64.S +16 -0
@@ -497,6 +497,8 @@ pgm_no_vtime2: #endif lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct lg %r1,__TI_task(%r9) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
@@ -531,6 +533,20 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts j sysc_do_svc +# +# per was called from kernel, must be kprobes +# +kernel_per: + lgf %r3,__LC_PGM_ILC # load program interruption code + lghi %r8,0x7f + ngr %r8,%r3 # clear per-event-bit and ilc +# j sysc_singlestep + lhi %r0,__LC_PGM_OLD_PSW + sth %r0,SP_TRAP(%r15) # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + larl %r14,sysc_leave # load adr. of system ret, no work + brcl 15,do_single_step # branch to do_single_step + /* * IO interrupt handler routine */
arch/s390/kernel/entry.S +15 -0
@@ -480,6 +480,8 @@ pgm_no_vtime2: mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz kernel_per l %r3,__LC_PGM_ILC # load program interruption code la %r8,0x7f nr %r8,%r3 # clear per-event-bit and ilc
@@ -510,6 +512,19 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts b BASED(sysc_do_svc) +# +# per was called from kernel, must be kprobes +# +kernel_per: + l %r3,__LC_PGM_ILC # load program interruption code + la %r8,0x7f + nr %r8,%r3 # clear per-event-bit and ilc + mvi SP_TRAP+1(%r15),0x28 # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + l %r1,BASED(.Lhandle_per) # load adr. of per handler + la %r14,BASED(sysc_leave) # load adr. of system return + br %r1 # branch to do_single_step + /* * IO interrupt handler routine */
arch/s390/kernel/kprobes.c +543 -0
543 lines not on this page · raw message
arch/s390/kernel/Makefile +1 -0
@@ -21,6 +21,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o obj-$(CONFIG_BINFMT_ELF32) += binfmt_elf32.o obj-$(CONFIG_VIRT_TIMER) += vtime.o +obj-$(CONFIG_KPROBES) += kprobes.o # Kexec part S390_KEXEC_OBJS := machine_kexec.o crash.o
arch/s390/kernel/traps.c +37 -5
85 lines not on this page · raw message
arch/s390/kernel/vmlinux.lds.S +1 -0
@@ -25,6 +25,7 @@ SECTIONS *(.text) SCHED_TEXT LOCK_TEXT + KPROBES_TEXT *(.fixup) *(.gnu.warning) } = 0x0700
arch/s390/mm/fault.c +7 -1
@@ -26,10 +26,12 @@#include <linux/console.h> #include <linux/module.h> #include <linux/hardirq.h> +#include <linux/kprobes.h> #include <asm/system.h> #include <asm/uaccess.h> #include <asm/pgtable.h> +#include <asm/kdebug.h> #ifndef CONFIG_64BIT #define __FAIL_ADDR_MASK 0x7ffff000
@@ -160,7 +162,7 @@ static void do_sigsegv(struct pt_regs *r* 11 Page translation -> Not present (nullification) * 3b Region third trans. -> Not present (nullification) */ -static inline void +static inline void __kprobes do_exception (struct pt_regs *regs,unsigned long error_code,int is_protection) {struct task_struct *tsk;
@@ -174,6 +176,10 @@ do_exception(struct pt_regs *regs, unsig tsk = current; mm = tsk->mm; +if (notify_die (DIE_PAGE_FAULT ,"page fault" , regs, error_code,14 , +SIGSEGV ) ==NOTIFY_STOP ) +return ; +/* * Check for low-address protection. This needs to be treated * as a special case because the translation exception code
include/asm-s390/kdebug.h +57 -0
57 lines not on this page · raw message
include/asm-s390/kprobes.h +105 -0
105 lines not on this page · raw message
Quoted 9 lines · Mike Grundy
Hi Martin - This patch implements the suggestions from your review. There were a couple points I wanted to go over:
Quoted 4 lines
There are some more instructions missing that need fixup:
"brxh"0x84??????, "brxle"0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr"0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.Since all of these are relative branches, and they don't save the psw, the standard clean up of adjusting the original psw by the offset from the out of line address after single step. Unless I'm just being dense :-)
All of these are conditional branches, if the branch is not taken you have to do a cleanup.
Quoted 14 lines
Quoted 6 lines
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+void __kprobes arch_arm_kprobe (struct kprobe *p) +{ + *p->addr =BREAKPOINT_INSTRUCTION ; +} + +void __kprobes arch_disarm_kprobe (struct kprobe *p)Quoted 8 lines
arch/s390/kernel/kprobes.c line 139
Quoted 4 lines
arch/s390/kernel/kprobes.c +4
-0+{ + *p->addr = p->opcode; +} +I would feel better if the kernel code is changed in a more controlled manner. Do an
smp_call_functionto avoid concurrent execution of the instruction you are changing.
Quoted 10 lines
I'm not sure that repeatedly executing the same operation on the same area of memory on multiple CPUs is the answer. I'm not sure there is a right answer:
If the instruction is brought into the pipeline while it is being changed on another cpu it will either execute the original instruction and that probe opportunity will be missed, execute the modified opcode and cause a probe hit (which is ok, everything is ready for it), or stall the pipeline while it figures out why the heck someone is modifying something in the I-cache (IIRC that will slow things down a tad. (I'd really like to plead "all the other architectures do it this way", but instead I'll read every paper I can find on I-cache operations and zseries processors over diner)
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
Signature · 8 lines
blue skies, Martin. Martin Schwidefsky Linux for zSeries Development & Services IBM Deutschland Entwicklung GmbH "Reality continues to ruin my life." - Calvin.
Quoted 7 lines · Martin Schwidefsky
Quoted 6 lines · Mike Grundy
Hi Martin - This patch implements the suggestions from your review. There were a couple points I wanted to go over:
Quoted 4 lines
There are some more instructions missing that need fixup:
"brxh"0x84??????, "brxle"0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr"0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.
Quoted 6 lines
Quoted 3 lines
Since all of these are relative branches, and they don't save the psw, the standard clean up of adjusting the original psw by the offset from the out of line address after single step. Unless I'm just being dense :-)
All of these are conditional branches, if the branch is not taken you have to do a cleanup.
The reason I have a special cleanup for the other branches is the easy way to tell if the branch wasn't taken is the pswa = orig pswa + instruction length. The relative branches get cleaned up the same way if the branch was taken or not, pswa = probe_addr + (out of line end psw - out of line start psw). These are all relative branches and while they need cleanup, they don't get treated differently based on the branch status.
Quoted 3 lines
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory
Yep, I misunderstood that. The serialization is the point, not the replacement of a word in memory.
Signature · 2 lines
Thanks Mike
Quoted 12 lines · Mike Grundy
Quoted 11 lines · Martin Schwidefsky
Quoted 9 lines · Mike Grundy
Hi Martin - This patch implements the suggestions from your review. There were a couple points I wanted to go over:
Quoted 4 lines
There are some more instructions missing that need fixup:
"brxh"0x84??????, "brxle"0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr"0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.Since all of these are relative branches, and they don't save the psw, the standard clean up of adjusting the original psw by the offset from the out of line address after single step. Unless I'm just being dense :-)
Quoted 8 lines
Quoted 2 lines
All of these are conditional branches, if the branch is not taken you have to do a cleanup.
The reason I have a special cleanup for the other branches is the easy way to tell if the branch wasn't taken is the pswa = orig pswa + instruction length. The relative branches get cleaned up the same way if the branch was taken or not, pswa =
probe_addr+ (out of line end psw - out of line start psw). These are all relative branches and while they need cleanup, they don't get treated differently based on the branch status.
So you are always doing a sort of branch cleanup, even for non-branch instructions. Seems reasonable, since non-branch instructions don't branch and the standard cleanup logic can deal with.
Quoted 5 lines
Quoted 3 lines
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory
Yep, I misunderstood that. The serialization is the point, not the replacement of a word in memory.
Exactly.
Signature · 8 lines
blue skies, Martin. Martin Schwidefsky Linux for zSeries Development & Services IBM Deutschland Entwicklung GmbH "Reality continues to ruin my life." - Calvin.
Quoted 7 lines · Martin Schwidefsky
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
So maybe something like this:
void smp_replace_instruction(void *info) {
struct ins_replace_args *parms;
parms = (struct ins_replace_args *) info;
*parms->addr = *parms->insn
}void __kprobes arch_arm_kprobe(struct kprobe *p)
{
struct ins_replace_args parms;
parms.addr = p->addr;
parms.insn = BREAKPOINT_INSTRUCTION
preempt_disable();
smp_call_function(smp_replace_instruction, &parms, 0, 1);
preempt_enable();
}Thanks
Mike
Quoted 18 lines · Mike Grundy
Quoted 7 lines · Martin Schwidefsky
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
So maybe something like this:
void smp_replace_instruction(void *info) { struct ins_replace_args *parms; parms = (struct ins_replace_args *) info; *parms->addr = *parms->insn }void
__kprobesarch_arm_kprobe(struct kprobe *p)
Quoted 9 lines
{
struct ins_replace_args parms;
parms.addr = p->addr;
parms.insn = BREAKPOINT_INSTRUCTION
preempt_disable();
smp_call_function(smp_replace_instruction, &parms, 0, 1);
preempt_enable();
}Preemption disabling is not necessary around smp_call_function(), since smp_call_function() takes a spin lock. But smp_call_function() is wrong here, it calls the code on all other CPUs but not on our own. Please use on_each_cpu() instead.
Jan
---
Jan Glauber
IBM Linux Technology Center
Linux on zSeries Development, Boeblingen
Quoted 10 lines · Jan Glauber
Quoted 8 lines · Mike Grundy
Quoted 7 lines · Martin Schwidefsky
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
Quoted 4 lines
Preemption disabling is not necessary around
smp_call_function(), sincesmp_call_function()takes a spin lock. Butsmp_call_function()is wrong here, it calls the code on all other CPUs but not on our own. Please useon_each_cpu()instead.
But on_each_cpu() does:
preempt_disable();
ret = smp_call_function(func, info, retry, wait);
local_irq_disable();
func(info);
local_irq_enable();
preempt_enable();I'm confused. I really don't need to swap the instruction on each cpu. I really need to make sure each cpu is not fetching that instruction while I change it. s390 doesn't have a flush_icache_range() (which the other arches use after the swap). I thought that the synchronization that smp_call_function() does was the primary reason for using it here, not repeatedly changing the same area of memory. If you'd prefer I use on_each_cpu() instead of smp_call_function(), no problem.
Thanks
Mike
Quoted 25 lines · Mike Grundy
Quoted 10 lines · Jan Glauber
Quoted 8 lines · Mike Grundy
Quoted 7 lines · Martin Schwidefsky
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
Quoted 4 lines
Preemption disabling is not necessary around
smp_call_function(), sincesmp_call_function()takes a spin lock. Butsmp_call_function()is wrong here, it calls the code on all other CPUs but not on our own. Please useon_each_cpu()instead.But
on_each_cpu()does:preempt_disable(); ret = smp_call_function(func, info, retry, wait); local_irq_disable(); func(info); local_irq_enable(); preempt_enable();
Quoted 7 lines
I'm confused. I really don't need to swap the instruction on each cpu. I really need to make sure each cpu is not fetching that instruction while I change it. s390 doesn't have a
flush_icache_range()(which the other arches use after the swap). I thought that the synchronization thatsmp_call_function()does was the primary reason for using it here, not repeatedly changing the same area of memory. If you'd prefer I useon_each_cpu()instead ofsmp_call_function(), no problem.
If I'm not completely off-track you _do_ swap the instruction on all other CPUs with the smp_call_function(). But since we don't have a flush_icache_range() interface on s390 we must understand how the instruction cache works and then we will know whether we need the smp call at all.
Quoted 25 lines · Mike Grundy
Quoted 10 lines · Jan Glauber
Quoted 8 lines · Mike Grundy
Quoted 7 lines · Martin Schwidefsky
You misunderstood me here. I'm not talking about storing the same piece of data to memory on each processor. I'm talking about isolating all other cpus so that the initiating cpu can store the breakpoint to memory without running into the danger that another cpu is trying to execute it at the same time. But probably the store should be atomic in regard to instruction fetching on the other cpus. It is only two bytes and it should be aligned.
Quoted 4 lines
Preemption disabling is not necessary around
smp_call_function(), sincesmp_call_function()takes a spin lock. Butsmp_call_function()is wrong here, it calls the code on all other CPUs but not on our own. Please useon_each_cpu()instead.But
on_each_cpu()does:preempt_disable(); ret = smp_call_function(func, info, retry, wait); local_irq_disable(); func(info); local_irq_enable(); preempt_enable();
Quoted 7 lines
I'm confused. I really don't need to swap the instruction on each cpu. I really need to make sure each cpu is not fetching that instruction while I change it. s390 doesn't have a
flush_icache_range()(which the other arches use after the swap). I thought that the synchronization thatsmp_call_function()does was the primary reason for using it here, not repeatedly changing the same area of memory. If you'd prefer I useon_each_cpu()instead ofsmp_call_function(), no problem.
This won't solve anything. What Martin probably meant is something like a poor man's stop_machine_run() implemented by using smp_call_function(). This way you synchronize all cpus and when all cpus are in a known state, you change the instruction in question and make sure that serialization happens before cpus leave the handler again... Except for the cpu that called smp_call_function() you get the serialization for free, since the last instruction of the handler is always an lpsw/lpswe instruction.
Otherwise there is still the possibility that a different cpu is fetching the instruction concurrently while you change it. This doesn't sound very good, especially if you take this paragraph of the Principles of Operation into account (p.5-89 of SA22-7832-04):
"It is possible, if another CPU or a channel program concurrently modifies the instruction, for one CPU to recognize the changes to some but not all bit positions of an instruction."
Hi Martin - New patch, has the smp_call_function for the instruction replacement and the alignment check Jan suggested. Also put in the lpsw, lpswe and larl checks. A few other clean ups included. Happy reading...
Thanks
Mike
arch/s390/Kconfig | 14 arch/s390/kernel/Makefile | 1 arch/s390/kernel/entry.S | 15 + arch/s390/kernel/entry64.S | 15 + arch/s390/kernel/kprobes.c | 587 +++++++++++++++++++++++++++++++++++++++++ arch/s390/kernel/traps.c | 42 ++ arch/s390/kernel/vmlinux.lds.S | 1 arch/s390/mm/fault.c | 8 include/asm-s390/kdebug.h | 57 +++ include/asm-s390/kprobes.h | 107 +++++++ 10 files changed, 841 insertions(+), 6 deletions(-)
arch/s390/Kconfig +14 -0
@@ -474,8 +474,22 @@ source "drivers/net/Kconfig" source "fs/Kconfig" +menu "Instrumentation Support" + depends on EXPERIMENTAL + source "arch/s390/oprofile/Kconfig" +config KPROBES + bool "Kprobes (EXPERIMENTAL)" + depends on EXPERIMENTAL && MODULES + help + Kprobes allows you to trap at almost any kernel address and + execute a callback function. register_kprobe() establishes + a probepoint and specifies the callback. Kprobes is useful + for kernel debugging, non-intrusive instrumentation and testing. + If in doubt, say "N". +endmenu + source "arch/s390/Kconfig.debug" source "security/Kconfig"
arch/s390/kernel/entry64.S +15 -0
@@ -497,6 +497,8 @@ pgm_no_vtime2: #endif lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct lg %r1,__TI_task(%r9) + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + jz kernel_per mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
@@ -531,6 +533,19 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts j sysc_do_svc +# +# per was called from kernel, must be kprobes +# +kernel_per: + lgf %r3,__LC_PGM_ILC # load program interruption code + lghi %r8,0x7f + ngr %r8,%r3 # clear per-event-bit and ilc + lhi %r0,__LC_PGM_OLD_PSW + sth %r0,SP_TRAP(%r15) # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + larl %r14,sysc_leave # load adr. of system ret, no work + brcl 15,do_single_step # branch to do_single_step + /* * IO interrupt handler routine */
arch/s390/kernel/entry.S +15 -0
@@ -480,6 +480,8 @@ pgm_no_vtime2: mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP + tm __LC_PGM_OLD_PSW+1(%r15),0x01 # kernel per event ? + bz kernel_per l %r3,__LC_PGM_ILC # load program interruption code la %r8,0x7f nr %r8,%r3 # clear per-event-bit and ilc
@@ -510,6 +512,19 @@ pgm_no_vtime3: stosm __SF_EMPTY(%r15),0x03 # reenable interrupts b BASED(sysc_do_svc) +# +# per was called from kernel, must be kprobes +# +kernel_per: + l %r3,__LC_PGM_ILC # load program interruption code + la %r8,0x7f + nr %r8,%r3 # clear per-event-bit and ilc + mvi SP_TRAP+1(%r15),0x28 # set trap indication to pgm check + la %r2,SP_PTREGS(%r15) # address of register-save area + l %r1,BASED(.Lhandle_per) # load adr. of per handler + la %r14,BASED(sysc_leave) # load adr. of system return + br %r1 # branch to do_single_step + /* * IO interrupt handler routine */
arch/s390/kernel/kprobes.c +587 -0
587 lines not on this page · raw message
arch/s390/kernel/Makefile +1 -0
@@ -21,6 +21,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o obj-$(CONFIG_BINFMT_ELF32) += binfmt_elf32.o obj-$(CONFIG_VIRT_TIMER) += vtime.o +obj-$(CONFIG_KPROBES) += kprobes.o # Kexec part S390_KEXEC_OBJS := machine_kexec.o crash.o
arch/s390/kernel/traps.c +37 -5
85 lines not on this page · raw message
arch/s390/kernel/vmlinux.lds.S +1 -0
@@ -25,6 +25,7 @@ SECTIONS *(.text) SCHED_TEXT LOCK_TEXT + KPROBES_TEXT *(.fixup) *(.gnu.warning) } = 0x0700
arch/s390/mm/fault.c +7 -1
@@ -26,10 +26,12 @@#include <linux/console.h> #include <linux/module.h> #include <linux/hardirq.h> +#include <linux/kprobes.h> #include <asm/system.h> #include <asm/uaccess.h> #include <asm/pgtable.h> +#include <asm/kdebug.h> #ifndef CONFIG_64BIT #define __FAIL_ADDR_MASK 0x7ffff000
@@ -160,7 +162,7 @@ static void do_sigsegv(struct pt_regs *r* 11 Page translation -> Not present (nullification) * 3b Region third trans. -> Not present (nullification) */ -static inline void +static inline void __kprobes do_exception (struct pt_regs *regs,unsigned long error_code,int is_protection) {struct task_struct *tsk;
@@ -174,6 +176,10 @@ do_exception(struct pt_regs *regs, unsig tsk = current; mm = tsk->mm; +if (notify_die (DIE_PAGE_FAULT ,"page fault" , regs, error_code,14 , +SIGSEGV ) ==NOTIFY_STOP ) +return ; +/* * Check for low-address protection. This needs to be treated * as a special case because the translation exception code
include/asm-s390/kdebug.h +57 -0
57 lines not on this page · raw message
include/asm-s390/kprobes.h +107 -0
107 lines not on this page · raw message
Quoted 163 lines · Martin Schwidefsky
arch/s390/kernel/kprobes.c line 104
Quoted 12 lines · Mike Grundy
arch/s390/kernel/kprobes.c +12
-0+/* get_instruction type will return 0 if only the regular offset adjustments +* after out of line singlestep are required. If a register needs to be fixed, +* bits 16-23 will contain the register number, bits 24-31 contain the length +* of the instruction unit. If fixup is only required when the branch is not +* taken, bits 0-16 will all be set. +*/ +int __kprobes get_instruction_type (kprobe_opcode_t * instruction) +{ +__u8 opcode[6 ]; +int ret =0 ; + +memcpy (opcode, instruction,6 *sizeof (__u8));Again that memcpy. Why don't you just cast the instruction pointer to
__u8and__u16and deference it?The following switch deals with all the instructions that need special handling. Please get rid of the BALR/BASR/BCR/BCTR/... defines and use the opcode number directly. Add a comment which instruction it is like in the new
is_prohibited_opcode. All these defines are only used inget_instruction_typeand the opcodes will certainly not change, only new ones will get added. No point in all those #defines.Quoted 4 lines
arch/s390/kernel/kprobes.c +4
-0+ +switch (opcode[0 ]) { +/* RR Format - instruction unit length = 2 +* ________ ____ ____ arch/s390/kernel/kprobes.c line 118
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+* |Op Code | R1 | R2 | +* |________|_M1_|____| +* 0 8 12 15 +*/ +case BALR :/* PSW addr saved in R1, branch address in R2 */ + ret = (opcode[1 ] &0xf0 ) +2 ; +/* Special non branching use of BALR */ +if ((opcode[1 ] &0x0f ) ==0 ) + ret &=FIXUP_NOBRANCH ; +break ;((opcode[1] &
0xf0) + 2) &FIXUP_NOBRANCHis always 0. If the target register is 0 no branch takes place but R1 still needs fixup.resume_executionwill just fixup the psw address in that case. I think you meant "ret |=FIXUP_NOBRANCH".arch/s390/kernel/kprobes.c line 124
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+case BASR :/* PSW addr saved in R1, branch address in R2 */ + ret = (opcode[1 ] &0xf0 ) +2 ; +/* Special non branching use of BASR */ +if ((opcode[1 ] &0x0f ) ==0 ) + ret &=FIXUP_NOBRANCH ; +break ;Same here..
arch/s390/kernel/kprobes.c line 127
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCR :/* M1 is mask val (condition), branch addr in R2 */ + ret =FIXUP_NOBRANCH &2 ; +break ;..here..
arch/s390/kernel/kprobes.c line 130
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCTR :/* R1 is count down, R2 is branch addr until R1 = 0 */ + ret =FIXUP_NOBRANCH &2 ; +break ;..here..
Quoted 5 lines
arch/s390/kernel/kprobes.c +5
-0+/* RX Format - instruction unit length = 4 +* ________ ____ ____ ____ ____________ +* |Op Code | R1 | X2 | B2 | D2 | +* |________|_M1_|____|____|____________| +* 0 8 12 16 20 31 arch/s390/kernel/kprobes.c line 145
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+*/ +case BAL :/* PSW addr saved in R1, branch addr D2(X2,B2) */ + ret = (opcode[1 ] &0xf0 ) +4 ; +break ; +case BAS :/* PSW addr saved in R1, branch addr D2(X2,B2) */ + ret = (opcode[1 ] &0xf0 ) +4 ; +break ; +case BC :/* M1 is mask val (condition), branch addr D2(X2,B2) */ + ret =FIXUP_NOBRANCH &4 ; +break ;..here..
arch/s390/kernel/kprobes.c line 148
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BCT :/* R1 is count down, D2(X2,B2) is branch addr */ + ret =FIXUP_NOBRANCH &4 ; +break ;..here..
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+/* RI Format - instruction unit length = 4 +* ________ ____ ____ _________________ +* |Op Code | R1 |OpCd| I2 | +* |________|____|____|_________________| +* 0 8 12 16 31 +*/ +case 0xA7 :/* first byte (multiple ops have same 1st byte) */ +if ((opcode[1 ] &0x0f ) ==BRAS ) { + ret = (opcode[1 ] &0xf0 ) +4 ; + }arch/s390/kernel/kprobes.c line 168
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+break ; +/* RS Format - instruction unit length = 4 +* ________ ____ ____ ____ ____________ +* |Op Code | R1 | R3 | B2 | D2 | +* |________|____|_M3_|____|____________| +* 0 8 12 16 20 31 +*/ +case BXH : + ret =FIXUP_NOBRANCH &4 ; +break ;..here..
arch/s390/kernel/kprobes.c line 171
Quoted 3 lines
arch/s390/kernel/kprobes.c +3
-0+case BXLE : + ret =FIXUP_NOBRANCH &4 ; +break ;..here..
arch/s390/kernel/kprobes.c line 184
Quoted 13 lines
arch/s390/kernel/kprobes.c +13
-0+/* RIL Format - instruction unit length = 6 +* ________ ____ ____ _____________/______________ +* |Op Code | R1 |OpCd| I2 | +* |________|_M1_|____|_____________/______________| +* 0 8 12 16 47 +*/ +case 0xC0 : +if ((opcode[1 ] &0x0f ) ==BRASL ) { + ret = (opcode[1 ] &0xf0 ) +6 ; + }else if ((opcode[1 ] &0x0f ) ==BRCL ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;..here..
arch/s390/kernel/kprobes.c line 195
Quoted 11 lines
arch/s390/kernel/kprobes.c +11
-0+/* RSY Format - instruction unit length = 6 +* ________ ____ ____ ____ __/__ ________ ________ +* |Op Code | R1 | R3 | B2 | DL2 | DH2 |Op Code | +* |________|____|_M3_|____|__/__|________|________| +* 0 8 12 16 20 32 40 47 +*/ +case 0xEB : +if (opcode[5 ] ==BXHG || opcode[5 ] ==BXLEG ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;..here..
arch/s390/kernel/kprobes.c line 206
Quoted 11 lines
arch/s390/kernel/kprobes.c +11
-0+/* RXY Format - instruction unit length = 6 +* ________ ____ ____ ____ __/__ ________ ________ +* |Op Code | R1 | X2 | B2 | DL2 | DH2 |Op Code | +* |________|____|____|____|__/__|________|________| +* 0 8 12 16 20 32 40 47 +*/ +case 0xE3 : +if (opcode[5 ] ==BCTG ) { + ret =FIXUP_NOBRANCH &6 ; + } +break ;..and here.
Quoted 11 lines
arch/s390/kernel/kprobes.c line 212
Quoted 6 lines
arch/s390/kernel/kprobes.c +6
-0+default : +break ; + } +return ret; +} +There are some more instructions missing that need fixup:
"brxh"0x84??????, "brxle"0x85??????, "brc" 0xa7?4????, "brct" 0xa7?6????, "brctg" 0xa7?7????, "bctgr"0xb946????, "brxhg" 0xec????????44 and "brxlg" 0xec??????45.
We need to handle lpsw and larl too, since they change the instruction pointer.
Jan
---
Jan Glauber
IBM Linux Technology Center
Linux on zSeries Development, Boeblingen
Quoted 13 lines · Mike Grundy
arch/s390/kernel/kprobes.c +13
-0+int __kprobes arch_prepare_kprobe (struct kprobe *p) +{ +int ret =0 ; + +/* Make sure the probe isn't going on a difficult instruction */ +if (is_prohibited_opcode ((kprobe_opcode_t *) p->addr)) + ret = -EINVAL ; + +/* Use the get_insn_slot() facility for correctness */ +if (!ret) { + p->ainsn.insn =get_insn_slot (); +if (!p->ainsn.insn) { + ret = -ENOMEM ;
arch/s390/kernel/kprobes.c line 57
Quoted 10 lines
arch/s390/kernel/kprobes.c +10
-0+ }else { +/* this should only happen if you got the slot */ +memcpy (p->ainsn.insn, p->addr, +MAX_INSN_SIZE *sizeof (kprobe_opcode_t)); + p->ainsn.inst_type = +get_instruction_type (p->ainsn.insn); + } + } + p->opcode = *p->addr; +return ret;
I think we should also check for correct instruction alignment in this function (2 bytes on s390), like:
if ((unsigned long)p->addr & 0x01) {
printk("Attempt to register kprobe at an unaligned address\n");
return -EINVAL;
}Jan
---
Jan Glauber
IBM Linux Technology Center
Linux on zSeries Development, Boeblingen