[PATCH 3c] utrace: s390 regset support This patch converts the machine-dependent ptrace code into utrace regset support for s390. Signed-off-by: Roland McGrath Signed-off-by: David Wilder --- include/asm-s390/tracehook.h | 14 + arch/s390/kernel/Makefile | 2 arch/s390/kernel/ptrace.c | 951 +++++++++++++++++------------------------- 3 files changed, 400 insertions(+), 567 deletions(-) --- linux-2.6/include/asm-s390/tracehook.h +++ linux-2.6/include/asm-s390/tracehook.h @@ -43,4 +43,18 @@ static inline void tracehook_abort_sysca regs->gprs[2] = -1L; } + +extern const struct utrace_regset_view utrace_s390_native_view; +static inline const struct utrace_regset_view * +utrace_native_view(struct task_struct *tsk) +{ +#ifdef CONFIG_COMPAT + extern const struct utrace_regset_view utrace_s390_compat_view; + + if (test_tsk_thread_flag(tsk, TIF_31BIT)) + return &utrace_s390_compat_view; +#endif + return &utrace_s390_native_view; +} + #endif --- linux-2.6/arch/s390/kernel/Makefile +++ linux-2.6/arch/s390/kernel/Makefile @@ -35,3 +35,5 @@ obj-$(CONFIG_KEXEC) += $(S390_KEXEC_OBJS # This is just to get the dependencies... # binfmt_elf32.o: $(TOPDIR)/fs/binfmt_elf.c + +CFLAGS_ptrace.o += -DUTS_MACHINE='"$(UTS_MACHINE)"' --- linux-2.6/arch/s390/kernel/ptrace.c +++ linux-2.6/arch/s390/kernel/ptrace.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -42,6 +43,7 @@ #include #include #include +#include #ifdef CONFIG_COMPAT #include "compat_ptrace.h" @@ -116,640 +118,455 @@ tracehook_single_step_enabled(struct tas return task->thread.per_info.single_step; } -/* - * Called by kernel/ptrace.c when detaching.. - * - * Make sure single step bits etc are not set. - */ -void -ptrace_disable(struct task_struct *child) -{ - /* make sure the single step bit is not set. */ - tracehook_disable_single_step(child); -} - -#ifndef CONFIG_64BIT -# define __ADDR_MASK 3 -#else -# define __ADDR_MASK 7 -#endif -/* - * Read the word at offset addr from the user area of a process. The - * trouble here is that the information is littered over different - * locations. The process registers are found on the kernel stack, - * the floating point stuff and the trace settings are stored in - * the task structure. In addition the different structures in - * struct user contain pad bytes that should be read as zeroes. - * Lovely... - */ static int -peek_user(struct task_struct *child, addr_t addr, addr_t data) +genregs_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) { - struct user *dummy = NULL; - addr_t offset, tmp, mask; + struct pt_regs *regs = task_pt_regs(target); + unsigned long pswmask; + int ret; - /* - * Stupid gdb peeks/pokes the access registers in 64 bit with - * an alignment of 4. Programmers from hell... - */ - mask = __ADDR_MASK; -#ifdef CONFIG_64BIT - if (addr >= (addr_t) &dummy->regs.acrs && - addr < (addr_t) &dummy->regs.orig_gpr2) - mask = 3; -#endif - if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK) - return -EIO; + /* Remove per bit from user psw. */ + pswmask = regs->psw.mask & ~PSW_MASK_PER; + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &pswmask, PT_PSWMASK, PT_PSWADDR); + + /* The rest of the PSW and the GPRs are directly on the stack. */ + if (ret == 0) + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + ®s->psw.addr, PT_PSWADDR, + PT_ACR0); + + /* The ACRs are kept in the thread_struct. */ + if (ret == 0 && count > 0 && pos < PT_ORIGGPR2) { + if (target == current) + save_access_regs(target->thread.acrs); + + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + target->thread.acrs, + PT_ACR0, PT_ORIGGPR2); + } - if (addr < (addr_t) &dummy->regs.acrs) { - /* - * psw and gprs are stored on the stack - */ - tmp = *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr); - if (addr == (addr_t) &dummy->regs.psw.mask) - /* Remove per bit from user psw. */ - tmp &= ~PSW_MASK_PER; + /* Finally, the ORIG_GPR2 value. */ + if (ret == 0) + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + ®s->orig_gpr2, PT_ORIGGPR2, -1); - } else if (addr < (addr_t) &dummy->regs.orig_gpr2) { - /* - * access registers are stored in the thread structure - */ - offset = addr - (addr_t) &dummy->regs.acrs; -#ifdef CONFIG_64BIT - /* - * Very special case: old & broken 64 bit gdb reading - * from acrs[15]. Result is a 64 bit value. Read the - * 32 bit acrs[15] value and shift it by 32. Sick... - */ - if (addr == (addr_t) &dummy->regs.acrs[15]) - tmp = ((unsigned long) child->thread.acrs[15]) << 32; - else -#endif - tmp = *(addr_t *)((addr_t) &child->thread.acrs + offset); + return ret; +} - } else if (addr == (addr_t) &dummy->regs.orig_gpr2) { - /* - * orig_gpr2 is stored on the kernel stack - */ - tmp = (addr_t) task_pt_regs(child)->orig_gpr2; +static int +genregs_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + struct pt_regs *regs = task_pt_regs(target); + int ret = 0; + + /* Check for an invalid PSW mask. */ + if (count > 0 && pos == PT_PSWMASK) { + unsigned long pswmask = regs->psw.mask; + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &pswmask, PT_PSWMASK, PT_PSWADDR); + if (pswmask != PSW_MASK_MERGE(psw_user_bits, pswmask) +#ifdef CONFIG_COMPAT + && pswmask != PSW_MASK_MERGE(psw_user32_bits, pswmask) +#endif + ) + /* Invalid psw mask. */ + return -EINVAL; + regs->psw.mask = pswmask; + FixPerRegisters(target); + } - } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) { - /* - * floating point regs. are stored in the thread structure - */ - offset = addr - (addr_t) &dummy->regs.fp_regs; - tmp = *(addr_t *)((addr_t) &child->thread.fp_regs + offset); - if (addr == (addr_t) &dummy->regs.fp_regs.fpc) - tmp &= (unsigned long) FPC_VALID_MASK - << (BITS_PER_LONG - 32); + /* The rest of the PSW and the GPRs are directly on the stack. */ + if (ret == 0) { + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + ®s->psw.addr, PT_PSWADDR, + PT_ACR0); +#ifndef CONFIG_64BIT + /* I'd like to reject addresses without the + high order bit but older gdb's rely on it */ + regs->psw.addr |= PSW_ADDR_AMODE; +#endif + } - } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) { - /* - * per_info is found in the thread structure - */ - offset = addr - (addr_t) &dummy->regs.per_info; - tmp = *(addr_t *)((addr_t) &child->thread.per_info + offset); + /* The ACRs are kept in the thread_struct. */ + if (ret == 0 && count > 0 && pos < PT_ORIGGPR2) { + if (target == current + && (pos != PT_ACR0 || count < sizeof(target->thread.acrs))) + save_access_regs(target->thread.acrs); + + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + target->thread.acrs, + PT_ACR0, PT_ORIGGPR2); + if (ret == 0 && target == current) + restore_access_regs(target->thread.acrs); + } - } else - tmp = 0; + /* Finally, the ORIG_GPR2 value. */ + if (ret == 0) + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + ®s->orig_gpr2, PT_ORIGGPR2, -1); - return put_user(tmp, (addr_t __user *) data); + return ret; } -/* - * Write a word to the user area of a process at location addr. This - * operation does have an additional problem compared to peek_user. - * Stores to the program status word and on the floating point - * control register needs to get checked for validity. - */ static int -poke_user(struct task_struct *child, addr_t addr, addr_t data) +fpregs_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) { - struct user *dummy = NULL; - addr_t offset, mask; + if (target == current) + save_fp_regs(&target->thread.fp_regs); - /* - * Stupid gdb peeks/pokes the access registers in 64 bit with - * an alignment of 4. Programmers from hell indeed... - */ - mask = __ADDR_MASK; -#ifdef CONFIG_64BIT - if (addr >= (addr_t) &dummy->regs.acrs && - addr < (addr_t) &dummy->regs.orig_gpr2) - mask = 3; -#endif - if ((addr & mask) || addr > sizeof(struct user) - __ADDR_MASK) - return -EIO; + return utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &target->thread.fp_regs, 0, -1); +} - if (addr < (addr_t) &dummy->regs.acrs) { - /* - * psw and gprs are stored on the stack - */ - if (addr == (addr_t) &dummy->regs.psw.mask && -#ifdef CONFIG_COMPAT - data != PSW_MASK_MERGE(psw_user32_bits, data) && -#endif - data != PSW_MASK_MERGE(psw_user_bits, data)) - /* Invalid psw mask. */ +static int +fpregs_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + int ret = 0; + + if (target == current && (pos != 0 || count != sizeof(s390_fp_regs))) + save_fp_regs(&target->thread.fp_regs); + + /* If setting FPC, must validate it first. */ + if (count > 0 && pos == 0) { + unsigned long fpc; + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &fpc, 0, sizeof(fpc)); + if (ret) + return ret; + + if ((fpc & ~((unsigned long) FPC_VALID_MASK + << (BITS_PER_LONG - 32))) != 0) return -EINVAL; -#ifndef CONFIG_64BIT - if (addr == (addr_t) &dummy->regs.psw.addr) - /* I'd like to reject addresses without the - high order bit but older gdb's rely on it */ - data |= PSW_ADDR_AMODE; -#endif - *(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data; - } else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) { - /* - * access registers are stored in the thread structure - */ - offset = addr - (addr_t) &dummy->regs.acrs; -#ifdef CONFIG_64BIT - /* - * Very special case: old & broken 64 bit gdb writing - * to acrs[15] with a 64 bit value. Ignore the lower - * half of the value and write the upper 32 bit to - * acrs[15]. Sick... - */ - if (addr == (addr_t) &dummy->regs.acrs[15]) - child->thread.acrs[15] = (unsigned int) (data >> 32); - else -#endif - *(addr_t *)((addr_t) &child->thread.acrs + offset) = data; + memcpy(&target->thread.fp_regs, &fpc, sizeof(fpc)); + } - } else if (addr == (addr_t) &dummy->regs.orig_gpr2) { - /* - * orig_gpr2 is stored on the kernel stack - */ - task_pt_regs(child)->orig_gpr2 = data; + if (ret == 0) + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &target->thread.fp_regs, 0, -1); - } else if (addr < (addr_t) (&dummy->regs.fp_regs + 1)) { - /* - * floating point regs. are stored in the thread structure - */ - if (addr == (addr_t) &dummy->regs.fp_regs.fpc && - (data & ~((unsigned long) FPC_VALID_MASK - << (BITS_PER_LONG - 32))) != 0) - return -EINVAL; - offset = addr - (addr_t) &dummy->regs.fp_regs; - *(addr_t *)((addr_t) &child->thread.fp_regs + offset) = data; + if (ret == 0 && target == current) + restore_fp_regs(&target->thread.fp_regs); - } else if (addr < (addr_t) (&dummy->regs.per_info + 1)) { - /* - * per_info is found in the thread structure - */ - offset = addr - (addr_t) &dummy->regs.per_info; - *(addr_t *)((addr_t) &child->thread.per_info + offset) = data; - - } + return ret; +} - FixPerRegisters(child); - return 0; +static int +per_info_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + return utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &target->thread.per_info, 0, -1); } static int -do_ptrace_normal(struct task_struct *child, long request, long addr, long data) +per_info_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) { - unsigned long tmp; - ptrace_area parea; - int copied, ret; - - switch (request) { - case PTRACE_PEEKTEXT: - case PTRACE_PEEKDATA: - /* Remove high order bit from address (only for 31 bit). */ - addr &= PSW_ADDR_INSN; - /* read word at location addr. */ - copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); - if (copied != sizeof(tmp)) - return -EIO; - return put_user(tmp, (unsigned long __force __user *) data); - - case PTRACE_PEEKUSR: - /* read the word at location addr in the USER area. */ - return peek_user(child, addr, data); - - case PTRACE_POKETEXT: - case PTRACE_POKEDATA: - /* Remove high order bit from address (only for 31 bit). */ - addr &= PSW_ADDR_INSN; - /* write the word at location addr. */ - copied = access_process_vm(child, addr, &data, sizeof(data),1); - if (copied != sizeof(data)) - return -EIO; - return 0; - - case PTRACE_POKEUSR: - /* write the word at location addr in the USER area */ - return poke_user(child, addr, data); - - case PTRACE_PEEKUSR_AREA: - case PTRACE_POKEUSR_AREA: - if (copy_from_user(&parea, (void __force __user *) addr, - sizeof(parea))) - return -EFAULT; - addr = parea.kernel_addr; - data = parea.process_addr; - copied = 0; - while (copied < parea.len) { - if (request == PTRACE_PEEKUSR_AREA) - ret = peek_user(child, addr, data); - else { - addr_t utmp; - if (get_user(utmp, - (addr_t __force __user *) data)) - return -EFAULT; - ret = poke_user(child, addr, utmp); - } - if (ret) - return ret; - addr += sizeof(unsigned long); - data += sizeof(unsigned long); - copied += sizeof(unsigned long); - } - return 0; - } - return ptrace_request(child, request, addr, data); + int ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &target->thread.per_info, 0, -1); + + FixPerRegisters(target); + + return ret; } -#ifdef CONFIG_COMPAT -/* - * Now the fun part starts... a 31 bit program running in the - * 31 bit emulation tracing another program. PTRACE_PEEKTEXT, - * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy - * to handle, the difference to the 64 bit versions of the requests - * is that the access is done in multiples of 4 byte instead of - * 8 bytes (sizeof(unsigned long) on 31/64 bit). - * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA, - * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program - * is a 31 bit program too, the content of struct user can be - * emulated. A 31 bit program peeking into the struct user of - * a 64 bit program is a no-no. - */ /* - * Same as peek_user but for a 31 bit program. + * These are our native regset flavors. */ -static int -peek_user_emu31(struct task_struct *child, addr_t addr, addr_t data) -{ - struct user32 *dummy32 = NULL; - per_struct32 *dummy_per32 = NULL; - addr_t offset; - __u32 tmp; - - if (!test_thread_flag(TIF_31BIT) || - (addr & 3) || addr > sizeof(struct user) - 3) - return -EIO; +static const struct utrace_regset native_regsets[] = { + { + .size = sizeof(long), .align = sizeof(long), + .n = sizeof(s390_regs) / sizeof(long), + .get = genregs_get, .set = genregs_set + }, + { + .size = sizeof(long), .align = sizeof(long), + .n = sizeof(s390_fp_regs) / sizeof(long), + .get = fpregs_get, .set = fpregs_set + }, + { + .size = sizeof(long), .align = sizeof(long), + .n = sizeof(per_struct) / sizeof(long), + .get = per_info_get, .set = per_info_set + }, +}; + +const struct utrace_regset_view utrace_s390_native_view = { + .name = UTS_MACHINE, .e_machine = ELF_ARCH, + .regsets = native_regsets, .n = ARRAY_SIZE(native_regsets) +}; +EXPORT_SYMBOL_GPL(utrace_s390_native_view); - if (addr < (addr_t) &dummy32->regs.acrs) { - /* - * psw and gprs are stored on the stack - */ - if (addr == (addr_t) &dummy32->regs.psw.mask) { - /* Fake a 31 bit psw mask. */ - tmp = (__u32)(task_pt_regs(child)->psw.mask >> 32); - tmp = PSW32_MASK_MERGE(psw32_user_bits, tmp); - } else if (addr == (addr_t) &dummy32->regs.psw.addr) { - /* Fake a 31 bit psw address. */ - tmp = (__u32) task_pt_regs(child)->psw.addr | - PSW32_ADDR_AMODE31; - } else { - /* gpr 0-15 */ - tmp = *(__u32 *)((addr_t) &task_pt_regs(child)->psw + - addr*2 + 4); - } - } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) { - /* - * access registers are stored in the thread structure - */ - offset = addr - (addr_t) &dummy32->regs.acrs; - tmp = *(__u32*)((addr_t) &child->thread.acrs + offset); - } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) { - /* - * orig_gpr2 is stored on the kernel stack - */ - tmp = *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4); +#ifdef CONFIG_COMPAT +static int +s390_genregs_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + struct pt_regs *regs = task_pt_regs(target); + int ret = 0; + + /* Fake a 31 bit psw mask. */ + if (count > 0 && pos == PT_PSWMASK / 2) { + u32 pswmask = PSW32_MASK_MERGE(psw32_user_bits, + (u32) (regs->psw.mask >> 32)); + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &pswmask, PT_PSWMASK / 2, + PT_PSWADDR / 2); + } - } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) { - /* - * floating point regs. are stored in the thread structure - */ - offset = addr - (addr_t) &dummy32->regs.fp_regs; - tmp = *(__u32 *)((addr_t) &child->thread.fp_regs + offset); + /* Fake a 31 bit psw address. */ + if (ret == 0 && count > 0 && pos == PT_PSWADDR / 2) { + u32 pswaddr = (u32) regs->psw.addr | PSW32_ADDR_AMODE31; + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + &pswaddr, PT_PSWADDR / 2, + PT_GPR0 / 2); + } - } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) { - /* - * per_info is found in the thread structure - */ - offset = addr - (addr_t) &dummy32->regs.per_info; - /* This is magic. See per_struct and per_struct32. */ - if ((offset >= (addr_t) &dummy_per32->control_regs && - offset < (addr_t) (&dummy_per32->control_regs + 1)) || - (offset >= (addr_t) &dummy_per32->starting_addr && - offset <= (addr_t) &dummy_per32->ending_addr) || - offset == (addr_t) &dummy_per32->lowcore.words.address) - offset = offset*2 + 4; + /* The GPRs are directly on the stack. Just truncate them. */ + while (ret == 0 && count > 0 && pos < PT_ACR0 / 2) { + u32 value = regs->gprs[(pos - PT_GPR0 / 2) / sizeof(u32)]; + if (kbuf) { + *(u32 *) kbuf = value; + kbuf += sizeof(u32); + } + else if (put_user(value, (u32 __user *) ubuf)) + ret = -EFAULT; else - offset = offset*2; - tmp = *(__u32 *)((addr_t) &child->thread.per_info + offset); + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + + /* The ACRs are kept in the thread_struct. */ + if (ret == 0 && count > 0 && pos < PT_ACR0 / 2 + NUM_ACRS * ACR_SIZE) { + if (target == current) + save_access_regs(target->thread.acrs); + + ret = utrace_regset_copyout(&pos, &count, &kbuf, &ubuf, + target->thread.acrs, + PT_ACR0 / 2, + PT_ACR0 / 2 + NUM_ACRS * ACR_SIZE); + } - } else - tmp = 0; + /* Finally, the ORIG_GPR2 value. */ + if (count > 0) { + if (kbuf) + *(u32 *) kbuf = regs->orig_gpr2; + else if (put_user((u32) regs->orig_gpr2, + (u32 __user *) ubuf)) + return -EFAULT; + } - return put_user(tmp, (__u32 __user *) data); + return 0; } -/* - * Same as poke_user but for a 31 bit program. - */ static int -poke_user_emu31(struct task_struct *child, addr_t addr, addr_t data) -{ - struct user32 *dummy32 = NULL; - per_struct32 *dummy_per32 = NULL; - addr_t offset; - __u32 tmp; +s390_genregs_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + struct pt_regs *regs = task_pt_regs(target); + int ret = 0; + + /* Check for an invalid PSW mask. */ + if (count > 0 && pos == PT_PSWMASK / 2) { + u32 pswmask; + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &pswmask, PT_PSWMASK / 2, + PT_PSWADDR / 2); + if (ret) + return ret; - if (!test_thread_flag(TIF_31BIT) || - (addr & 3) || addr > sizeof(struct user32) - 3) - return -EIO; + if (pswmask != PSW_MASK_MERGE(psw_user32_bits, pswmask)) + /* Invalid psw mask. */ + return -EINVAL; - tmp = (__u32) data; + /* Build a 64 bit psw mask from 31 bit mask. */ + regs->psw.mask = PSW_MASK_MERGE(psw_user32_bits, + (u64) pswmask << 32); + FixPerRegisters(target); + } - if (addr < (addr_t) &dummy32->regs.acrs) { - /* - * psw, gprs, acrs and orig_gpr2 are stored on the stack - */ - if (addr == (addr_t) &dummy32->regs.psw.mask) { + /* Build a 64 bit psw address from 31 bit address. */ + if (count > 0 && pos == PT_PSWADDR / 2) { + u32 pswaddr; + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + &pswaddr, PT_PSWADDR / 2, + PT_GPR0 / 2); + if (ret == 0) /* Build a 64 bit psw mask from 31 bit mask. */ - if (tmp != PSW32_MASK_MERGE(psw32_user_bits, tmp)) - /* Invalid psw mask. */ - return -EINVAL; - task_pt_regs(child)->psw.mask = - PSW_MASK_MERGE(psw_user32_bits, (__u64) tmp << 32); - } else if (addr == (addr_t) &dummy32->regs.psw.addr) { - /* Build a 64 bit psw address from 31 bit address. */ - task_pt_regs(child)->psw.addr = - (__u64) tmp & PSW32_ADDR_INSN; - } else { - /* gpr 0-15 */ - *(__u32*)((addr_t) &task_pt_regs(child)->psw - + addr*2 + 4) = tmp; - } - } else if (addr < (addr_t) (&dummy32->regs.orig_gpr2)) { - /* - * access registers are stored in the thread structure - */ - offset = addr - (addr_t) &dummy32->regs.acrs; - *(__u32*)((addr_t) &child->thread.acrs + offset) = tmp; - - } else if (addr == (addr_t) (&dummy32->regs.orig_gpr2)) { - /* - * orig_gpr2 is stored on the kernel stack - */ - *(__u32*)((addr_t) &task_pt_regs(child)->orig_gpr2 + 4) = tmp; - - } else if (addr < (addr_t) (&dummy32->regs.fp_regs + 1)) { - /* - * floating point regs. are stored in the thread structure - */ - if (addr == (addr_t) &dummy32->regs.fp_regs.fpc && - (tmp & ~FPC_VALID_MASK) != 0) - /* Invalid floating point control. */ - return -EINVAL; - offset = addr - (addr_t) &dummy32->regs.fp_regs; - *(__u32 *)((addr_t) &child->thread.fp_regs + offset) = tmp; + regs->psw.addr = pswaddr & PSW32_ADDR_INSN; + } - } else if (addr < (addr_t) (&dummy32->regs.per_info + 1)) { - /* - * per_info is found in the thread structure. - */ - offset = addr - (addr_t) &dummy32->regs.per_info; - /* - * This is magic. See per_struct and per_struct32. - * By incident the offsets in per_struct are exactly - * twice the offsets in per_struct32 for all fields. - * The 8 byte fields need special handling though, - * because the second half (bytes 4-7) is needed and - * not the first half. - */ - if ((offset >= (addr_t) &dummy_per32->control_regs && - offset < (addr_t) (&dummy_per32->control_regs + 1)) || - (offset >= (addr_t) &dummy_per32->starting_addr && - offset <= (addr_t) &dummy_per32->ending_addr) || - offset == (addr_t) &dummy_per32->lowcore.words.address) - offset = offset*2 + 4; + /* The GPRs are directly onto the stack. */ + while (ret == 0 && count > 0 && pos < PT_ACR0 / 2) { + u32 value; + + if (kbuf) { + value = *(const u32 *) kbuf; + kbuf += sizeof(u32); + } + else if (get_user(value, (const u32 __user *) ubuf)) + return -EFAULT; else - offset = offset*2; - *(__u32 *)((addr_t) &child->thread.per_info + offset) = tmp; + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + regs->gprs[(pos - PT_GPR0 / 2) / sizeof(u32)] = value; } - FixPerRegisters(child); - return 0; -} + /* The ACRs are kept in the thread_struct. */ + if (count > 0 && pos < PT_ORIGGPR2 / 2) { + if (target == current + && (pos != PT_ACR0 / 2 + || count < sizeof(target->thread.acrs))) + save_access_regs(target->thread.acrs); + + ret = utrace_regset_copyin(&pos, &count, &kbuf, &ubuf, + target->thread.acrs, + PT_ACR0 / 2, + PT_ACR0 / 2 + NUM_ACRS * ACR_SIZE); -static int -do_ptrace_emu31(struct task_struct *child, long request, long addr, long data) -{ - unsigned int tmp; /* 4 bytes !! */ - ptrace_area_emu31 parea; - int copied, ret; - - switch (request) { - case PTRACE_PEEKTEXT: - case PTRACE_PEEKDATA: - /* read word at location addr. */ - copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); - if (copied != sizeof(tmp)) - return -EIO; - return put_user(tmp, (unsigned int __force __user *) data); - - case PTRACE_PEEKUSR: - /* read the word at location addr in the USER area. */ - return peek_user_emu31(child, addr, data); - - case PTRACE_POKETEXT: - case PTRACE_POKEDATA: - /* write the word at location addr. */ - tmp = data; - copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 1); - if (copied != sizeof(tmp)) - return -EIO; - return 0; - - case PTRACE_POKEUSR: - /* write the word at location addr in the USER area */ - return poke_user_emu31(child, addr, data); - - case PTRACE_PEEKUSR_AREA: - case PTRACE_POKEUSR_AREA: - if (copy_from_user(&parea, (void __force __user *) addr, - sizeof(parea))) + if (ret == 0 && target == current) + restore_access_regs(target->thread.acrs); + } + + /* Finally, the ORIG_GPR2 value. */ + if (ret == 0 && count > 0) { + u32 value; + if (kbuf) + value = *(const u32 *) kbuf; + else if (get_user(value, (const u32 __user *) ubuf)) return -EFAULT; - addr = parea.kernel_addr; - data = parea.process_addr; - copied = 0; - while (copied < parea.len) { - if (request == PTRACE_PEEKUSR_AREA) - ret = peek_user_emu31(child, addr, data); - else { - __u32 utmp; - if (get_user(utmp, - (__u32 __force __user *) data)) - return -EFAULT; - ret = poke_user_emu31(child, addr, utmp); - } - if (ret) - return ret; - addr += sizeof(unsigned int); - data += sizeof(unsigned int); - copied += sizeof(unsigned int); - } - return 0; -#if 0 /* XXX */ - case PTRACE_GETEVENTMSG: - return put_user((__u32) child->ptrace_message, - (unsigned int __force __user *) data); - case PTRACE_GETSIGINFO: - if (child->last_siginfo == NULL) - return -EINVAL; - return copy_siginfo_to_user32((compat_siginfo_t - __force __user *) data, - child->last_siginfo); - case PTRACE_SETSIGINFO: - if (child->last_siginfo == NULL) - return -EINVAL; - return copy_siginfo_from_user32(child->last_siginfo, - (compat_siginfo_t - __force __user *) data); + regs->orig_gpr2 = value; } - return ptrace_request(child, request, addr, data); + + return ret; } -#endif -#define PT32_IEEE_IP 0x13c -static int -do_ptrace(struct task_struct *child, long request, long addr, long data) +/* + * This is magic. See per_struct and per_struct32. + * By incident the offsets in per_struct are exactly + * twice the offsets in per_struct32 for all fields. + * The 8 byte fields need special handling though, + * because the second half (bytes 4-7) is needed and + * not the first half. + */ +static unsigned int +offset_from_per32(unsigned int offset) { - int ret; - - if (request == PTRACE_ATTACH) - return ptrace_attach(child); - - /* - * Special cases to get/store the ieee instructions pointer. - */ - if (child == current) { - if (request == PTRACE_PEEKUSR && addr == PT_IEEE_IP) - return peek_user(child, addr, data); - if (request == PTRACE_POKEUSR && addr == PT_IEEE_IP) - return poke_user(child, addr, data); -#ifdef CONFIG_COMPAT - if (request == PTRACE_PEEKUSR && - addr == PT32_IEEE_IP && test_thread_flag(TIF_31BIT)) - return peek_user_emu31(child, addr, data); - if (request == PTRACE_POKEUSR && - addr == PT32_IEEE_IP && test_thread_flag(TIF_31BIT)) - return poke_user_emu31(child, addr, data); -#endif - } + BUILD_BUG_ON(offsetof(per_struct32, control_regs) != 0); + if (offset - offsetof(per_struct32, control_regs) < 3*sizeof(u32) + || (offset >= offsetof(per_struct32, starting_addr) && + offset <= offsetof(per_struct32, ending_addr)) + || offset == offsetof(per_struct32, lowcore.words.address)) + offset = offset*2 + 4; + else + offset = offset*2; + return offset; +} - ret = ptrace_check_attach(child, request == PTRACE_KILL); - if (ret < 0) - return ret; - - switch (request) { - case PTRACE_SYSCALL: - /* continue and stop at next (return from) syscall */ - case PTRACE_CONT: - /* restart after signal. */ - if (!valid_signal(data)) - return -EIO; - if (request == PTRACE_SYSCALL) - set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); +static int +s390_per_info_get(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + void *kbuf, void __user *ubuf) +{ + while (count > 0) { + u32 val = *(u32 *) ((char *) &target->thread.per_info + + offset_from_per32 (pos)); + if (kbuf) { + *(u32 *) kbuf = val; + kbuf += sizeof(u32); + } + else if (put_user(val, (u32 __user *) ubuf)) + return -EFAULT; else - clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); - child->exit_code = data; - /* make sure the single step bit is not set. */ - tracehook_disable_single_step(child); - wake_up_process(child); - return 0; + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); + } + return 0; +} - case PTRACE_KILL: - /* - * make the child exit. Best I can do is send it a sigkill. - * perhaps it should be put in the status that it wants to - * exit. - */ - if (child->exit_state == EXIT_ZOMBIE) /* already dead */ - return 0; - child->exit_code = SIGKILL; - /* make sure the single step bit is not set. */ - tracehook_disable_single_step(child); - wake_up_process(child); - return 0; - - case PTRACE_SINGLESTEP: - /* set the trap flag. */ - if (!valid_signal(data)) - return -EIO; - clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); - child->exit_code = data; - if (data) - set_tsk_thread_flag(child, TIF_SINGLE_STEP); +static int +s390_per_info_set(struct task_struct *target, + const struct utrace_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, const void __user *ubuf) +{ + while (count > 0) { + u32 val; + + if (kbuf) { + val = *(const u32 *) kbuf; + kbuf += sizeof(u32); + } + else if (get_user(val, (const u32 __user *) ubuf)) + return -EFAULT; else - tracehook_enable_single_step(child); - /* give it a chance to run. */ - wake_up_process(child); - return 0; - - case PTRACE_DETACH: - /* detach a process that was attached. */ - return ptrace_detach(child, data); - + ubuf += sizeof(u32); + pos += sizeof(u32); + count -= sizeof(u32); - /* Do requests that differ for 31/64 bit */ - default: -#ifdef CONFIG_COMPAT - if (test_thread_flag(TIF_31BIT)) - return do_ptrace_emu31(child, request, addr, data); -#endif - return do_ptrace_normal(child, request, addr, data); + *(u32 *) ((char *) &target->thread.per_info + + offset_from_per32 (pos)) = val; } - /* Not reached. */ - return -EIO; + return 0; } -asmlinkage long -sys_ptrace(long request, long pid, long addr, long data) -{ - struct task_struct *child; - int ret; - lock_kernel(); - if (request == PTRACE_TRACEME) { - ret = ptrace_traceme(); - goto out; - } - - child = ptrace_get_task_struct(pid); - if (IS_ERR(child)) { - ret = PTR_ERR(child); - goto out; - } - - ret = do_ptrace(child, request, addr, data); - put_task_struct(child); -out: - unlock_kernel(); - return ret; -} +static const struct utrace_regset s390_compat_regsets[] = { + { + .size = sizeof(u32), .align = sizeof(u32), + .n = sizeof(s390_regs) / sizeof(long), + .get = s390_genregs_get, .set = s390_genregs_set + }, + { + .size = sizeof(u32), .align = sizeof(u32), + .n = sizeof(s390_fp_regs) / sizeof(u32), + .get = fpregs_get, .set = fpregs_set + }, + { + .size = sizeof(u32), .align = sizeof(u32), + .n = sizeof(per_struct) / sizeof(u32), + .get = s390_per_info_get, .set = s390_per_info_set + }, +}; + +const struct utrace_regset_view utrace_s390_compat_view = { + .name = "s390", .e_machine = EM_S390, + .regsets = s390_compat_regsets, .n = ARRAY_SIZE(s390_compat_regsets) +}; +EXPORT_SYMBOL_GPL(utrace_s390_compat_view); +#endif /* CONFIG_COMPAT */ + asmlinkage void syscall_trace(struct pt_regs *regs, int entryexit)