Dynamic ftrace support for s390
Subsystems (5)
cover Dynamic ftrace support for s390
This patch series adds dynamic ftrace support for s390.
The first three patches are actually just preparation and cleanup. However the first patch touches common code, because I want to be able to have an arch specific version of probe_kernel_write().
The reason for that is that s390 enables page write protection for the kernel text segment in order to catch random (broken) writes to kernel text. Since write proctection is enabled any probe_kernel_write() call would fail.
Now to solve this, we could disable write protection before writing to the segment and afterwards enable it again (like the x86 specific ftrace code does). Alternatively we could use some s390 special instructions in order to bypass virtual addresses and their protection and directly access the physical page that belongs to the virtual address. That's my preferred solution and why I'd like to be able an arch specific version of probe_kernel_write().
If there are no objections, these patches should go upstream via git-s390 I would guess?
Thanks,
Heiko
PATCH 1/4 maccess: add weak attribute to probe_kernel_write
From: Heiko Carstens <[email protected]>
probe_kernel_write() gets used to write to the kernel address space. E.g. to patch the kernel (kgdb, ftrace, kprobes...). Some architectures however enable write protection for the kernel text section, so that writes to this region would fault.
This patch allows to specify an architecture specific version of probe_kernel_write() which allows to handle and bypass write protection of the text segment.
That way it is still possible to catch random writes to kernel text and explicitly allow writes via this interface.
---
mm/maccess.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/maccess.c +1 -1
@@ -39,7 +39,7 @@ EXPORT_SYMBOL_GPL(probe_kernel_read);* Safely write to address @dst from the buffer at @src. If a kernel fault * happens, handle that and return -EFAULT. */ -long probe_kernel_write (void *dst,void *src,size_t size) +long notrace __weak probe_kernel_write (void *dst,void *src,size_t size) {long ret;mm_segment_t old_fs =get_fs ();
PATCH 2/4 arch specific probe_kernel_write() implementation
In reply to Heiko CarstensFrom: Heiko Carstens <[email protected]>
Add an s390 specific probe_kernel_write() function which allows to write to the kernel text segment even if write protection is enabled. This is implemented using the lra (load real address) and stura (store using real address) instructions.
---
arch/s390/mm/Makefile | 2 - arch/s390/mm/maccess.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 1 deletion(-)
arch/s390/mm/maccess.c +61 -0
@@ -0,0 +1,61 @@ +/* +* Access kernel memory without faulting -- s390 specific implementation. +* +* Copyright IBM Corp. 2009 +* +* Author(s): Heiko Carstens <[email protected]>, +* +*/ + +#include <linux/uaccess.h> +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/errno.h> +#include <asm/system.h> + +/* +* This function writes to kernel memory bypassing DAT and possible +* write protection. It copies one to four bytes from src to dst +* using the stura instruction. +* Returns the number of bytes copied or -EFAULT. +*/ +static long probe_kernel_write_odd (void *dst,void *src,size_t size) +{ +unsigned long count, aligned; +int offset, mask; +int rc = -EFAULT ; + + aligned = (unsigned long ) dst & ~3UL ; + offset = (unsigned long ) dst &3 ; + count = min_t(unsigned long, 4 - offset, size); + mask = (0xf << (4 - count)) &0xf ; + mask >>= offset; + asmvolatile ( +" bras 1,0f\n" +" icm 0,0,0(%3)\n" +"0: l 0,0(%1)\n" +" lra %1,0(%1)\n" +"1: ex %2,0(1)\n" +"2: stura 0,%1\n" +" la %0,0\n" +"3:\n" + EX_TABLE(0b,3b) EX_TABLE(1b,3b) EX_TABLE(2b,3b) + : "+d" (rc), "+a" (aligned) + : "a" (mask), "a" (src) : "cc", "memory", "0", "1"); + return rc ? rc : count; +} + +long probe_kernel_write (void *dst,void *src,size_t size) +{ +long copied =0 ; + +while (size) { + copied =probe_kernel_write_odd (dst, src, size); +if (copied <0 ) +break ; + dst += copied; + src += copied; + size -= copied; + } +return copied <0 ? -EFAULT :0 ; +}
arch/s390/mm/Makefile +1 -1
@@ -2,7 +2,7 @@ # Makefile for the linux s390-specific parts of the memory manager. # -obj-y := init.o fault.o extmem.o mmap.o vmem.o pgtable.o +obj-y := init.o fault.o extmem.o mmap.o vmem.o pgtable.o maccess.o obj-$(CONFIG_CMM) += cmm.o obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o obj-$(CONFIG_PAGE_STATES) += page-states.o
PATCH 3/4 kprobes: use probe_kernel_write
In reply to Heiko CarstensFrom: Heiko Carstens <[email protected]>
Use proble_kernel_write() to patch the kernel.
---
arch/s390/kernel/kprobes.c | 31 ++----------------------------- 1 file changed, 2 insertions(+), 29 deletions(-)
arch/s390/kernel/kprobes.c +2 -29
@@ -25,9 +25,9 @@#include <linux/preempt.h> #include <linux/stop_machine.h> #include <linux/kdebug.h> +#include <linux/uaccess.h> #include <asm/cacheflush.h> #include <asm/sections.h> -#include <asm/uaccess.h> #include <linux/module.h> DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
@@ -155,35 +155,8 @@ void __kprobes get_instruction_type(strustatic int __kprobes swap_instruction (void *aref) {struct ins_replace_args *args = aref; -u32 *addr; -u32 instr; -int err = -EFAULT ; -/* -* Text segment is read-only, hence we use stura to bypass dynamic -* address translation to exchange the instruction. Since stura -* always operates on four bytes, but we only want to exchange two -* bytes do some calculations to get things right. In addition we -* shall not cross any page boundaries (vmalloc area!) when writing -* the new instruction. -*/ - addr = (u32 *)((unsigned long )args->ptr &-4UL ); -if ((unsigned long )args->ptr &2 ) - instr = ((*addr) &0xffff0000 ) | args->new; -else - instr = ((*addr) &0x0000ffff ) | args->new <<16 ; - - asmvolatile ( -" lra %1,0(%1)\n" -"0: stura %2,%1\n" -"1: la %0,0\n" -"2:\n" - EX_TABLE(0b,2b) - : "+d" (err) - : "a" (addr), "d" (instr) - : "memory", "cc"); - - return err; +return probe_kernel_write (args->ptr, &args->new,sizeof (args->new)); }void __kprobes arch_arm_kprobe (struct kprobe *p)
PATCH 4/4 add dynamic ftrace support
In reply to Heiko CarstensFrom: Heiko Carstens <[email protected]>
Dynamic ftrace support for s390.
---
arch/s390/Kconfig | 2 arch/s390/include/asm/ftrace.h | 19 +++++ arch/s390/include/asm/lowcore.h | 8 +- arch/s390/kernel/Makefile | 5 + arch/s390/kernel/early.c | 4 + arch/s390/kernel/ftrace.c | 132 ++++++++++++++++++++++++++++++++++++++++ arch/s390/kernel/mcount.S | 119 +++++++++++++++++++++++++++--------- arch/s390/kernel/setup.c | 2 arch/s390/kernel/smp.c | 1 scripts/recordmcount.pl | 13 +++ 10 files changed, 276 insertions(+), 29 deletions(-)
arch/s390/include/asm/ftrace.h +19 -0
@@ -2,7 +2,26 @@#define _ASM_S390_FTRACE_H#ifndef __ASSEMBLY__ +extern void _mcount (void ); +extern unsigned long ftrace_dyn_func; + +struct dyn_arch_ftrace { }; + +#define MCOUNT_ADDR ((long)_mcount) + +#ifdef CONFIG_64BIT +#define MCOUNT_INSN_SIZE 24 +#define MCOUNT_OFFSET 14 +#else +#define MCOUNT_INSN_SIZE 30 +#define MCOUNT_OFFSET 8#endif +static inline unsigned long ftrace_call_adjust (unsigned long addr) +{ +return addr -MCOUNT_OFFSET ; +} + +#endif /* __ASSEMBLY__ */ #endif /* _ASM_S390_FTRACE_H */
arch/s390/include/asm/lowcore.h +6 -2
@@ -67,6 +67,7 @@#define __LC_CPUID 0x02b0#define __LC_INT_CLOCK 0x02c8#define __LC_MACHINE_FLAGS 0x02d8 +#define __LC_FTRACE_FUNC 0x02dc#define __LC_IRB 0x0300#define __LC_PFAULT_INTPARM 0x0080#define __LC_CPU_TIMER_SAVE_AREA 0x00d8
@@ -112,6 +113,7 @@#define __LC_INT_CLOCK 0x0340#define __LC_VDSO_PER_CPU 0x0350#define __LC_MACHINE_FLAGS 0x0358 +#define __LC_FTRACE_FUNC 0x0360#define __LC_IRB 0x0380#define __LC_PASTE 0x03c0#define __LC_PFAULT_INTPARM 0x11b8
@@ -280,7 +282,8 @@ struct _lowcore__u64 int_clock;/* 0x02c8 */ __u64 clock_comparator;/* 0x02d0 */ __u32 machine_flags;/* 0x02d8 */ -__u8 pad_0x02dc[0x0300 -0x02dc ];/* 0x02dc */ +__u32 ftrace_func;/* 0x02dc */ +__u8 pad_0x02f0[0x0300 -0x02f0 ];/* 0x02f0 */ /* Interrupt response block */ __u8 irb[64 ];/* 0x0300 */
@@ -385,7 +388,8 @@ struct _lowcore__u64 clock_comparator;/* 0x0348 */ __u64 vdso_per_cpu_data;/* 0x0350 */ __u64 machine_flags;/* 0x0358 */ -__u8 pad_0x0360[0x0380 -0x0360 ];/* 0x0360 */ +__u64 ftrace_func;/* 0x0360 */ +__u8 pad_0x0368[0x0380 -0x0368 ];/* 0x0368 */ /* Interrupt response block. */ __u8 irb[64 ];/* 0x0380 */
arch/s390/Kconfig +2 -0
@@ -82,6 +82,8 @@ config S390 select USE_GENERIC_SMP_HELPERS if SMP select HAVE_SYSCALL_WRAPPERS select HAVE_FUNCTION_TRACER + select HAVE_FTRACE_MCOUNT_RECORD + select HAVE_DYNAMIC_FTRACE select HAVE_DEFAULT_NO_SPIN_MUTEXES select HAVE_OPROFILE select HAVE_KPROBES
arch/s390/kernel/early.c +4 -0
@@ -11,6 +11,7 @@#include <linux/errno.h> #include <linux/string.h> #include <linux/ctype.h> +#include <linux/ftrace.h> #include <linux/lockdep.h> #include <linux/module.h> #include <linux/pfn.h>
@@ -410,5 +411,8 @@ void __init startup_init(void)sclp_facilities_detect ();detect_memory_layout (memory_chunk); S390_lowcore.machine_flags = machine_flags; +#ifdef CONFIG_DYNAMIC_FTRACE + S390_lowcore.ftrace_func = (unsigned long )ftrace_caller; +#endif lockdep_on (); }
arch/s390/kernel/ftrace.c new file +132 -0
132 lines not on this page · raw message
arch/s390/kernel/Makefile +5 -0
@@ -7,6 +7,10 @@ ifdef CONFIG_FUNCTION_TRACER CFLAGS_REMOVE_early.o = -pg endif +ifdef CONFIG_DYNAMIC_FTRACE +CFLAGS_REMOVE_ftrace.o = -pg +endif + # # Passing null pointers is ok for smp code, since we access the lowcore here. #
@@ -41,6 +45,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o obj-$(CONFIG_STACKTRACE) += stacktrace.o obj-$(CONFIG_KPROBES) += kprobes.o obj-$(CONFIG_FUNCTION_TRACER) += mcount.o +obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o # Kexec part S390_KEXEC_OBJS := machine_kexec.o crash.o
arch/s390/kernel/mcount.S +92 -27
145 lines not on this page · raw message
arch/s390/kernel/setup.c +2 -0
@@ -42,6 +42,7 @@#include <linux/ctype.h> #include <linux/reboot.h> #include <linux/topology.h> +#include <linux/ftrace.h> #include <asm/ipl.h> #include <asm/uaccess.h>
@@ -442,6 +443,7 @@ setup_lowcore(void) lc->steal_timer = S390_lowcore.steal_timer; lc->last_update_timer = S390_lowcore.last_update_timer; lc->last_update_clock = S390_lowcore.last_update_clock; + lc->ftrace_func = S390_lowcore.ftrace_func;set_prefix ((u32 )(unsigned long ) lc); lowcore_ptr[0 ] = lc; }
arch/s390/kernel/smp.c +1 -0
@@ -572,6 +572,7 @@ int __cpuinit __cpu_up(unsigned int cpu) cpu_lowcore->cpu_nr = cpu; cpu_lowcore->kernel_asce = S390_lowcore.kernel_asce; cpu_lowcore->machine_flags = S390_lowcore.machine_flags; + cpu_lowcore->ftrace_func = S390_lowcore.ftrace_func;eieio ();while (signal_processor (cpu, sigp_restart) == sigp_busy)
scripts/recordmcount.pl +13 -0
@@ -185,6 +185,19 @@ if ($arch eq "x86_64") { $objcopy .= " -O elf32-i386"; $cc .= " -m32"; +} elsif ($arch eq "s390" && $bits == 32) { + $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_32\\s+_mcount\$"; + $alignment = 4; + $ld .= " -m elf_s390"; + $cc .= " -m31"; + +} elsif ($arch eq "s390" && $bits == 64) { + $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_(PC|PLT)32DBL\\s+_mcount\\+0x2\$"; + $alignment = 8; + $type = ".quad"; + $ld .= " -m elf64_s390"; + $cc .= " -m64"; + } elsif ($arch eq "sh") { $alignment = 2;
Re: [PATCH/RFC 4/4] add dynamic ftrace support
Quoted 5 lines · Heiko Carstens
From: Heiko Carstens <[email protected]>
Dynamic ftrace support for s390.
Signed-off-by Heiko Carstens <[email protected]>
Looks good.
-- Steve