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