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