1 #ifndef __ASM_SH_PTRACE_H 2 #define __ASM_SH_PTRACE_H 3 4 /* 5 * Copyright (C) 1999, 2000 Niibe Yutaka 6 */ 7 8 #define PTRACE_GETREGS 12 /* General registers */ 9 #define PTRACE_SETREGS 13 10 11 #define PTRACE_GETFPREGS 14 /* FPU registers */ 12 #define PTRACE_SETFPREGS 15 13 14 #define PTRACE_GETFDPIC 31 /* get the ELF fdpic loadmap address */ 15 16 #define PTRACE_GETFDPIC_EXEC 0 /* [addr] request the executable loadmap */ 17 #define PTRACE_GETFDPIC_INTERP 1 /* [addr] request the interpreter loadmap */ 18 19 #define PTRACE_GETDSPREGS 55 /* DSP registers */ 20 #define PTRACE_SETDSPREGS 56 21 22 #define PT_TEXT_END_ADDR 240 23 #define PT_TEXT_ADDR 244 /* &(struct user)->start_code */ 24 #define PT_DATA_ADDR 248 /* &(struct user)->start_data */ 25 #define PT_TEXT_LEN 252 26 27 #if defined(__SH5__) || defined(CONFIG_CPU_SH5) 28 #include "ptrace_64.h" 29 #else 30 #include "ptrace_32.h" 31 #endif 32 33 #ifdef __KERNEL__ 34 35 #include <linux/stringify.h> 36 #include <linux/stddef.h> 37 #include <linux/thread_info.h> 38 #include <asm/addrspace.h> 39 #include <asm/page.h> 40 41 #define user_mode(regs) (((regs)->sr & 0x40000000)==0) 42 #define kernel_stack_pointer(_regs) ((unsigned long)(_regs)->regs[15]) 43 44 #define GET_FP(regs) ((regs)->regs[14]) 45 #define GET_USP(regs) ((regs)->regs[15]) 46 47 #define arch_has_single_step() (1) 48 49 /* 50 * kprobe-based event tracer support 51 */ 52 struct pt_regs_offset { 53 const char *name; 54 int offset; 55 }; 56 57 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)} 58 #define REGS_OFFSET_NAME(num) \ 59 {.name = __stringify(r##num), .offset = offsetof(struct pt_regs, regs[num])} 60 #define TREGS_OFFSET_NAME(num) \ 61 {.name = __stringify(tr##num), .offset = offsetof(struct pt_regs, tregs[num])} 62 #define REG_OFFSET_END {.name = NULL, .offset = 0} 63 64 /* Query offset/name of register from its name/offset */ 65 extern int regs_query_register_offset(const char *name); 66 extern const char *regs_query_register_name(unsigned int offset); 67 68 extern const struct pt_regs_offset regoffset_table[]; 69 70 /** 71 * regs_get_register() - get register value from its offset 72 * @regs: pt_regs from which register value is gotten. 73 * @offset: offset number of the register. 74 * 75 * regs_get_register returns the value of a register. The @offset is the 76 * offset of the register in struct pt_regs address which specified by @regs. 77 * If @offset is bigger than MAX_REG_OFFSET, this returns 0. 78 */ 79 static inline unsigned long regs_get_register(struct pt_regs *regs, 80 unsigned int offset) 81 { 82 if (unlikely(offset > MAX_REG_OFFSET)) 83 return 0; 84 return *(unsigned long *)((unsigned long)regs + offset); 85 } 86 87 /** 88 * regs_within_kernel_stack() - check the address in the stack 89 * @regs: pt_regs which contains kernel stack pointer. 90 * @addr: address which is checked. 91 * 92 * regs_within_kernel_stack() checks @addr is within the kernel stack page(s). 93 * If @addr is within the kernel stack, it returns true. If not, returns false. 94 */ 95 static inline int regs_within_kernel_stack(struct pt_regs *regs, 96 unsigned long addr) 97 { 98 return ((addr & ~(THREAD_SIZE - 1)) == 99 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1))); 100 } 101 102 /** 103 * regs_get_kernel_stack_nth() - get Nth entry of the stack 104 * @regs: pt_regs which contains kernel stack pointer. 105 * @n: stack entry number. 106 * 107 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which 108 * is specified by @regs. If the @n th entry is NOT in the kernel stack, 109 * this returns 0. 110 */ 111 static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, 112 unsigned int n) 113 { 114 unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs); 115 addr += n; 116 if (regs_within_kernel_stack(regs, (unsigned long)addr)) 117 return *addr; 118 else 119 return 0; 120 } 121 122 struct perf_event; 123 struct perf_sample_data; 124 125 extern void ptrace_triggered(struct perf_event *bp, 126 struct perf_sample_data *data, struct pt_regs *regs); 127 128 #define task_pt_regs(task) \ 129 ((struct pt_regs *) (task_stack_page(task) + THREAD_SIZE) - 1) 130 131 static inline unsigned long profile_pc(struct pt_regs *regs) 132 { 133 unsigned long pc = regs->pc; 134 135 if (virt_addr_uncached(pc)) 136 return CAC_ADDR(pc); 137 138 return pc; 139 } 140 #define profile_pc profile_pc 141 142 #include <asm-generic/ptrace.h> 143 #endif /* __KERNEL__ */ 144 145 #endif /* __ASM_SH_PTRACE_H */ 146