Skip to contentSkip to conversation

kprobes for s390 architecture

PATCH In review Mike Grundy 4 participants 14 messages Jun 12, 2006 – Jun 27, 2006

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

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
diff -urNp linux-2.6.17-rc6/arch/s390/Kconfig linux-2.6.17-rc6-kp390/arch/s390/Kconfig
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/entry64.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry64.S
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/entry.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry.S
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/Makefile linux-2.6.17-rc6-kp390/arch/s390/kernel/Makefile
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/vmlinux.lds.S linux-2.6.17-rc6-kp390/arch/s390/kernel/vmlinux.lds.S
@@ -25,6 +25,7 @@ SECTIONS
 	*(.text)
 	SCHED_TEXT
 	LOCK_TEXT
+	KPROBES_TEXT
 	*(.fixup)
 	*(.gnu.warning)
 	} = 0x0700
arch/s390/mm/fault.c +7 -1
diff -urNp linux-2.6.17-rc6/arch/s390/mm/fault.c linux-2.6.17-rc6-kp390/arch/s390/mm/fault.c
@@ -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

#1 lore raw
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.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry64.S

arch/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.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry.S

arch/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.c linux-2.6.17-rc6-kp390/arch/s390/kernel/kprobes.c

arch/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)
+{
+	asm volatile (".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.
#2 lore raw

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_function to 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
diff -urNp linux-2.6.17-rc6/arch/s390/Kconfig linux-2.6.17-rc6-kp390/arch/s390/Kconfig
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/entry64.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry64.S
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/entry.S linux-2.6.17-rc6-kp390/arch/s390/kernel/entry.S
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/Makefile linux-2.6.17-rc6-kp390/arch/s390/kernel/Makefile
@@ -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
diff -urNp linux-2.6.17-rc6/arch/s390/kernel/vmlinux.lds.S linux-2.6.17-rc6-kp390/arch/s390/kernel/vmlinux.lds.S
@@ -25,6 +25,7 @@ SECTIONS
 	*(.text)
 	SCHED_TEXT
 	LOCK_TEXT
+	KPROBES_TEXT
 	*(.fixup)
 	*(.gnu.warning)
 	} = 0x0700
arch/s390/mm/fault.c +7 -1
diff -urNp linux-2.6.17-rc6/arch/s390/mm/fault.c linux-2.6.17-rc6-kp390/arch/s390/mm/fault.c
@@ -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

#3 lore raw
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_function to 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.
#4 lore raw
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
#5 lore raw
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.
#6 lore raw
In reply to Martin Schwidefsky
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

#7 lore raw
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 __kprobes arch_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

#8 lore raw
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(), 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.

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

#9 lore raw
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(), 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.

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 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.

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.

#10 lore raw
In reply to Mike Grundy
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(), 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.

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 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.

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."

#11 lore raw
In reply to Martin Schwidefsky

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
diff -urNp linux-2.6.17.1/arch/s390/Kconfig linux-2.6.17.1-kp390/arch/s390/Kconfig
@@ -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
diff -urNp linux-2.6.17.1/arch/s390/kernel/entry64.S linux-2.6.17.1-kp390/arch/s390/kernel/entry64.S
@@ -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
diff -urNp linux-2.6.17.1/arch/s390/kernel/entry.S linux-2.6.17.1-kp390/arch/s390/kernel/entry.S
@@ -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
diff -urNp linux-2.6.17.1/arch/s390/kernel/Makefile linux-2.6.17.1-kp390/arch/s390/kernel/Makefile
@@ -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
diff -urNp linux-2.6.17.1/arch/s390/kernel/vmlinux.lds.S linux-2.6.17.1-kp390/arch/s390/kernel/vmlinux.lds.S
@@ -25,6 +25,7 @@ SECTIONS
 	*(.text)
 	SCHED_TEXT
 	LOCK_TEXT
+	KPROBES_TEXT
 	*(.fixup)
 	*(.gnu.warning)
 	} = 0x0700
arch/s390/mm/fault.c +7 -1
diff -urNp linux-2.6.17.1/arch/s390/mm/fault.c linux-2.6.17.1-kp390/arch/s390/mm/fault.c
@@ -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

#12 lore raw
In reply to Martin Schwidefsky
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 __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.

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

#13 lore raw
In reply to Mike Grundy
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