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

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

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 */
  2 #ifndef _ASM_X86_PTRACE_H
  3 #define _ASM_X86_PTRACE_H
  4 
  5 #include <asm/segment.h>
  6 #include <asm/page_types.h>
  7 #include <uapi/asm/ptrace.h>
  8 
  9 #ifndef __ASSEMBLY__
 10 #ifdef __i386__
 11 
 12 struct pt_regs {
 13         /*
 14          * NB: 32-bit x86 CPUs are inconsistent as what happens in the
 15          * following cases (where %seg represents a segment register):
 16          *
 17          * - pushl %seg: some do a 16-bit write and leave the high
 18          *   bits alone
 19          * - movl %seg, [mem]: some do a 16-bit write despite the movl
 20          * - IDT entry: some (e.g. 486) will leave the high bits of CS
 21          *   and (if applicable) SS undefined.
 22          *
 23          * Fortunately, x86-32 doesn't read the high bits on POP or IRET,
 24          * so we can just treat all of the segment registers as 16-bit
 25          * values.
 26          */
 27         unsigned long bx;
 28         unsigned long cx;
 29         unsigned long dx;
 30         unsigned long si;
 31         unsigned long di;
 32         unsigned long bp;
 33         unsigned long ax;
 34         unsigned short ds;
 35         unsigned short __dsh;
 36         unsigned short es;
 37         unsigned short __esh;
 38         unsigned short fs;
 39         unsigned short __fsh;
 40         unsigned short gs;
 41         unsigned short __gsh;
 42         unsigned long orig_ax;
 43         unsigned long ip;
 44         unsigned short cs;
 45         unsigned short __csh;
 46         unsigned long flags;
 47         unsigned long sp;
 48         unsigned short ss;
 49         unsigned short __ssh;
 50 };
 51 
 52 #else /* __i386__ */
 53 
 54 struct pt_regs {
 55 /*
 56  * C ABI says these regs are callee-preserved. They aren't saved on kernel entry
 57  * unless syscall needs a complete, fully filled "struct pt_regs".
 58  */
 59         unsigned long r15;
 60         unsigned long r14;
 61         unsigned long r13;
 62         unsigned long r12;
 63         unsigned long bp;
 64         unsigned long bx;
 65 /* These regs are callee-clobbered. Always saved on kernel entry. */
 66         unsigned long r11;
 67         unsigned long r10;
 68         unsigned long r9;
 69         unsigned long r8;
 70         unsigned long ax;
 71         unsigned long cx;
 72         unsigned long dx;
 73         unsigned long si;
 74         unsigned long di;
 75 /*
 76  * On syscall entry, this is syscall#. On CPU exception, this is error code.
 77  * On hw interrupt, it's IRQ number:
 78  */
 79         unsigned long orig_ax;
 80 /* Return frame for iretq */
 81         unsigned long ip;
 82         unsigned long cs;
 83         unsigned long flags;
 84         unsigned long sp;
 85         unsigned long ss;
 86 /* top of stack page */
 87 };
 88 
 89 #endif /* !__i386__ */
 90 
 91 #ifdef CONFIG_PARAVIRT
 92 #include <asm/paravirt_types.h>
 93 #endif
 94 
 95 struct cpuinfo_x86;
 96 struct task_struct;
 97 
 98 extern unsigned long profile_pc(struct pt_regs *regs);
 99 #define profile_pc profile_pc
