projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'drm-radeon-testing' of ../drm-radeon-next into drm-core-next
[linux-2.6-block.git] / arch / s390 / kernel / ptrace.c
CommitLineData
1da177e4 1/*
5e9a2692 2 * Ptrace user space interface.
1da177e4 3 *
5e9a2692
MS		 4 * Copyright IBM Corp. 1999,2010
5 * Author(s): Denis Joseph Barrow
1da177e4 6 * Martin Schwidefsky (schwidefsky@de.ibm.com)
1da177e4
LT		 7 */
8
9#include <linux/kernel.h>
10#include <linux/sched.h>
11#include <linux/mm.h>
12#include <linux/smp.h>
1da177e4
LT		 13#include <linux/errno.h>
14#include <linux/ptrace.h>
15#include <linux/user.h>
16#include <linux/security.h>
17#include <linux/audit.h>
7ed20e1a 18#include <linux/signal.h>
63506c41
MS		 19#include <linux/elf.h>
20#include <linux/regset.h>
753c4dd6 21#include <linux/tracehook.h>
bcf5cef7 22#include <linux/seccomp.h>
9bf1226b 23#include <trace/syscall.h>
bcf5cef7 24#include <asm/compat.h>
1da177e4
LT		 25#include <asm/segment.h>
26#include <asm/page.h>
27#include <asm/pgtable.h>
28#include <asm/pgalloc.h>
29#include <asm/system.h>
30#include <asm/uaccess.h>
778959db 31#include <asm/unistd.h>
a806170e 32#include "entry.h"
1da177e4 33
347a8dc3 34#ifdef CONFIG_COMPAT
1da177e4
LT		 35#include "compat_ptrace.h"
36#endif
37
1c569f02
JS		 38#define CREATE_TRACE_POINTS
39#include <trace/events/syscalls.h>
5e9ad7df 40
63506c41
MS		 41enum s390_regset {
42 REGSET_GENERAL,
43 REGSET_FP,
86f2552b 44 REGSET_LAST_BREAK,
20b40a79 45 REGSET_SYSTEM_CALL,
ea2a4d3a 46 REGSET_GENERAL_EXTENDED,
63506c41
MS		 47};
48
5e9a2692 49void update_per_regs(struct task_struct *task)
1da177e4 50{
5e9a2692
MS		 51 struct pt_regs *regs = task_pt_regs(task);
52 struct thread_struct *thread = &task->thread;
a45aff52 53 struct per_regs old, new;
5e9a2692 54
a45aff52
MS		 55 /* Copy user specified PER registers */
56 new.control = thread->per_user.control;
57 new.start = thread->per_user.start;
58 new.end = thread->per_user.end;
59
60 /* merge TIF_SINGLE_STEP into user specified PER registers. */
61 if (test_tsk_thread_flag(task, TIF_SINGLE_STEP)) {
62 new.control |= PER_EVENT_IFETCH;
63 new.start = 0;
64 new.end = PSW_ADDR_INSN;
65 }
5e9a2692
MS		 66
67 /* Take care of the PER enablement bit in the PSW. */
a45aff52 68 if (!(new.control & PER_EVENT_MASK)) {
1da177e4 69 regs->psw.mask &= ~PSW_MASK_PER;
5e9a2692 70 return;
c3311c13 71 }
5e9a2692
MS		 72 regs->psw.mask |= PSW_MASK_PER;
73 __ctl_store(old, 9, 11);
a45aff52
MS		 74 if (memcmp(&new, &old, sizeof(struct per_regs)) != 0)
75 __ctl_load(new, 9, 11);
1da177e4
LT		 76}
77
0ac30be4 78void user_enable_single_step(struct task_struct *task)
1da177e4 79{
5e9a2692
MS		 80 set_tsk_thread_flag(task, TIF_SINGLE_STEP);
81 if (task == current)
82 update_per_regs(task);
1da177e4
LT		 83}
84
0ac30be4 85void user_disable_single_step(struct task_struct *task)
1da177e4 86{
5e9a2692
MS		 87 clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
88 if (task == current)
89 update_per_regs(task);
1da177e4
LT		 90}
91
92/*
93 * Called by kernel/ptrace.c when detaching..
94 *
5e9a2692 95 * Clear all debugging related fields.
1da177e4 96 */
5e9a2692 97void ptrace_disable(struct task_struct *task)
1da177e4 98{
5e9a2692
MS		 99 memset(&task->thread.per_user, 0, sizeof(task->thread.per_user));
100 memset(&task->thread.per_event, 0, sizeof(task->thread.per_event));
101 clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
102 clear_tsk_thread_flag(task, TIF_PER_TRAP);
1da177e4
LT		 103}
104
347a8dc3 105#ifndef CONFIG_64BIT
1da177e4
LT		 106# define __ADDR_MASK 3
107#else
108# define __ADDR_MASK 7
109#endif
110
5e9a2692
MS		 111static inline unsigned long __peek_user_per(struct task_struct *child,
112 addr_t addr)
113{
114 struct per_struct_kernel *dummy = NULL;
115
116 if (addr == (addr_t) &dummy->cr9)
117 /* Control bits of the active per set. */
118 return test_thread_flag(TIF_SINGLE_STEP) ?
119 PER_EVENT_IFETCH : child->thread.per_user.control;
120 else if (addr == (addr_t) &dummy->cr10)
121 /* Start address of the active per set. */
122 return test_thread_flag(TIF_SINGLE_STEP) ?
123 0 : child->thread.per_user.start;
124 else if (addr == (addr_t) &dummy->cr11)
125 /* End address of the active per set. */
126 return test_thread_flag(TIF_SINGLE_STEP) ?
127 PSW_ADDR_INSN : child->thread.per_user.end;
128 else if (addr == (addr_t) &dummy->bits)
129 /* Single-step bit. */
130 return test_thread_flag(TIF_SINGLE_STEP) ?
131 (1UL << (BITS_PER_LONG - 1)) : 0;
132 else if (addr == (addr_t) &dummy->starting_addr)
133 /* Start address of the user specified per set. */
134 return child->thread.per_user.start;
135 else if (addr == (addr_t) &dummy->ending_addr)
136 /* End address of the user specified per set. */
137 return child->thread.per_user.end;
138 else if (addr == (addr_t) &dummy->perc_atmid)
139 /* PER code, ATMID and AI of the last PER trap */
140 return (unsigned long)
141 child->thread.per_event.cause << (BITS_PER_LONG - 16);
142 else if (addr == (addr_t) &dummy->address)
143 /* Address of the last PER trap */
144 return child->thread.per_event.address;
145 else if (addr == (addr_t) &dummy->access_id)
146 /* Access id of the last PER trap */
147 return (unsigned long)
148 child->thread.per_event.paid << (BITS_PER_LONG - 8);
149 return 0;
150}
151
1da177e4
LT		 152/*
153 * Read the word at offset addr from the user area of a process. The
154 * trouble here is that the information is littered over different
155 * locations. The process registers are found on the kernel stack,
156 * the floating point stuff and the trace settings are stored in
157 * the task structure. In addition the different structures in
158 * struct user contain pad bytes that should be read as zeroes.
159 * Lovely...
160 */
63506c41 161static unsigned long __peek_user(struct task_struct *child, addr_t addr)
1da177e4
LT		 162{
163 struct user *dummy = NULL;
63506c41 164 addr_t offset, tmp;
1da177e4
LT		 165
166 if (addr < (addr_t) &dummy->regs.acrs) {
167 /*
168 * psw and gprs are stored on the stack
169 */
c7584fb6 170 tmp = *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr);
1da177e4 171 if (addr == (addr_t) &dummy->regs.psw.mask)
b50511e4 172 /* Return a clean psw mask. */
d4e81b35 173 tmp = psw_user_bits | (tmp & PSW_MASK_USER);
1da177e4
LT		 174
175 } else if (addr < (addr_t) &dummy->regs.orig_gpr2) {
176 /*
177 * access registers are stored in the thread structure
178 */
179 offset = addr - (addr_t) &dummy->regs.acrs;
347a8dc3 180#ifdef CONFIG_64BIT
778959db
MS		 181 /*
182 * Very special case: old & broken 64 bit gdb reading
183 * from acrs[15]. Result is a 64 bit value. Read the
184 * 32 bit acrs[15] value and shift it by 32. Sick...
185 */
186 if (addr == (addr_t) &dummy->regs.acrs[15])
187 tmp = ((unsigned long) child->thread.acrs[15]) << 32;
188 else
189#endif
1da177e4
LT		 190 tmp = *(addr_t *)((addr_t) &child->thread.acrs + offset);
191
192 } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
193 /*
194 * orig_gpr2 is stored on the kernel stack
195 */
c7584fb6 196 tmp = (addr_t) task_pt_regs(child)->orig_gpr2;
1da177e4 197
3d6e48f4
JW		 198 } else if (addr < (addr_t) &dummy->regs.fp_regs) {
199 /*
200 * prevent reads of padding hole between
201 * orig_gpr2 and fp_regs on s390.
202 */
203 tmp = 0;
204
1da177e4
LT		 205 } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
206 /*
207 * floating point regs. are stored in the thread structure
208 */
209 offset = addr - (addr_t) &dummy->regs.fp_regs;
210 tmp = *(addr_t *)((addr_t) &child->thread.fp_regs + offset);
778959db
MS		 211 if (addr == (addr_t) &dummy->regs.fp_regs.fpc)
212 tmp &= (unsigned long) FPC_VALID_MASK
213 << (BITS_PER_LONG - 32);
1da177e4
LT		 214
215 } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
216 /*
5e9a2692 217 * Handle access to the per_info structure.
1da177e4 218 */
5e9a2692
MS		 219 addr -= (addr_t) &dummy->regs.per_info;
220 tmp = __peek_user_per(child, addr);
1da177e4
LT		 221
222 } else
223 tmp = 0;
224
63506c41 225 return tmp;
1da177e4
LT		 226}
227
1da177e4 228static int
63506c41 229peek_user(struct task_struct *child, addr_t addr, addr_t data)
1da177e4 230{
63506c41 231 addr_t tmp, mask;
1da177e4
LT		 232
233 /*
234 * Stupid gdb peeks/pokes the access registers in 64 bit with
63506c41 235 * an alignment of 4. Programmers from hell...
1da177e4 236 */
778959db 237 mask = __ADDR_MASK;
347a8dc3 238#ifdef CONFIG_64BIT
547e3cec
MS		 239 if (addr >= (addr_t) &((struct user *) NULL)->regs.acrs &&
240 addr < (addr_t) &((struct user *) NULL)->regs.orig_gpr2)
778959db
MS		 241 mask = 3;
242#endif
243 if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
1da177e4
LT		 244 return -EIO;
245
63506c41
MS		 246 tmp = __peek_user(child, addr);
247 return put_user(tmp, (addr_t __user *) data);
248}
249
5e9a2692
MS		 250static inline void __poke_user_per(struct task_struct *child,
251 addr_t addr, addr_t data)
252{
253 struct per_struct_kernel *dummy = NULL;
254
255 /*
256 * There are only three fields in the per_info struct that the
257 * debugger user can write to.
258 * 1) cr9: the debugger wants to set a new PER event mask
259 * 2) starting_addr: the debugger wants to set a new starting
260 * address to use with the PER event mask.
261 * 3) ending_addr: the debugger wants to set a new ending
262 * address to use with the PER event mask.
263 * The user specified PER event mask and the start and end
264 * addresses are used only if single stepping is not in effect.
265 * Writes to any other field in per_info are ignored.
266 */
267 if (addr == (addr_t) &dummy->cr9)
268 /* PER event mask of the user specified per set. */
269 child->thread.per_user.control =
270 data & (PER_EVENT_MASK | PER_CONTROL_MASK);
271 else if (addr == (addr_t) &dummy->starting_addr)
272 /* Starting address of the user specified per set. */
273 child->thread.per_user.start = data;
274 else if (addr == (addr_t) &dummy->ending_addr)
275 /* Ending address of the user specified per set. */
276 child->thread.per_user.end = data;
277}
278
63506c41
MS		 279/*
280 * Write a word to the user area of a process at location addr. This
281 * operation does have an additional problem compared to peek_user.
282 * Stores to the program status word and on the floating point
283 * control register needs to get checked for validity.
284 */
285static int __poke_user(struct task_struct *child, addr_t addr, addr_t data)
286{
287 struct user *dummy = NULL;
d4e81b35 288 addr_t offset;
63506c41 289
1da177e4
LT		 290 if (addr < (addr_t) &dummy->regs.acrs) {
291 /*
292 * psw and gprs are stored on the stack
293 */
294 if (addr == (addr_t) &dummy->regs.psw.mask &&
d4e81b35
MS		 295 ((data & ~PSW_MASK_USER) != psw_user_bits ||
296 ((data & PSW_MASK_EA) && !(data & PSW_MASK_BA))))
1da177e4
LT		 297 /* Invalid psw mask. */
298 return -EINVAL;
c7584fb6 299 *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data;
1da177e4
LT		 300
301 } else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) {
302 /*
303 * access registers are stored in the thread structure
304 */
305 offset = addr - (addr_t) &dummy->regs.acrs;
347a8dc3 306#ifdef CONFIG_64BIT
778959db
MS		 307 /*
308 * Very special case: old & broken 64 bit gdb writing
309 * to acrs[15] with a 64 bit value. Ignore the lower
310 * half of the value and write the upper 32 bit to
311 * acrs[15]. Sick...
312 */
313 if (addr == (addr_t) &dummy->regs.acrs[15])
314 child->thread.acrs[15] = (unsigned int) (data >> 32);
315 else
316#endif
1da177e4
LT		 317 *(addr_t *)((addr_t) &child->thread.acrs + offset) = data;
318
319 } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
320 /*
321 * orig_gpr2 is stored on the kernel stack
322 */
c7584fb6 323 task_pt_regs(child)->orig_gpr2 = data;
1da177e4 324
3d6e48f4
JW		 325 } else if (addr < (addr_t) &dummy->regs.fp_regs) {
326 /*
327 * prevent writes of padding hole between
328 * orig_gpr2 and fp_regs on s390.
329 */
330 return 0;
331
1da177e4
LT		 332 } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
333 /*
334 * floating point regs. are stored in the thread structure
335 */
336 if (addr == (addr_t) &dummy->regs.fp_regs.fpc &&
778959db
MS		 337 (data & ~((unsigned long) FPC_VALID_MASK
338 << (BITS_PER_LONG - 32))) != 0)
1da177e4
LT		 339 return -EINVAL;
340 offset = addr - (addr_t) &dummy->regs.fp_regs;
341 *(addr_t *)((addr_t) &child->thread.fp_regs + offset) = data;
342
343 } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
344 /*
5e9a2692 345 * Handle access to the per_info structure.
1da177e4 346 */
5e9a2692
MS		 347 addr -= (addr_t) &dummy->regs.per_info;
348 __poke_user_per(child, addr, data);
1da177e4
LT		 349
350 }
351
1da177e4
LT		 352 return 0;
353}
354
5e9a2692 355static int poke_user(struct task_struct *child, addr_t addr, addr_t data)
63506c41 356{
63506c41
MS		 357 addr_t mask;
358
359 /*
360 * Stupid gdb peeks/pokes the access registers in 64 bit with
361 * an alignment of 4. Programmers from hell indeed...
362 */
363 mask = __ADDR_MASK;
364#ifdef CONFIG_64BIT
547e3cec
MS		 365 if (addr >= (addr_t) &((struct user *) NULL)->regs.acrs &&
366 addr < (addr_t) &((struct user *) NULL)->regs.orig_gpr2)
63506c41
MS		 367 mask = 3;
368#endif
369 if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
370 return -EIO;
371
372 return __poke_user(child, addr, data);
373}
374
9b05a69e
NK		 375long arch_ptrace(struct task_struct *child, long request,
376 unsigned long addr, unsigned long data)
1da177e4 377{
1da177e4
LT		 378 ptrace_area parea;
379 int copied, ret;
380
381 switch (request) {
1da177e4
LT		 382 case PTRACE_PEEKUSR:
383 /* read the word at location addr in the USER area. */
384 return peek_user(child, addr, data);
385
1da177e4
LT		 386 case PTRACE_POKEUSR:
387 /* write the word at location addr in the USER area */
388 return poke_user(child, addr, data);
389
390 case PTRACE_PEEKUSR_AREA:
391 case PTRACE_POKEUSR_AREA:
2b67fc46 392 if (copy_from_user(&parea, (void __force __user *) addr,
1da177e4
LT		 393 sizeof(parea)))
394 return -EFAULT;
395 addr = parea.kernel_addr;
396 data = parea.process_addr;
397 copied = 0;
398 while (copied < parea.len) {
399 if (request == PTRACE_PEEKUSR_AREA)
400 ret = peek_user(child, addr, data);
401 else {
2b67fc46
HC		 402 addr_t utmp;
403 if (get_user(utmp,
404 (addr_t __force __user *) data))
1da177e4 405 return -EFAULT;
2b67fc46 406 ret = poke_user(child, addr, utmp);
1da177e4
LT		 407 }
408 if (ret)
409 return ret;
410 addr += sizeof(unsigned long);
411 data += sizeof(unsigned long);
412 copied += sizeof(unsigned long);
413 }
414 return 0;
86f2552b
MS		 415 case PTRACE_GET_LAST_BREAK:
416 put_user(task_thread_info(child)->last_break,
417 (unsigned long __user *) data);
418 return 0;
07805ac8
CB		 419 default:
420 /* Removing high order bit from addr (only for 31 bit). */
421 addr &= PSW_ADDR_INSN;
422 return ptrace_request(child, request, addr, data);
1da177e4 423 }
1da177e4
LT		 424}
425
347a8dc3 426#ifdef CONFIG_COMPAT
1da177e4
LT		 427/*
428 * Now the fun part starts... a 31 bit program running in the
429 * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
430 * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy
431 * to handle, the difference to the 64 bit versions of the requests
432 * is that the access is done in multiples of 4 byte instead of
433 * 8 bytes (sizeof(unsigned long) on 31/64 bit).
434 * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA,
435 * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program
436 * is a 31 bit program too, the content of struct user can be
437 * emulated. A 31 bit program peeking into the struct user of
438 * a 64 bit program is a no-no.
439 */
440
5e9a2692
MS		 441/*
442 * Same as peek_user_per but for a 31 bit program.
443 */
444static inline __u32 __peek_user_per_compat(struct task_struct *child,
445 addr_t addr)
446{
447 struct compat_per_struct_kernel *dummy32 = NULL;
448
449 if (addr == (addr_t) &dummy32->cr9)
450 /* Control bits of the active per set. */
451 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
452 PER_EVENT_IFETCH : child->thread.per_user.control;
453 else if (addr == (addr_t) &dummy32->cr10)
454 /* Start address of the active per set. */
455 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
456 0 : child->thread.per_user.start;
457 else if (addr == (addr_t) &dummy32->cr11)
458 /* End address of the active per set. */
459 return test_thread_flag(TIF_SINGLE_STEP) ?
460 PSW32_ADDR_INSN : child->thread.per_user.end;
461 else if (addr == (addr_t) &dummy32->bits)
462 /* Single-step bit. */
463 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
464 0x80000000 : 0;
465 else if (addr == (addr_t) &dummy32->starting_addr)
466 /* Start address of the user specified per set. */
467 return (__u32) child->thread.per_user.start;
468 else if (addr == (addr_t) &dummy32->ending_addr)
469 /* End address of the user specified per set. */
470 return (__u32) child->thread.per_user.end;
471 else if (addr == (addr_t) &dummy32->perc_atmid)
472 /* PER code, ATMID and AI of the last PER trap */
473 return (__u32) child->thread.per_event.cause << 16;
474 else if (addr == (addr_t) &dummy32->address)
475 /* Address of the last PER trap */
476 return (__u32) child->thread.per_event.address;
477 else if (addr == (addr_t) &dummy32->access_id)
478 /* Access id of the last PER trap */
479 return (__u32) child->thread.per_event.paid << 24;
480 return 0;
481}
482
1da177e4
LT		 483/*
484 * Same as peek_user but for a 31 bit program.
485 */
63506c41 486static u32 __peek_user_compat(struct task_struct *child, addr_t addr)
1da177e4 487{
5e9a2692 488 struct compat_user *dummy32 = NULL;
1da177e4
LT		 489 addr_t offset;
490 __u32 tmp;
491
1da177e4 492 if (addr < (addr_t) &dummy32->regs.acrs) {
b50511e4 493 struct pt_regs *regs = task_pt_regs(child);
1da177e4
LT		 494 /*
495 * psw and gprs are stored on the stack
496 */
497 if (addr == (addr_t) &dummy32->regs.psw.mask) {
498 /* Fake a 31 bit psw mask. */
b50511e4
MS		 499 tmp = (__u32)(regs->psw.mask >> 32);
500 tmp = psw32_user_bits | (tmp & PSW32_MASK_USER);
1da177e4
LT		 501 } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
502 /* Fake a 31 bit psw address. */
d4e81b35
MS		 503 tmp = (__u32) regs->psw.addr |
504 (__u32)(regs->psw.mask & PSW_MASK_BA);
1da177e4
LT		 505 } else {
506 /* gpr 0-15 */
b50511e4 507 tmp = *(__u32 *)((addr_t) &regs->psw + addr*2 + 4);
1da177e4
LT		 508 }
509 } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
510 /*
511 * access registers are stored in the thread structure
512 */
513 offset = addr - (addr_t) &dummy32->regs.acrs;
514 tmp = *(__u32*)((addr_t) &child->thread.acrs + offset);
515
516 } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
517 /*
518 * orig_gpr2 is stored on the kernel stack
519 */
c7584fb6 520 tmp = *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4);
1da177e4 521
3d6e48f4
JW		 522 } else if (addr < (addr_t) &dummy32->regs.fp_regs) {
523 /*
524 * prevent reads of padding hole between
525 * orig_gpr2 and fp_regs on s390.
526 */
527 tmp = 0;
528
1da177e4
LT		 529 } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
530 /*
531 * floating point regs. are stored in the thread structure
532 */
533 offset = addr - (addr_t) &dummy32->regs.fp_regs;
534 tmp = *(__u32 *)((addr_t) &child->thread.fp_regs + offset);
535
536 } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
537 /*
5e9a2692 538 * Handle access to the per_info structure.
1da177e4 539 */
5e9a2692
MS		 540 addr -= (addr_t) &dummy32->regs.per_info;
541 tmp = __peek_user_per_compat(child, addr);
1da177e4
LT		 542
543 } else
544 tmp = 0;
545
63506c41
MS		 546 return tmp;
547}
548
549static int peek_user_compat(struct task_struct *child,
550 addr_t addr, addr_t data)
551{
552 __u32 tmp;
553
7757591a 554 if (!is_compat_task() || (addr & 3) || addr > sizeof(struct user) - 3)
63506c41
MS		 555 return -EIO;
556
557 tmp = __peek_user_compat(child, addr);
1da177e4
LT		 558 return put_user(tmp, (__u32 __user *) data);
559}
560
5e9a2692
MS		 561/*
562 * Same as poke_user_per but for a 31 bit program.
563 */
564static inline void __poke_user_per_compat(struct task_struct *child,
565 addr_t addr, __u32 data)
566{
567 struct compat_per_struct_kernel *dummy32 = NULL;
568
569 if (addr == (addr_t) &dummy32->cr9)
570 /* PER event mask of the user specified per set. */
571 child->thread.per_user.control =
572 data & (PER_EVENT_MASK | PER_CONTROL_MASK);
573 else if (addr == (addr_t) &dummy32->starting_addr)
574 /* Starting address of the user specified per set. */
575 child->thread.per_user.start = data;
576 else if (addr == (addr_t) &dummy32->ending_addr)
577 /* Ending address of the user specified per set. */
578 child->thread.per_user.end = data;
579}
580
1da177e4
LT		 581/*
582 * Same as poke_user but for a 31 bit program.
583 */
63506c41
MS		 584static int __poke_user_compat(struct task_struct *child,
585 addr_t addr, addr_t data)
1da177e4 586{
5e9a2692 587 struct compat_user *dummy32 = NULL;
63506c41 588 __u32 tmp = (__u32) data;
1da177e4 589 addr_t offset;
1da177e4
LT		 590
591 if (addr < (addr_t) &dummy32->regs.acrs) {
b50511e4 592 struct pt_regs *regs = task_pt_regs(child);
1da177e4
LT		 593 /*
594 * psw, gprs, acrs and orig_gpr2 are stored on the stack
595 */
596 if (addr == (addr_t) &dummy32->regs.psw.mask) {
597 /* Build a 64 bit psw mask from 31 bit mask. */
b50511e4 598 if ((tmp & ~PSW32_MASK_USER) != psw32_user_bits)
1da177e4
LT		 599 /* Invalid psw mask. */
600 return -EINVAL;
b50511e4 601 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
d4e81b35 602 (regs->psw.mask & PSW_MASK_BA) |
b50511e4 603 (__u64)(tmp & PSW32_MASK_USER) << 32;
1da177e4
LT		 604 } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
605 /* Build a 64 bit psw address from 31 bit address. */
b50511e4 606 regs->psw.addr = (__u64) tmp & PSW32_ADDR_INSN;
d4e81b35
MS		 607 /* Transfer 31 bit amode bit to psw mask. */
608 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_BA) |
609 (__u64)(tmp & PSW32_ADDR_AMODE);
1da177e4
LT		 610 } else {
611 /* gpr 0-15 */
b50511e4 612 *(__u32*)((addr_t) &regs->psw + addr*2 + 4) = tmp;
1da177e4
LT		 613 }
614 } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
615 /*
616 * access registers are stored in the thread structure
617 */
618 offset = addr - (addr_t) &dummy32->regs.acrs;
619 *(__u32*)((addr_t) &child->thread.acrs + offset) = tmp;
620
621 } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
622 /*
623 * orig_gpr2 is stored on the kernel stack
624 */
c7584fb6 625 *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4) = tmp;
1da177e4 626
3d6e48f4
JW		 627 } else if (addr < (addr_t) &dummy32->regs.fp_regs) {
628 /*
629 * prevent writess of padding hole between
630 * orig_gpr2 and fp_regs on s390.
631 */
632 return 0;
633
1da177e4
LT		 634 } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
635 /*
636 * floating point regs. are stored in the thread structure
637 */
638 if (addr == (addr_t) &dummy32->regs.fp_regs.fpc &&
639 (tmp & ~FPC_VALID_MASK) != 0)
640 /* Invalid floating point control. */
641 return -EINVAL;
642 offset = addr - (addr_t) &dummy32->regs.fp_regs;
643 *(__u32 *)((addr_t) &child->thread.fp_regs + offset) = tmp;
644
645 } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
646 /*
5e9a2692 647 * Handle access to the per_info structure.
1da177e4 648 */
5e9a2692
MS		 649 addr -= (addr_t) &dummy32->regs.per_info;
650 __poke_user_per_compat(child, addr, data);
1da177e4
LT		 651 }
652
1da177e4
LT		 653 return 0;
654}
655
63506c41
MS		 656static int poke_user_compat(struct task_struct *child,
657 addr_t addr, addr_t data)
658{
5e9a2692
MS		 659 if (!is_compat_task() || (addr & 3) ||
660 addr > sizeof(struct compat_user) - 3)
63506c41
MS		 661 return -EIO;
662
663 return __poke_user_compat(child, addr, data);
664}
665
b499d76b
RM		 666long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
667 compat_ulong_t caddr, compat_ulong_t cdata)
1da177e4 668{
b499d76b
RM		 669 unsigned long addr = caddr;
670 unsigned long data = cdata;
5e9a2692 671 compat_ptrace_area parea;
1da177e4
LT		 672 int copied, ret;
673
674 switch (request) {
1da177e4
LT		 675 case PTRACE_PEEKUSR:
676 /* read the word at location addr in the USER area. */
63506c41 677 return peek_user_compat(child, addr, data);
1da177e4 678
1da177e4
LT		 679 case PTRACE_POKEUSR:
680 /* write the word at location addr in the USER area */
63506c41 681 return poke_user_compat(child, addr, data);
1da177e4
LT		 682
683 case PTRACE_PEEKUSR_AREA:
684 case PTRACE_POKEUSR_AREA:
2b67fc46 685 if (copy_from_user(&parea, (void __force __user *) addr,
1da177e4
LT		 686 sizeof(parea)))
687 return -EFAULT;
688 addr = parea.kernel_addr;
689 data = parea.process_addr;
690 copied = 0;
691 while (copied < parea.len) {
692 if (request == PTRACE_PEEKUSR_AREA)
63506c41 693 ret = peek_user_compat(child, addr, data);
1da177e4 694 else {
2b67fc46
HC		 695 __u32 utmp;
696 if (get_user(utmp,
697 (__u32 __force __user *) data))
1da177e4 698 return -EFAULT;
63506c41 699 ret = poke_user_compat(child, addr, utmp);
1da177e4
LT		 700 }
701 if (ret)
702 return ret;
703 addr += sizeof(unsigned int);
704 data += sizeof(unsigned int);
705 copied += sizeof(unsigned int);
706 }
707 return 0;
86f2552b
MS		 708 case PTRACE_GET_LAST_BREAK:
709 put_user(task_thread_info(child)->last_break,
710 (unsigned int __user *) data);
711 return 0;
1da177e4 712 }
b499d76b 713 return compat_ptrace_request(child, request, addr, data);
1da177e4
LT		 714}
715#endif
716
753c4dd6 717asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
1da177e4 718{
545c174d 719 long ret = 0;
1da177e4 720
bcf5cef7
HC		 721 /* Do the secure computing check first. */
722 secure_computing(regs->gprs[2]);
723
c5c3a6d8 724 /*
753c4dd6
MS		 725 * The sysc_tracesys code in entry.S stored the system
726 * call number to gprs[2].
c5c3a6d8 727 */
753c4dd6
MS		 728 if (test_thread_flag(TIF_SYSCALL_TRACE) &&
729 (tracehook_report_syscall_entry(regs) ||
730 regs->gprs[2] >= NR_syscalls)) {
731 /*
732 * Tracing decided this syscall should not happen or the
733 * debugger stored an invalid system call number. Skip
734 * the system call and the system call restart handling.
735 */
b6ef5bb3 736 clear_thread_flag(TIF_SYSCALL);
753c4dd6 737 ret = -1;
1da177e4 738 }
753c4dd6 739
66700001 740 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
1c569f02 741 trace_sys_enter(regs, regs->gprs[2]);
9bf1226b 742
753c4dd6 743 if (unlikely(current->audit_context))
7757591a 744 audit_syscall_entry(is_compat_task() ?
753c4dd6
MS		 745 AUDIT_ARCH_S390 : AUDIT_ARCH_S390X,
746 regs->gprs[2], regs->orig_gpr2,
747 regs->gprs[3], regs->gprs[4],
748 regs->gprs[5]);
545c174d 749 return ret ?: regs->gprs[2];
753c4dd6
MS		 750}
751
752asmlinkage void do_syscall_trace_exit(struct pt_regs *regs)
753{
754 if (unlikely(current->audit_context))
755 audit_syscall_exit(AUDITSC_RESULT(regs->gprs[2]),
756 regs->gprs[2]);
757
66700001 758 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
1c569f02 759 trace_sys_exit(regs, regs->gprs[2]);
9bf1226b 760
753c4dd6
MS		 761 if (test_thread_flag(TIF_SYSCALL_TRACE))
762 tracehook_report_syscall_exit(regs, 0);
1da177e4 763}
63506c41
MS		 764
765/*
766 * user_regset definitions.
767 */
768
769static int s390_regs_get(struct task_struct *target,
770 const struct user_regset *regset,
771 unsigned int pos, unsigned int count,
772 void *kbuf, void __user *ubuf)
773{
774 if (target == current)
775 save_access_regs(target->thread.acrs);
776
777 if (kbuf) {
778 unsigned long *k = kbuf;
779 while (count > 0) {
780 *k++ = __peek_user(target, pos);
781 count -= sizeof(*k);
782 pos += sizeof(*k);
783 }
784 } else {
785 unsigned long __user *u = ubuf;
786 while (count > 0) {
787 if (__put_user(__peek_user(target, pos), u++))
788 return -EFAULT;
789 count -= sizeof(*u);
790 pos += sizeof(*u);
791 }
792 }
793 return 0;
794}
795
796static int s390_regs_set(struct task_struct *target,
797 const struct user_regset *regset,
798 unsigned int pos, unsigned int count,
799 const void *kbuf, const void __user *ubuf)
800{
801 int rc = 0;
802
803 if (target == current)
804 save_access_regs(target->thread.acrs);
805
806 if (kbuf) {
807 const unsigned long *k = kbuf;
808 while (count > 0 && !rc) {
809 rc = __poke_user(target, pos, *k++);
810 count -= sizeof(*k);
811 pos += sizeof(*k);
812 }
813 } else {
814 const unsigned long __user *u = ubuf;
815 while (count > 0 && !rc) {
816 unsigned long word;
817 rc = __get_user(word, u++);
818 if (rc)
819 break;
820 rc = __poke_user(target, pos, word);
821 count -= sizeof(*u);
822 pos += sizeof(*u);
823 }
824 }
825
826 if (rc == 0 && target == current)
827 restore_access_regs(target->thread.acrs);
828
829 return rc;
830}
831
832static int s390_fpregs_get(struct task_struct *target,
833 const struct user_regset *regset, unsigned int pos,
834 unsigned int count, void *kbuf, void __user *ubuf)
835{
836 if (target == current)
837 save_fp_regs(&target->thread.fp_regs);
838
839 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
840 &target->thread.fp_regs, 0, -1);
841}
842
843static int s390_fpregs_set(struct task_struct *target,
844 const struct user_regset *regset, unsigned int pos,
845 unsigned int count, const void *kbuf,
846 const void __user *ubuf)
847{
848 int rc = 0;
849
850 if (target == current)
851 save_fp_regs(&target->thread.fp_regs);
852
853 /* If setting FPC, must validate it first. */
854 if (count > 0 && pos < offsetof(s390_fp_regs, fprs)) {
855 u32 fpc[2] = { target->thread.fp_regs.fpc, 0 };
856 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &fpc,
857 0, offsetof(s390_fp_regs, fprs));
858 if (rc)
859 return rc;
860 if ((fpc[0] & ~FPC_VALID_MASK) != 0 || fpc[1] != 0)
861 return -EINVAL;
862 target->thread.fp_regs.fpc = fpc[0];
863 }
864
865 if (rc == 0 && count > 0)
866 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
867 target->thread.fp_regs.fprs,
868 offsetof(s390_fp_regs, fprs), -1);
869
870 if (rc == 0 && target == current)
871 restore_fp_regs(&target->thread.fp_regs);
872
873 return rc;
874}
875
86f2552b
MS		 876#ifdef CONFIG_64BIT
877
878static int s390_last_break_get(struct task_struct *target,
879 const struct user_regset *regset,
880 unsigned int pos, unsigned int count,
881 void *kbuf, void __user *ubuf)
882{
883 if (count > 0) {
884 if (kbuf) {
885 unsigned long *k = kbuf;
886 *k = task_thread_info(target)->last_break;
887 } else {
888 unsigned long __user *u = ubuf;
889 if (__put_user(task_thread_info(target)->last_break, u))
890 return -EFAULT;
891 }
892 }
893 return 0;
894}
895
b934069c
MS		 896static int s390_last_break_set(struct task_struct *target,
897 const struct user_regset *regset,
898 unsigned int pos, unsigned int count,
899 const void *kbuf, const void __user *ubuf)
900{
901 return 0;
902}
903
86f2552b
MS		 904#endif
905
20b40a79
MS		 906static int s390_system_call_get(struct task_struct *target,
907 const struct user_regset *regset,
908 unsigned int pos, unsigned int count,
909 void *kbuf, void __user *ubuf)
910{
911 unsigned int *data = &task_thread_info(target)->system_call;
912 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
913 data, 0, sizeof(unsigned int));
914}
915
916static int s390_system_call_set(struct task_struct *target,
917 const struct user_regset *regset,
918 unsigned int pos, unsigned int count,
919 const void *kbuf, const void __user *ubuf)
920{
921 unsigned int *data = &task_thread_info(target)->system_call;
922 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
923 data, 0, sizeof(unsigned int));
924}
925
63506c41
MS		 926static const struct user_regset s390_regsets[] = {
927 [REGSET_GENERAL] = {
928 .core_note_type = NT_PRSTATUS,
929 .n = sizeof(s390_regs) / sizeof(long),
930 .size = sizeof(long),
931 .align = sizeof(long),
932 .get = s390_regs_get,
933 .set = s390_regs_set,
934 },
935 [REGSET_FP] = {
936 .core_note_type = NT_PRFPREG,
937 .n = sizeof(s390_fp_regs) / sizeof(long),
938 .size = sizeof(long),
939 .align = sizeof(long),
940 .get = s390_fpregs_get,
941 .set = s390_fpregs_set,
942 },
86f2552b
MS		 943#ifdef CONFIG_64BIT
944 [REGSET_LAST_BREAK] = {
945 .core_note_type = NT_S390_LAST_BREAK,
946 .n = 1,
947 .size = sizeof(long),
948 .align = sizeof(long),
949 .get = s390_last_break_get,
b934069c 950 .set = s390_last_break_set,
86f2552b
MS		 951 },
952#endif
20b40a79
MS		 953 [REGSET_SYSTEM_CALL] = {
954 .core_note_type = NT_S390_SYSTEM_CALL,
955 .n = 1,
956 .size = sizeof(unsigned int),
957 .align = sizeof(unsigned int),
958 .get = s390_system_call_get,
959 .set = s390_system_call_set,
960 },
63506c41
MS		 961};
962
963static const struct user_regset_view user_s390_view = {
964 .name = UTS_MACHINE,
965 .e_machine = EM_S390,
966 .regsets = s390_regsets,
967 .n = ARRAY_SIZE(s390_regsets)
968};
969
970#ifdef CONFIG_COMPAT
971static int s390_compat_regs_get(struct task_struct *target,
972 const struct user_regset *regset,
973 unsigned int pos, unsigned int count,
974 void *kbuf, void __user *ubuf)
975{
976 if (target == current)
977 save_access_regs(target->thread.acrs);
978
979 if (kbuf) {
980 compat_ulong_t *k = kbuf;
981 while (count > 0) {
982 *k++ = __peek_user_compat(target, pos);
983 count -= sizeof(*k);
984 pos += sizeof(*k);
985 }
986 } else {
987 compat_ulong_t __user *u = ubuf;
988 while (count > 0) {
989 if (__put_user(__peek_user_compat(target, pos), u++))
990 return -EFAULT;
991 count -= sizeof(*u);
992 pos += sizeof(*u);
993 }
994 }
995 return 0;
996}
997
998static int s390_compat_regs_set(struct task_struct *target,
999 const struct user_regset *regset,
1000 unsigned int pos, unsigned int count,
1001 const void *kbuf, const void __user *ubuf)
1002{
1003 int rc = 0;
1004
1005 if (target == current)
1006 save_access_regs(target->thread.acrs);
1007
1008 if (kbuf) {
1009 const compat_ulong_t *k = kbuf;
1010 while (count > 0 && !rc) {
1011 rc = __poke_user_compat(target, pos, *k++);
1012 count -= sizeof(*k);
1013 pos += sizeof(*k);
1014 }
1015 } else {
1016 const compat_ulong_t __user *u = ubuf;
1017 while (count > 0 && !rc) {
1018 compat_ulong_t word;
1019 rc = __get_user(word, u++);
1020 if (rc)
1021 break;
1022 rc = __poke_user_compat(target, pos, word);
1023 count -= sizeof(*u);
1024 pos += sizeof(*u);
1025 }
1026 }
1027
1028 if (rc == 0 && target == current)
1029 restore_access_regs(target->thread.acrs);
1030
1031 return rc;
1032}
1033
ea2a4d3a
HC		 1034static int s390_compat_regs_high_get(struct task_struct *target,
1035 const struct user_regset *regset,
1036 unsigned int pos, unsigned int count,
1037 void *kbuf, void __user *ubuf)
1038{
1039 compat_ulong_t *gprs_high;
1040
1041 gprs_high = (compat_ulong_t *)
1042 &task_pt_regs(target)->gprs[pos / sizeof(compat_ulong_t)];
1043 if (kbuf) {
1044 compat_ulong_t *k = kbuf;
1045 while (count > 0) {
1046 *k++ = *gprs_high;
1047 gprs_high += 2;
1048 count -= sizeof(*k);
1049 }
1050 } else {
1051 compat_ulong_t __user *u = ubuf;
1052 while (count > 0) {
1053 if (__put_user(*gprs_high, u++))
1054 return -EFAULT;
1055 gprs_high += 2;
1056 count -= sizeof(*u);
1057 }
1058 }
1059 return 0;
1060}
1061
1062static int s390_compat_regs_high_set(struct task_struct *target,
1063 const struct user_regset *regset,
1064 unsigned int pos, unsigned int count,
1065 const void *kbuf, const void __user *ubuf)
1066{
1067 compat_ulong_t *gprs_high;
1068 int rc = 0;
1069
1070 gprs_high = (compat_ulong_t *)
1071 &task_pt_regs(target)->gprs[pos / sizeof(compat_ulong_t)];
1072 if (kbuf) {
1073 const compat_ulong_t *k = kbuf;
1074 while (count > 0) {
1075 *gprs_high = *k++;
1076 *gprs_high += 2;
1077 count -= sizeof(*k);
1078 }
1079 } else {
1080 const compat_ulong_t __user *u = ubuf;
1081 while (count > 0 && !rc) {
1082 unsigned long word;
1083 rc = __get_user(word, u++);
1084 if (rc)
1085 break;
1086 *gprs_high = word;
1087 *gprs_high += 2;
1088 count -= sizeof(*u);
1089 }
1090 }
1091
1092 return rc;
1093}
1094
86f2552b
MS		 1095static int s390_compat_last_break_get(struct task_struct *target,
1096 const struct user_regset *regset,
1097 unsigned int pos, unsigned int count,
1098 void *kbuf, void __user *ubuf)
1099{
1100 compat_ulong_t last_break;
1101
1102 if (count > 0) {
1103 last_break = task_thread_info(target)->last_break;
1104 if (kbuf) {
1105 unsigned long *k = kbuf;
1106 *k = last_break;
1107 } else {
1108 unsigned long __user *u = ubuf;
1109 if (__put_user(last_break, u))
1110 return -EFAULT;
1111 }
1112 }
1113 return 0;
1114}
1115
b934069c
MS		 1116static int s390_compat_last_break_set(struct task_struct *target,
1117 const struct user_regset *regset,
1118 unsigned int pos, unsigned int count,
1119 const void *kbuf, const void __user *ubuf)
1120{
1121 return 0;
1122}
1123
63506c41
MS		 1124static const struct user_regset s390_compat_regsets[] = {
1125 [REGSET_GENERAL] = {
1126 .core_note_type = NT_PRSTATUS,
1127 .n = sizeof(s390_compat_regs) / sizeof(compat_long_t),
1128 .size = sizeof(compat_long_t),
1129 .align = sizeof(compat_long_t),
1130 .get = s390_compat_regs_get,
1131 .set = s390_compat_regs_set,
1132 },
1133 [REGSET_FP] = {
1134 .core_note_type = NT_PRFPREG,
1135 .n = sizeof(s390_fp_regs) / sizeof(compat_long_t),
1136 .size = sizeof(compat_long_t),
1137 .align = sizeof(compat_long_t),
1138 .get = s390_fpregs_get,
1139 .set = s390_fpregs_set,
1140 },
86f2552b
MS		 1141 [REGSET_LAST_BREAK] = {
1142 .core_note_type = NT_S390_LAST_BREAK,
1143 .n = 1,
1144 .size = sizeof(long),
1145 .align = sizeof(long),
1146 .get = s390_compat_last_break_get,
b934069c 1147 .set = s390_compat_last_break_set,
86f2552b 1148 },
20b40a79
MS		 1149 [REGSET_SYSTEM_CALL] = {
1150 .core_note_type = NT_S390_SYSTEM_CALL,
1151 .n = 1,
1152 .size = sizeof(compat_uint_t),
1153 .align = sizeof(compat_uint_t),
1154 .get = s390_system_call_get,
1155 .set = s390_system_call_set,
1156 },
ea2a4d3a 1157 [REGSET_GENERAL_EXTENDED] = {
622e99bf 1158 .core_note_type = NT_S390_HIGH_GPRS,
ea2a4d3a
HC		 1159 .n = sizeof(s390_compat_regs_high) / sizeof(compat_long_t),
1160 .size = sizeof(compat_long_t),
1161 .align = sizeof(compat_long_t),
1162 .get = s390_compat_regs_high_get,
1163 .set = s390_compat_regs_high_set,
1164 },
63506c41
MS		 1165};
1166
1167static const struct user_regset_view user_s390_compat_view = {
1168 .name = "s390",
1169 .e_machine = EM_S390,
1170 .regsets = s390_compat_regsets,
1171 .n = ARRAY_SIZE(s390_compat_regsets)
1172};
1173#endif
1174
1175const struct user_regset_view *task_user_regset_view(struct task_struct *task)
1176{
1177#ifdef CONFIG_COMPAT
1178 if (test_tsk_thread_flag(task, TIF_31BIT))
1179 return &user_s390_compat_view;
1180#endif
1181 return &user_s390_view;
1182}
952974ac
HC		 1183
1184static const char *gpr_names[NUM_GPRS] = {
1185 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1186 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1187};
1188
1189unsigned long regs_get_register(struct pt_regs *regs, unsigned int offset)
1190{
1191 if (offset >= NUM_GPRS)
1192 return 0;
1193 return regs->gprs[offset];
1194}
1195
1196int regs_query_register_offset(const char *name)
1197{
1198 unsigned long offset;
1199
1200 if (!name || *name != 'r')
1201 return -EINVAL;
1202 if (strict_strtoul(name + 1, 10, &offset))
1203 return -EINVAL;
1204 if (offset >= NUM_GPRS)
1205 return -EINVAL;
1206 return offset;
1207}
1208
1209const char *regs_query_register_name(unsigned int offset)
1210{
1211 if (offset >= NUM_GPRS)
1212 return NULL;
1213 return gpr_names[offset];
1214}
1215
1216static int regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
1217{
1218 unsigned long ksp = kernel_stack_pointer(regs);
1219
1220 return (addr & ~(THREAD_SIZE - 1)) == (ksp & ~(THREAD_SIZE - 1));
1221}
1222
1223/**
1224 * regs_get_kernel_stack_nth() - get Nth entry of the stack
1225 * @regs:pt_regs which contains kernel stack pointer.
1226 * @n:stack entry number.
1227 *
1228 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
1229 * is specifined by @regs. If the @n th entry is NOT in the kernel stack,
1230 * this returns 0.
1231 */
1232unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
1233{
1234 unsigned long addr;
1235
1236 addr = kernel_stack_pointer(regs) + n * sizeof(long);
1237 if (!regs_within_kernel_stack(regs, addr))
1238 return 0;
1239 return *(unsigned long *)addr;
1240}
Linux 6.x block layer and io_uring tree(s)