From 949e84da2d80837b192209efb4122f2ff59ab54d Mon Sep 17 00:00:00 2001 From: "Frank Ch. Eigler" Date: Tue, 25 Mar 2008 11:46:14 -0400 Subject: add (back) runtime/unwind files --- runtime/unwind/i386.h | 97 +++++++++++++++++++++++++++++++++ runtime/unwind/unwind.h | 142 ++++++++++++++++++++++++++++++++++++++++++++++++ runtime/unwind/x86_64.h | 101 ++++++++++++++++++++++++++++++++++ 3 files changed, 340 insertions(+) create mode 100644 runtime/unwind/i386.h create mode 100644 runtime/unwind/unwind.h create mode 100644 runtime/unwind/x86_64.h (limited to 'runtime/unwind') diff --git a/runtime/unwind/i386.h b/runtime/unwind/i386.h new file mode 100644 index 00000000..de68c67b --- /dev/null +++ b/runtime/unwind/i386.h @@ -0,0 +1,97 @@ +#ifndef _STP_I386_UNWIND_H +#define _STP_I386_UNWIND_H + +/* + * Copyright (C) 2002-2006 Novell, Inc. + * Jan Beulich + * This code is released under version 2 of the GNU GPL. + */ + + +#include +#include +#include +#include + +/* these are simple for i386 */ +#define _stp_get_unaligned(ptr) (*(ptr)) +#define _stp_put_unaligned(val, ptr) ((void)( *(ptr) = (val) )) + +struct unwind_frame_info +{ + struct pt_regs regs; + struct task_struct *task; + unsigned call_frame:1; +}; + +#define UNW_PC(frame) (frame)->regs.eip +#define UNW_SP(frame) (frame)->regs.esp +#ifdef CONFIG_FRAME_POINTER +#define UNW_FP(frame) (frame)->regs.ebp +#define FRAME_RETADDR_OFFSET 4 +#define FRAME_LINK_OFFSET 0 +#define STACK_BOTTOM(tsk) STACK_LIMIT((tsk)->thread.esp0) +#define STACK_TOP(tsk) ((tsk)->thread.esp0) +#else +#define UNW_FP(frame) ((void)(frame), 0) +#endif +#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) + +#define UNW_REGISTER_INFO \ + PTREGS_INFO(eax), \ + PTREGS_INFO(ecx), \ + PTREGS_INFO(edx), \ + PTREGS_INFO(ebx), \ + PTREGS_INFO(esp), \ + PTREGS_INFO(ebp), \ + PTREGS_INFO(esi), \ + PTREGS_INFO(edi), \ + PTREGS_INFO(eip) + +#define UNW_DEFAULT_RA(raItem, dataAlign) \ + ((raItem).where == Memory && \ + !((raItem).value * (dataAlign) + 4)) + +static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, + /*const*/ struct pt_regs *regs) +{ + if (user_mode_vm(regs)) + info->regs = *regs; + else { + memcpy(&info->regs, regs, offsetof(struct pt_regs, esp)); + info->regs.esp = (unsigned long)®s->esp; + info->regs.xss = __KERNEL_DS; + } +} + +static inline void arch_unw_init_blocked(struct unwind_frame_info *info) +{ + memset(&info->regs, 0, sizeof(info->regs)); + info->regs.eip = info->task->thread.eip; + info->regs.xcs = __KERNEL_CS; + __get_user(info->regs.ebp, (long *)info->task->thread.esp); + info->regs.esp = info->task->thread.esp; + info->regs.xss = __KERNEL_DS; + info->regs.xds = __USER_DS; + info->regs.xes = __USER_DS; +} + +extern asmlinkage int arch_unwind_init_running(struct unwind_frame_info *, + asmlinkage int (*callback)(struct unwind_frame_info *, + void *arg), + void *arg); + +static inline int arch_unw_user_mode(const struct unwind_frame_info *info) +{ +#if 0 /* This can only work when selector register and EFLAGS saves/restores + are properly annotated (and tracked in UNW_REGISTER_INFO). */ + return user_mode_vm(&info->regs); +#else + return info->regs.eip < PAGE_OFFSET + || (info->regs.eip >= __fix_to_virt(FIX_VDSO) + && info->regs.eip < __fix_to_virt(FIX_VDSO) + PAGE_SIZE) + || info->regs.esp < PAGE_OFFSET; +#endif +} + +#endif /* _STP_I386_UNWIND_H */ diff --git a/runtime/unwind/unwind.h b/runtime/unwind/unwind.h new file mode 100644 index 00000000..8651cb9e --- /dev/null +++ b/runtime/unwind/unwind.h @@ -0,0 +1,142 @@ +/* -*- linux-c -*- + * + * dwarf unwinder header file + * Copyright (C) 2008 Red Hat Inc. + * Copyright (C) 2002-2006 Novell, Inc. + * + * This file is part of systemtap, and is free software. You can + * redistribute it and/or modify it under the terms of the GNU General + * Public License (GPL); either version 2, or (at your option) any + * later version. + */ + +#ifndef _STP_UNWIND_H_ +#define _STP_UNWIND_H_ + +#if defined (__x86_64__) +#include "x86_64.h" +#elif defined (__i386__) +#include "i386.h" +#else +#error "Unsupported dwarf unwind architecture" +#endif + +#define MAX_STACK_DEPTH 8 + +#define EXTRA_INFO(f) { \ + BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) \ + % FIELD_SIZEOF(struct unwind_frame_info, f)) \ + + offsetof(struct unwind_frame_info, f) \ + / FIELD_SIZEOF(struct unwind_frame_info, f), \ + FIELD_SIZEOF(struct unwind_frame_info, f) \ + } +#define PTREGS_INFO(f) EXTRA_INFO(regs.f) + +static const struct { + unsigned offs:BITS_PER_LONG / 2; + unsigned width:BITS_PER_LONG / 2; +} reg_info[] = { + UNW_REGISTER_INFO +}; + +#undef PTREGS_INFO +#undef EXTRA_INFO + +#ifndef REG_INVALID +#define REG_INVALID(r) (reg_info[r].width == 0) +#endif + +#define DW_CFA_nop 0x00 +#define DW_CFA_set_loc 0x01 +#define DW_CFA_advance_loc1 0x02 +#define DW_CFA_advance_loc2 0x03 +#define DW_CFA_advance_loc4 0x04 +#define DW_CFA_offset_extended 0x05 +#define DW_CFA_restore_extended 0x06 +#define DW_CFA_undefined 0x07 +#define DW_CFA_same_value 0x08 +#define DW_CFA_register 0x09 +#define DW_CFA_remember_state 0x0a +#define DW_CFA_restore_state 0x0b +#define DW_CFA_def_cfa 0x0c +#define DW_CFA_def_cfa_register 0x0d +#define DW_CFA_def_cfa_offset 0x0e +#define DW_CFA_def_cfa_expression 0x0f +#define DW_CFA_expression 0x10 +#define DW_CFA_offset_extended_sf 0x11 +#define DW_CFA_def_cfa_sf 0x12 +#define DW_CFA_def_cfa_offset_sf 0x13 +#define DW_CFA_val_offset 0x14 +#define DW_CFA_val_offset_sf 0x15 +#define DW_CFA_val_expression 0x16 +#define DW_CFA_lo_user 0x1c +#define DW_CFA_GNU_window_save 0x2d +#define DW_CFA_GNU_args_size 0x2e +#define DW_CFA_GNU_negative_offset_extended 0x2f +#define DW_CFA_hi_user 0x3f + +#define DW_EH_PE_absptr 0x00 +#define DW_EH_PE_leb128 0x01 +#define DW_EH_PE_data2 0x02 +#define DW_EH_PE_data4 0x03 +#define DW_EH_PE_data8 0x04 +#define DW_EH_PE_FORM 0x07 /* mask */ +#define DW_EH_PE_signed 0x08 /* signed versions of above have this bit set */ + +#define DW_EH_PE_pcrel 0x10 +#define DW_EH_PE_textrel 0x20 +#define DW_EH_PE_datarel 0x30 +#define DW_EH_PE_funcrel 0x40 +#define DW_EH_PE_aligned 0x50 +#define DW_EH_PE_ADJUST 0x70 /* mask */ +#define DW_EH_PE_indirect 0x80 +#define DW_EH_PE_omit 0xff + +typedef unsigned long uleb128_t; +typedef signed long sleb128_t; + +static struct unwind_table { + unsigned long pc; /* text */ + unsigned long range; /* text_size */ + const void *address; /* unwind_data */ + unsigned long size; /* unwind_data_len */ + const unsigned char *header; /* unwind_header */ + unsigned long hdrsz; + struct unwind_table *link; + const char *name; /* module name */ +} root_table; + +struct unwind_item { + enum item_location { + Nowhere, + Memory, + Register, + Value + } where; + uleb128_t value; +}; + +struct unwind_state { + uleb128_t loc, org; + const u8 *cieStart, *cieEnd; + uleb128_t codeAlign; + sleb128_t dataAlign; + struct cfa { + uleb128_t reg, offs; + } cfa; + struct unwind_item regs[ARRAY_SIZE(reg_info)]; + unsigned stackDepth:8; + unsigned version:8; + const u8 *label; + const u8 *stack[MAX_STACK_DEPTH]; +}; + +static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 }; +static unsigned long read_pointer(const u8 **pLoc, + const void *end, + signed ptrType); +static const u32 bad_cie, not_fde; +static const u32 *cie_for_fde(const u32 *fde, const struct _stp_module *); +static signed fde_pointer_type(const u32 *cie); + +#endif /*_STP_UNWIND_H_*/ diff --git a/runtime/unwind/x86_64.h b/runtime/unwind/x86_64.h new file mode 100644 index 00000000..eddf276d --- /dev/null +++ b/runtime/unwind/x86_64.h @@ -0,0 +1,101 @@ +#ifndef _STP_X86_64_UNWIND_H +#define _STP_X86_64_UNWIND_H + +/* + * Copyright (C) 2002-2006 Novell, Inc. + * Jan Beulich + * This code is released under version 2 of the GNU GPL. + */ + +#include +#include +#include + +/* these are simple for x86_64 */ +#define _stp_get_unaligned(ptr) (*(ptr)) +#define _stp_put_unaligned(val, ptr) ((void)( *(ptr) = (val) )) + +struct unwind_frame_info +{ + struct pt_regs regs; + struct task_struct *task; + unsigned call_frame:1; +}; + +#define UNW_PC(frame) (frame)->regs.rip +#define UNW_SP(frame) (frame)->regs.rsp +#ifdef CONFIG_FRAME_POINTER +#define UNW_FP(frame) (frame)->regs.rbp +#define FRAME_RETADDR_OFFSET 8 +#define FRAME_LINK_OFFSET 0 +#define STACK_BOTTOM(tsk) (((tsk)->thread.rsp0 - 1) & ~(THREAD_SIZE - 1)) +#define STACK_TOP(tsk) ((tsk)->thread.rsp0) +#endif +/* Might need to account for the special exception and interrupt handling + stacks here, since normally + EXCEPTION_STACK_ORDER < THREAD_ORDER < IRQSTACK_ORDER, + but the construct is needed only for getting across the stack switch to + the interrupt stack - thus considering the IRQ stack itself is unnecessary, + and the overhead of comparing against all exception handling stacks seems + not desirable. */ +#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) + +#define UNW_REGISTER_INFO \ + PTREGS_INFO(rax), \ + PTREGS_INFO(rdx), \ + PTREGS_INFO(rcx), \ + PTREGS_INFO(rbx), \ + PTREGS_INFO(rsi), \ + PTREGS_INFO(rdi), \ + PTREGS_INFO(rbp), \ + PTREGS_INFO(rsp), \ + PTREGS_INFO(r8), \ + PTREGS_INFO(r9), \ + PTREGS_INFO(r10), \ + PTREGS_INFO(r11), \ + PTREGS_INFO(r12), \ + PTREGS_INFO(r13), \ + PTREGS_INFO(r14), \ + PTREGS_INFO(r15), \ + PTREGS_INFO(rip) + +#define UNW_DEFAULT_RA(raItem, dataAlign) \ + ((raItem).where == Memory && \ + !((raItem).value * (dataAlign) + 8)) + +static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, + /*const*/ struct pt_regs *regs) +{ + info->regs = *regs; +} + +static inline void arch_unw_init_blocked(struct unwind_frame_info *info) +{ + extern const char thread_return[]; + + memset(&info->regs, 0, sizeof(info->regs)); + info->regs.rip = (unsigned long)thread_return; + info->regs.cs = __KERNEL_CS; + __get_user(info->regs.rbp, (unsigned long *)info->task->thread.rsp); + info->regs.rsp = info->task->thread.rsp; + info->regs.ss = __KERNEL_DS; +} + +extern int arch_unwind_init_running(struct unwind_frame_info *, + int (*callback)(struct unwind_frame_info *, + void *arg), + void *arg); + +static inline int arch_unw_user_mode(const struct unwind_frame_info *info) +{ +#if 0 /* This can only work when selector register saves/restores + are properly annotated (and tracked in UNW_REGISTER_INFO). */ + return user_mode(&info->regs); +#else + return (long)info->regs.rip >= 0 + || (info->regs.rip >= VSYSCALL_START && info->regs.rip < VSYSCALL_END) + || (long)info->regs.rsp >= 0; +#endif +} + +#endif /* _STP_X86_64_UNWIND_H */ -- cgit From b56639bb84656464efbf88912f68c36e7f099d49 Mon Sep 17 00:00:00 2001 From: Martin Hunt Date: Tue, 25 Mar 2008 12:26:46 -0400 Subject: Cleanup. --- runtime/unwind/i386.h | 11 +++++++++++ runtime/unwind/x86_64.h | 12 ++++++++++++ 2 files changed, 23 insertions(+) (limited to 'runtime/unwind') diff --git a/runtime/unwind/i386.h b/runtime/unwind/i386.h index de68c67b..1a6b678b 100644 --- a/runtime/unwind/i386.h +++ b/runtime/unwind/i386.h @@ -1,3 +1,14 @@ +/* -*- linux-c -*- + * + * 32-bit x86 dwarf unwinder header file + * Copyright (C) 2008 Red Hat Inc. + * Copyright (C) 2002-2006 Novell, Inc. + * + * This file is part of systemtap, and is free software. You can + * redistribute it and/or modify it under the terms of the GNU General + * Public License (GPL); either version 2, or (at your option) any + * later version. + */ #ifndef _STP_I386_UNWIND_H #define _STP_I386_UNWIND_H diff --git a/runtime/unwind/x86_64.h b/runtime/unwind/x86_64.h index eddf276d..3c4a97be 100644 --- a/runtime/unwind/x86_64.h +++ b/runtime/unwind/x86_64.h @@ -1,3 +1,14 @@ +/* -*- linux-c -*- + * + * x86_64 dwarf unwinder header file + * Copyright (C) 2008 Red Hat Inc. + * Copyright (C) 2002-2006 Novell, Inc. + * + * This file is part of systemtap, and is free software. You can + * redistribute it and/or modify it under the terms of the GNU General + * Public License (GPL); either version 2, or (at your option) any + * later version. + */ #ifndef _STP_X86_64_UNWIND_H #define _STP_X86_64_UNWIND_H @@ -67,6 +78,7 @@ static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, /*const*/ struct pt_regs *regs) { info->regs = *regs; + info->call_frame = 1; } static inline void arch_unw_init_blocked(struct unwind_frame_info *info) -- cgit From fd2ef8221625866219d6fc8e99ac36520ac6017b Mon Sep 17 00:00:00 2001 From: Martin Hunt Date: Wed, 26 Mar 2008 10:06:19 -0400 Subject: i386 fixes. --- runtime/unwind/i386.h | 12 +----------- runtime/unwind/x86_64.h | 5 ----- 2 files changed, 1 insertion(+), 16 deletions(-) (limited to 'runtime/unwind') diff --git a/runtime/unwind/i386.h b/runtime/unwind/i386.h index 1a6b678b..cb2efab7 100644 --- a/runtime/unwind/i386.h +++ b/runtime/unwind/i386.h @@ -12,13 +12,6 @@ #ifndef _STP_I386_UNWIND_H #define _STP_I386_UNWIND_H -/* - * Copyright (C) 2002-2006 Novell, Inc. - * Jan Beulich - * This code is released under version 2 of the GNU GPL. - */ - - #include #include #include @@ -73,6 +66,7 @@ static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, info->regs.esp = (unsigned long)®s->esp; info->regs.xss = __KERNEL_DS; } + info->call_frame = 1; } static inline void arch_unw_init_blocked(struct unwind_frame_info *info) @@ -87,10 +81,6 @@ static inline void arch_unw_init_blocked(struct unwind_frame_info *info) info->regs.xes = __USER_DS; } -extern asmlinkage int arch_unwind_init_running(struct unwind_frame_info *, - asmlinkage int (*callback)(struct unwind_frame_info *, - void *arg), - void *arg); static inline int arch_unw_user_mode(const struct unwind_frame_info *info) { diff --git a/runtime/unwind/x86_64.h b/runtime/unwind/x86_64.h index 3c4a97be..6e6e521f 100644 --- a/runtime/unwind/x86_64.h +++ b/runtime/unwind/x86_64.h @@ -93,11 +93,6 @@ static inline void arch_unw_init_blocked(struct unwind_frame_info *info) info->regs.ss = __KERNEL_DS; } -extern int arch_unwind_init_running(struct unwind_frame_info *, - int (*callback)(struct unwind_frame_info *, - void *arg), - void *arg); - static inline int arch_unw_user_mode(const struct unwind_frame_info *info) { #if 0 /* This can only work when selector register saves/restores -- cgit From 20d2c2c26b42b27a4881a46364a33330b2a6ea31 Mon Sep 17 00:00:00 2001 From: Martin Hunt Date: Sun, 30 Mar 2008 19:47:51 -0400 Subject: Support for kernels built with CONFIG_FRAME_POINTER --- runtime/unwind/i386.h | 2 +- runtime/unwind/x86_64.h | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'runtime/unwind') diff --git a/runtime/unwind/i386.h b/runtime/unwind/i386.h index cb2efab7..354807a0 100644 --- a/runtime/unwind/i386.h +++ b/runtime/unwind/i386.h @@ -30,7 +30,7 @@ struct unwind_frame_info #define UNW_PC(frame) (frame)->regs.eip #define UNW_SP(frame) (frame)->regs.esp -#ifdef CONFIG_FRAME_POINTER +#ifdef STP_USE_FRAME_POINTER #define UNW_FP(frame) (frame)->regs.ebp #define FRAME_RETADDR_OFFSET 4 #define FRAME_LINK_OFFSET 0 diff --git a/runtime/unwind/x86_64.h b/runtime/unwind/x86_64.h index 6e6e521f..48838490 100644 --- a/runtime/unwind/x86_64.h +++ b/runtime/unwind/x86_64.h @@ -35,13 +35,16 @@ struct unwind_frame_info #define UNW_PC(frame) (frame)->regs.rip #define UNW_SP(frame) (frame)->regs.rsp -#ifdef CONFIG_FRAME_POINTER + +#if 0 /* STP_USE_FRAME_POINTER */ +/* Frame pointers not implemented in x86_64 currently */ #define UNW_FP(frame) (frame)->regs.rbp #define FRAME_RETADDR_OFFSET 8 #define FRAME_LINK_OFFSET 0 #define STACK_BOTTOM(tsk) (((tsk)->thread.rsp0 - 1) & ~(THREAD_SIZE - 1)) #define STACK_TOP(tsk) ((tsk)->thread.rsp0) #endif + /* Might need to account for the special exception and interrupt handling stacks here, since normally EXCEPTION_STACK_ORDER < THREAD_ORDER < IRQSTACK_ORDER, -- cgit From b53c1feef55dc74501a90257e4beff6c1a9cf03b Mon Sep 17 00:00:00 2001 From: Martin Hunt Date: Wed, 9 Apr 2008 17:02:40 -0400 Subject: Fixes for 2.6.25 pt_regs changes. --- runtime/unwind/i386.h | 59 +++++++++++++++++++++++++++++++++++++++++++++++-- runtime/unwind/x86_64.h | 43 +++++++++++++++++++++++++++++++++-- 2 files changed, 98 insertions(+), 4 deletions(-) (limited to 'runtime/unwind') diff --git a/runtime/unwind/i386.h b/runtime/unwind/i386.h index 354807a0..1f69b4a9 100644 --- a/runtime/unwind/i386.h +++ b/runtime/unwind/i386.h @@ -28,6 +28,35 @@ struct unwind_frame_info unsigned call_frame:1; }; +#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) + +#ifdef STAPCONF_X86_UNIREGS + +#define UNW_PC(frame) (frame)->regs.ip +#define UNW_SP(frame) (frame)->regs.sp +#ifdef STP_USE_FRAME_POINTER +#define UNW_FP(frame) (frame)->regs.bp +#define FRAME_RETADDR_OFFSET 4 +#define FRAME_LINK_OFFSET 0 +#define STACK_BOTTOM(tsk) STACK_LIMIT((tsk)->thread.sp0) +#define STACK_TOP(tsk) ((tsk)->thread.sp0) +#else +#define UNW_FP(frame) ((void)(frame), 0) +#endif + +#define UNW_REGISTER_INFO \ + PTREGS_INFO(ax), \ + PTREGS_INFO(cx), \ + PTREGS_INFO(dx), \ + PTREGS_INFO(bx), \ + PTREGS_INFO(sp), \ + PTREGS_INFO(bp), \ + PTREGS_INFO(si), \ + PTREGS_INFO(di), \ + PTREGS_INFO(ip) + +#else /* !STAPCONF_X86_UNIREGS */ + #define UNW_PC(frame) (frame)->regs.eip #define UNW_SP(frame) (frame)->regs.esp #ifdef STP_USE_FRAME_POINTER @@ -39,7 +68,6 @@ struct unwind_frame_info #else #define UNW_FP(frame) ((void)(frame), 0) #endif -#define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) #define UNW_REGISTER_INFO \ PTREGS_INFO(eax), \ @@ -52,6 +80,8 @@ struct unwind_frame_info PTREGS_INFO(edi), \ PTREGS_INFO(eip) +#endif /* STAPCONF_X86_UNIREGS */ + #define UNW_DEFAULT_RA(raItem, dataAlign) \ ((raItem).where == Memory && \ !((raItem).value * (dataAlign) + 4)) @@ -62,9 +92,16 @@ static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, if (user_mode_vm(regs)) info->regs = *regs; else { +#ifdef STAPCONF_X86_UNIREGS + memcpy(&info->regs, regs, offsetof(struct pt_regs, sp)); + info->regs.sp = (unsigned long)®s->sp; + info->regs.ss = __KERNEL_DS; +#else memcpy(&info->regs, regs, offsetof(struct pt_regs, esp)); info->regs.esp = (unsigned long)®s->esp; - info->regs.xss = __KERNEL_DS; + info->regs.xss = __KERNEL_DS; +#endif + } info->call_frame = 1; } @@ -72,6 +109,15 @@ static inline void arch_unw_init_frame_info(struct unwind_frame_info *info, static inline void arch_unw_init_blocked(struct unwind_frame_info *info) { memset(&info->regs, 0, sizeof(info->regs)); +#ifdef STAPCONF_X86_UNIREGS + info->regs.ip = info->task->thread.ip; + info->regs.cs = __KERNEL_CS; + __get_user(info->regs.bp, (long *)info->task->thread.sp); + info->regs.sp = info->task->thread.sp; + info->regs.ss = __KERNEL_DS; + info->regs.ds = __USER_DS; + info->regs.es = __USER_DS; +#else info->regs.eip = info->task->thread.eip; info->regs.xcs = __KERNEL_CS; __get_user(info->regs.ebp, (long *)info->task->thread.esp); @@ -79,6 +125,8 @@ static inline void arch_unw_init_blocked(struct unwind_frame_info *info) info->regs.xss = __KERNEL_DS; info->regs.xds = __USER_DS; info->regs.xes = __USER_DS; +#endif + } @@ -87,11 +135,18 @@ static inline int arch_unw_user_mode(const struct unwind_frame_info *info) #if 0 /* This can only work when selector register and EFLAGS saves/restores are properly annotated (and tracked in UNW_REGISTER_INFO). */ return user_mode_vm(&info->regs); +#else +#ifdef STAPCONF_X86_UNIREGS + return info->regs.ip < PAGE_OFFSET + || (info->regs.ip >= __fix_to_virt(FIX_VDSO) + && info->regs.ip < __fix_to_virt(FIX_VDSO) + PAGE_SIZE) + || info->regs.sp < PAGE_OFFSET; #else return info->regs.eip < PAGE_OFFSET || (info->regs.eip >= __fix_to_virt(FIX_VDSO) && info->regs.eip < __fix_to_virt(FIX_VDSO) + PAGE_SIZE) || info->regs.esp < PAGE_OFFSET; +#endif #endif } diff --git a/runtime/unwind/x86_64.h b/runtime/unwind/x86_64.h index 48838490..5eb3a58f 100644 --- a/runtime/unwind/x86_64.h +++ b/runtime/unwind/x86_64.h @@ -33,8 +33,13 @@ struct unwind_frame_info unsigned call_frame:1; }; +#ifdef STAPCONF_X86_UNIREGS +#define UNW_PC(frame) (frame)->regs.ip +#define UNW_SP(frame) (frame)->regs.sp +#else #define UNW_PC(frame) (frame)->regs.rip #define UNW_SP(frame) (frame)->regs.rsp +#endif /* STAPCONF_X86_UNIREGS */ #if 0 /* STP_USE_FRAME_POINTER */ /* Frame pointers not implemented in x86_64 currently */ @@ -54,6 +59,26 @@ struct unwind_frame_info not desirable. */ #define STACK_LIMIT(ptr) (((ptr) - 1) & ~(THREAD_SIZE - 1)) +#ifdef STAPCONF_X86_UNIREGS +#define UNW_REGISTER_INFO \ + PTREGS_INFO(ax), \ + PTREGS_INFO(dx), \ + PTREGS_INFO(cx), \ + PTREGS_INFO(bx), \ + PTREGS_INFO(si), \ + PTREGS_INFO(di), \ + PTREGS_INFO(bp), \ + PTREGS_INFO(sp), \ + PTREGS_INFO(r8), \ + PTREGS_INFO(r9), \ + PTREGS_INFO(r10), \ + PTREGS_INFO(r11), \ + PTREGS_INFO(r12), \ + PTREGS_INFO(r13), \ + PTREGS_INFO(r14), \ + PTREGS_INFO(r15), \ + PTREGS_INFO(ip) +#else #define UNW_REGISTER_INFO \ PTREGS_INFO(rax), \ PTREGS_INFO(rdx), \ @@ -72,6 +97,7 @@ struct unwind_frame_info PTREGS_INFO(r14), \ PTREGS_INFO(r15), \ PTREGS_INFO(rip) +#endif /* STAPCONF_X86_UNIREGS */ #define UNW_DEFAULT_RA(raItem, dataAlign) \ ((raItem).where == Memory && \ @@ -89,11 +115,18 @@ static inline void arch_unw_init_blocked(struct unwind_frame_info *info) extern const char thread_return[]; memset(&info->regs, 0, sizeof(info->regs)); - info->regs.rip = (unsigned long)thread_return; info->regs.cs = __KERNEL_CS; + info->regs.ss = __KERNEL_DS; + +#ifdef STAPCONF_X86_UNIREGS + info->regs.ip = (unsigned long)thread_return; + __get_user(info->regs.bp, (unsigned long *)info->task->thread.sp); + info->regs.sp = info->task->thread.sp; +#else + info->regs.rip = (unsigned long)thread_return; __get_user(info->regs.rbp, (unsigned long *)info->task->thread.rsp); info->regs.rsp = info->task->thread.rsp; - info->regs.ss = __KERNEL_DS; +#endif } static inline int arch_unw_user_mode(const struct unwind_frame_info *info) @@ -101,11 +134,17 @@ static inline int arch_unw_user_mode(const struct unwind_frame_info *info) #if 0 /* This can only work when selector register saves/restores are properly annotated (and tracked in UNW_REGISTER_INFO). */ return user_mode(&info->regs); +#else +#ifdef STAPCONF_X86_UNIREGS + return (long)info->regs.ip >= 0 + || (info->regs.ip >= VSYSCALL_START && info->regs.ip < VSYSCALL_END) + || (long)info->regs.sp >= 0; #else return (long)info->regs.rip >= 0 || (info->regs.rip >= VSYSCALL_START && info->regs.rip < VSYSCALL_END) || (long)info->regs.rsp >= 0; #endif +#endif } #endif /* _STP_X86_64_UNWIND_H */ -- cgit