Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  Ptrace user space interface.
0004  *
0005  *    Copyright IBM Corp. 1999, 2010
0006  *    Author(s): Denis Joseph Barrow
0007  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
0008  */
0009 
0010 #include "asm/ptrace.h"
0011 #include <linux/kernel.h>
0012 #include <linux/sched.h>
0013 #include <linux/sched/task_stack.h>
0014 #include <linux/mm.h>
0015 #include <linux/smp.h>
0016 #include <linux/errno.h>
0017 #include <linux/ptrace.h>
0018 #include <linux/user.h>
0019 #include <linux/security.h>
0020 #include <linux/audit.h>
0021 #include <linux/signal.h>
0022 #include <linux/elf.h>
0023 #include <linux/regset.h>
0024 #include <linux/seccomp.h>
0025 #include <linux/compat.h>
0026 #include <trace/syscall.h>
0027 #include <asm/page.h>
0028 #include <linux/uaccess.h>
0029 #include <asm/unistd.h>
0030 #include <asm/switch_to.h>
0031 #include <asm/runtime_instr.h>
0032 #include <asm/facility.h>
0033 
0034 #include "entry.h"
0035 
0036 #ifdef CONFIG_COMPAT
0037 #include "compat_ptrace.h"
0038 #endif
0039 
0040 void update_cr_regs(struct task_struct *task)
0041 {
0042     struct pt_regs *regs = task_pt_regs(task);
0043     struct thread_struct *thread = &task->thread;
0044     struct per_regs old, new;
0045     union ctlreg0 cr0_old, cr0_new;
0046     union ctlreg2 cr2_old, cr2_new;
0047     int cr0_changed, cr2_changed;
0048 
0049     __ctl_store(cr0_old.val, 0, 0);
0050     __ctl_store(cr2_old.val, 2, 2);
0051     cr0_new = cr0_old;
0052     cr2_new = cr2_old;
0053     /* Take care of the enable/disable of transactional execution. */
0054     if (MACHINE_HAS_TE) {
0055         /* Set or clear transaction execution TXC bit 8. */
0056         cr0_new.tcx = 1;
0057         if (task->thread.per_flags & PER_FLAG_NO_TE)
0058             cr0_new.tcx = 0;
0059         /* Set or clear transaction execution TDC bits 62 and 63. */
0060         cr2_new.tdc = 0;
0061         if (task->thread.per_flags & PER_FLAG_TE_ABORT_RAND) {
0062             if (task->thread.per_flags & PER_FLAG_TE_ABORT_RAND_TEND)
0063                 cr2_new.tdc = 1;
0064             else
0065                 cr2_new.tdc = 2;
0066         }
0067     }
0068     /* Take care of enable/disable of guarded storage. */
0069     if (MACHINE_HAS_GS) {
0070         cr2_new.gse = 0;
0071         if (task->thread.gs_cb)
0072             cr2_new.gse = 1;
0073     }
0074     /* Load control register 0/2 iff changed */
0075     cr0_changed = cr0_new.val != cr0_old.val;
0076     cr2_changed = cr2_new.val != cr2_old.val;
0077     if (cr0_changed)
0078         __ctl_load(cr0_new.val, 0, 0);
0079     if (cr2_changed)
0080         __ctl_load(cr2_new.val, 2, 2);
0081     /* Copy user specified PER registers */
0082     new.control = thread->per_user.control;
0083     new.start = thread->per_user.start;
0084     new.end = thread->per_user.end;
0085 
0086     /* merge TIF_SINGLE_STEP into user specified PER registers. */
0087     if (test_tsk_thread_flag(task, TIF_SINGLE_STEP) ||
0088         test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP)) {
0089         if (test_tsk_thread_flag(task, TIF_BLOCK_STEP))
0090             new.control |= PER_EVENT_BRANCH;
0091         else
0092             new.control |= PER_EVENT_IFETCH;
0093         new.control |= PER_CONTROL_SUSPENSION;
0094         new.control |= PER_EVENT_TRANSACTION_END;
0095         if (test_tsk_thread_flag(task, TIF_UPROBE_SINGLESTEP))
0096             new.control |= PER_EVENT_IFETCH;
0097         new.start = 0;
0098         new.end = -1UL;
0099     }
0100 
0101     /* Take care of the PER enablement bit in the PSW. */
0102     if (!(new.control & PER_EVENT_MASK)) {
0103         regs->psw.mask &= ~PSW_MASK_PER;
0104         return;
0105     }
0106     regs->psw.mask |= PSW_MASK_PER;
0107     __ctl_store(old, 9, 11);
0108     if (memcmp(&new, &old, sizeof(struct per_regs)) != 0)
0109         __ctl_load(new, 9, 11);
0110 }
0111 
0112 void user_enable_single_step(struct task_struct *task)
0113 {
0114     clear_tsk_thread_flag(task, TIF_BLOCK_STEP);
0115     set_tsk_thread_flag(task, TIF_SINGLE_STEP);
0116 }
0117 
0118 void user_disable_single_step(struct task_struct *task)
0119 {
0120     clear_tsk_thread_flag(task, TIF_BLOCK_STEP);
0121     clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
0122 }
0123 
0124 void user_enable_block_step(struct task_struct *task)
0125 {
0126     set_tsk_thread_flag(task, TIF_SINGLE_STEP);
0127     set_tsk_thread_flag(task, TIF_BLOCK_STEP);
0128 }
0129 
0130 /*
0131  * Called by kernel/ptrace.c when detaching..
0132  *
0133  * Clear all debugging related fields.
0134  */
0135 void ptrace_disable(struct task_struct *task)
0136 {
0137     memset(&task->thread.per_user, 0, sizeof(task->thread.per_user));
0138     memset(&task->thread.per_event, 0, sizeof(task->thread.per_event));
0139     clear_tsk_thread_flag(task, TIF_SINGLE_STEP);
0140     clear_tsk_thread_flag(task, TIF_PER_TRAP);
0141     task->thread.per_flags = 0;
0142 }
0143 
0144 #define __ADDR_MASK 7
0145 
0146 static inline unsigned long __peek_user_per(struct task_struct *child,
0147                         addr_t addr)
0148 {
0149     if (addr == offsetof(struct per_struct_kernel, cr9))
0150         /* Control bits of the active per set. */
0151         return test_thread_flag(TIF_SINGLE_STEP) ?
0152             PER_EVENT_IFETCH : child->thread.per_user.control;
0153     else if (addr == offsetof(struct per_struct_kernel, cr10))
0154         /* Start address of the active per set. */
0155         return test_thread_flag(TIF_SINGLE_STEP) ?
0156             0 : child->thread.per_user.start;
0157     else if (addr == offsetof(struct per_struct_kernel, cr11))
0158         /* End address of the active per set. */
0159         return test_thread_flag(TIF_SINGLE_STEP) ?
0160             -1UL : child->thread.per_user.end;
0161     else if (addr == offsetof(struct per_struct_kernel, bits))
0162         /* Single-step bit. */
0163         return test_thread_flag(TIF_SINGLE_STEP) ?
0164             (1UL << (BITS_PER_LONG - 1)) : 0;
0165     else if (addr == offsetof(struct per_struct_kernel, starting_addr))
0166         /* Start address of the user specified per set. */
0167         return child->thread.per_user.start;
0168     else if (addr == offsetof(struct per_struct_kernel, ending_addr))
0169         /* End address of the user specified per set. */
0170         return child->thread.per_user.end;
0171     else if (addr == offsetof(struct per_struct_kernel, perc_atmid))
0172         /* PER code, ATMID and AI of the last PER trap */
0173         return (unsigned long)
0174             child->thread.per_event.cause << (BITS_PER_LONG - 16);
0175     else if (addr == offsetof(struct per_struct_kernel, address))
0176         /* Address of the last PER trap */
0177         return child->thread.per_event.address;
0178     else if (addr == offsetof(struct per_struct_kernel, access_id))
0179         /* Access id of the last PER trap */
0180         return (unsigned long)
0181             child->thread.per_event.paid << (BITS_PER_LONG - 8);
0182     return 0;
0183 }
0184 
0185 /*
0186  * Read the word at offset addr from the user area of a process. The
0187  * trouble here is that the information is littered over different
0188  * locations. The process registers are found on the kernel stack,
0189  * the floating point stuff and the trace settings are stored in
0190  * the task structure. In addition the different structures in
0191  * struct user contain pad bytes that should be read as zeroes.
0192  * Lovely...
0193  */
0194 static unsigned long __peek_user(struct task_struct *child, addr_t addr)
0195 {
0196     addr_t offset, tmp;
0197 
0198     if (addr < offsetof(struct user, regs.acrs)) {
0199         /*
0200          * psw and gprs are stored on the stack
0201          */
0202         tmp = *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr);
0203         if (addr == offsetof(struct user, regs.psw.mask)) {
0204             /* Return a clean psw mask. */
0205             tmp &= PSW_MASK_USER | PSW_MASK_RI;
0206             tmp |= PSW_USER_BITS;
0207         }
0208 
0209     } else if (addr < offsetof(struct user, regs.orig_gpr2)) {
0210         /*
0211          * access registers are stored in the thread structure
0212          */
0213         offset = addr - offsetof(struct user, regs.acrs);
0214         /*
0215          * Very special case: old & broken 64 bit gdb reading
0216          * from acrs[15]. Result is a 64 bit value. Read the
0217          * 32 bit acrs[15] value and shift it by 32. Sick...
0218          */
0219         if (addr == offsetof(struct user, regs.acrs[15]))
0220             tmp = ((unsigned long) child->thread.acrs[15]) << 32;
0221         else
0222             tmp = *(addr_t *)((addr_t) &child->thread.acrs + offset);
0223 
0224     } else if (addr == offsetof(struct user, regs.orig_gpr2)) {
0225         /*
0226          * orig_gpr2 is stored on the kernel stack
0227          */
0228         tmp = (addr_t) task_pt_regs(child)->orig_gpr2;
0229 
0230     } else if (addr < offsetof(struct user, regs.fp_regs)) {
0231         /*
0232          * prevent reads of padding hole between
0233          * orig_gpr2 and fp_regs on s390.
0234          */
0235         tmp = 0;
0236 
0237     } else if (addr == offsetof(struct user, regs.fp_regs.fpc)) {
0238         /*
0239          * floating point control reg. is in the thread structure
0240          */
0241         tmp = child->thread.fpu.fpc;
0242         tmp <<= BITS_PER_LONG - 32;
0243 
0244     } else if (addr < offsetof(struct user, regs.fp_regs) + sizeof(s390_fp_regs)) {
0245         /*
0246          * floating point regs. are either in child->thread.fpu
0247          * or the child->thread.fpu.vxrs array
0248          */
0249         offset = addr - offsetof(struct user, regs.fp_regs.fprs);
0250         if (MACHINE_HAS_VX)
0251             tmp = *(addr_t *)
0252                    ((addr_t) child->thread.fpu.vxrs + 2*offset);
0253         else
0254             tmp = *(addr_t *)
0255                    ((addr_t) child->thread.fpu.fprs + offset);
0256 
0257     } else if (addr < offsetof(struct user, regs.per_info) + sizeof(per_struct)) {
0258         /*
0259          * Handle access to the per_info structure.
0260          */
0261         addr -= offsetof(struct user, regs.per_info);
0262         tmp = __peek_user_per(child, addr);
0263 
0264     } else
0265         tmp = 0;
0266 
0267     return tmp;
0268 }
0269 
0270 static int
0271 peek_user(struct task_struct *child, addr_t addr, addr_t data)
0272 {
0273     addr_t tmp, mask;
0274 
0275     /*
0276      * Stupid gdb peeks/pokes the access registers in 64 bit with
0277      * an alignment of 4. Programmers from hell...
0278      */
0279     mask = __ADDR_MASK;
0280     if (addr >= offsetof(struct user, regs.acrs) &&
0281         addr < offsetof(struct user, regs.orig_gpr2))
0282         mask = 3;
0283     if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
0284         return -EIO;
0285 
0286     tmp = __peek_user(child, addr);
0287     return put_user(tmp, (addr_t __user *) data);
0288 }
0289 
0290 static inline void __poke_user_per(struct task_struct *child,
0291                    addr_t addr, addr_t data)
0292 {
0293     /*
0294      * There are only three fields in the per_info struct that the
0295      * debugger user can write to.
0296      * 1) cr9: the debugger wants to set a new PER event mask
0297      * 2) starting_addr: the debugger wants to set a new starting
0298      *    address to use with the PER event mask.
0299      * 3) ending_addr: the debugger wants to set a new ending
0300      *    address to use with the PER event mask.
0301      * The user specified PER event mask and the start and end
0302      * addresses are used only if single stepping is not in effect.
0303      * Writes to any other field in per_info are ignored.
0304      */
0305     if (addr == offsetof(struct per_struct_kernel, cr9))
0306         /* PER event mask of the user specified per set. */
0307         child->thread.per_user.control =
0308             data & (PER_EVENT_MASK | PER_CONTROL_MASK);
0309     else if (addr == offsetof(struct per_struct_kernel, starting_addr))
0310         /* Starting address of the user specified per set. */
0311         child->thread.per_user.start = data;
0312     else if (addr == offsetof(struct per_struct_kernel, ending_addr))
0313         /* Ending address of the user specified per set. */
0314         child->thread.per_user.end = data;
0315 }
0316 
0317 /*
0318  * Write a word to the user area of a process at location addr. This
0319  * operation does have an additional problem compared to peek_user.
0320  * Stores to the program status word and on the floating point
0321  * control register needs to get checked for validity.
0322  */
0323 static int __poke_user(struct task_struct *child, addr_t addr, addr_t data)
0324 {
0325     addr_t offset;
0326 
0327 
0328     if (addr < offsetof(struct user, regs.acrs)) {
0329         struct pt_regs *regs = task_pt_regs(child);
0330         /*
0331          * psw and gprs are stored on the stack
0332          */
0333         if (addr == offsetof(struct user, regs.psw.mask)) {
0334             unsigned long mask = PSW_MASK_USER;
0335 
0336             mask |= is_ri_task(child) ? PSW_MASK_RI : 0;
0337             if ((data ^ PSW_USER_BITS) & ~mask)
0338                 /* Invalid psw mask. */
0339                 return -EINVAL;
0340             if ((data & PSW_MASK_ASC) == PSW_ASC_HOME)
0341                 /* Invalid address-space-control bits */
0342                 return -EINVAL;
0343             if ((data & PSW_MASK_EA) && !(data & PSW_MASK_BA))
0344                 /* Invalid addressing mode bits */
0345                 return -EINVAL;
0346         }
0347 
0348         if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
0349             addr == offsetof(struct user, regs.gprs[2])) {
0350             struct pt_regs *regs = task_pt_regs(child);
0351 
0352             regs->int_code = 0x20000 | (data & 0xffff);
0353         }
0354         *(addr_t *)((addr_t) &regs->psw + addr) = data;
0355     } else if (addr < offsetof(struct user, regs.orig_gpr2)) {
0356         /*
0357          * access registers are stored in the thread structure
0358          */
0359         offset = addr - offsetof(struct user, regs.acrs);
0360         /*
0361          * Very special case: old & broken 64 bit gdb writing
0362          * to acrs[15] with a 64 bit value. Ignore the lower
0363          * half of the value and write the upper 32 bit to
0364          * acrs[15]. Sick...
0365          */
0366         if (addr == offsetof(struct user, regs.acrs[15]))
0367             child->thread.acrs[15] = (unsigned int) (data >> 32);
0368         else
0369             *(addr_t *)((addr_t) &child->thread.acrs + offset) = data;
0370 
0371     } else if (addr == offsetof(struct user, regs.orig_gpr2)) {
0372         /*
0373          * orig_gpr2 is stored on the kernel stack
0374          */
0375         task_pt_regs(child)->orig_gpr2 = data;
0376 
0377     } else if (addr < offsetof(struct user, regs.fp_regs)) {
0378         /*
0379          * prevent writes of padding hole between
0380          * orig_gpr2 and fp_regs on s390.
0381          */
0382         return 0;
0383 
0384     } else if (addr == offsetof(struct user, regs.fp_regs.fpc)) {
0385         /*
0386          * floating point control reg. is in the thread structure
0387          */
0388         if ((unsigned int) data != 0 ||
0389             test_fp_ctl(data >> (BITS_PER_LONG - 32)))
0390             return -EINVAL;
0391         child->thread.fpu.fpc = data >> (BITS_PER_LONG - 32);
0392 
0393     } else if (addr < offsetof(struct user, regs.fp_regs) + sizeof(s390_fp_regs)) {
0394         /*
0395          * floating point regs. are either in child->thread.fpu
0396          * or the child->thread.fpu.vxrs array
0397          */
0398         offset = addr - offsetof(struct user, regs.fp_regs.fprs);
0399         if (MACHINE_HAS_VX)
0400             *(addr_t *)((addr_t)
0401                 child->thread.fpu.vxrs + 2*offset) = data;
0402         else
0403             *(addr_t *)((addr_t)
0404                 child->thread.fpu.fprs + offset) = data;
0405 
0406     } else if (addr < offsetof(struct user, regs.per_info) + sizeof(per_struct)) {
0407         /*
0408          * Handle access to the per_info structure.
0409          */
0410         addr -= offsetof(struct user, regs.per_info);
0411         __poke_user_per(child, addr, data);
0412 
0413     }
0414 
0415     return 0;
0416 }
0417 
0418 static int poke_user(struct task_struct *child, addr_t addr, addr_t data)
0419 {
0420     addr_t mask;
0421 
0422     /*
0423      * Stupid gdb peeks/pokes the access registers in 64 bit with
0424      * an alignment of 4. Programmers from hell indeed...
0425      */
0426     mask = __ADDR_MASK;
0427     if (addr >= offsetof(struct user, regs.acrs) &&
0428         addr < offsetof(struct user, regs.orig_gpr2))
0429         mask = 3;
0430     if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK)
0431         return -EIO;
0432 
0433     return __poke_user(child, addr, data);
0434 }
0435 
0436 long arch_ptrace(struct task_struct *child, long request,
0437          unsigned long addr, unsigned long data)
0438 {
0439     ptrace_area parea; 
0440     int copied, ret;
0441 
0442     switch (request) {
0443     case PTRACE_PEEKUSR:
0444         /* read the word at location addr in the USER area. */
0445         return peek_user(child, addr, data);
0446 
0447     case PTRACE_POKEUSR:
0448         /* write the word at location addr in the USER area */
0449         return poke_user(child, addr, data);
0450 
0451     case PTRACE_PEEKUSR_AREA:
0452     case PTRACE_POKEUSR_AREA:
0453         if (copy_from_user(&parea, (void __force __user *) addr,
0454                             sizeof(parea)))
0455             return -EFAULT;
0456         addr = parea.kernel_addr;
0457         data = parea.process_addr;
0458         copied = 0;
0459         while (copied < parea.len) {
0460             if (request == PTRACE_PEEKUSR_AREA)
0461                 ret = peek_user(child, addr, data);
0462             else {
0463                 addr_t utmp;
0464                 if (get_user(utmp,
0465                          (addr_t __force __user *) data))
0466                     return -EFAULT;
0467                 ret = poke_user(child, addr, utmp);
0468             }
0469             if (ret)
0470                 return ret;
0471             addr += sizeof(unsigned long);
0472             data += sizeof(unsigned long);
0473             copied += sizeof(unsigned long);
0474         }
0475         return 0;
0476     case PTRACE_GET_LAST_BREAK:
0477         put_user(child->thread.last_break,
0478              (unsigned long __user *) data);
0479         return 0;
0480     case PTRACE_ENABLE_TE:
0481         if (!MACHINE_HAS_TE)
0482             return -EIO;
0483         child->thread.per_flags &= ~PER_FLAG_NO_TE;
0484         return 0;
0485     case PTRACE_DISABLE_TE:
0486         if (!MACHINE_HAS_TE)
0487             return -EIO;
0488         child->thread.per_flags |= PER_FLAG_NO_TE;
0489         child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND;
0490         return 0;
0491     case PTRACE_TE_ABORT_RAND:
0492         if (!MACHINE_HAS_TE || (child->thread.per_flags & PER_FLAG_NO_TE))
0493             return -EIO;
0494         switch (data) {
0495         case 0UL:
0496             child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND;
0497             break;
0498         case 1UL:
0499             child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND;
0500             child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND_TEND;
0501             break;
0502         case 2UL:
0503             child->thread.per_flags |= PER_FLAG_TE_ABORT_RAND;
0504             child->thread.per_flags &= ~PER_FLAG_TE_ABORT_RAND_TEND;
0505             break;
0506         default:
0507             return -EINVAL;
0508         }
0509         return 0;
0510     default:
0511         return ptrace_request(child, request, addr, data);
0512     }
0513 }
0514 
0515 #ifdef CONFIG_COMPAT
0516 /*
0517  * Now the fun part starts... a 31 bit program running in the
0518  * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
0519  * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy
0520  * to handle, the difference to the 64 bit versions of the requests
0521  * is that the access is done in multiples of 4 byte instead of
0522  * 8 bytes (sizeof(unsigned long) on 31/64 bit).
0523  * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA,
0524  * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program
0525  * is a 31 bit program too, the content of struct user can be
0526  * emulated. A 31 bit program peeking into the struct user of
0527  * a 64 bit program is a no-no.
0528  */
0529 
0530 /*
0531  * Same as peek_user_per but for a 31 bit program.
0532  */
0533 static inline __u32 __peek_user_per_compat(struct task_struct *child,
0534                        addr_t addr)
0535 {
0536     if (addr == offsetof(struct compat_per_struct_kernel, cr9))
0537         /* Control bits of the active per set. */
0538         return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
0539             PER_EVENT_IFETCH : child->thread.per_user.control;
0540     else if (addr == offsetof(struct compat_per_struct_kernel, cr10))
0541         /* Start address of the active per set. */
0542         return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
0543             0 : child->thread.per_user.start;
0544     else if (addr == offsetof(struct compat_per_struct_kernel, cr11))
0545         /* End address of the active per set. */
0546         return test_thread_flag(TIF_SINGLE_STEP) ?
0547             PSW32_ADDR_INSN : child->thread.per_user.end;
0548     else if (addr == offsetof(struct compat_per_struct_kernel, bits))
0549         /* Single-step bit. */
0550         return (__u32) test_thread_flag(TIF_SINGLE_STEP) ?
0551             0x80000000 : 0;
0552     else if (addr == offsetof(struct compat_per_struct_kernel, starting_addr))
0553         /* Start address of the user specified per set. */
0554         return (__u32) child->thread.per_user.start;
0555     else if (addr == offsetof(struct compat_per_struct_kernel, ending_addr))
0556         /* End address of the user specified per set. */
0557         return (__u32) child->thread.per_user.end;
0558     else if (addr == offsetof(struct compat_per_struct_kernel, perc_atmid))
0559         /* PER code, ATMID and AI of the last PER trap */
0560         return (__u32) child->thread.per_event.cause << 16;
0561     else if (addr == offsetof(struct compat_per_struct_kernel, address))
0562         /* Address of the last PER trap */
0563         return (__u32) child->thread.per_event.address;
0564     else if (addr == offsetof(struct compat_per_struct_kernel, access_id))
0565         /* Access id of the last PER trap */
0566         return (__u32) child->thread.per_event.paid << 24;
0567     return 0;
0568 }
0569 
0570 /*
0571  * Same as peek_user but for a 31 bit program.
0572  */
0573 static u32 __peek_user_compat(struct task_struct *child, addr_t addr)
0574 {
0575     addr_t offset;
0576     __u32 tmp;
0577 
0578     if (addr < offsetof(struct compat_user, regs.acrs)) {
0579         struct pt_regs *regs = task_pt_regs(child);
0580         /*
0581          * psw and gprs are stored on the stack
0582          */
0583         if (addr == offsetof(struct compat_user, regs.psw.mask)) {
0584             /* Fake a 31 bit psw mask. */
0585             tmp = (__u32)(regs->psw.mask >> 32);
0586             tmp &= PSW32_MASK_USER | PSW32_MASK_RI;
0587             tmp |= PSW32_USER_BITS;
0588         } else if (addr == offsetof(struct compat_user, regs.psw.addr)) {
0589             /* Fake a 31 bit psw address. */
0590             tmp = (__u32) regs->psw.addr |
0591                 (__u32)(regs->psw.mask & PSW_MASK_BA);
0592         } else {
0593             /* gpr 0-15 */
0594             tmp = *(__u32 *)((addr_t) &regs->psw + addr*2 + 4);
0595         }
0596     } else if (addr < offsetof(struct compat_user, regs.orig_gpr2)) {
0597         /*
0598          * access registers are stored in the thread structure
0599          */
0600         offset = addr - offsetof(struct compat_user, regs.acrs);
0601         tmp = *(__u32*)((addr_t) &child->thread.acrs + offset);
0602 
0603     } else if (addr == offsetof(struct compat_user, regs.orig_gpr2)) {
0604         /*
0605          * orig_gpr2 is stored on the kernel stack
0606          */
0607         tmp = *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4);
0608 
0609     } else if (addr < offsetof(struct compat_user, regs.fp_regs)) {
0610         /*
0611          * prevent reads of padding hole between
0612          * orig_gpr2 and fp_regs on s390.
0613          */
0614         tmp = 0;
0615 
0616     } else if (addr == offsetof(struct compat_user, regs.fp_regs.fpc)) {
0617         /*
0618          * floating point control reg. is in the thread structure
0619          */
0620         tmp = child->thread.fpu.fpc;
0621 
0622     } else if (addr < offsetof(struct compat_user, regs.fp_regs) + sizeof(s390_fp_regs)) {
0623         /*
0624          * floating point regs. are either in child->thread.fpu
0625          * or the child->thread.fpu.vxrs array
0626          */
0627         offset = addr - offsetof(struct compat_user, regs.fp_regs.fprs);
0628         if (MACHINE_HAS_VX)
0629             tmp = *(__u32 *)
0630                    ((addr_t) child->thread.fpu.vxrs + 2*offset);
0631         else
0632             tmp = *(__u32 *)
0633                    ((addr_t) child->thread.fpu.fprs + offset);
0634 
0635     } else if (addr < offsetof(struct compat_user, regs.per_info) + sizeof(struct compat_per_struct_kernel)) {
0636         /*
0637          * Handle access to the per_info structure.
0638          */
0639         addr -= offsetof(struct compat_user, regs.per_info);
0640         tmp = __peek_user_per_compat(child, addr);
0641 
0642     } else
0643         tmp = 0;
0644 
0645     return tmp;
0646 }
0647 
0648 static int peek_user_compat(struct task_struct *child,
0649                 addr_t addr, addr_t data)
0650 {
0651     __u32 tmp;
0652 
0653     if (!is_compat_task() || (addr & 3) || addr > sizeof(struct user) - 3)
0654         return -EIO;
0655 
0656     tmp = __peek_user_compat(child, addr);
0657     return put_user(tmp, (__u32 __user *) data);
0658 }
0659 
0660 /*
0661  * Same as poke_user_per but for a 31 bit program.
0662  */
0663 static inline void __poke_user_per_compat(struct task_struct *child,
0664                       addr_t addr, __u32 data)
0665 {
0666     if (addr == offsetof(struct compat_per_struct_kernel, cr9))
0667         /* PER event mask of the user specified per set. */
0668         child->thread.per_user.control =
0669             data & (PER_EVENT_MASK | PER_CONTROL_MASK);
0670     else if (addr == offsetof(struct compat_per_struct_kernel, starting_addr))
0671         /* Starting address of the user specified per set. */
0672         child->thread.per_user.start = data;
0673     else if (addr == offsetof(struct compat_per_struct_kernel, ending_addr))
0674         /* Ending address of the user specified per set. */
0675         child->thread.per_user.end = data;
0676 }
0677 
0678 /*
0679  * Same as poke_user but for a 31 bit program.
0680  */
0681 static int __poke_user_compat(struct task_struct *child,
0682                   addr_t addr, addr_t data)
0683 {
0684     __u32 tmp = (__u32) data;
0685     addr_t offset;
0686 
0687     if (addr < offsetof(struct compat_user, regs.acrs)) {
0688         struct pt_regs *regs = task_pt_regs(child);
0689         /*
0690          * psw, gprs, acrs and orig_gpr2 are stored on the stack
0691          */
0692         if (addr == offsetof(struct compat_user, regs.psw.mask)) {
0693             __u32 mask = PSW32_MASK_USER;
0694 
0695             mask |= is_ri_task(child) ? PSW32_MASK_RI : 0;
0696             /* Build a 64 bit psw mask from 31 bit mask. */
0697             if ((tmp ^ PSW32_USER_BITS) & ~mask)
0698                 /* Invalid psw mask. */
0699                 return -EINVAL;
0700             if ((data & PSW32_MASK_ASC) == PSW32_ASC_HOME)
0701                 /* Invalid address-space-control bits */
0702                 return -EINVAL;
0703             regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
0704                 (regs->psw.mask & PSW_MASK_BA) |
0705                 (__u64)(tmp & mask) << 32;
0706         } else if (addr == offsetof(struct compat_user, regs.psw.addr)) {
0707             /* Build a 64 bit psw address from 31 bit address. */
0708             regs->psw.addr = (__u64) tmp & PSW32_ADDR_INSN;
0709             /* Transfer 31 bit amode bit to psw mask. */
0710             regs->psw.mask = (regs->psw.mask & ~PSW_MASK_BA) |
0711                 (__u64)(tmp & PSW32_ADDR_AMODE);
0712         } else {
0713             if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
0714                 addr == offsetof(struct compat_user, regs.gprs[2])) {
0715                 struct pt_regs *regs = task_pt_regs(child);
0716 
0717                 regs->int_code = 0x20000 | (data & 0xffff);
0718             }
0719             /* gpr 0-15 */
0720             *(__u32*)((addr_t) &regs->psw + addr*2 + 4) = tmp;
0721         }
0722     } else if (addr < offsetof(struct compat_user, regs.orig_gpr2)) {
0723         /*
0724          * access registers are stored in the thread structure
0725          */
0726         offset = addr - offsetof(struct compat_user, regs.acrs);
0727         *(__u32*)((addr_t) &child->thread.acrs + offset) = tmp;
0728 
0729     } else if (addr == offsetof(struct compat_user, regs.orig_gpr2)) {
0730         /*
0731          * orig_gpr2 is stored on the kernel stack
0732          */
0733         *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4) = tmp;
0734 
0735     } else if (addr < offsetof(struct compat_user, regs.fp_regs)) {
0736         /*
0737          * prevent writess of padding hole between
0738          * orig_gpr2 and fp_regs on s390.
0739          */
0740         return 0;
0741 
0742     } else if (addr == offsetof(struct compat_user, regs.fp_regs.fpc)) {
0743         /*
0744          * floating point control reg. is in the thread structure
0745          */
0746         if (test_fp_ctl(tmp))
0747             return -EINVAL;
0748         child->thread.fpu.fpc = data;
0749 
0750     } else if (addr < offsetof(struct compat_user, regs.fp_regs) + sizeof(s390_fp_regs)) {
0751         /*
0752          * floating point regs. are either in child->thread.fpu
0753          * or the child->thread.fpu.vxrs array
0754          */
0755         offset = addr - offsetof(struct compat_user, regs.fp_regs.fprs);
0756         if (MACHINE_HAS_VX)
0757             *(__u32 *)((addr_t)
0758                 child->thread.fpu.vxrs + 2*offset) = tmp;
0759         else
0760             *(__u32 *)((addr_t)
0761                 child->thread.fpu.fprs + offset) = tmp;
0762 
0763     } else if (addr < offsetof(struct compat_user, regs.per_info) + sizeof(struct compat_per_struct_kernel)) {
0764         /*
0765          * Handle access to the per_info structure.
0766          */
0767         addr -= offsetof(struct compat_user, regs.per_info);
0768         __poke_user_per_compat(child, addr, data);
0769     }
0770 
0771     return 0;
0772 }
0773 
0774 static int poke_user_compat(struct task_struct *child,
0775                 addr_t addr, addr_t data)
0776 {
0777     if (!is_compat_task() || (addr & 3) ||
0778         addr > sizeof(struct compat_user) - 3)
0779         return -EIO;
0780 
0781     return __poke_user_compat(child, addr, data);
0782 }
0783 
0784 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
0785             compat_ulong_t caddr, compat_ulong_t cdata)
0786 {
0787     unsigned long addr = caddr;
0788     unsigned long data = cdata;
0789     compat_ptrace_area parea;
0790     int copied, ret;
0791 
0792     switch (request) {
0793     case PTRACE_PEEKUSR:
0794         /* read the word at location addr in the USER area. */
0795         return peek_user_compat(child, addr, data);
0796 
0797     case PTRACE_POKEUSR:
0798         /* write the word at location addr in the USER area */
0799         return poke_user_compat(child, addr, data);
0800 
0801     case PTRACE_PEEKUSR_AREA:
0802     case PTRACE_POKEUSR_AREA:
0803         if (copy_from_user(&parea, (void __force __user *) addr,
0804                             sizeof(parea)))
0805             return -EFAULT;
0806         addr = parea.kernel_addr;
0807         data = parea.process_addr;
0808         copied = 0;
0809         while (copied < parea.len) {
0810             if (request == PTRACE_PEEKUSR_AREA)
0811                 ret = peek_user_compat(child, addr, data);
0812             else {
0813                 __u32 utmp;
0814                 if (get_user(utmp,
0815                          (__u32 __force __user *) data))
0816                     return -EFAULT;
0817                 ret = poke_user_compat(child, addr, utmp);
0818             }
0819             if (ret)
0820                 return ret;
0821             addr += sizeof(unsigned int);
0822             data += sizeof(unsigned int);
0823             copied += sizeof(unsigned int);
0824         }
0825         return 0;
0826     case PTRACE_GET_LAST_BREAK:
0827         put_user(child->thread.last_break,
0828              (unsigned int __user *) data);
0829         return 0;
0830     }
0831     return compat_ptrace_request(child, request, addr, data);
0832 }
0833 #endif
0834 
0835 /*
0836  * user_regset definitions.
0837  */
0838 
0839 static int s390_regs_get(struct task_struct *target,
0840              const struct user_regset *regset,
0841              struct membuf to)
0842 {
0843     unsigned pos;
0844     if (target == current)
0845         save_access_regs(target->thread.acrs);
0846 
0847     for (pos = 0; pos < sizeof(s390_regs); pos += sizeof(long))
0848         membuf_store(&to, __peek_user(target, pos));
0849     return 0;
0850 }
0851 
0852 static int s390_regs_set(struct task_struct *target,
0853              const struct user_regset *regset,
0854              unsigned int pos, unsigned int count,
0855              const void *kbuf, const void __user *ubuf)
0856 {
0857     int rc = 0;
0858 
0859     if (target == current)
0860         save_access_regs(target->thread.acrs);
0861 
0862     if (kbuf) {
0863         const unsigned long *k = kbuf;
0864         while (count > 0 && !rc) {
0865             rc = __poke_user(target, pos, *k++);
0866             count -= sizeof(*k);
0867             pos += sizeof(*k);
0868         }
0869     } else {
0870         const unsigned long  __user *u = ubuf;
0871         while (count > 0 && !rc) {
0872             unsigned long word;
0873             rc = __get_user(word, u++);
0874             if (rc)
0875                 break;
0876             rc = __poke_user(target, pos, word);
0877             count -= sizeof(*u);
0878             pos += sizeof(*u);
0879         }
0880     }
0881 
0882     if (rc == 0 && target == current)
0883         restore_access_regs(target->thread.acrs);
0884 
0885     return rc;
0886 }
0887 
0888 static int s390_fpregs_get(struct task_struct *target,
0889                const struct user_regset *regset,
0890                struct membuf to)
0891 {
0892     _s390_fp_regs fp_regs;
0893 
0894     if (target == current)
0895         save_fpu_regs();
0896 
0897     fp_regs.fpc = target->thread.fpu.fpc;
0898     fpregs_store(&fp_regs, &target->thread.fpu);
0899 
0900     return membuf_write(&to, &fp_regs, sizeof(fp_regs));
0901 }
0902 
0903 static int s390_fpregs_set(struct task_struct *target,
0904                const struct user_regset *regset, unsigned int pos,
0905                unsigned int count, const void *kbuf,
0906                const void __user *ubuf)
0907 {
0908     int rc = 0;
0909     freg_t fprs[__NUM_FPRS];
0910 
0911     if (target == current)
0912         save_fpu_regs();
0913 
0914     if (MACHINE_HAS_VX)
0915         convert_vx_to_fp(fprs, target->thread.fpu.vxrs);
0916     else
0917         memcpy(&fprs, target->thread.fpu.fprs, sizeof(fprs));
0918 
0919     /* If setting FPC, must validate it first. */
0920     if (count > 0 && pos < offsetof(s390_fp_regs, fprs)) {
0921         u32 ufpc[2] = { target->thread.fpu.fpc, 0 };
0922         rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &ufpc,
0923                     0, offsetof(s390_fp_regs, fprs));
0924         if (rc)
0925             return rc;
0926         if (ufpc[1] != 0 || test_fp_ctl(ufpc[0]))
0927             return -EINVAL;
0928         target->thread.fpu.fpc = ufpc[0];
0929     }
0930 
0931     if (rc == 0 && count > 0)
0932         rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
0933                     fprs, offsetof(s390_fp_regs, fprs), -1);
0934     if (rc)
0935         return rc;
0936 
0937     if (MACHINE_HAS_VX)
0938         convert_fp_to_vx(target->thread.fpu.vxrs, fprs);
0939     else
0940         memcpy(target->thread.fpu.fprs, &fprs, sizeof(fprs));
0941 
0942     return rc;
0943 }
0944 
0945 static int s390_last_break_get(struct task_struct *target,
0946                    const struct user_regset *regset,
0947                    struct membuf to)
0948 {
0949     return membuf_store(&to, target->thread.last_break);
0950 }
0951 
0952 static int s390_last_break_set(struct task_struct *target,
0953                    const struct user_regset *regset,
0954                    unsigned int pos, unsigned int count,
0955                    const void *kbuf, const void __user *ubuf)
0956 {
0957     return 0;
0958 }
0959 
0960 static int s390_tdb_get(struct task_struct *target,
0961             const struct user_regset *regset,
0962             struct membuf to)
0963 {
0964     struct pt_regs *regs = task_pt_regs(target);
0965     size_t size;
0966 
0967     if (!(regs->int_code & 0x200))
0968         return -ENODATA;
0969     size = sizeof(target->thread.trap_tdb.data);
0970     return membuf_write(&to, target->thread.trap_tdb.data, size);
0971 }
0972 
0973 static int s390_tdb_set(struct task_struct *target,
0974             const struct user_regset *regset,
0975             unsigned int pos, unsigned int count,
0976             const void *kbuf, const void __user *ubuf)
0977 {
0978     return 0;
0979 }
0980 
0981 static int s390_vxrs_low_get(struct task_struct *target,
0982                  const struct user_regset *regset,
0983                  struct membuf to)
0984 {
0985     __u64 vxrs[__NUM_VXRS_LOW];
0986     int i;
0987 
0988     if (!MACHINE_HAS_VX)
0989         return -ENODEV;
0990     if (target == current)
0991         save_fpu_regs();
0992     for (i = 0; i < __NUM_VXRS_LOW; i++)
0993         vxrs[i] = *((__u64 *)(target->thread.fpu.vxrs + i) + 1);
0994     return membuf_write(&to, vxrs, sizeof(vxrs));
0995 }
0996 
0997 static int s390_vxrs_low_set(struct task_struct *target,
0998                  const struct user_regset *regset,
0999                  unsigned int pos, unsigned int count,
1000                  const void *kbuf, const void __user *ubuf)
1001 {
1002     __u64 vxrs[__NUM_VXRS_LOW];
1003     int i, rc;
1004 
1005     if (!MACHINE_HAS_VX)
1006         return -ENODEV;
1007     if (target == current)
1008         save_fpu_regs();
1009 
1010     for (i = 0; i < __NUM_VXRS_LOW; i++)
1011         vxrs[i] = *((__u64 *)(target->thread.fpu.vxrs + i) + 1);
1012 
1013     rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf, vxrs, 0, -1);
1014     if (rc == 0)
1015         for (i = 0; i < __NUM_VXRS_LOW; i++)
1016             *((__u64 *)(target->thread.fpu.vxrs + i) + 1) = vxrs[i];
1017 
1018     return rc;
1019 }
1020 
1021 static int s390_vxrs_high_get(struct task_struct *target,
1022                   const struct user_regset *regset,
1023                   struct membuf to)
1024 {
1025     if (!MACHINE_HAS_VX)
1026         return -ENODEV;
1027     if (target == current)
1028         save_fpu_regs();
1029     return membuf_write(&to, target->thread.fpu.vxrs + __NUM_VXRS_LOW,
1030                 __NUM_VXRS_HIGH * sizeof(__vector128));
1031 }
1032 
1033 static int s390_vxrs_high_set(struct task_struct *target,
1034                   const struct user_regset *regset,
1035                   unsigned int pos, unsigned int count,
1036                   const void *kbuf, const void __user *ubuf)
1037 {
1038     int rc;
1039 
1040     if (!MACHINE_HAS_VX)
1041         return -ENODEV;
1042     if (target == current)
1043         save_fpu_regs();
1044 
1045     rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1046                 target->thread.fpu.vxrs + __NUM_VXRS_LOW, 0, -1);
1047     return rc;
1048 }
1049 
1050 static int s390_system_call_get(struct task_struct *target,
1051                 const struct user_regset *regset,
1052                 struct membuf to)
1053 {
1054     return membuf_store(&to, target->thread.system_call);
1055 }
1056 
1057 static int s390_system_call_set(struct task_struct *target,
1058                 const struct user_regset *regset,
1059                 unsigned int pos, unsigned int count,
1060                 const void *kbuf, const void __user *ubuf)
1061 {
1062     unsigned int *data = &target->thread.system_call;
1063     return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1064                   data, 0, sizeof(unsigned int));
1065 }
1066 
1067 static int s390_gs_cb_get(struct task_struct *target,
1068               const struct user_regset *regset,
1069               struct membuf to)
1070 {
1071     struct gs_cb *data = target->thread.gs_cb;
1072 
1073     if (!MACHINE_HAS_GS)
1074         return -ENODEV;
1075     if (!data)
1076         return -ENODATA;
1077     if (target == current)
1078         save_gs_cb(data);
1079     return membuf_write(&to, data, sizeof(struct gs_cb));
1080 }
1081 
1082 static int s390_gs_cb_set(struct task_struct *target,
1083               const struct user_regset *regset,
1084               unsigned int pos, unsigned int count,
1085               const void *kbuf, const void __user *ubuf)
1086 {
1087     struct gs_cb gs_cb = { }, *data = NULL;
1088     int rc;
1089 
1090     if (!MACHINE_HAS_GS)
1091         return -ENODEV;
1092     if (!target->thread.gs_cb) {
1093         data = kzalloc(sizeof(*data), GFP_KERNEL);
1094         if (!data)
1095             return -ENOMEM;
1096     }
1097     if (!target->thread.gs_cb)
1098         gs_cb.gsd = 25;
1099     else if (target == current)
1100         save_gs_cb(&gs_cb);
1101     else
1102         gs_cb = *target->thread.gs_cb;
1103     rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1104                 &gs_cb, 0, sizeof(gs_cb));
1105     if (rc) {
1106         kfree(data);
1107         return -EFAULT;
1108     }
1109     preempt_disable();
1110     if (!target->thread.gs_cb)
1111         target->thread.gs_cb = data;
1112     *target->thread.gs_cb = gs_cb;
1113     if (target == current) {
1114         __ctl_set_bit(2, 4);
1115         restore_gs_cb(target->thread.gs_cb);
1116     }
1117     preempt_enable();
1118     return rc;
1119 }
1120 
1121 static int s390_gs_bc_get(struct task_struct *target,
1122               const struct user_regset *regset,
1123               struct membuf to)
1124 {
1125     struct gs_cb *data = target->thread.gs_bc_cb;
1126 
1127     if (!MACHINE_HAS_GS)
1128         return -ENODEV;
1129     if (!data)
1130         return -ENODATA;
1131     return membuf_write(&to, data, sizeof(struct gs_cb));
1132 }
1133 
1134 static int s390_gs_bc_set(struct task_struct *target,
1135               const struct user_regset *regset,
1136               unsigned int pos, unsigned int count,
1137               const void *kbuf, const void __user *ubuf)
1138 {
1139     struct gs_cb *data = target->thread.gs_bc_cb;
1140 
1141     if (!MACHINE_HAS_GS)
1142         return -ENODEV;
1143     if (!data) {
1144         data = kzalloc(sizeof(*data), GFP_KERNEL);
1145         if (!data)
1146             return -ENOMEM;
1147         target->thread.gs_bc_cb = data;
1148     }
1149     return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1150                   data, 0, sizeof(struct gs_cb));
1151 }
1152 
1153 static bool is_ri_cb_valid(struct runtime_instr_cb *cb)
1154 {
1155     return (cb->rca & 0x1f) == 0 &&
1156         (cb->roa & 0xfff) == 0 &&
1157         (cb->rla & 0xfff) == 0xfff &&
1158         cb->s == 1 &&
1159         cb->k == 1 &&
1160         cb->h == 0 &&
1161         cb->reserved1 == 0 &&
1162         cb->ps == 1 &&
1163         cb->qs == 0 &&
1164         cb->pc == 1 &&
1165         cb->qc == 0 &&
1166         cb->reserved2 == 0 &&
1167         cb->reserved3 == 0 &&
1168         cb->reserved4 == 0 &&
1169         cb->reserved5 == 0 &&
1170         cb->reserved6 == 0 &&
1171         cb->reserved7 == 0 &&
1172         cb->reserved8 == 0 &&
1173         cb->rla >= cb->roa &&
1174         cb->rca >= cb->roa &&
1175         cb->rca <= cb->rla+1 &&
1176         cb->m < 3;
1177 }
1178 
1179 static int s390_runtime_instr_get(struct task_struct *target,
1180                 const struct user_regset *regset,
1181                 struct membuf to)
1182 {
1183     struct runtime_instr_cb *data = target->thread.ri_cb;
1184 
1185     if (!test_facility(64))
1186         return -ENODEV;
1187     if (!data)
1188         return -ENODATA;
1189 
1190     return membuf_write(&to, data, sizeof(struct runtime_instr_cb));
1191 }
1192 
1193 static int s390_runtime_instr_set(struct task_struct *target,
1194                   const struct user_regset *regset,
1195                   unsigned int pos, unsigned int count,
1196                   const void *kbuf, const void __user *ubuf)
1197 {
1198     struct runtime_instr_cb ri_cb = { }, *data = NULL;
1199     int rc;
1200 
1201     if (!test_facility(64))
1202         return -ENODEV;
1203 
1204     if (!target->thread.ri_cb) {
1205         data = kzalloc(sizeof(*data), GFP_KERNEL);
1206         if (!data)
1207             return -ENOMEM;
1208     }
1209 
1210     if (target->thread.ri_cb) {
1211         if (target == current)
1212             store_runtime_instr_cb(&ri_cb);
1213         else
1214             ri_cb = *target->thread.ri_cb;
1215     }
1216 
1217     rc = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
1218                 &ri_cb, 0, sizeof(struct runtime_instr_cb));
1219     if (rc) {
1220         kfree(data);
1221         return -EFAULT;
1222     }
1223 
1224     if (!is_ri_cb_valid(&ri_cb)) {
1225         kfree(data);
1226         return -EINVAL;
1227     }
1228     /*
1229      * Override access key in any case, since user space should
1230      * not be able to set it, nor should it care about it.
1231      */
1232     ri_cb.key = PAGE_DEFAULT_KEY >> 4;
1233     preempt_disable();
1234     if (!target->thread.ri_cb)
1235         target->thread.ri_cb = data;
1236     *target->thread.ri_cb = ri_cb;
1237     if (target == current)
1238         load_runtime_instr_cb(target->thread.ri_cb);
1239     preempt_enable();
1240 
1241     return 0;
1242 }
1243 
1244 static const struct user_regset s390_regsets[] = {
1245     {
1246         .core_note_type = NT_PRSTATUS,
1247         .n = sizeof(s390_regs) / sizeof(long),
1248         .size = sizeof(long),
1249         .align = sizeof(long),
1250         .regset_get = s390_regs_get,
1251         .set = s390_regs_set,
1252     },
1253     {
1254         .core_note_type = NT_PRFPREG,
1255         .n = sizeof(s390_fp_regs) / sizeof(long),
1256         .size = sizeof(long),
1257         .align = sizeof(long),
1258         .regset_get = s390_fpregs_get,
1259         .set = s390_fpregs_set,
1260     },
1261     {
1262         .core_note_type = NT_S390_SYSTEM_CALL,
1263         .n = 1,
1264         .size = sizeof(unsigned int),
1265         .align = sizeof(unsigned int),
1266         .regset_get = s390_system_call_get,
1267         .set = s390_system_call_set,
1268     },
1269     {
1270         .core_note_type = NT_S390_LAST_BREAK,
1271         .n = 1,
1272         .size = sizeof(long),
1273         .align = sizeof(long),
1274         .regset_get = s390_last_break_get,
1275         .set = s390_last_break_set,
1276     },
1277     {
1278         .core_note_type = NT_S390_TDB,
1279         .n = 1,
1280         .size = 256,
1281         .align = 1,
1282         .regset_get = s390_tdb_get,
1283         .set = s390_tdb_set,
1284     },
1285     {
1286         .core_note_type = NT_S390_VXRS_LOW,
1287         .n = __NUM_VXRS_LOW,
1288         .size = sizeof(__u64),
1289         .align = sizeof(__u64),
1290         .regset_get = s390_vxrs_low_get,
1291         .set = s390_vxrs_low_set,
1292     },
1293     {
1294         .core_note_type = NT_S390_VXRS_HIGH,
1295         .n = __NUM_VXRS_HIGH,
1296         .size = sizeof(__vector128),
1297         .align = sizeof(__vector128),
1298         .regset_get = s390_vxrs_high_get,
1299         .set = s390_vxrs_high_set,
1300     },
1301     {
1302         .core_note_type = NT_S390_GS_CB,
1303         .n = sizeof(struct gs_cb) / sizeof(__u64),
1304         .size = sizeof(__u64),
1305         .align = sizeof(__u64),
1306         .regset_get = s390_gs_cb_get,
1307         .set = s390_gs_cb_set,
1308     },
1309     {
1310         .core_note_type = NT_S390_GS_BC,
1311         .n = sizeof(struct gs_cb) / sizeof(__u64),
1312         .size = sizeof(__u64),
1313         .align = sizeof(__u64),
1314         .regset_get = s390_gs_bc_get,
1315         .set = s390_gs_bc_set,
1316     },
1317     {
1318         .core_note_type = NT_S390_RI_CB,
1319         .n = sizeof(struct runtime_instr_cb) / sizeof(__u64),
1320         .size = sizeof(__u64),
1321         .align = sizeof(__u64),
1322         .regset_get = s390_runtime_instr_get,
1323         .set = s390_runtime_instr_set,
1324     },
1325 };
1326 
1327 static const struct user_regset_view user_s390_view = {
1328     .name = "s390x",
1329     .e_machine = EM_S390,
1330     .regsets = s390_regsets,
1331     .n = ARRAY_SIZE(s390_regsets)
1332 };
1333 
1334 #ifdef CONFIG_COMPAT
1335 static int s390_compat_regs_get(struct task_struct *target,
1336                 const struct user_regset *regset,
1337                 struct membuf to)
1338 {
1339     unsigned n;
1340 
1341     if (target == current)
1342         save_access_regs(target->thread.acrs);
1343 
1344     for (n = 0; n < sizeof(s390_compat_regs); n += sizeof(compat_ulong_t))
1345         membuf_store(&to, __peek_user_compat(target, n));
1346     return 0;
1347 }
1348 
1349 static int s390_compat_regs_set(struct task_struct *target,
1350                 const struct user_regset *regset,
1351                 unsigned int pos, unsigned int count,
1352                 const void *kbuf, const void __user *ubuf)
1353 {
1354     int rc = 0;
1355 
1356     if (target == current)
1357         save_access_regs(target->thread.acrs);
1358 
1359     if (kbuf) {
1360         const compat_ulong_t *k = kbuf;
1361         while (count > 0 && !rc) {
1362             rc = __poke_user_compat(target, pos, *k++);
1363             count -= sizeof(*k);
1364             pos += sizeof(*k);
1365         }
1366     } else {
1367         const compat_ulong_t  __user *u = ubuf;
1368         while (count > 0 && !rc) {
1369             compat_ulong_t word;
1370             rc = __get_user(word, u++);
1371             if (rc)
1372                 break;
1373             rc = __poke_user_compat(target, pos, word);
1374             count -= sizeof(*u);
1375             pos += sizeof(*u);
1376         }
1377     }
1378 
1379     if (rc == 0 && target == current)
1380         restore_access_regs(target->thread.acrs);
1381 
1382     return rc;
1383 }
1384 
1385 static int s390_compat_regs_high_get(struct task_struct *target,
1386                      const struct user_regset *regset,
1387                      struct membuf to)
1388 {
1389     compat_ulong_t *gprs_high;
1390     int i;
1391 
1392     gprs_high = (compat_ulong_t *)task_pt_regs(target)->gprs;
1393     for (i = 0; i < NUM_GPRS; i++, gprs_high += 2)
1394         membuf_store(&to, *gprs_high);
1395     return 0;
1396 }
1397 
1398 static int s390_compat_regs_high_set(struct task_struct *target,
1399                      const struct user_regset *regset,
1400                      unsigned int pos, unsigned int count,
1401                      const void *kbuf, const void __user *ubuf)
1402 {
1403     compat_ulong_t *gprs_high;
1404     int rc = 0;
1405 
1406     gprs_high = (compat_ulong_t *)
1407         &task_pt_regs(target)->gprs[pos / sizeof(compat_ulong_t)];
1408     if (kbuf) {
1409         const compat_ulong_t *k = kbuf;
1410         while (count > 0) {
1411             *gprs_high = *k++;
1412             *gprs_high += 2;
1413             count -= sizeof(*k);
1414         }
1415     } else {
1416         const compat_ulong_t  __user *u = ubuf;
1417         while (count > 0 && !rc) {
1418             unsigned long word;
1419             rc = __get_user(word, u++);
1420             if (rc)
1421                 break;
1422             *gprs_high = word;
1423             *gprs_high += 2;
1424             count -= sizeof(*u);
1425         }
1426     }
1427 
1428     return rc;
1429 }
1430 
1431 static int s390_compat_last_break_get(struct task_struct *target,
1432                       const struct user_regset *regset,
1433                       struct membuf to)
1434 {
1435     compat_ulong_t last_break = target->thread.last_break;
1436 
1437     return membuf_store(&to, (unsigned long)last_break);
1438 }
1439 
1440 static int s390_compat_last_break_set(struct task_struct *target,
1441                       const struct user_regset *regset,
1442                       unsigned int pos, unsigned int count,
1443                       const void *kbuf, const void __user *ubuf)
1444 {
1445     return 0;
1446 }
1447 
1448 static const struct user_regset s390_compat_regsets[] = {
1449     {
1450         .core_note_type = NT_PRSTATUS,
1451         .n = sizeof(s390_compat_regs) / sizeof(compat_long_t),
1452         .size = sizeof(compat_long_t),
1453         .align = sizeof(compat_long_t),
1454         .regset_get = s390_compat_regs_get,
1455         .set = s390_compat_regs_set,
1456     },
1457     {
1458         .core_note_type = NT_PRFPREG,
1459         .n = sizeof(s390_fp_regs) / sizeof(compat_long_t),
1460         .size = sizeof(compat_long_t),
1461         .align = sizeof(compat_long_t),
1462         .regset_get = s390_fpregs_get,
1463         .set = s390_fpregs_set,
1464     },
1465     {
1466         .core_note_type = NT_S390_SYSTEM_CALL,
1467         .n = 1,
1468         .size = sizeof(compat_uint_t),
1469         .align = sizeof(compat_uint_t),
1470         .regset_get = s390_system_call_get,
1471         .set = s390_system_call_set,
1472     },
1473     {
1474         .core_note_type = NT_S390_LAST_BREAK,
1475         .n = 1,
1476         .size = sizeof(long),
1477         .align = sizeof(long),
1478         .regset_get = s390_compat_last_break_get,
1479         .set = s390_compat_last_break_set,
1480     },
1481     {
1482         .core_note_type = NT_S390_TDB,
1483         .n = 1,
1484         .size = 256,
1485         .align = 1,
1486         .regset_get = s390_tdb_get,
1487         .set = s390_tdb_set,
1488     },
1489     {
1490         .core_note_type = NT_S390_VXRS_LOW,
1491         .n = __NUM_VXRS_LOW,
1492         .size = sizeof(__u64),
1493         .align = sizeof(__u64),
1494         .regset_get = s390_vxrs_low_get,
1495         .set = s390_vxrs_low_set,
1496     },
1497     {
1498         .core_note_type = NT_S390_VXRS_HIGH,
1499         .n = __NUM_VXRS_HIGH,
1500         .size = sizeof(__vector128),
1501         .align = sizeof(__vector128),
1502         .regset_get = s390_vxrs_high_get,
1503         .set = s390_vxrs_high_set,
1504     },
1505     {
1506         .core_note_type = NT_S390_HIGH_GPRS,
1507         .n = sizeof(s390_compat_regs_high) / sizeof(compat_long_t),
1508         .size = sizeof(compat_long_t),
1509         .align = sizeof(compat_long_t),
1510         .regset_get = s390_compat_regs_high_get,
1511         .set = s390_compat_regs_high_set,
1512     },
1513     {
1514         .core_note_type = NT_S390_GS_CB,
1515         .n = sizeof(struct gs_cb) / sizeof(__u64),
1516         .size = sizeof(__u64),
1517         .align = sizeof(__u64),
1518         .regset_get = s390_gs_cb_get,
1519         .set = s390_gs_cb_set,
1520     },
1521     {
1522         .core_note_type = NT_S390_GS_BC,
1523         .n = sizeof(struct gs_cb) / sizeof(__u64),
1524         .size = sizeof(__u64),
1525         .align = sizeof(__u64),
1526         .regset_get = s390_gs_bc_get,
1527         .set = s390_gs_bc_set,
1528     },
1529     {
1530         .core_note_type = NT_S390_RI_CB,
1531         .n = sizeof(struct runtime_instr_cb) / sizeof(__u64),
1532         .size = sizeof(__u64),
1533         .align = sizeof(__u64),
1534         .regset_get = s390_runtime_instr_get,
1535         .set = s390_runtime_instr_set,
1536     },
1537 };
1538 
1539 static const struct user_regset_view user_s390_compat_view = {
1540     .name = "s390",
1541     .e_machine = EM_S390,
1542     .regsets = s390_compat_regsets,
1543     .n = ARRAY_SIZE(s390_compat_regsets)
1544 };
1545 #endif
1546 
1547 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
1548 {
1549 #ifdef CONFIG_COMPAT
1550     if (test_tsk_thread_flag(task, TIF_31BIT))
1551         return &user_s390_compat_view;
1552 #endif
1553     return &user_s390_view;
1554 }
1555 
1556 static const char *gpr_names[NUM_GPRS] = {
1557     "r0", "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
1558     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1559 };
1560 
1561 unsigned long regs_get_register(struct pt_regs *regs, unsigned int offset)
1562 {
1563     if (offset >= NUM_GPRS)
1564         return 0;
1565     return regs->gprs[offset];
1566 }
1567 
1568 int regs_query_register_offset(const char *name)
1569 {
1570     unsigned long offset;
1571 
1572     if (!name || *name != 'r')
1573         return -EINVAL;
1574     if (kstrtoul(name + 1, 10, &offset))
1575         return -EINVAL;
1576     if (offset >= NUM_GPRS)
1577         return -EINVAL;
1578     return offset;
1579 }
1580 
1581 const char *regs_query_register_name(unsigned int offset)
1582 {
1583     if (offset >= NUM_GPRS)
1584         return NULL;
1585     return gpr_names[offset];
1586 }
1587 
1588 static int regs_within_kernel_stack(struct pt_regs *regs, unsigned long addr)
1589 {
1590     unsigned long ksp = kernel_stack_pointer(regs);
1591 
1592     return (addr & ~(THREAD_SIZE - 1)) == (ksp & ~(THREAD_SIZE - 1));
1593 }
1594 
1595 /**
1596  * regs_get_kernel_stack_nth() - get Nth entry of the stack
1597  * @regs:pt_regs which contains kernel stack pointer.
1598  * @n:stack entry number.
1599  *
1600  * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
1601  * is specifined by @regs. If the @n th entry is NOT in the kernel stack,
1602  * this returns 0.
1603  */
1604 unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs, unsigned int n)
1605 {
1606     unsigned long addr;
1607 
1608     addr = kernel_stack_pointer(regs) + n * sizeof(long);
1609     if (!regs_within_kernel_stack(regs, addr))
1610         return 0;
1611     return *(unsigned long *)addr;
1612 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!