?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.13.16
[linux/fpc-iii.git] / arch / s390 / kernel / ptrace.c
blob252ed61a128b8689a3cbacf592031adeeab5c6cc
1 /*
2 * Ptrace user space interface.
3 *
4 * Copyright IBM Corp. 1999, 2010
5 * Author(s): Denis Joseph Barrow
6 * Martin Schwidefsky (schwidefsky@de.ibm.com)
7 */
8
9 #include <linux/kernel.h>
10 #include <linux/sched.h>
11 #include <linux/sched/task_stack.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/errno.h>
15 #include <linux/ptrace.h>
16 #include <linux/user.h>
17 #include <linux/security.h>
18 #include <linux/audit.h>
19 #include <linux/signal.h>
20 #include <linux/elf.h>
21 #include <linux/regset.h>
22 #include <linux/tracehook.h>
23 #include <linux/seccomp.h>
24 #include <linux/compat.h>
25 #include <trace/syscall.h>
26 #include <asm/segment.h>
27 #include <asm/page.h>
28 #include <asm/pgtable.h>
29 #include <asm/pgalloc.h>
30 #include <linux/uaccess.h>
31 #include <asm/unistd.h>
32 #include <asm/switch_to.h>
33 #include "entry.h"
34
35 #ifdef CONFIG_COMPAT
36 #include "compat_ptrace.h"
37 #endif
38
39 #define CREATE_TRACE_POINTS
40 #include <trace/events/syscalls.h>
41
42 void update_cr_regs(struct task_struct *task)
43 {
44 struct pt_regs *regs = task_pt_regs(task);
45 struct thread_struct *thread = &task->thread;
46 struct per_regs old, new;
47 unsigned long cr0_old, cr0_new;
48 unsigned long cr2_old, cr2_new;
49 int cr0_changed, cr2_changed;
50
51 __ctl_store(cr0_old, 0, 0);
52 __ctl_store(cr2_old, 2, 2);
53 cr0_new = cr0_old;
54 cr2_new = cr2_old;
55 /* Take care of the enable/disable of transactional execution. */
56 if (MACHINE_HAS_TE) {
57 /* Set or clear transaction execution TXC bit 8. */
58 cr0_new |= (1UL << 55);
59 if (task->thread.per_flags & PER_FLAG_NO_TE)
60 cr0_new &= ~(1UL << 55);
61 /* Set or clear transaction execution TDC bits 62 and 63. */
62 cr2_new &= ~3UL;
63 if (task->thread.per_flags & PER_FLAG_TE_ABORT_RAND) {
64 if (task->thread.per_flags & PER_FLAG_TE_ABORT_RAND_TEND)
65 cr2_new |= 1UL;
66 else
67 cr2_new |= 2UL;
68 }
69 }
70 /* Take care of enable/disable of guarded storage. */
71 if (MACHINE_HAS_GS) {
72 cr2_new &= ~(1UL << 4);
73 if (task->thread.gs_cb)
74 cr2_new |= (1UL << 4);
75 }
76 /* Load control register 0/2 iff changed */
77 cr0_changed = cr0_new != cr0_old;
78 cr2_changed = cr2_new != cr2_old;
79 if (cr0_changed)
80 __ctl_load(cr0_new, 0, 0);
81 if (cr2_changed)
82 __ctl_load(cr2_new, 2, 2);
83 /* Copy user specified PER registers */
84 new.control = thread->per_user.control;
85 new.start = thread->per_user.start;
86 new.end = thread->per_user.end;
87
88 /* merge TIF_SINGLE_STEP into user specified PER registers. */
89 if (test_tsk_thread_flag(task, TIF_SINGLE_STEP) ||
90 test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP)) {
91 if (test_tsk_thread_flag(task, TIF_BLOCK_STEP))
92 new.control |= PER_EVENT_BRANCH;
93 else
94 new.control |= PER_EVENT_IFETCH;
95 new.control |= PER_CONTROL_SUSPENSION;
96 new.control |= PER_EVENT_TRANSACTION_END;
97 if (test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP))
98 new.control |= PER_EVENT_IFETCH;
99 new.start = 0;
100 new.end = -1UL;
101 }
102
103 /* Take care of the PER enablement bit in the PSW. */
104 if (!(new.control & PER_EVENT_MASK)) {
105 regs->psw.mask &= ~PSW_MASK_PER;
106 return;
107 }
108 regs->psw.mask |= PSW_MASK_PER;
109 __ctl_store(old, 9, 11);
110 if (memcmp(&new, &old, sizeof(struct per_regs)) != 0)
111 __ctl_load(new, 9, 11);
112 }
113
114 void user_enable_single_step(struct task_struct *task)
115 {
116 clear_tsk_thread_flag(task, TIF_BLOCK_STEP);
117 set_tsk_thread_flag(task, TIF_SINGLE_STEP);
118 }
119
120 void user_disable_single_step(struct task_struct *task)
121 {
122 clear_tsk_thread_flag(task, TIF_BLOCK_STEP);
123 clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
124 }
125
126 void user_enable_block_step(struct task_struct *task)
127 {
128 set_tsk_thread_flag(task, TIF_SINGLE_STEP);
129 set_tsk_thread_flag(task, TIF_BLOCK_STEP);
130 }
131
132 /*
133 * Called by kernel/ptrace.c when detaching..
134 *
135 * Clear all debugging related fields.
136 */
137 void ptrace_disable(struct task_struct *task)
138 {
139 memset(&task->thread.per_user, 0, sizeof(task->thread.per_user));
140 memset(&task->thread.per_event, 0, sizeof(task->thread.per_event));
141 clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
142 clear_pt_regs_flag(task_pt_regs(task), PIF_PER_TRAP);
143 task->thread.per_flags = 0;
144 }
145
146 #define __ADDR_MASK 7
147
148 static inline unsigned long __peek_user_per(struct task_struct *child,
149 addr_t addr)
150 {
151 struct per_struct_kernel *dummy = NULL;
152
153 if (addr == (addr_t) &dummy->cr9)
154 /* Control bits of the active per set. */
155 return test_thread_flag(TIF_SINGLE_STEP) ?
156 PER_EVENT_IFETCH : child->thread.per_user.control;
157 else if (addr == (addr_t) &dummy->cr10)
158 /* Start address of the active per set. */
159 return test_thread_flag(TIF_SINGLE_STEP) ?
160 0 : child->thread.per_user.start;
161 else if (addr == (addr_t) &dummy->cr11)
162 /* End address of the active per set. */
163 return test_thread_flag(TIF_SINGLE_STEP) ?
164 -1UL : child->thread.per_user.end;
165 else if (addr == (addr_t) &dummy->bits)
166 /* Single-step bit. */
167 return test_thread_flag(TIF_SINGLE_STEP) ?
168 (1UL << (BITS_PER_LONG - 1)) : 0;
169 else if (addr == (addr_t) &dummy->starting_addr)
170 /* Start address of the user specified per set. */
171 return child->thread.per_user.start;
172 else if (addr == (addr_t) &dummy->ending_addr)
173 /* End address of the user specified per set. */
174 return child->thread.per_user.end;
175 else if (addr == (addr_t) &dummy->perc_atmid)
176 /* PER code, ATMID and AI of the last PER trap */
177 return (unsigned long)
178 child->thread.per_event.cause << (BITS_PER_LONG - 16);
179 else if (addr == (addr_t) &dummy->address)
180 /* Address of the last PER trap */
181 return child->thread.per_event.address;
182 else if (addr == (addr_t) &dummy->access_id)
183 /* Access id of the last PER trap */
184 return (unsigned long)
185 child->thread.per_event.paid << (BITS_PER_LONG - 8);
186 return 0;
187 }
188
189 /*
190 * Read the word at offset addr from the user area of a process. The
191 * trouble here is that the information is littered over different
192 * locations. The process registers are found on the kernel stack,
193 * the floating point stuff and the trace settings are stored in
194 * the task structure. In addition the different structures in
195 * struct user contain pad bytes that should be read as zeroes.
196 * Lovely...
197 */
198 static unsigned long __peek_user(struct task_struct *child, addr_t addr)
199 {
200 struct user *dummy = NULL;
201 addr_t offset, tmp;
202
203 if (addr < (addr_t) &dummy->regs.acrs) {
204 /*
205 * psw and gprs are stored on the stack
206 */
207 tmp = *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr);
208 if (addr == (addr_t) &dummy->regs.psw.mask) {
209 /* Return a clean psw mask. */
210 tmp &= PSW_MASK_USER | PSW_MASK_RI;
211 tmp |= PSW_USER_BITS;
212 }
213
214 } else if (addr < (addr_t) &dummy->regs.orig_gpr2) {
215 /*
216 * access registers are stored in the thread structure
217 */
218 offset = addr - (addr_t) &dummy->regs.acrs;
219 /*
220 * Very special case: old & broken 64 bit gdb reading
221 * from acrs[15]. Result is a 64 bit value. Read the
222 * 32 bit acrs[15] value and shift it by 32. Sick...
223 */
224 if (addr == (addr_t) &dummy->regs.acrs[15])
225 tmp = ((unsigned long) child->thread.acrs[15]) << 32;
226 else
227 tmp = *(addr_t *)((addr_t) &child->thread.acrs + offset);
228
229 } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
230 /*
231 * orig_gpr2 is stored on the kernel stack
232 */
233 tmp = (addr_t) task_pt_regs(child)->orig_gpr2;
234
235 } else if (addr < (addr_t) &dummy->regs.fp_regs) {
236 /*
237 * prevent reads of padding hole between
238 * orig_gpr2 and fp_regs on s390.
239 */
240 tmp = 0;
241
242 } else if (addr == (addr_t) &dummy->regs.fp_regs.fpc) {
243 /*
244 * floating point control reg. is in the thread structure
245 */
246 tmp = child->thread.fpu.fpc;
247 tmp <<= BITS_PER_LONG - 32;
248
249 } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
250 /*
251 * floating point regs. are either in child->thread.fpu
252 * or the child->thread.fpu.vxrs array
253 */
254 offset = addr - (addr_t) &dummy->regs.fp_regs.fprs;
255 if (MACHINE_HAS_VX)
256 tmp = *(addr_t *)
257 ((addr_t) child->thread.fpu.vxrs + 2*offset);
258 else
259 tmp = *(addr_t *)
260 ((addr_t) child->thread.fpu.fprs + offset);
261
262 } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
263 /*
264 * Handle access to the per_info structure.
265 */
266 addr -= (addr_t) &dummy->regs.per_info;
267 tmp = __peek_user_per(child, addr);
268
269 } else
270 tmp = 0;
271
272 return tmp;
273 }
274
275 static int
276 peek_user(struct task_struct *child, addr_t addr, addr_t data)
277 {
278 addr_t tmp, mask;
279
280 /*
281 * Stupid gdb peeks/pokes the access registers in 64 bit with
282 * an alignment of 4. Programmers from hell...
283 */
284 mask = __ADDR_MASK;
285 if (addr >= (addr_t) &((struct user *) NULL)->regs.acrs &&
286 addr < (addr_t) &((struct user *) NULL)->regs.orig_gpr2)
287 mask = 3;
288 if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
289 return -EIO;
290
291 tmp = __peek_user(child, addr);
292 return put_user(tmp, (addr_t __user *) data);
293 }
294
295 static inline void __poke_user_per(struct task_struct *child,
296 addr_t addr, addr_t data)
297 {
298 struct per_struct_kernel *dummy = NULL;
299
300 /*
301 * There are only three fields in the per_info struct that the
302 * debugger user can write to.
303 * 1) cr9: the debugger wants to set a new PER event mask
304 * 2) starting_addr: the debugger wants to set a new starting
305 * address to use with the PER event mask.
306 * 3) ending_addr: the debugger wants to set a new ending
307 * address to use with the PER event mask.
308 * The user specified PER event mask and the start and end
309 * addresses are used only if single stepping is not in effect.
310 * Writes to any other field in per_info are ignored.
311 */
312 if (addr == (addr_t) &dummy->cr9)
313 /* PER event mask of the user specified per set. */
314 child->thread.per_user.control =
315 data & (PER_EVENT_MASK | PER_CONTROL_MASK);
316 else if (addr == (addr_t) &dummy->starting_addr)
317 /* Starting address of the user specified per set. */
318 child->thread.per_user.start = data;
319 else if (addr == (addr_t) &dummy->ending_addr)
320 /* Ending address of the user specified per set. */
321 child->thread.per_user.end = data;
322 }
323
324 /*
325 * Write a word to the user area of a process at location addr. This
326 * operation does have an additional problem compared to peek_user.
327 * Stores to the program status word and on the floating point
328 * control register needs to get checked for validity.
329 */
330 static int __poke_user(struct task_struct *child, addr_t addr, addr_t data)
331 {
332 struct user *dummy = NULL;
333 addr_t offset;
334
335 if (addr < (addr_t) &dummy->regs.acrs) {
336 /*
337 * psw and gprs are stored on the stack
338 */
339 if (addr == (addr_t) &dummy->regs.psw.mask) {
340 unsigned long mask = PSW_MASK_USER;
341
342 mask |= is_ri_task(child) ? PSW_MASK_RI : 0;
343 if ((data ^ PSW_USER_BITS) & ~mask)
344 /* Invalid psw mask. */
345 return -EINVAL;
346 if ((data & PSW_MASK_ASC) == PSW_ASC_HOME)
347 /* Invalid address-space-control bits */
348 return -EINVAL;
349 if ((data & PSW_MASK_EA) && !(data & PSW_MASK_BA))
350 /* Invalid addressing mode bits */
351 return -EINVAL;
352 }
353 *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data;
354
355 } else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) {
356 /*
357 * access registers are stored in the thread structure
358 */
359 offset = addr - (addr_t) &dummy->regs.acrs;
360 /*
361 * Very special case: old & broken 64 bit gdb writing
362 * to acrs[15] with a 64 bit value. Ignore the lower
363 * half of the value and write the upper 32 bit to
364 * acrs[15]. Sick...
365 */
366 if (addr == (addr_t) &dummy->regs.acrs[15])
367 child->thread.acrs[15] = (unsigned int) (data >> 32);
368 else
369 *(addr_t *)((addr_t) &child->thread.acrs + offset) = data;
370
371 } else if (addr == (addr_t) &dummy->regs.orig_gpr2) {
372 /*
373 * orig_gpr2 is stored on the kernel stack
374 */
375 task_pt_regs(child)->orig_gpr2 = data;
376
377 } else if (addr < (addr_t) &dummy->regs.fp_regs) {
378 /*
379 * prevent writes of padding hole between
380 * orig_gpr2 and fp_regs on s390.
381 */
382 return 0;
383
384 } else if (addr == (addr_t) &dummy->regs.fp_regs.fpc) {
385 /*
386 * floating point control reg. is in the thread structure
387 */
388 if ((unsigned int) data != 0 ||
389 test_fp_ctl(data >> (BITS_PER_LONG - 32)))
390 return -EINVAL;
391 child->thread.fpu.fpc = data >> (BITS_PER_LONG - 32);
392
393 } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) {
394 /*
395 * floating point regs. are either in child->thread.fpu
396 * or the child->thread.fpu.vxrs array
397 */
398 offset = addr - (addr_t) &dummy->regs.fp_regs.fprs;
399 if (MACHINE_HAS_VX)
400 *(addr_t *)((addr_t)
401 child->thread.fpu.vxrs + 2*offset) = data;
402 else
403 *(addr_t *)((addr_t)
404 child->thread.fpu.fprs + offset) = data;
405
406 } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) {
407 /*
408 * Handle access to the per_info structure.
409 */
410 addr -= (addr_t) &dummy->regs.per_info;
411 __poke_user_per(child, addr, data);
412
413 }
414
415 return 0;
416 }
417
418 static int poke_user(struct task_struct *child, addr_t addr, addr_t data)
419 {
420 addr_t mask;
421
422 /*
423 * Stupid gdb peeks/pokes the access registers in 64 bit with
424 * an alignment of 4. Programmers from hell indeed...
425 */
426 mask = __ADDR_MASK;
427 if (addr >= (addr_t) &((struct user *) NULL)->regs.acrs &&
428 addr < (addr_t) &((struct user *) NULL)->regs.orig_gpr2)
429 mask = 3;
430 if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
431 return -EIO;
432
433 return __poke_user(child, addr, data);
434 }
435
436 long arch_ptrace(struct task_struct *child, long request,
437 unsigned long addr, unsigned long data)
438 {
439 ptrace_area parea;
440 int copied, ret;
441
442 switch (request) {
443 case PTRACE_PEEKUSR:
444 /* read the word at location addr in the USER area. */
445 return peek_user(child, addr, data);
446
447 case PTRACE_POKEUSR:
448 /* write the word at location addr in the USER area */
449 return poke_user(child, addr, data);
450
451 case PTRACE_PEEKUSR_AREA:
452 case PTRACE_POKEUSR_AREA:
453 if (copy_from_user(&parea, (void __force __user *) addr,
454 sizeof(parea)))
455 return -EFAULT;
456 addr = parea.kernel_addr;
457 data = parea.process_addr;
458 copied = 0;
459 while (copied < parea.len) {
460 if (request == PTRACE_PEEKUSR_AREA)
461 ret = peek_user(child, addr, data);
462 else {
463 addr_t utmp;
464 if (get_user(utmp,
465 (addr_t __force __user *) data))
466 return -EFAULT;
467 ret = poke_user(child, addr, utmp);
468 }
469 if (ret)
470 return ret;
471 addr += sizeof(unsigned long);
472 data += sizeof(unsigned long);
473 copied += sizeof(unsigned long);
474 }
475 return 0;
476 case PTRACE_GET_LAST_BREAK:
477 put_user(child->thread.last_break,
478 (unsigned long __user *) data);
479 return 0;
480 case PTRACE_ENABLE_TE:
481 if (!MACHINE_HAS_TE)
482 return -EIO;
483 child->thread.per_flags &= ~PER_FLAG_NO_TE;
484 return 0;
485 case PTRACE_DISABLE_TE:
486 if (!MACHINE_HAS_TE)
487 return -EIO;
488 child->thread.per_flags |= PER_FLAG_NO_TE;
489 child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND;
490 return 0;
491 case PTRACE_TE_ABORT_RAND:
492 if (!MACHINE_HAS_TE || (child->thread.per_flags & PER_FLAG_NO_TE))
493 return -EIO;
494 switch (data) {
495 case 0UL:
496 child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND;
497 break;
498 case 1UL:
499 child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND;
500 child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND_TEND;
501 break;
502 case 2UL:
503 child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND;
504 child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND_TEND;
505 break;
506 default:
507 return -EINVAL;
508 }
509 return 0;
510 default:
511 return ptrace_request(child, request, addr, data);
512 }
513 }
514
515 #ifdef CONFIG_COMPAT
516 /*
517 * Now the fun part starts... a 31 bit program running in the
518 * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
519 * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy
520 * to handle, the difference to the 64 bit versions of the requests
521 * is that the access is done in multiples of 4 byte instead of
522 * 8 bytes (sizeof(unsigned long) on 31/64 bit).
523 * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA,
524 * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program
525 * is a 31 bit program too, the content of struct user can be
526 * emulated. A 31 bit program peeking into the struct user of
527 * a 64 bit program is a no-no.
528 */
529
530 /*
531 * Same as peek_user_per but for a 31 bit program.
532 */
533 static inline __u32 __peek_user_per_compat(struct task_struct *child,
534 addr_t addr)
535 {
536 struct compat_per_struct_kernel *dummy32 = NULL;
537
538 if (addr == (addr_t) &dummy32->cr9)
539 /* Control bits of the active per set. */
540 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
541 PER_EVENT_IFETCH : child->thread.per_user.control;
542 else if (addr == (addr_t) &dummy32->cr10)
543 /* Start address of the active per set. */
544 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
545 0 : child->thread.per_user.start;
546 else if (addr == (addr_t) &dummy32->cr11)
547 /* End address of the active per set. */
548 return test_thread_flag(TIF_SINGLE_STEP) ?
549 PSW32_ADDR_INSN : child->thread.per_user.end;
550 else if (addr == (addr_t) &dummy32->bits)
551 /* Single-step bit. */
552 return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
553 0x80000000 : 0;
554 else if (addr == (addr_t) &dummy32->starting_addr)
555 /* Start address of the user specified per set. */
556 return (__u32) child->thread.per_user.start;
557 else if (addr == (addr_t) &dummy32->ending_addr)
558 /* End address of the user specified per set. */
559 return (__u32) child->thread.per_user.end;
560 else if (addr == (addr_t) &dummy32->perc_atmid)
561 /* PER code, ATMID and AI of the last PER trap */
562 return (__u32) child->thread.per_event.cause << 16;
563 else if (addr == (addr_t) &dummy32->address)
564 /* Address of the last PER trap */
565 return (__u32) child->thread.per_event.address;
566 else if (addr == (addr_t) &dummy32->access_id)
567 /* Access id of the last PER trap */
568 return (__u32) child->thread.per_event.paid << 24;
569 return 0;
570 }
571
572 /*
573 * Same as peek_user but for a 31 bit program.
574 */
575 static u32 __peek_user_compat(struct task_struct *child, addr_t addr)
576 {
577 struct compat_user *dummy32 = NULL;
578 addr_t offset;
579 __u32 tmp;
580
581 if (addr < (addr_t) &dummy32->regs.acrs) {
582 struct pt_regs *regs = task_pt_regs(child);
583 /*
584 * psw and gprs are stored on the stack
585 */
586 if (addr == (addr_t) &dummy32->regs.psw.mask) {
587 /* Fake a 31 bit psw mask. */
588 tmp = (__u32)(regs->psw.mask >> 32);
589 tmp &= PSW32_MASK_USER | PSW32_MASK_RI;
590 tmp |= PSW32_USER_BITS;
591 } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
592 /* Fake a 31 bit psw address. */
593 tmp = (__u32) regs->psw.addr |
594 (__u32)(regs->psw.mask & PSW_MASK_BA);
595 } else {
596 /* gpr 0-15 */
597 tmp = *(__u32 *)((addr_t) &regs->psw + addr*2 + 4);
598 }
599 } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
600 /*
601 * access registers are stored in the thread structure
602 */
603 offset = addr - (addr_t) &dummy32->regs.acrs;
604 tmp = *(__u32*)((addr_t) &child->thread.acrs + offset);
605
606 } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
607 /*
608 * orig_gpr2 is stored on the kernel stack
609 */
610 tmp = *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4);
611
612 } else if (addr < (addr_t) &dummy32->regs.fp_regs) {
613 /*
614 * prevent reads of padding hole between
615 * orig_gpr2 and fp_regs on s390.
616 */
617 tmp = 0;
618
619 } else if (addr == (addr_t) &dummy32->regs.fp_regs.fpc) {
620 /*
621 * floating point control reg. is in the thread structure
622 */
623 tmp = child->thread.fpu.fpc;
624
625 } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
626 /*
627 * floating point regs. are either in child->thread.fpu
628 * or the child->thread.fpu.vxrs array
629 */
630 offset = addr - (addr_t) &dummy32->regs.fp_regs.fprs;
631 if (MACHINE_HAS_VX)
632 tmp = *(__u32 *)
633 ((addr_t) child->thread.fpu.vxrs + 2*offset);
634 else
635 tmp = *(__u32 *)
636 ((addr_t) child->thread.fpu.fprs + offset);
637
638 } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
639 /*
640 * Handle access to the per_info structure.
641 */
642 addr -= (addr_t) &dummy32->regs.per_info;
643 tmp = __peek_user_per_compat(child, addr);
644
645 } else
646 tmp = 0;
647
648 return tmp;
649 }
650
651 static int peek_user_compat(struct task_struct *child,
652 addr_t addr, addr_t data)
653 {
654 __u32 tmp;
655
656 if (!is_compat_task() || (addr & 3) || addr > sizeof(struct user) - 3)
657 return -EIO;
658
659 tmp = __peek_user_compat(child, addr);
660 return put_user(tmp, (__u32 __user *) data);
661 }
662
663 /*
664 * Same as poke_user_per but for a 31 bit program.
665 */
666 static inline void __poke_user_per_compat(struct task_struct *child,
667 addr_t addr, __u32 data)
668 {
669 struct compat_per_struct_kernel *dummy32 = NULL;
670
671 if (addr == (addr_t) &dummy32->cr9)
672 /* PER event mask of the user specified per set. */
673 child->thread.per_user.control =
674 data & (PER_EVENT_MASK | PER_CONTROL_MASK);
675 else if (addr == (addr_t) &dummy32->starting_addr)
676 /* Starting address of the user specified per set. */
677 child->thread.per_user.start = data;
678 else if (addr == (addr_t) &dummy32->ending_addr)
679 /* Ending address of the user specified per set. */
680 child->thread.per_user.end = data;
681 }
682
683 /*
684 * Same as poke_user but for a 31 bit program.
685 */
686 static int __poke_user_compat(struct task_struct *child,
687 addr_t addr, addr_t data)
688 {
689 struct compat_user *dummy32 = NULL;
690 __u32 tmp = (__u32) data;
691 addr_t offset;
692
693 if (addr < (addr_t) &dummy32->regs.acrs) {
694 struct pt_regs *regs = task_pt_regs(child);
695 /*
696 * psw, gprs, acrs and orig_gpr2 are stored on the stack
697 */
698 if (addr == (addr_t) &dummy32->regs.psw.mask) {
699 __u32 mask = PSW32_MASK_USER;
700
701 mask |= is_ri_task(child) ? PSW32_MASK_RI : 0;
702 /* Build a 64 bit psw mask from 31 bit mask. */
703 if ((tmp ^ PSW32_USER_BITS) & ~mask)
704 /* Invalid psw mask. */
705 return -EINVAL;
706 if ((data & PSW32_MASK_ASC) == PSW32_ASC_HOME)
707 /* Invalid address-space-control bits */
708 return -EINVAL;
709 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
710 (regs->psw.mask & PSW_MASK_BA) |
711 (__u64)(tmp & mask) << 32;
712 } else if (addr == (addr_t) &dummy32->regs.psw.addr) {
713 /* Build a 64 bit psw address from 31 bit address. */
714 regs->psw.addr = (__u64) tmp & PSW32_ADDR_INSN;
715 /* Transfer 31 bit amode bit to psw mask. */
716 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_BA) |
717 (__u64)(tmp & PSW32_ADDR_AMODE);
718 } else {
719 /* gpr 0-15 */
720 *(__u32*)((addr_t) &regs->psw + addr*2 + 4) = tmp;
721 }
722 } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) {
723 /*
724 * access registers are stored in the thread structure
725 */
726 offset = addr - (addr_t) &dummy32->regs.acrs;
727 *(__u32*)((addr_t) &child->thread.acrs + offset) = tmp;
728
729 } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) {
730 /*
731 * orig_gpr2 is stored on the kernel stack
732 */
733 *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4) = tmp;
734
735 } else if (addr < (addr_t) &dummy32->regs.fp_regs) {
736 /*
737 * prevent writess of padding hole between
738 * orig_gpr2 and fp_regs on s390.
739 */
740 return 0;
741
742 } else if (addr == (addr_t) &dummy32->regs.fp_regs.fpc) {
743 /*
744 * floating point control reg. is in the thread structure
745 */
746 if (test_fp_ctl(tmp))
747 return -EINVAL;
748 child->thread.fpu.fpc = data;
749
750 } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) {
751 /*
752 * floating point regs. are either in child->thread.fpu
753 * or the child->thread.fpu.vxrs array
754 */
755 offset = addr - (addr_t) &dummy32->regs.fp_regs.fprs;
756 if (MACHINE_HAS_VX)
757 *(__u32 *)((addr_t)
758 child->thread.fpu.vxrs + 2*offset) = tmp;
759 else
760 *(__u32 *)((addr_t)
761 child->thread.fpu.fprs + offset) = tmp;
762
763 } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) {
764 /*
765 * Handle access to the per_info structure.
766 */
767 addr -= (addr_t) &dummy32->regs.per_info;
768 __poke_user_per_compat(child, addr, data);
769 }
770
771 return 0;
772 }
773
774 static int poke_user_compat(struct task_struct *child,
775 addr_t addr, addr_t data)
776 {
777 if (!is_compat_task() || (addr & 3) ||
778 addr > sizeof(struct compat_user) - 3)
779 return -EIO;
780
781 return __poke_user_compat(child, addr, data);
782 }
783
784 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
785 compat_ulong_t caddr, compat_ulong_t cdata)
786 {
787 unsigned long addr = caddr;
788 unsigned long data = cdata;
789 compat_ptrace_area parea;
790 int copied, ret;
791
792 switch (request) {
793 case PTRACE_PEEKUSR:
794 /* read the word at location addr in the USER area. */
795 return peek_user_compat(child, addr, data);
796
797 case PTRACE_POKEUSR:
798 /* write the word at location addr in the USER area */
799 return poke_user_compat(child, addr, data);
800
801 case PTRACE_PEEKUSR_AREA:
802 case PTRACE_POKEUSR_AREA:
803 if (copy_from_user(&parea, (void __force __user *) addr,
804 sizeof(parea)))
805 return -EFAULT;
806 addr = parea.kernel_addr;
807 data = parea.process_addr;
808 copied = 0;
809 while (copied < parea.len) {
810 if (request == PTRACE_PEEKUSR_AREA)
811 ret = peek_user_compat(child, addr, data);
812 else {
813 __u32 utmp;
814 if (get_user(utmp,
815 (__u32 __force __user *) data))
816 return -EFAULT;
817 ret = poke_user_compat(child, addr, utmp);
818 }
819 if (ret)
820 return ret;
821 addr += sizeof(unsigned int);
822 data += sizeof(unsigned int);
823 copied += sizeof(unsigned int);
824 }
825 return 0;
826 case PTRACE_GET_LAST_BREAK:
827 put_user(child->thread.last_break,
828 (unsigned int __user *) data);
829 return 0;
830 }
831 return compat_ptrace_request(child, request, addr, data);
832 }
833 #endif
834
835 asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
836 {
837 unsigned long mask = -1UL;
838
839 /*
840 * The sysc_tracesys code in entry.S stored the system
841 * call number to gprs[2].
842 */
843 if (test_thread_flag(TIF_SYSCALL_TRACE) &&
844 (tracehook_report_syscall_entry(regs) ||
845 regs->gprs[2] >= NR_syscalls)) {
846 /*
847 * Tracing decided this syscall should not happen or the
848 * debugger stored an invalid system call number. Skip
849 * the system call and the system call restart handling.
850 */
851 clear_pt_regs_flag(regs, PIF_SYSCALL);
852 return -1;
853 }
854
855 /* Do the secure computing check after ptrace. */
856 if (secure_computing(NULL)) {
857 /* seccomp failures shouldn't expose any additional code. */
858 return -1;
859 }
860
861 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
862 trace_sys_enter(regs, regs->gprs[2]);
863
864 if (is_compat_task())
865 mask = 0xffffffff;
866
867 audit_syscall_entry(regs->gprs[2], regs->orig_gpr2 & mask,
868 regs->gprs[3] &mask, regs->gprs[4] &mask,
869 regs->gprs[5] &mask);
870
871 return regs->gprs[2];
872 }
873
874 asmlinkage void do_syscall_trace_exit(struct pt_regs *regs)
875 {
876 audit_syscall_exit(regs);
877
878 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
879 trace_sys_exit(regs, regs->gprs[2]);
880
881 if (test_thread_flag(TIF_SYSCALL_TRACE))
882 tracehook_report_syscall_exit(regs, 0);
883 }
884
885 /*
886 * user_regset definitions.
887 */
888
889 static int s390_regs_get(struct task_struct *target,
890 const struct user_regset *regset,
891 unsigned int pos, unsigned int count,
892 void *kbuf, void __user *ubuf)
893 {
894 if (target == current)
895 save_access_regs(target->thread.acrs);
896
897 if (kbuf) {
898 unsigned long *k = kbuf;
899 while (count > 0) {
900 *k++ = __peek_user(target, pos);
901 count -= sizeof(*k);
902 pos += sizeof(*k);
903 }
904 } else {
905 unsigned long __user *u = ubuf;
906 while (count > 0) {
907 if (__put_user(__peek_user(target, pos), u++))
908 return -EFAULT;
909 count -= sizeof(*u);
910 pos += sizeof(*u);
911 }
912 }
913 return 0;
914 }
915
916 static int s390_regs_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 int rc = 0;
922
923 if (target == current)
924 save_access_regs(target->thread.acrs);
925
926 if (kbuf) {
927 const unsigned long *k = kbuf;
928 while (count > 0 && !rc) {
929 rc = __poke_user(target, pos, *k++);
930 count -= sizeof(*k);
931 pos += sizeof(*k);
932 }
933 } else {
934 const unsigned long __user *u = ubuf;
935 while (count > 0 && !rc) {
936 unsigned long word;
937 rc = __get_user(word, u++);
938 if (rc)
939 break;
940 rc = __poke_user(target, pos, word);
941 count -= sizeof(*u);
942 pos += sizeof(*u);
943 }
944 }
945
946 if (rc == 0 && target == current)
947 restore_access_regs(target->thread.acrs);
948
949 return rc;
950 }
951
952 static int s390_fpregs_get(struct task_struct *target,
953 const struct user_regset *regset, unsigned int pos,
954 unsigned int count, void *kbuf, void __user *ubuf)
955 {
956 _s390_fp_regs fp_regs;
957
958 if (target == current)
959 save_fpu_regs();
960
961 fp_regs.fpc = target->thread.fpu.fpc;
962 fpregs_store(&fp_regs, &target->thread.fpu);
963
964 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
965 &fp_regs, 0, -1);
966 }
967
968 static int s390_fpregs_set(struct task_struct *target,
969 const struct user_regset *regset, unsigned int pos,
970 unsigned int count, const void *kbuf,
971 const void __user *ubuf)
972 {
973 int rc = 0;
974 freg_t fprs[__NUM_FPRS];
975
976 if (target == current)
977 save_fpu_regs();
978
979 if (MACHINE_HAS_VX)
980 convert_vx_to_fp(fprs, target->thread.fpu.vxrs);
981 else
982 memcpy(&fprs, target->thread.fpu.fprs, sizeof(fprs));
983
984 /* If setting FPC, must validate it first. */
985 if (count > 0 && pos < offsetof(s390_fp_regs, fprs)) {
986 u32 ufpc[2] = { target->thread.fpu.fpc, 0 };
987 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &ufpc,
988 0, offsetof(s390_fp_regs, fprs));
989 if (rc)
990 return rc;
991 if (ufpc[1] != 0 || test_fp_ctl(ufpc[0]))
992 return -EINVAL;
993 target->thread.fpu.fpc = ufpc[0];
994 }
995
996 if (rc == 0 && count > 0)
997 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
998 fprs, offsetof(s390_fp_regs, fprs), -1);
999 if (rc)
1000 return rc;
1001
1002 if (MACHINE_HAS_VX)
1003 convert_fp_to_vx(target->thread.fpu.vxrs, fprs);
1004 else
1005 memcpy(target->thread.fpu.fprs, &fprs, sizeof(fprs));
1006
1007 return rc;
1008 }
1009
1010 static int s390_last_break_get(struct task_struct *target,
1011 const struct user_regset *regset,
1012 unsigned int pos, unsigned int count,
1013 void *kbuf, void __user *ubuf)
1014 {
1015 if (count > 0) {
1016 if (kbuf) {
1017 unsigned long *k = kbuf;
1018 *k = target->thread.last_break;
1019 } else {
1020 unsigned long __user *u = ubuf;
1021 if (__put_user(target->thread.last_break, u))
1022 return -EFAULT;
1023 }
1024 }
1025 return 0;
1026 }
1027
1028 static int s390_last_break_set(struct task_struct *target,
1029 const struct user_regset *regset,
1030 unsigned int pos, unsigned int count,
1031 const void *kbuf, const void __user *ubuf)
1032 {
1033 return 0;
1034 }
1035
1036 static int s390_tdb_get(struct task_struct *target,
1037 const struct user_regset *regset,
1038 unsigned int pos, unsigned int count,
1039 void *kbuf, void __user *ubuf)
1040 {
1041 struct pt_regs *regs = task_pt_regs(target);
1042 unsigned char *data;
1043
1044 if (!(regs->int_code & 0x200))
1045 return -ENODATA;
1046 data = target->thread.trap_tdb;
1047 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, data, 0, 256);
1048 }
1049
1050 static int s390_tdb_set(struct task_struct *target,
1051 const struct user_regset *regset,
1052 unsigned int pos, unsigned int count,
1053 const void *kbuf, const void __user *ubuf)
1054 {
1055 return 0;
1056 }
1057
1058 static int s390_vxrs_low_get(struct task_struct *target,
1059 const struct user_regset *regset,
1060 unsigned int pos, unsigned int count,
1061 void *kbuf, void __user *ubuf)
1062 {
1063 __u64 vxrs[__NUM_VXRS_LOW];
1064 int i;
1065
1066 if (!MACHINE_HAS_VX)
1067 return -ENODEV;
1068 if (target == current)
1069 save_fpu_regs();
1070 for (i = 0; i < __NUM_VXRS_LOW; i++)
1071 vxrs[i] = *((__u64 *)(target->thread.fpu.vxrs + i) + 1);
1072 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, vxrs, 0, -1);
1073 }
1074
1075 static int s390_vxrs_low_set(struct task_struct *target,
1076 const struct user_regset *regset,
1077 unsigned int pos, unsigned int count,
1078 const void *kbuf, const void __user *ubuf)
1079 {
1080 __u64 vxrs[__NUM_VXRS_LOW];
1081 int i, rc;
1082
1083 if (!MACHINE_HAS_VX)
1084 return -ENODEV;
1085 if (target == current)
1086 save_fpu_regs();
1087
1088 for (i = 0; i < __NUM_VXRS_LOW; i++)
1089 vxrs[i] = *((__u64 *)(target->thread.fpu.vxrs + i) + 1);
1090
1091 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf, vxrs, 0, -1);
1092 if (rc == 0)
1093 for (i = 0; i < __NUM_VXRS_LOW; i++)
1094 *((__u64 *)(target->thread.fpu.vxrs + i) + 1) = vxrs[i];
1095
1096 return rc;
1097 }
1098
1099 static int s390_vxrs_high_get(struct task_struct *target,
1100 const struct user_regset *regset,
1101 unsigned int pos, unsigned int count,
1102 void *kbuf, void __user *ubuf)
1103 {
1104 __vector128 vxrs[__NUM_VXRS_HIGH];
1105
1106 if (!MACHINE_HAS_VX)
1107 return -ENODEV;
1108 if (target == current)
1109 save_fpu_regs();
1110 memcpy(vxrs, target->thread.fpu.vxrs + __NUM_VXRS_LOW, sizeof(vxrs));
1111
1112 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, vxrs, 0, -1);
1113 }
1114
1115 static int s390_vxrs_high_set(struct task_struct *target,
1116 const struct user_regset *regset,
1117 unsigned int pos, unsigned int count,
1118 const void *kbuf, const void __user *ubuf)
1119 {
1120 int rc;
1121
1122 if (!MACHINE_HAS_VX)
1123 return -ENODEV;
1124 if (target == current)
1125 save_fpu_regs();
1126
1127 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1128 target->thread.fpu.vxrs + __NUM_VXRS_LOW, 0, -1);
1129 return rc;
1130 }
1131
1132 static int s390_system_call_get(struct task_struct *target,
1133 const struct user_regset *regset,
1134 unsigned int pos, unsigned int count,
1135 void *kbuf, void __user *ubuf)
1136 {
1137 unsigned int *data = &target->thread.system_call;
1138 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
1139 data, 0, sizeof(unsigned int));
1140 }
1141
1142 static int s390_system_call_set(struct task_struct *target,
1143 const struct user_regset *regset,
1144 unsigned int pos, unsigned int count,
1145 const void *kbuf, const void __user *ubuf)
1146 {
1147 unsigned int *data = &target->thread.system_call;
1148 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1149 data, 0, sizeof(unsigned int));
1150 }
1151
1152 static int s390_gs_cb_get(struct task_struct *target,
1153 const struct user_regset *regset,
1154 unsigned int pos, unsigned int count,
1155 void *kbuf, void __user *ubuf)
1156 {
1157 struct gs_cb *data = target->thread.gs_cb;
1158
1159 if (!MACHINE_HAS_GS)
1160 return -ENODEV;
1161 if (!data)
1162 return -ENODATA;
1163 if (target == current)
1164 save_gs_cb(data);
1165 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
1166 data, 0, sizeof(struct gs_cb));
1167 }
1168
1169 static int s390_gs_cb_set(struct task_struct *target,
1170 const struct user_regset *regset,
1171 unsigned int pos, unsigned int count,
1172 const void *kbuf, const void __user *ubuf)
1173 {
1174 struct gs_cb *data = target->thread.gs_cb;
1175 int rc;
1176
1177 if (!MACHINE_HAS_GS)
1178 return -ENODEV;
1179 if (!data) {
1180 data = kzalloc(sizeof(*data), GFP_KERNEL);
1181 if (!data)
1182 return -ENOMEM;
1183 data->gsd = 25;
1184 target->thread.gs_cb = data;
1185 if (target == current)
1186 __ctl_set_bit(2, 4);
1187 } else if (target == current) {
1188 save_gs_cb(data);
1189 }
1190 rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1191 data, 0, sizeof(struct gs_cb));
1192 if (target == current)
1193 restore_gs_cb(data);
1194 return rc;
1195 }
1196
1197 static int s390_gs_bc_get(struct task_struct *target,
1198 const struct user_regset *regset,
1199 unsigned int pos, unsigned int count,
1200 void *kbuf, void __user *ubuf)
1201 {
1202 struct gs_cb *data = target->thread.gs_bc_cb;
1203
1204 if (!MACHINE_HAS_GS)
1205 return -ENODEV;
1206 if (!data)
1207 return -ENODATA;
1208 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
1209 data, 0, sizeof(struct gs_cb));
1210 }
1211
1212 static int s390_gs_bc_set(struct task_struct *target,
1213 const struct user_regset *regset,
1214 unsigned int pos, unsigned int count,
1215 const void *kbuf, const void __user *ubuf)
1216 {
1217 struct gs_cb *data = target->thread.gs_bc_cb;
1218
1219 if (!MACHINE_HAS_GS)
1220 return -ENODEV;
1221 if (!data) {
1222 data = kzalloc(sizeof(*data), GFP_KERNEL);
1223 if (!data)
1224 return -ENOMEM;
1225 target->thread.gs_bc_cb = data;
1226 }
1227 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1228 data, 0, sizeof(struct gs_cb));
1229 }
1230
1231 static const struct user_regset s390_regsets[] = {
1232 {
1233 .core_note_type = NT_PRSTATUS,
1234 .n = sizeof(s390_regs) / sizeof(long),
1235 .size = sizeof(long),
1236 .align = sizeof(long),
1237 .get = s390_regs_get,
1238 .set = s390_regs_set,
1239 },
1240 {
1241 .core_note_type = NT_PRFPREG,
1242 .n = sizeof(s390_fp_regs) / sizeof(long),
1243 .size = sizeof(long),
1244 .align = sizeof(long),
1245 .get = s390_fpregs_get,
1246 .set = s390_fpregs_set,
1247 },
1248 {
1249 .core_note_type = NT_S390_SYSTEM_CALL,
1250 .n = 1,
1251 .size = sizeof(unsigned int),
1252 .align = sizeof(unsigned int),
1253 .get = s390_system_call_get,
1254 .set = s390_system_call_set,
1255 },
1256 {
1257 .core_note_type = NT_S390_LAST_BREAK,
1258 .n = 1,
1259 .size = sizeof(long),
1260 .align = sizeof(long),
1261 .get = s390_last_break_get,
1262 .set = s390_last_break_set,
1263 },
1264 {
1265 .core_note_type = NT_S390_TDB,
1266 .n = 1,
1267 .size = 256,
1268 .align = 1,
1269 .get = s390_tdb_get,
1270 .set = s390_tdb_set,
1271 },
1272 {
1273 .core_note_type = NT_S390_VXRS_LOW,
1274 .n = __NUM_VXRS_LOW,
1275 .size = sizeof(__u64),
1276 .align = sizeof(__u64),
1277 .get = s390_vxrs_low_get,
1278 .set = s390_vxrs_low_set,
1279 },
1280 {
1281 .core_note_type = NT_S390_VXRS_HIGH,
1282 .n = __NUM_VXRS_HIGH,
1283 .size = sizeof(__vector128),
1284 .align = sizeof(__vector128),
1285 .get = s390_vxrs_high_get,
1286 .set = s390_vxrs_high_set,
1287 },
1288 {
1289 .core_note_type = NT_S390_GS_CB,
1290 .n = sizeof(struct gs_cb) / sizeof(__u64),
1291 .size = sizeof(__u64),
1292 .align = sizeof(__u64),
1293 .get = s390_gs_cb_get,
1294 .set = s390_gs_cb_set,
1295 },
1296 {
1297 .core_note_type = NT_S390_GS_BC,
1298 .n = sizeof(struct gs_cb) / sizeof(__u64),
1299 .size = sizeof(__u64),
1300 .align = sizeof(__u64),
1301 .get = s390_gs_bc_get,
1302 .set = s390_gs_bc_set,
1303 },
1304 };
1305
1306 static const struct user_regset_view user_s390_view = {
1307 .name = UTS_MACHINE,
1308 .e_machine = EM_S390,
1309 .regsets = s390_regsets,
1310 .n = ARRAY_SIZE(s390_regsets)
1311 };
1312
1313 #ifdef CONFIG_COMPAT
1314 static int s390_compat_regs_get(struct task_struct *target,
1315 const struct user_regset *regset,
1316 unsigned int pos, unsigned int count,
1317 void *kbuf, void __user *ubuf)
1318 {
1319 if (target == current)
1320 save_access_regs(target->thread.acrs);
1321
1322 if (kbuf) {
1323 compat_ulong_t *k = kbuf;
1324 while (count > 0) {
1325 *k++ = __peek_user_compat(target, pos);
1326 count -= sizeof(*k);
1327 pos += sizeof(*k);
1328 }
1329 } else {
1330 compat_ulong_t __user *u = ubuf;
1331 while (count > 0) {
1332 if (__put_user(__peek_user_compat(target, pos), u++))
1333 return -EFAULT;
1334 count -= sizeof(*u);
1335 pos += sizeof(*u);
1336 }
1337 }
1338 return 0;
1339 }
1340
1341 static int s390_compat_regs_set(struct task_struct *target,
1342 const struct user_regset *regset,
1343 unsigned int pos, unsigned int count,
1344 const void *kbuf, const void __user *ubuf)
1345 {
1346 int rc = 0;
1347
1348 if (target == current)
1349 save_access_regs(target->thread.acrs);
1350
1351 if (kbuf) {
1352 const compat_ulong_t *k = kbuf;
1353 while (count > 0 && !rc) {
1354 rc = __poke_user_compat(target, pos, *k++);
1355 count -= sizeof(*k);
1356 pos += sizeof(*k);
1357 }
1358 } else {
1359 const compat_ulong_t __user *u = ubuf;
1360 while (count > 0 && !rc) {
1361 compat_ulong_t word;
1362 rc = __get_user(word, u++);
1363 if (rc)
1364 break;
1365 rc = __poke_user_compat(target, pos, word);
1366 count -= sizeof(*u);
1367 pos += sizeof(*u);
1368 }
1369 }
1370
1371 if (rc == 0 && target == current)
1372 restore_access_regs(target->thread.acrs);
1373
1374 return rc;
1375 }
1376
1377 static int s390_compat_regs_high_get(struct task_struct *target,
1378 const struct user_regset *regset,
1379 unsigned int pos, unsigned int count,
1380 void *kbuf, void __user *ubuf)
1381 {
1382 compat_ulong_t *gprs_high;
1383
1384 gprs_high = (compat_ulong_t *)
1385 &task_pt_regs(target)->gprs[pos / sizeof(compat_ulong_t)];
1386 if (kbuf) {
1387 compat_ulong_t *k = kbuf;
1388 while (count > 0) {
1389 *k++ = *gprs_high;
1390 gprs_high += 2;
1391 count -= sizeof(*k);
1392 }
1393 } else {
1394 compat_ulong_t __user *u = ubuf;
1395 while (count > 0) {
1396 if (__put_user(*gprs_high, u++))
1397 return -EFAULT;
1398 gprs_high += 2;
1399 count -= sizeof(*u);
1400 }
1401 }
1402 return 0;
1403 }
1404
1405 static int s390_compat_regs_high_set(struct task_struct *target,
1406 const struct user_regset *regset,
1407 unsigned int pos, unsigned int count,
1408 const void *kbuf, const void __user *ubuf)
1409 {
1410 compat_ulong_t *gprs_high;
1411 int rc = 0;
1412
1413 gprs_high = (compat_ulong_t *)
1414 &task_pt_regs(target)->gprs[pos / sizeof(compat_ulong_t)];
1415 if (kbuf) {
1416 const compat_ulong_t *k = kbuf;
1417 while (count > 0) {
1418 *gprs_high = *k++;
1419 *gprs_high += 2;
1420 count -= sizeof(*k);
1421 }
1422 } else {
1423 const compat_ulong_t __user *u = ubuf;
1424 while (count > 0 && !rc) {
1425 unsigned long word;
1426 rc = __get_user(word, u++);
1427 if (rc)
1428 break;
1429 *gprs_high = word;
1430 *gprs_high += 2;
1431 count -= sizeof(*u);
1432 }
1433 }
1434
1435 return rc;
1436 }
1437
1438 static int s390_compat_last_break_get(struct task_struct *target,
1439 const struct user_regset *regset,
1440 unsigned int pos, unsigned int count,
1441 void *kbuf, void __user *ubuf)
1442 {
1443 compat_ulong_t last_break;
1444
1445 if (count > 0) {
1446 last_break = target->thread.last_break;
1447 if (kbuf) {
1448 unsigned long *k = kbuf;
1449 *k = last_break;
1450 } else {
1451 unsigned long __user *u = ubuf;
1452 if (__put_user(last_break, u))
1453 return -EFAULT;
1454 }
1455 }
1456 return 0;
1457 }
1458
1459 static int s390_compat_last_break_set(struct task_struct *target,
1460 const struct user_regset *regset,
1461 unsigned int pos, unsigned int count,
1462 const void *kbuf, const void __user *ubuf)
1463 {
1464 return 0;
1465 }
1466
1467 static const struct user_regset s390_compat_regsets[] = {
1468 {
1469 .core_note_type = NT_PRSTATUS,
1470 .n = sizeof(s390_compat_regs) / sizeof(compat_long_t),
1471 .size = sizeof(compat_long_t),
1472 .align = sizeof(compat_long_t),
1473 .get = s390_compat_regs_get,
1474 .set = s390_compat_regs_set,
1475 },
1476 {
1477 .core_note_type = NT_PRFPREG,
1478 .n = sizeof(s390_fp_regs) / sizeof(compat_long_t),
1479 .size = sizeof(compat_long_t),
1480 .align = sizeof(compat_long_t),
1481 .get = s390_fpregs_get,
1482 .set = s390_fpregs_set,
1483 },
1484 {
1485 .core_note_type = NT_S390_SYSTEM_CALL,
1486 .n = 1,
1487 .size = sizeof(compat_uint_t),
1488 .align = sizeof(compat_uint_t),
1489 .get = s390_system_call_get,
1490 .set = s390_system_call_set,
1491 },
1492 {
1493 .core_note_type = NT_S390_LAST_BREAK,
1494 .n = 1,
1495 .size = sizeof(long),
1496 .align = sizeof(long),
1497 .get = s390_compat_last_break_get,
1498 .set = s390_compat_last_break_set,
1499 },
1500 {
1501 .core_note_type = NT_S390_TDB,
1502 .n = 1,
1503 .size = 256,
1504 .align = 1,
1505 .get = s390_tdb_get,
1506 .set = s390_tdb_set,
1507 },
1508 {
1509 .core_note_type = NT_S390_VXRS_LOW,
1510 .n = __NUM_VXRS_LOW,
1511 .size = sizeof(__u64),
1512 .align = sizeof(__u64),
1513 .get = s390_vxrs_low_get,
1514 .set = s390_vxrs_low_set,
1515 },
1516 {
1517 .core_note_type = NT_S390_VXRS_HIGH,
1518 .n = __NUM_VXRS_HIGH,
1519 .size = sizeof(__vector128),
1520 .align = sizeof(__vector128),
1521 .get = s390_vxrs_high_get,
1522 .set = s390_vxrs_high_set,
1523 },
1524 {
1525 .core_note_type = NT_S390_HIGH_GPRS,
1526 .n = sizeof(s390_compat_regs_high) / sizeof(compat_long_t),
1527 .size = sizeof(compat_long_t),
1528 .align = sizeof(compat_long_t),
1529 .get = s390_compat_regs_high_get,
1530 .set = s390_compat_regs_high_set,
1531 },
1532 {
1533 .core_note_type = NT_S390_GS_CB,
1534 .n = sizeof(struct gs_cb) / sizeof(__u64),
1535 .size = sizeof(__u64),
1536 .align = sizeof(__u64),
1537 .get = s390_gs_cb_get,
1538 .set = s390_gs_cb_set,
1539 },
1540 };
1541
1542 static const struct user_regset_view user_s390_compat_view = {
1543 .name = "s390",
1544 .e_machine = EM_S390,
1545 .regsets = s390_compat_regsets,
1546 .n = ARRAY_SIZE(s390_compat_regsets)
1547 };
1548 #endif
1549
1550 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
1551 {
1552 #ifdef CONFIG_COMPAT
1553 if (test_tsk_thread_flag(task, TIF_31BIT))
1554 return &user_s390_compat_view;
1555 #endif
1556 return &user_s390_view;
1557 }
1558
1559 static const char *gpr_names[NUM_GPRS] = {
1560 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1561 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1562 };
1563
1564 unsigned long regs_get_register(struct pt_regs *regs, unsigned int offset)
1565 {
1566 if (offset >= NUM_GPRS)
1567 return 0;
1568 return regs->gprs[offset];
1569 }
1570
1571 int regs_query_register_offset(const char *name)
1572 {
1573 unsigned long offset;
1574
1575 if (!name || *name != 'r')
1576 return -EINVAL;
1577 if (kstrtoul(name + 1, 10, &offset))
1578 return -EINVAL;
1579 if (offset >= NUM_GPRS)
1580 return -EINVAL;
1581 return offset;
1582 }
1583
1584 const char *regs_query_register_name(unsigned int offset)
1585 {
1586 if (offset >= NUM_GPRS)
1587 return NULL;
1588 return gpr_names[offset];
1589 }
1590
1591 static int regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
1592 {
1593 unsigned long ksp = kernel_stack_pointer(regs);
1594
1595 return (addr & ~(THREAD_SIZE - 1)) == (ksp & ~(THREAD_SIZE - 1));
1596 }
1597
1598 /**
1599 * regs_get_kernel_stack_nth() - get Nth entry of the stack
1600 * @regs:pt_regs which contains kernel stack pointer.
1601 * @n:stack entry number.
1602 *
1603 * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
1604 * is specifined by @regs. If the @n th entry is NOT in the kernel stack,
1605 * this returns 0.
1606 */
1607 unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
1608 {
1609 unsigned long addr;
1610
1611 addr = kernel_stack_pointer(regs) + n * sizeof(long);
1612 if (!regs_within_kernel_stack(regs, addr))
1613 return 0;
1614 return *(unsigned long *)addr;
1615 }
Linux with added FPC-III support