LXR linux/arch/s390/kernel/compat

   1/*
   2 *    Copyright IBM Corp. 2000, 2006
   3 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   4 *               Gerhard Tonn (ton@de.ibm.com)                  
   5 *
   6 *  Copyright (C) 1991, 1992  Linus Torvalds
   7 *
   8 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
   9 */
  10
  11#include <linux/compat.h>
  12#include <linux/sched.h>
  13#include <linux/mm.h>
  14#include <linux/smp.h>
  15#include <linux/kernel.h>
  16#include <linux/signal.h>
  17#include <linux/errno.h>
  18#include <linux/wait.h>
  19#include <linux/ptrace.h>
  20#include <linux/unistd.h>
  21#include <linux/stddef.h>
  22#include <linux/tty.h>
  23#include <linux/personality.h>
  24#include <linux/binfmts.h>
  25#include <asm/ucontext.h>
  26#include <asm/uaccess.h>
  27#include <asm/lowcore.h>
  28#include <asm/switch_to.h>
  29#include "compat_linux.h"
  30#include "compat_ptrace.h"
  31#include "entry.h"
  32
  33typedef struct 
  34{
  35        __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  36        struct sigcontext32 sc;
  37        _sigregs32 sregs;
  38        int signo;
  39        _sigregs_ext32 sregs_ext;
  40        __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
  41} sigframe32;
  42
  43typedef struct 
  44{
  45        __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  46        __u16 svc_insn;
  47        compat_siginfo_t info;
  48        struct ucontext32 uc;
  49} rt_sigframe32;
  50
  51static inline void sigset_to_sigset32(unsigned long *set64,
  52                                      compat_sigset_word *set32)
  53{
  54        set32[0] = (compat_sigset_word) set64[0];
  55        set32[1] = (compat_sigset_word)(set64[0] >> 32);
  56}
  57
  58static inline void sigset32_to_sigset(compat_sigset_word *set32,
  59                                      unsigned long *set64)
  60{
  61        set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32);
  62}
  63
  64int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
  65{
  66        int err;
  67
  68        /* If you change siginfo_t structure, please be sure
  69           this code is fixed accordingly.
  70           It should never copy any pad contained in the structure
  71           to avoid security leaks, but must copy the generic
  72           3 ints plus the relevant union member.  
  73           This routine must convert siginfo from 64bit to 32bit as well
  74           at the same time.  */
  75        err = __put_user(from->si_signo, &to->si_signo);
  76        err |= __put_user(from->si_errno, &to->si_errno);
  77        err |= __put_user((short)from->si_code, &to->si_code);
  78        if (from->si_code < 0)
  79                err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  80        else {
  81                switch (from->si_code >> 16) {
  82                case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
  83                case __SI_MESGQ >> 16:
  84                        err |= __put_user(from->si_int, &to->si_int);
  85                        /* fallthrough */
  86                case __SI_KILL >> 16:
  87                        err |= __put_user(from->si_pid, &to->si_pid);
  88                        err |= __put_user(from->si_uid, &to->si_uid);
  89                        break;
  90                case __SI_CHLD >> 16:
  91                        err |= __put_user(from->si_pid, &to->si_pid);
  92                        err |= __put_user(from->si_uid, &to->si_uid);
  93                        err |= __put_user(from->si_utime, &to->si_utime);
  94                        err |= __put_user(from->si_stime, &to->si_stime);
  95                        err |= __put_user(from->si_status, &to->si_status);
  96                        break;
  97                case __SI_FAULT >> 16:
  98                        err |= __put_user((unsigned long) from->si_addr,
  99                                          &to->si_addr);
 100                        break;
 101                case __SI_POLL >> 16:
 102                        err |= __put_user(from->si_band, &to->si_band);
 103                        err |= __put_user(from->si_fd, &to->si_fd);
 104                        break;
 105                case __SI_TIMER >> 16:
 106                        err |= __put_user(from->si_tid, &to->si_tid);
 107                        err |= __put_user(from->si_overrun, &to->si_overrun);
 108                        err |= __put_user(from->si_int, &to->si_int);
 109                        break;
 110                default:
 111                        break;
 112                }
 113        }
 114        return err ? -EFAULT : 0;
 115}
 116
 117int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 118{
 119        int err;
 120        u32 tmp;
 121
 122        err = __get_user(to->si_signo, &from->si_signo);
 123        err |= __get_user(to->si_errno, &from->si_errno);
 124        err |= __get_user(to->si_code, &from->si_code);
 125
 126        if (to->si_code < 0)
 127                err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 128        else {
 129                switch (to->si_code >> 16) {
 130                case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 131                case __SI_MESGQ >> 16:
 132                        err |= __get_user(to->si_int, &from->si_int);
 133                        /* fallthrough */
 134                case __SI_KILL >> 16:
 135                        err |= __get_user(to->si_pid, &from->si_pid);
 136                        err |= __get_user(to->si_uid, &from->si_uid);
 137                        break;
 138                case __SI_CHLD >> 16:
 139                        err |= __get_user(to->si_pid, &from->si_pid);
 140                        err |= __get_user(to->si_uid, &from->si_uid);
 141                        err |= __get_user(to->si_utime, &from->si_utime);
 142                        err |= __get_user(to->si_stime, &from->si_stime);
 143                        err |= __get_user(to->si_status, &from->si_status);
 144                        break;
 145                case __SI_FAULT >> 16:
 146                        err |= __get_user(tmp, &from->si_addr);
 147                        to->si_addr = (void __force __user *)
 148                                (u64) (tmp & PSW32_ADDR_INSN);
 149                        break;
 150                case __SI_POLL >> 16:
 151                        err |= __get_user(to->si_band, &from->si_band);
 152                        err |= __get_user(to->si_fd, &from->si_fd);
 153                        break;
 154                case __SI_TIMER >> 16:
 155                        err |= __get_user(to->si_tid, &from->si_tid);
 156                        err |= __get_user(to->si_overrun, &from->si_overrun);
 157                        err |= __get_user(to->si_int, &from->si_int);
 158                        break;
 159                default:
 160                        break;
 161                }
 162        }
 163        return err ? -EFAULT : 0;
 164}
 165
 166/* Store registers needed to create the signal frame */
 167static void store_sigregs(void)
 168{
 169        save_access_regs(current->thread.acrs);
 170        save_fpu_regs();
 171}
 172
 173/* Load registers after signal return */
 174static void load_sigregs(void)
 175{
 176        restore_access_regs(current->thread.acrs);
 177}
 178
 179static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 180{
 181        _sigregs32 user_sregs;
 182        int i;
 183
 184        user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
 185        user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
 186        user_sregs.regs.psw.mask |= PSW32_USER_BITS;
 187        user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
 188                (__u32)(regs->psw.mask & PSW_MASK_BA);
 189        for (i = 0; i < NUM_GPRS; i++)
 190                user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
 191        memcpy(&user_sregs.regs.acrs, current->thread.acrs,
 192               sizeof(user_sregs.regs.acrs));
 193        fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
 194        if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
 195                return -EFAULT;
 196        return 0;
 197}
 198
 199static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 200{
 201        _sigregs32 user_sregs;
 202        int i;
 203
 204        /* Alwys make any pending restarted system call return -EINTR */
 205        current->restart_block.fn = do_no_restart_syscall;
 206
 207        if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
 208                return -EFAULT;
 209
 210        if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
 211                return -EINVAL;
 212
 213        /* Test the floating-point-control word. */
 214        if (test_fp_ctl(user_sregs.fpregs.fpc))
 215                return -EINVAL;
 216
 217        /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
 218        regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
 219                (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
 220                (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
 221                (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
 222        /* Check for invalid user address space control. */
 223        if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
 224                regs->psw.mask = PSW_ASC_PRIMARY |
 225                        (regs->psw.mask & ~PSW_MASK_ASC);
 226        regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
 227        for (i = 0; i < NUM_GPRS; i++)
 228                regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
 229        memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
 230               sizeof(current->thread.acrs));
 231        fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
 232
 233        clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
 234        return 0;
 235}
 236
 237static int save_sigregs_ext32(struct pt_regs *regs,
 238                              _sigregs_ext32 __user *sregs_ext)
 239{
 240        __u32 gprs_high[NUM_GPRS];
 241        __u64 vxrs[__NUM_VXRS_LOW];
 242        int i;
 243
 244        /* Save high gprs to signal stack */
 245        for (i = 0; i < NUM_GPRS; i++)
 246                gprs_high[i] = regs->gprs[i] >> 32;
 247        if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
 248                           sizeof(sregs_ext->gprs_high)))
 249                return -EFAULT;
 250
 251        /* Save vector registers to signal stack */
 252        if (MACHINE_HAS_VX) {
 253                for (i = 0; i < __NUM_VXRS_LOW; i++)
 254                        vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
 255                if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
 256                                   sizeof(sregs_ext->vxrs_low)) ||
 257                    __copy_to_user(&sregs_ext->vxrs_high,
 258                                   current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 259                                   sizeof(sregs_ext->vxrs_high)))
 260                        return -EFAULT;
 261        }
 262        return 0;
 263}
 264
 265static int restore_sigregs_ext32(struct pt_regs *regs,
 266                                 _sigregs_ext32 __user *sregs_ext)
 267{
 268        __u32 gprs_high[NUM_GPRS];
 269        __u64 vxrs[__NUM_VXRS_LOW];
 270        int i;
 271
 272        /* Restore high gprs from signal stack */
 273        if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
 274                             sizeof(sregs_ext->gprs_high)))
 275                return -EFAULT;
 276        for (i = 0; i < NUM_GPRS; i++)
 277                *(__u32 *)&regs->gprs[i] = gprs_high[i];
 278
 279        /* Restore vector registers from signal stack */
 280        if (MACHINE_HAS_VX) {
 281                if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
 282                                     sizeof(sregs_ext->vxrs_low)) ||
 283                    __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 284                                     &sregs_ext->vxrs_high,
 285                                     sizeof(sregs_ext->vxrs_high)))
 286                        return -EFAULT;
 287                for (i = 0; i < __NUM_VXRS_LOW; i++)
 288                        *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
 289        }
 290        return 0;
 291}
 292
 293COMPAT_SYSCALL_DEFINE0(sigreturn)
 294{
 295        struct pt_regs *regs = task_pt_regs(current);
 296        sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 297        compat_sigset_t cset;
 298        sigset_t set;
 299
 300        if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 301                goto badframe;
 302        sigset32_to_sigset(cset.sig, set.sig);
 303        set_current_blocked(&set);
 304        save_fpu_regs();
 305        if (restore_sigregs32(regs, &frame->sregs))
 306                goto badframe;
 307        if (restore_sigregs_ext32(regs, &frame->sregs_ext))
 308                goto badframe;
 309        load_sigregs();
 310        return regs->gprs[2];
 311badframe:
 312        force_sig(SIGSEGV, current);
 313        return 0;
 314}
 315
 316COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
 317{
 318        struct pt_regs *regs = task_pt_regs(current);
 319        rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 320        compat_sigset_t cset;
 321        sigset_t set;
 322
 323        if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset)))
 324                goto badframe;
 325        sigset32_to_sigset(cset.sig, set.sig);
 326        set_current_blocked(&set);
 327        if (compat_restore_altstack(&frame->uc.uc_stack))
 328                goto badframe;
 329        save_fpu_regs();
 330        if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 331                goto badframe;
 332        if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
 333                goto badframe;
 334        load_sigregs();
 335        return regs->gprs[2];
 336badframe:
 337        force_sig(SIGSEGV, current);
 338        return 0;
 339}       
 340
 341/*
 342 * Set up a signal frame.
 343 */
 344
 345
 346/*
 347 * Determine which stack to use..
 348 */
 349static inline void __user *
 350get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 351{
 352        unsigned long sp;
 353
 354        /* Default to using normal stack */
 355        sp = (unsigned long) A(regs->gprs[15]);
 356
 357        /* Overflow on alternate signal stack gives SIGSEGV. */
 358        if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
 359                return (void __user *) -1UL;
 360
 361        /* This is the X/Open sanctioned signal stack switching.  */
 362        if (ka->sa.sa_flags & SA_ONSTACK) {
 363                if (! sas_ss_flags(sp))
 364                        sp = current->sas_ss_sp + current->sas_ss_size;
 365        }
 366
 367        return (void __user *)((sp - frame_size) & -8ul);
 368}
 369
 370static int setup_frame32(struct ksignal *ksig, sigset_t *set,
 371                         struct pt_regs *regs)
 372{
 373        int sig = ksig->sig;
 374        sigframe32 __user *frame;
 375        struct sigcontext32 sc;
 376        unsigned long restorer;
 377        size_t frame_size;
 378
 379        /*
 380         * gprs_high are always present for 31-bit compat tasks.
 381         * The space for vector registers is only allocated if
 382         * the machine supports it
 383         */
 384        frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
 385        if (!MACHINE_HAS_VX)
 386                frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
 387                              sizeof(frame->sregs_ext.vxrs_high);
 388        frame = get_sigframe(&ksig->ka, regs, frame_size);
 389        if (frame == (void __user *) -1UL)
 390                return -EFAULT;
 391
 392        /* Set up backchain. */
 393        if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 394                return -EFAULT;
 395
 396        /* Create struct sigcontext32 on the signal stack */
 397        sigset_to_sigset32(set->sig, sc.oldmask);
 398        sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
 399        if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
 400                return -EFAULT;
 401
 402        /* Store registers needed to create the signal frame */
 403        store_sigregs();
 404
 405        /* Create _sigregs32 on the signal stack */
 406        if (save_sigregs32(regs, &frame->sregs))
 407                return -EFAULT;
 408
 409        /* Place signal number on stack to allow backtrace from handler.  */
 410        if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
 411                return -EFAULT;
 412
 413        /* Create _sigregs_ext32 on the signal stack */
 414        if (save_sigregs_ext32(regs, &frame->sregs_ext))
 415                return -EFAULT;
 416
 417        /* Set up to return from userspace.  If provided, use a stub
 418           already in userspace.  */
 419        if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 420                restorer = (unsigned long __force)
 421                        ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
 422        } else {
 423                /* Signal frames without vectors registers are short ! */
 424                __u16 __user *svc = (void __user *) frame + frame_size - 2;
 425                if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
 426                        return -EFAULT;
 427                restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
 428        }
 429
 430        /* Set up registers for signal handler */
 431        regs->gprs[14] = restorer;
 432        regs->gprs[15] = (__force __u64) frame;
 433        /* Force 31 bit amode and default user address space control. */
 434        regs->psw.mask = PSW_MASK_BA |
 435                (PSW_USER_BITS & PSW_MASK_ASC) |
 436                (regs->psw.mask & ~PSW_MASK_ASC);
 437        regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
 438
 439        regs->gprs[2] = sig;
 440        regs->gprs[3] = (__force __u64) &frame->sc;
 441
 442        /* We forgot to include these in the sigcontext.
 443           To avoid breaking binary compatibility, they are passed as args. */
 444        if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
 445            sig == SIGTRAP || sig == SIGFPE) {
 446                /* set extra registers only for synchronous signals */
 447                regs->gprs[4] = regs->int_code & 127;
 448                regs->gprs[5] = regs->int_parm_long;
 449                regs->gprs[6] = task_thread_info(current)->last_break;
 450        }
 451
 452        return 0;
 453}
 454
 455static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
 456                            struct pt_regs *regs)
 457{
 458        compat_sigset_t cset;
 459        rt_sigframe32 __user *frame;
 460        unsigned long restorer;
 461        size_t frame_size;
 462        u32 uc_flags;
 463
 464        frame_size = sizeof(*frame) -
 465                     sizeof(frame->uc.uc_mcontext_ext.__reserved);
 466        /*
 467         * gprs_high are always present for 31-bit compat tasks.
 468         * The space for vector registers is only allocated if
 469         * the machine supports it
 470         */
 471        uc_flags = UC_GPRS_HIGH;
 472        if (MACHINE_HAS_VX) {
 473                uc_flags |= UC_VXRS;
 474        } else
 475                frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
 476                              sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
 477        frame = get_sigframe(&ksig->ka, regs, frame_size);
 478        if (frame == (void __user *) -1UL)
 479                return -EFAULT;
 480
 481        /* Set up backchain. */
 482        if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
 483                return -EFAULT;
 484
 485        /* Set up to return from userspace.  If provided, use a stub
 486           already in userspace.  */
 487        if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 488                restorer = (unsigned long __force)
 489                        ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
 490        } else {
 491                __u16 __user *svc = &frame->svc_insn;
 492                if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
 493                        return -EFAULT;
 494                restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
 495        }
 496
 497        /* Create siginfo on the signal stack */
 498        if (copy_siginfo_to_user32(&frame->info, &ksig->info))
 499                return -EFAULT;
 500
 501        /* Store registers needed to create the signal frame */
 502        store_sigregs();
 503
 504        /* Create ucontext on the signal stack. */
 505        sigset_to_sigset32(set->sig, cset.sig);
 506        if (__put_user(uc_flags, &frame->uc.uc_flags) ||
 507            __put_user(0, &frame->uc.uc_link) ||
 508            __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
 509            save_sigregs32(regs, &frame->uc.uc_mcontext) ||
 510            __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) ||
 511            save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
 512                return -EFAULT;
 513
 514        /* Set up registers for signal handler */
 515        regs->gprs[14] = restorer;
 516        regs->gprs[15] = (__force __u64) frame;
 517        /* Force 31 bit amode and default user address space control. */
 518        regs->psw.mask = PSW_MASK_BA |
 519                (PSW_USER_BITS & PSW_MASK_ASC) |
 520                (regs->psw.mask & ~PSW_MASK_ASC);
 521        regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
 522
 523        regs->gprs[2] = ksig->sig;
 524        regs->gprs[3] = (__force __u64) &frame->info;
 525        regs->gprs[4] = (__force __u64) &frame->uc;
 526        regs->gprs[5] = task_thread_info(current)->last_break;
 527        return 0;
 528}
 529
 530/*
 531 * OK, we're invoking a handler
 532 */     
 533
 534void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
 535                     struct pt_regs *regs)
 536{
 537        int ret;
 538
 539        /* Set up the stack frame */
 540        if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 541                ret = setup_rt_frame32(ksig, oldset, regs);
 542        else
 543                ret = setup_frame32(ksig, oldset, regs);
 544
 545        signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
 546}
 547
 548