arch/s390/kernel/ptrace.c

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