~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/include/asm/ptrace.h

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0-or-later */
  2 /*
  3  * Copyright (C) 2001 PPC64 Team, IBM Corp
  4  *
  5  * This struct defines the way the registers are stored on the
  6  * kernel stack during a system call or other kernel entry.
  7  *
  8  * this should only contain volatile regs
  9  * since we can keep non-volatile in the thread_struct
 10  * should set this up when only volatiles are saved
 11  * by intr code.
 12  *
 13  * Since this is going on the stack, *CARE MUST BE TAKEN* to insure
 14  * that the overall structure is a multiple of 16 bytes in length.
 15  *
 16  * Note that the offsets of the fields in this struct correspond with
 17  * the PT_* values below.  This simplifies arch/powerpc/kernel/ptrace.c.
 18  */
 19 #ifndef _ASM_POWERPC_PTRACE_H
 20 #define _ASM_POWERPC_PTRACE_H
 21 
 22 #include <uapi/asm/ptrace.h>
 23 #include <asm/asm-const.h>
 24 
 25 #ifndef __ASSEMBLY__
 26 struct pt_regs
 27 {
 28         union {
 29                 struct user_pt_regs user_regs;
 30                 struct {
 31                         unsigned long gpr[32];
 32                         unsigned long nip;
 33                         unsigned long msr;
 34                         unsigned long orig_gpr3;
 35                         unsigned long ctr;
 36                         unsigned long link;
 37                         unsigned long xer;
 38                         unsigned long ccr;
 39 #ifdef CONFIG_PPC64
 40                         unsigned long softe;
 41 #else
 42                         unsigned long mq;
 43 #endif
 44                         unsigned long trap;
 45                         unsigned long dar;
 46                         unsigned long dsisr;
 47                         unsigned long result;
 48                 };
 49         };
 50 
 51         union {
 52                 struct {
 53 #ifdef CONFIG_PPC64
 54                         unsigned long ppr;
 55 #endif
 56 #ifdef CONFIG_PPC_KUAP
 57                         unsigned long kuap;
 58 #endif
 59                 };
 60                 unsigned long __pad[2]; /* Maintain 16 byte interrupt stack alignment */
 61         };
 62 };
 63 #endif
 64 
 65 #ifdef __powerpc64__
 66 
 67 /*
 68  * Size of redzone that userspace is allowed to use below the stack
 69  * pointer.  This is 288 in the 64-bit big-endian ELF ABI, and 512 in
 70  * the new ELFv2 little-endian ABI, so we allow the larger amount.
 71  *
 72  * For kernel code we allow a 288-byte redzone, in order to conserve
 73  * kernel stack space; gcc currently only uses 288 bytes, and will
 74  * hopefully allow explicit control of the redzone size in future.
 75  */
 76 #define USER_REDZONE_SIZE       512
 77 #define KERNEL_REDZONE_SIZE     288
 78 
 79 #define STACK_FRAME_OVERHEAD    112     /* size of minimum stack frame */
 80 #define STACK_FRAME_LR_SAVE     2       /* Location of LR in stack frame */
 81 #define STACK_FRAME_REGS_MARKER ASM_CONST(0x7265677368657265)
 82 #define STACK_INT_FRAME_SIZE    (sizeof(struct pt_regs) + \
 83                                  STACK_FRAME_OVERHEAD + KERNEL_REDZONE_SIZE)
 84 #define STACK_FRAME_MARKER      12
 85 
 86 #ifdef PPC64_ELF_ABI_v2
 87 #define STACK_FRAME_MIN_SIZE    32
 88 #else
 89 #define STACK_FRAME_MIN_SIZE    STACK_FRAME_OVERHEAD
 90 #endif
 91 
 92 /* Size of dummy stack frame allocated when calling signal handler. */
 93 #define __SIGNAL_FRAMESIZE      128
 94 #define __SIGNAL_FRAMESIZE32    64
 95 
 96 #else /* __powerpc64__ */
 97 
 98 #define USER_REDZONE_SIZE       0
 99 #define KERNEL_REDZONE_SIZE     0