100 
101 extern unsigned long
102 convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs);
103 extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
104                          int error_code, int si_code);
105 
106 
107 static inline unsigned long regs_return_value(struct pt_regs *regs)
108 {
109         return regs->ax;
110 }
111 
112 /*
113  * user_mode(regs) determines whether a register set came from user
114  * mode.  On x86_32, this is true if V8086 mode was enabled OR if the
115  * register set was from protected mode with RPL-3 CS value.  This
116  * tricky test checks that with one comparison.
117  *
118  * On x86_64, vm86 mode is mercifully nonexistent, and we don't need
119  * the extra check.
120  */
121 static inline int user_mode(struct pt_regs *regs)
122 {
123 #ifdef CONFIG_X86_32
124         return ((regs->cs & SEGMENT_RPL_MASK) | (regs->flags & X86_VM_MASK)) >= USER_RPL;
125 #else
126         return !!(regs->cs & 3);
127 #endif
128 }
129 
130 static inline int v8086_mode(struct pt_regs *regs)
131 {
132 #ifdef CONFIG_X86_32
133         return (regs->flags & X86_VM_MASK);
134 #else
135         return 0;       /* No V86 mode support in long mode */
136 #endif
137 }
138 
139 static inline bool user_64bit_mode(struct pt_regs *regs)
140 {
141 #ifdef CONFIG_X86_64
142 #ifndef CONFIG_PARAVIRT
143         /*
144          * On non-paravirt systems, this is the only long mode CPL 3
145          * selector.  We do not allow long mode selectors in the LDT.
146          */
147         return regs->cs == __USER_CS;
148 #else
149         /* Headers are too twisted for this to go in paravirt.h. */
150         return regs->cs == __USER_CS || regs->cs == pv_info.extra_user_64bit_cs;
151 #endif
152 #else /* !CONFIG_X86_64 */
153         return false;
154 #endif
155 }
156 
157 #ifdef CONFIG_X86_64
158 #define current_user_stack_pointer()    current_pt_regs()->sp
159 #define compat_user_stack_pointer()     current_pt_regs()->sp
160 #endif
161 
162 #ifdef CONFIG_X86_32
163 extern unsigned long kernel_stack_pointer(struct pt_regs *regs);
164 #else
165 static inline unsigned long kernel_stack_pointer(struct pt_regs *regs)
166 {
167         return regs->sp;
168 }
169 #endif
170 
171 #define GET_IP(regs) ((regs)->ip)
172 #define GET_FP(regs) ((regs)->bp)
173 #define GET_USP(regs) ((regs)->sp)
174 
175 #include <asm-generic/ptrace.h>
176 
177 /* Query offset/name of register from its name/offset */
178 extern int regs_query_register_offset(const char *name);
179 extern const char *regs_query_register_name(unsigned int offset);
180 #define MAX_REG_OFFSET (offsetof(struct pt_regs, ss))
181 
182 /**
183  * regs_get_register() - get register value from its offset
184  * @regs:       pt_regs from which register value is gotten.
185  * @offset:     offset number of the register.
186  *
187  * regs_get_register returns the value of a register. The @offset is the
188  * offset of the register in struct pt_regs address which specified by @regs.
189  * If @offset is bigger than MAX_REG_OFFSET, this returns 0.
190  */
191 static inline unsigned long regs_get_register(struct pt_regs *regs,
192                                               unsigned int offset)
193 {
194         if (unlikely(offset > MAX_REG_OFFSET))
195                 return 0;
196 #ifdef CONFIG_X86_32
197         /*
198          * Traps from the kernel do not save sp and ss.
199          * Use the helper function to retrieve sp.
200          */
201         if (offset == offsetof(struct pt_regs, sp) &&
202             regs->cs == __KERNEL_CS)
203                 return kernel_stack_pointer(regs);
204 
205         /* The selector fields are 16-bit. */
206         if (offset == offsetof(struct pt_regs, cs) ||
207             offset == offsetof(struct pt_regs, ss) ||
208             offset == offsetof(struct pt_regs, ds) ||
209             offset == offsetof(struct pt_regs, es) ||
210             offset == offsetof(struct pt_regs, fs) ||
211             offset == offsetof(struct pt_regs, gs)) {
212                 return *(u16 *)((unsigned long)regs + offset);
213 
214         }
215 #endif
216         return *(unsigned long *)((unsigned long)regs + offset);
217 }
218 
219 /**
220  * regs_within_kernel_stack() - check the address in the stack
221  * @regs:       pt_regs which contains kernel stack pointer.
222  * @addr:       address which is checked.
223  *
224  * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
225  * If @addr is within the kernel stack, it returns true. If not, returns false.
226  */
227 static inline int regs_within_kernel_stack(struct pt_regs *regs,
228                                            unsigned long addr)
229 {
230         return ((addr & ~(THREAD_SIZE - 1))  ==
231                 (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
232 }
233 
234 /**
235  * regs_get_kernel_stack_nth() - get Nth entry of the stack
236  * @regs:       pt_regs which contains kernel stack pointer.
237  * @n:          stack entry number.
238  *
239  * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
240  * is specified by @regs. If the @n th entry is NOT in the kernel stack,
241  * this returns 0.
242  */
243 static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
244                                                       unsigned int n)
245 {
246         unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
247         addr += n;
248         if (regs_within_kernel_stack(regs, (unsigned long)addr))
249                 return *addr;
250         else
251                 return 0;
252 }
253 
254 #define arch_has_single_step()  (1)
255 #ifdef CONFIG_X86_DEBUGCTLMSR
256 #define arch_has_block_step()   (1)
257 #else
258 #define arch_has_block_step()   (boot_cpu_data.x86 >= 6)
259 #endif
260 
261 #define ARCH_HAS_USER_SINGLE_STEP_INFO
262 
263 /*
264  * When hitting ptrace_stop(), we cannot return using SYSRET because
265  * that does not restore the full CPU state, only a minimal set.  The
266  * ptracer can change arbitrary register values, which is usually okay
267  * because the usual ptrace stops run off the signal delivery path which
268  * forces IRET; however, ptrace_event() stops happen in arbitrary places
269  * in the kernel and don't force IRET path.
270  *
271  * So force IRET path after a ptrace stop.
272  */
273 #define arch_ptrace_stop_needed(code, info)                             \
274 ({                                                                      \
275         force_iret();                                                   \
276         false;                                                          \
277 })
278 
279 struct user_desc;
280 extern int do_get_thread_area(struct task_struct *p, int idx,
281                               struct user_desc __user *info);
282 extern int do_set_thread_area(struct task_struct *p, int idx,
283                               struct user_desc __user *info, int can_allocate);
284 
285 #endif /* !__ASSEMBLY__ */
286 #endif /* _ASM_X86_PTRACE_H */
287 

~ [ 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