arch/sh/include/asm/ptrace.h

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