100 #define STACK_FRAME_OVERHEAD    16      /* size of minimum stack frame */
101 #define STACK_FRAME_LR_SAVE     1       /* Location of LR in stack frame */
102 #define STACK_FRAME_REGS_MARKER ASM_CONST(0x72656773)
103 #define STACK_INT_FRAME_SIZE    (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD)
104 #define STACK_FRAME_MARKER      2
105 #define STACK_FRAME_MIN_SIZE    STACK_FRAME_OVERHEAD
106 
107 /* Size of stack frame allocated when calling signal handler. */
108 #define __SIGNAL_FRAMESIZE      64
109 
110 #endif /* __powerpc64__ */
111 
112 #ifndef __ASSEMBLY__
113 
114 static inline unsigned long instruction_pointer(struct pt_regs *regs)
115 {
116         return regs->nip;
117 }
118 
119 static inline void instruction_pointer_set(struct pt_regs *regs,
120                 unsigned long val)
121 {
122         regs->nip = val;
123 }
124 
125 static inline unsigned long user_stack_pointer(struct pt_regs *regs)
126 {
127         return regs->gpr[1];
128 }
129 
130 static inline unsigned long frame_pointer(struct pt_regs *regs)
131 {
132         return 0;
133 }
134 
135 #ifdef CONFIG_SMP
136 extern unsigned long profile_pc(struct pt_regs *regs);
137 #else
138 #define profile_pc(regs) instruction_pointer(regs)
139 #endif
140 
141 long do_syscall_trace_enter(struct pt_regs *regs);
142 void do_syscall_trace_leave(struct pt_regs *regs);
143 
144 #define kernel_stack_pointer(regs) ((regs)->gpr[1])
145 static inline int is_syscall_success(struct pt_regs *regs)
146 {
147         return !(regs->ccr & 0x10000000);
148 }
149 
150 static inline long regs_return_value(struct pt_regs *regs)
151 {
152         if (is_syscall_success(regs))
153                 return regs->gpr[3];
154         else
155                 return -regs->gpr[3];
156 }
157 
158 static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc)
159 {
160         regs->gpr[3] = rc;
161 }
162 
163 #ifdef __powerpc64__
164 #define user_mode(regs) ((((regs)->msr) >> MSR_PR_LG) & 0x1)
165 #else
166 #define user_mode(regs) (((regs)->msr & MSR_PR) != 0)
167 #endif
168 
169 #define force_successful_syscall_return()   \
170         do { \
171                 set_thread_flag(TIF_NOERROR); \
172         } while(0)
173 
174 struct task_struct;
175 extern int ptrace_get_reg(struct task_struct *task, int regno,
176                           unsigned long *data);
177 extern int ptrace_put_reg(struct task_struct *task, int regno,
178                           unsigned long data);
179 
180 #define current_pt_regs() \
181         ((struct pt_regs *)((unsigned long)task_stack_page(current) + THREAD_SIZE) - 1)
182 /*
183  * We use the least-significant bit of the trap field to indicate
184  * whether we have saved the full set of registers, or only a
185  * partial set.  A 1 there means the partial set.
186  * On 4xx we use the next bit to indicate whether the exception
187  * is a critical exception (1 means it is).
188  */
189 #define FULL_REGS(regs)         (((regs)->trap & 1) == 0)
190 #ifndef __powerpc64__
191 #define IS_CRITICAL_EXC(regs)   (((regs)->trap & 2) != 0)
192 #define IS_MCHECK_EXC(regs)     (((regs)->trap & 4) != 0)
193 #define IS_DEBUG_EXC(regs)      (((regs)->trap & 8) != 0)
194 #endif /* ! __powerpc64__ */
195 #define TRAP(regs)              ((regs)->trap & ~0xF)
196 #ifdef __powerpc64__
197 #define NV_REG_POISON           0xdeadbeefdeadbeefUL
198 #define CHECK_FULL_REGS(regs)   BUG_ON(regs->trap & 1)
199 #else
200 #define NV_REG_POISON           0xdeadbeef
201 #define CHECK_FULL_REGS(regs)                                                 \
202 do {                                                                          \
203         if ((regs)->trap & 1)                                                 \
204                 printk(KERN_CRIT "%s: partial register set\n", __func__); \
205 } while (0)
206 #endif /* __powerpc64__ */
207 
208 #define arch_has_single_step()  (1)
209 #ifndef CONFIG_PPC_BOOK3S_601
210 #define arch_has_block_step()   (true)
211 #else
212 #define arch_has_block_step()   (false)
213 #endif
214 #define ARCH_HAS_USER_SINGLE_STEP_REPORT
215 
216 /*
217  * kprobe-based event tracer support
218  */
219 
220 #include <linux/stddef.h>
221 #include <linux/thread_info.h>
222 extern int regs_query_register_offset(const char *name);
223 extern const char *regs_query_register_name(unsigned int offset);
224 #define MAX_REG_OFFSET (offsetof(struct pt_regs, dsisr))
225 
226 /**
227  * regs_get_register() - get register value from its offset
228  * @regs:          pt_regs from which register value is gotten
229  * @offset:    offset number of the register.
230  *
231  * regs_get_register returns the value of a register whose offset from @regs.
232  * The @offset is the offset of the register in struct pt_regs.
233  * If @offset is bigger than MAX_REG_OFFSET, this returns 0.
234  */
235 static inline unsigned long regs_get_register(struct pt_regs *regs,
236                                                 unsigned int offset)
237 {
238         if (unlikely(offset > MAX_REG_OFFSET))
239                 return 0;
240         return *(unsigned long *)((unsigned long)regs + offset);
241 }
242 
243 /**
244  * regs_within_kernel_stack() - check the address in the stack
245  * @regs:      pt_regs which contains kernel stack pointer.
246  * @addr:      address which is checked.
247  *
248  * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
249  * If @addr is within the kernel stack, it returns true. If not, returns false.
250  */
251 
252 static inline bool regs_within_kernel_stack(struct pt_regs *regs,
253                                                 unsigned long addr)
254 {
255         return ((addr & ~(THREAD_SIZE - 1))  ==
256                 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
257 }
258 
259 /**
260  * regs_get_kernel_stack_nth() - get Nth entry of the stack
261  * @regs:       pt_regs which contains kernel stack pointer.
262  * @n:          stack entry number.
263  *
264  * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
265  * is specified by @regs. If the @n th entry is NOT in the kernel stack,
266  * this returns 0.
267  */
268 static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
269                                                       unsigned int n)
270 {
271         unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
272         addr += n;
273         if (regs_within_kernel_stack(regs, (unsigned long)addr))
274                 return *addr;
275         else
276                 return 0;
277 }
278 
279 #endif /* __ASSEMBLY__ */
280 
281 #ifndef __powerpc64__
282 /* We need PT_SOFTE defined at all time to avoid #ifdefs */
283 #define PT_SOFTE PT_MQ
284 #else /* __powerpc64__ */
285 #define PT_FPSCR32 (PT_FPR0 + 2*32 + 1) /* each FP reg occupies 2 32-bit userspace slots */
286 #define PT_VR0_32 164   /* each Vector reg occupies 4 slots in 32-bit */
287 #define PT_VSCR_32 (PT_VR0 + 32*4 + 3)
288 #define PT_VRSAVE_32 (PT_VR0 + 33*4)
289 #define PT_VSR0_32 300  /* each VSR reg occupies 4 slots in 32-bit */
290 #endif /* __powerpc64__ */
291 #endif /* _ASM_POWERPC_PTRACE_H */
292 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp