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 #include <asm/system.h> 41 42 #define user_mode(regs) (((regs)->sr & 0x40000000)==0) 43 #define user_stack_pointer(_regs) ((unsigned long)(_regs)->regs[15]) 44 #define kernel_stack_pointer(_regs) ((unsigned long)(_regs)->regs[15]) 45 #define instruction_pointer(regs) ((unsigned long)(regs)->pc) 46 47 extern void show_regs(struct pt_regs *); 48 49 #define arch_has_single_step() (1) 50 51 /* 52 * kprobe-based event tracer support 53 */ 54 struct pt_regs_offset { 55 const char *name; 56 int offset; 57 }; 58 59 #define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)} 60 #define REGS_OFFSET_NAME(num) \ 61 {.name = __stringify(r##num), .offset = offsetof(struct pt_regs, regs[num])} 62 #define TREGS_OFFSET_NAME(num) \ 63 {.name = __stringify(tr##num), .offset = offsetof(struct pt_regs, tregs[num])} 64 #define REG_OFFSET_END {.name = NULL, .offset = 0} 65 66 /* Query offset/name of register from its name/offset */ 67 extern int regs_query_register_offset(const char *name); 68 extern const char *regs_query_register_name(unsigned int offset); 69 70 extern const struct pt_regs_offset regoffset_table[]; 71 72 /** 73 * regs_get_register() - get register value from its offset 74 * @regs: pt_regs from which register value is gotten. 75 * @offset: offset number of the register. 76 * 77 * regs_get_register returns the value of a register. The @offset is the 78 * offset of the register in struct pt_regs address which specified by @regs. 79 * If @offset is bigger than MAX_REG_OFFSET, this returns 0. 80 */ 81 static inline unsigned long regs_get_register(struct pt_regs *regs, 82 unsigned int offset) 83 { 84 if (unlikely(offset > MAX_REG_OFFSET)) 85 return 0; 86 return *(unsigned long *)((unsigned long)regs + offset); 87 } 88 89 /** 90 * regs_within_kernel_stack() - check the address in the stack 91 * @regs: pt_regs which contains kernel stack pointer. 92 * @addr: address which is checked. 93 * 94 * regs_within_kernel_stack() checks @addr is within the kernel stack page(s). 95 * If @addr is within the kernel stack, it returns true. If not, returns false. 96 */ 97 static inline int regs_within_kernel_stack(struct pt_regs *regs, 98 unsigned long addr) 99 { 100 return ((addr & ~(THREAD_SIZE - 1)) == 101 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1))); 102 } 103 104 /** 105 * regs_get_kernel_stack_nth() - get Nth entry of the stack 106 * @regs: pt_regs which contains kernel stack pointer. 107 * @n: stack entry number. 108 * 109 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which 110 * is specified by @regs. If the @n th entry is NOT in the kernel stack, 111 * this returns 0. 112 */ 113 static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, 114 unsigned int n) 115 { 116 unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs); 117 addr += n; 118 if (regs_within_kernel_stack(regs, (unsigned long)addr)) 119 return *addr; 120 else 121 return 0; 122 } 123 124 struct perf_event; 125 struct perf_sample_data; 126 127 extern void ptrace_triggered(struct perf_event *bp, int nmi, 128 struct perf_sample_data *data, struct pt_regs *regs); 129 130 #define task_pt_regs(task) \ 131 ((struct pt_regs *) (task_stack_page(task) + THREAD_SIZE) - 1) 132 133 static inline unsigned long profile_pc(struct pt_regs *regs) 134 { 135 unsigned long pc = instruction_pointer(regs); 136 137 if (virt_addr_uncached(pc)) 138 return CAC_ADDR(pc); 139 140 return pc; 141 } 142 #endif /* __KERNEL__ */ 143 144 #endif /* __ASM_SH_PTRACE_H */ 145