arch/openrisc/include/asm/ptrace.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * OpenRISC Linux
   4  *
   5  * Linux architectural port borrowing liberally from similar works of
   6  * others.  All original copyrights apply as per the original source
   7  * declaration.
   8  *
   9  * OpenRISC implementation:
  10  * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
  11  * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
  12  * et al.
  13  */
  14 #ifndef __ASM_OPENRISC_PTRACE_H
  15 #define __ASM_OPENRISC_PTRACE_H
  16
  17
  18 #include <asm/spr_defs.h>
  19 #include <uapi/asm/ptrace.h>
  20 #include <linux/compiler.h>
  21
  22 /*
  23  * Make kernel PTrace/register structures opaque to userspace... userspace can
  24  * access thread state via the regset mechanism.  This allows us a bit of
  25  * flexibility in how we order the registers on the stack, permitting some
  26  * optimizations like packing call-clobbered registers together so that
  27  * they share a cacheline (not done yet, though... future optimization).
  28  */
  29
  30 #ifndef __ASSEMBLY__
  31 /*
  32  * This struct describes how the registers are laid out on the kernel stack
  33  * during a syscall or other kernel entry.
  34  *
  35  * This structure should always be cacheline aligned on the stack.
  36  * FIXME: I don't think that's the case right now.  The alignment is
  37  * taken care of elsewhere... head.S, process.c, etc.
  38  */
  39
  40 struct pt_regs {
  41         union {
  42                 struct {
  43                         /* Named registers */
  44                         long  sr;       /* Stored in place of r0 */
  45                         long  sp;       /* r1 */
  46                         long  gpr2;
  47                         long  gpr3;
  48                         long  gpr4;
  49                         long  gpr5;
  50                         long  gpr6;
  51                         long  gpr7;
  52                         long  gpr8;
  53                         long  gpr9;
  54                         long  gpr10;
  55                         long  gpr11;
  56                         long  gpr12;
  57                         long  gpr13;
  58                         long  gpr14;
  59                         long  gpr15;
  60                         long  gpr16;
  61                         long  gpr17;
  62                         long  gpr18;
  63                         long  gpr19;
  64                         long  gpr20;
  65                         long  gpr21;
  66                         long  gpr22;
  67                         long  gpr23;
  68                         long  gpr24;
  69                         long  gpr25;
  70                         long  gpr26;
  71                         long  gpr27;
  72                         long  gpr28;
  73                         long  gpr29;
  74                         long  gpr30;
  75                         long  gpr31;
  76                 };
  77                 struct {
  78                         /* Old style */
  79                         long offset[2];
  80                         long gprs[30];
  81                 };
  82                 struct {
  83                         /* New style */
  84                         long gpr[32];
  85                 };
  86         };
  87         long  pc;
  88         /* For restarting system calls:
  89          * Set to syscall number for syscall exceptions,
  90          * -1 for all other exceptions.
  91          */
  92         long  orig_gpr11;       /* For restarting system calls */
  93         long dummy;             /* Cheap alignment fix */
  94         long dummy2;            /* Cheap alignment fix */
  95 };
  96
  97 /* TODO: Rename this to REDZONE because that's what it is */
  98 #define STACK_FRAME_OVERHEAD  128  /* size of minimum stack frame */
  99
 100 #define MAX_REG_OFFSET offsetof(struct pt_regs, orig_gpr11)
 101
 102 /* Helpers for working with the instruction pointer */
 103 static inline unsigned long instruction_pointer(struct pt_regs *regs)
 104 {
 105         return (unsigned long)regs->pc;
 106 }
 107 static inline void instruction_pointer_set(struct pt_regs *regs,
 108                                            unsigned long val)
 109 {
 110         regs->pc = val;
 111 }
 112
 113 #define user_mode(regs)                 (((regs)->sr & SPR_SR_SM) == 0)
 114 #define user_stack_pointer(regs)        ((unsigned long)(regs)->sp)
 115 #define profile_pc(regs)                instruction_pointer(regs)
 116
 117 /* Valid only for Kernel mode traps. */
 118 static inline unsigned long kernel_stack_pointer(struct pt_regs *regs)
 119 {
 120         return (unsigned long)regs->sp;
 121 }
 122
 123 static inline long regs_return_value(struct pt_regs *regs)
 124 {
 125         return regs->gpr[11];
 126 }
 127
 128 extern int regs_query_register_offset(const char *name);
 129 extern unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
 130                                                unsigned int n);
 131
 132 /**
 133  * regs_get_register() - get register value from its offset
 134  * @regs:       pt_regs from which register value is gotten
 135  * @offset:     offset of the register.
 136  *
 137  * regs_get_register returns the value of a register whose offset from @regs.
 138  * The @offset is the offset of the register in struct pt_regs.
 139  * If @offset is bigger than MAX_REG_OFFSET, this returns 0.
 140  */
 141 static inline unsigned long regs_get_register(struct pt_regs *regs,
 142                                               unsigned int offset)
 143 {
 144         if (unlikely(offset > MAX_REG_OFFSET))
 145                 return 0;
 146
 147         return *(unsigned long *)((unsigned long)regs + offset);
 148 }
 149
 150 #endif /* __ASSEMBLY__ */
 151
 152 /*
 153  * Offsets used by 'ptrace' system call interface.
 154  */
 155 #define PT_SR         0
 156 #define PT_SP         4
 157 #define PT_GPR2       8
 158 #define PT_GPR3       12
 159 #define PT_GPR4       16
 160 #define PT_GPR5       20
 161 #define PT_GPR6       24
 162 #define PT_GPR7       28
 163 #define PT_GPR8       32
 164 #define PT_GPR9       36
 165 #define PT_GPR10      40
 166 #define PT_GPR11      44
 167 #define PT_GPR12      48
 168 #define PT_GPR13      52
 169 #define PT_GPR14      56
 170 #define PT_GPR15      60
 171 #define PT_GPR16      64
 172 #define PT_GPR17      68
 173 #define PT_GPR18      72
 174 #define PT_GPR19      76
 175 #define PT_GPR20      80
 176 #define PT_GPR21      84
 177 #define PT_GPR22      88
 178 #define PT_GPR23      92
 179 #define PT_GPR24      96
 180 #define PT_GPR25      100
 181 #define PT_GPR26      104
 182 #define PT_GPR27      108
 183 #define PT_GPR28      112
 184 #define PT_GPR29      116
 185 #define PT_GPR30      120
 186 #define PT_GPR31      124
 187 #define PT_PC         128
 188 #define PT_ORIG_GPR11 132
 189
 190 #endif /* __ASM_OPENRISC_PTRACE_H */