arch/ppc64/kernel/signal.c

   1 /*
   2  *  linux/arch/ppc64/kernel/signal.c
   3  *
   4  *  PowerPC version
   5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   6  *
   7  *  Derived from "arch/i386/kernel/signal.c"
   8  *    Copyright (C) 1991, 1992 Linus Torvalds
   9  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  10  *
  11  *  This program is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU General Public License
  13  *  as published by the Free Software Foundation; either version
  14  *  2 of the License, or (at your option) any later version.
  15  */
  16
  17 #include <linux/config.h>
  18 #include <linux/sched.h>
  19 #include <linux/mm.h>
  20 #include <linux/smp.h>
  21 #include <linux/smp_lock.h>
  22 #include <linux/kernel.h>
  23 #include <linux/signal.h>
  24 #include <linux/errno.h>
  25 #include <linux/wait.h>
  26 #include <linux/unistd.h>
  27 #include <linux/stddef.h>
  28 #include <linux/elf.h>
  29 #include <linux/ptrace.h>
  30 #include <linux/module.h>
  31
  32 #include <asm/sigcontext.h>
  33 #include <asm/ucontext.h>
  34 #include <asm/uaccess.h>
  35 #include <asm/pgtable.h>
  36 #include <asm/ppcdebug.h>
  37 #include <asm/unistd.h>
  38 #include <asm/cacheflush.h>
  39 #include <asm/vdso.h>
  40
  41 #define DEBUG_SIG 0
  42
  43 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  44
  45 #ifndef MIN
  46 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  47 #endif
  48
  49 #define GP_REGS_SIZE    MIN(sizeof(elf_gregset_t), sizeof(struct pt_regs))
  50 #define FP_REGS_SIZE    sizeof(elf_fpregset_t)
  51
  52 #define TRAMP_TRACEBACK 3
  53 #define TRAMP_SIZE      6
  54
  55 /*
  56  * When we have signals to deliver, we set up on the user stack,
  57  * going down from the original stack pointer:
  58  *      1) a rt_sigframe struct which contains the ucontext
  59  *      2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller
  60  *         frame for the signal handler.
  61  */
  62
  63 struct rt_sigframe {
  64         /* sys_rt_sigreturn requires the ucontext be the first field */
  65         struct ucontext uc;
  66         unsigned long _unused[2];
  67         unsigned int tramp[TRAMP_SIZE];
  68         struct siginfo *pinfo;
  69         void *puc;
  70         struct siginfo info;
  71         /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
  72         char abigap[288];
  73 } __attribute__ ((aligned (16)));
  74
  75
  76 /*
  77  * Atomically swap in the new signal mask, and wait for a signal.
  78  */
  79 long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, int p3, int p4,
  80                        int p6, int p7, struct pt_regs *regs)
  81 {
  82         sigset_t saveset, newset;
  83
  84         /* XXX: Don't preclude handling different sized sigset_t's.  */
  85         if (sigsetsize != sizeof(sigset_t))
  86                 return -EINVAL;
  87
  88         if (copy_from_user(&newset, unewset, sizeof(newset)))
  89                 return -EFAULT;
  90         sigdelsetmask(&newset, ~_BLOCKABLE);
  91
  92         spin_lock_irq(&current->sighand->siglock);
  93         saveset = current->blocked;
  94         current->blocked = newset;
  95         recalc_sigpending();
  96         spin_unlock_irq(&current->sighand->siglock);
  97
  98         regs->result = -EINTR;
  99         regs->gpr[3] = EINTR;
 100         regs->ccr |= 0x10000000;
 101         while (1) {
 102                 current->state = TASK_INTERRUPTIBLE;
 103                 schedule();
 104                 if (do_signal(&saveset, regs))
 105                         return 0;
 106         }
 107 }
 108
 109 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, unsigned long r5,
 110                      unsigned long r6, unsigned long r7, unsigned long r8,
 111                      struct pt_regs *regs)
 112 {
 113         return do_sigaltstack(uss, uoss, regs->gpr[1]);
 114 }
 115
 116
 117 /*
 118  * Set up the sigcontext for the signal frame.
 119  */
 120
 121 static long setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 122                  int signr, sigset_t *set, unsigned long handler)
 123 {
 124         /* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
 125          * process never used altivec yet (MSR_VEC is zero in pt_regs of
 126          * the context). This is very important because we must ensure we
 127          * don't lose the VRSAVE content that may have been set prior to
 128          * the process doing its first vector operation
 129          * Userland shall check AT_HWCAP to know wether it can rely on the
 130          * v_regs pointer or not
 131          */
 132 #ifdef CONFIG_ALTIVEC
 133         elf_vrreg_t __user *v_regs = (elf_vrreg_t __user *)(((unsigned long)sc->vmx_reserve + 15) & ~0xful);
 134 #endif
 135         long err = 0;
 136
 137         flush_fp_to_thread(current);
 138
 139         /* Make sure signal doesn't get spurrious FP exceptions */
 140         current->thread.fpscr = 0;
 141
 142 #ifdef CONFIG_ALTIVEC
 143         err |= __put_user(v_regs, &sc->v_regs);
 144
 145         /* save altivec registers */
 146         if (current->thread.used_vr) {
 147                 flush_altivec_to_thread(current);
 148                 /* Copy 33 vec registers (vr0..31 and vscr) to the stack */
 149                 err |= __copy_to_user(v_regs, current->thread.vr, 33 * sizeof(vector128));
 150                 /* set MSR_VEC in the MSR value in the frame to indicate that sc->v_reg)
 151                  * contains valid data.
 152                  */
 153                 regs->msr |= MSR_VEC;
 154         }
 155         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 156          * use altivec.
 157          */
 158         err |= __put_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
 159 #else /* CONFIG_ALTIVEC */
 160         err |= __put_user(0, &sc->v_regs);
 161 #endif /* CONFIG_ALTIVEC */
 162         err |= __put_user(&sc->gp_regs, &sc->regs);
 163         err |= __copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE);
 164         err |= __copy_to_user(&sc->fp_regs, &current->thread.fpr, FP_REGS_SIZE);
 165         err |= __put_user(signr, &sc->signal);
 166         err |= __put_user(handler, &sc->handler);
 167         if (set != NULL)
 168                 err |=  __put_user(set->sig[0], &sc->oldmask);
 169
 170         return err;
 171 }
 172
 173 /*
 174  * Restore the sigcontext from the signal frame.
 175  */
 176
 177 static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
 178                               struct sigcontext __user *sc)
 179 {
 180 #ifdef CONFIG_ALTIVEC
 181         elf_vrreg_t __user *v_regs;
 182 #endif
 183         unsigned long err = 0;
 184         unsigned long save_r13 = 0;
 185         elf_greg_t *gregs = (elf_greg_t *)regs;
 186 #ifdef CONFIG_ALTIVEC
 187         unsigned long msr;
 188 #endif
 189         int i;
 190
 191         /* If this is not a signal return, we preserve the TLS in r13 */
 192         if (!sig)
 193                 save_r13 = regs->gpr[13];
 194
 195         /* copy everything before MSR */
 196         err |= __copy_from_user(regs, &sc->gp_regs,
 197                                 PT_MSR*sizeof(unsigned long));
 198
 199         /* skip MSR and SOFTE */
 200         for (i = PT_MSR+1; i <= PT_RESULT; i++) {
 201                 if (i == PT_SOFTE)
 202                         continue;
 203                 err |= __get_user(gregs[i], &sc->gp_regs[i]);
 204         }
 205
 206         if (!sig)
 207                 regs->gpr[13] = save_r13;
 208         err |= __copy_from_user(&current->thread.fpr, &sc->fp_regs, FP_REGS_SIZE);
 209         if (set != NULL)
 210                 err |=  __get_user(set->sig[0], &sc->oldmask);
 211
 212 #ifdef CONFIG_ALTIVEC
 213         err |= __get_user(v_regs, &sc->v_regs);
 214         err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
 215         if (err)
 216                 return err;
 217         /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
 218         if (v_regs != 0 && (msr & MSR_VEC) != 0)
 219                 err |= __copy_from_user(current->thread.vr, v_regs,
 220                                         33 * sizeof(vector128));
 221         else if (current->thread.used_vr)
 222                 memset(current->thread.vr, 0, 33 * sizeof(vector128));
 223         /* Always get VRSAVE back */
 224         if (v_regs != 0)
 225                 err |= __get_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
 226         else
 227                 current->thread.vrsave = 0;
 228 #endif /* CONFIG_ALTIVEC */
 229
 230 #ifndef CONFIG_SMP
 231         preempt_disable();
 232         if (last_task_used_math == current)
 233                 last_task_used_math = NULL;
 234         if (last_task_used_altivec == current)
 235                 last_task_used_altivec = NULL;
 236         preempt_enable();
 237 #endif
 238         /* Force reload of FP/VEC */
 239         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC);
 240
 241         return err;
 242 }
 243
 244 /*
 245  * Allocate space for the signal frame
 246  */
 247 static inline void __user * get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 248                                   size_t frame_size)
 249 {
 250         unsigned long newsp;
 251
 252         /* Default to using normal stack */
 253         newsp = regs->gpr[1];
 254
 255         if (ka->sa.sa_flags & SA_ONSTACK) {
 256                 if (! on_sig_stack(regs->gpr[1]))
 257                         newsp = (current->sas_ss_sp + current->sas_ss_size);
 258         }
 259
 260         return (void __user *)((newsp - frame_size) & -16ul);
 261 }
 262
 263 /*
 264  * Setup the trampoline code on the stack
 265  */
 266 static long setup_trampoline(unsigned int syscall, unsigned int __user *tramp)
 267 {
 268         int i;
 269         long err = 0;
 270
 271         /* addi r1, r1, __SIGNAL_FRAMESIZE  # Pop the dummy stackframe */
 272         err |= __put_user(0x38210000UL | (__SIGNAL_FRAMESIZE & 0xffff), &tramp[0]);
 273         /* li r0, __NR_[rt_]sigreturn| */
 274         err |= __put_user(0x38000000UL | (syscall & 0xffff), &tramp[1]);
 275         /* sc */
 276         err |= __put_user(0x44000002UL, &tramp[2]);
 277
 278         /* Minimal traceback info */
 279         for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
 280                 err |= __put_user(0, &tramp[i]);
 281
 282         if (!err)
 283                 flush_icache_range((unsigned long) &tramp[0],
 284                            (unsigned long) &tramp[TRAMP_SIZE]);
 285
 286         return err;
 287 }
 288
 289 /*
 290  * Restore the user process's signal mask (also used by signal32.c)
 291  */
 292 void restore_sigmask(sigset_t *set)
 293 {
 294         sigdelsetmask(set, ~_BLOCKABLE);
 295         spin_lock_irq(&current->sighand->siglock);
 296         current->blocked = *set;
 297         recalc_sigpending();
 298         spin_unlock_irq(&current->sighand->siglock);
 299 }
 300
 301
 302 /*
 303  * Handle {get,set,swap}_context operations
 304  */
 305 int sys_swapcontext(struct ucontext __user *old_ctx,
 306                     struct ucontext __user *new_ctx,
 307                     long ctx_size, long r6, long r7, long r8, struct pt_regs *regs)
 308 {
 309         unsigned char tmp;
 310         sigset_t set;
 311
 312         /* Context size is for future use. Right now, we only make sure
 313          * we are passed something we understand
 314          */
 315         if (ctx_size < sizeof(struct ucontext))
 316                 return -EINVAL;
 317
 318         if (old_ctx != NULL) {
 319                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
 320                     || setup_sigcontext(&old_ctx->uc_mcontext, regs, 0, NULL, 0)
 321                     || __copy_to_user(&old_ctx->uc_sigmask,
 322                                       &current->blocked, sizeof(sigset_t)))
 323                         return -EFAULT;
 324         }
 325         if (new_ctx == NULL)
 326                 return 0;
 327         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
 328             || __get_user(tmp, (u8 __user *) new_ctx)
 329             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
 330                 return -EFAULT;
 331
 332         /*
 333          * If we get a fault copying the context into the kernel's
 334          * image of the user's registers, we can't just return -EFAULT
 335          * because the user's registers will be corrupted.  For instance
 336          * the NIP value may have been updated but not some of the
 337          * other registers.  Given that we have done the access_ok
 338          * and successfully read the first and last bytes of the region
 339          * above, this should only happen in an out-of-memory situation
 340          * or if another thread unmaps the region containing the context.
 341          * We kill the task with a SIGSEGV in this situation.
 342          */
 343
 344         if (__copy_from_user(&set, &new_ctx->uc_sigmask, sizeof(set)))
 345                 do_exit(SIGSEGV);
 346         restore_sigmask(&set);
 347         if (restore_sigcontext(regs, NULL, 0, &new_ctx->uc_mcontext))
 348                 do_exit(SIGSEGV);
 349
 350         /* This returns like rt_sigreturn */
 351         return 0;
 352 }
 353
 354
 355 /*
 356  * Do a signal return; undo the signal stack.
 357  */
 358
 359 int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
 360                      unsigned long r6, unsigned long r7, unsigned long r8,
 361                      struct pt_regs *regs)
 362 {
 363         struct ucontext __user *uc = (struct ucontext __user *)regs->gpr[1];
 364         sigset_t set;
 365
 366         /* Always make any pending restarted system calls return -EINTR */
 367         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 368
 369         if (!access_ok(VERIFY_READ, uc, sizeof(*uc)))
 370                 goto badframe;
 371
 372         if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
 373                 goto badframe;
 374         restore_sigmask(&set);
 375         if (restore_sigcontext(regs, NULL, 1, &uc->uc_mcontext))
 376                 goto badframe;
 377
 378         /* do_sigaltstack expects a __user pointer and won't modify
 379          * what's in there anyway
 380          */
 381         do_sigaltstack(&uc->uc_stack, NULL, regs->gpr[1]);
 382
 383         return regs->result;
 384
 385 badframe:
 386 #if DEBUG_SIG
 387         printk("badframe in sys_rt_sigreturn, regs=%p uc=%p &uc->uc_mcontext=%p\n",
 388                regs, uc, &uc->uc_mcontext);
 389 #endif
 390         force_sig(SIGSEGV, current);
 391         return 0;
 392 }
 393
 394 static int setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
 395                 sigset_t *set, struct pt_regs *regs)
 396 {
 397         /* Handler is *really* a pointer to the function descriptor for
 398          * the signal routine.  The first entry in the function
 399          * descriptor is the entry address of signal and the second
 400          * entry is the TOC value we need to use.
 401          */
 402         func_descr_t __user *funct_desc_ptr;
 403         struct rt_sigframe __user *frame;
 404         unsigned long newsp = 0;
 405         long err = 0;
 406
 407         frame = get_sigframe(ka, regs, sizeof(*frame));
 408
 409         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 410                 goto badframe;
 411
 412         err |= __put_user(&frame->info, &frame->pinfo);
 413         err |= __put_user(&frame->uc, &frame->puc);
 414         err |= copy_siginfo_to_user(&frame->info, info);
 415         if (err)
 416                 goto badframe;
 417
 418         /* Create the ucontext.  */
 419         err |= __put_user(0, &frame->uc.uc_flags);
 420         err |= __put_user(0, &frame->uc.uc_link);
 421         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 422         err |= __put_user(sas_ss_flags(regs->gpr[1]),
 423                           &frame->uc.uc_stack.ss_flags);
 424         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 425         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr, NULL,
 426                                 (unsigned long)ka->sa.sa_handler);
 427         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 428         if (err)
 429                 goto badframe;
 430
 431         /* Set up to return from userspace. */
 432         if (vdso64_rt_sigtramp && current->thread.vdso_base) {
 433                 regs->link = current->thread.vdso_base + vdso64_rt_sigtramp;
 434         } else {
 435                 err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]);
 436                 if (err)
 437                         goto badframe;
 438                 regs->link = (unsigned long) &frame->tramp[0];
 439         }
 440         funct_desc_ptr = (func_descr_t __user *) ka->sa.sa_handler;
 441
 442         /* Allocate a dummy caller frame for the signal handler. */
 443         newsp = (unsigned long)frame - __SIGNAL_FRAMESIZE;
 444         err |= put_user(regs->gpr[1], (unsigned long __user *)newsp);
 445
 446         /* Set up "regs" so we "return" to the signal handler. */
 447         err |= get_user(regs->nip, &funct_desc_ptr->entry);
 448         regs->gpr[1] = newsp;
 449         err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
 450         regs->gpr[3] = signr;
 451         regs->result = 0;
 452         if (ka->sa.sa_flags & SA_SIGINFO) {
 453                 err |= get_user(regs->gpr[4], (unsigned long __user *)&frame->pinfo);
 454                 err |= get_user(regs->gpr[5], (unsigned long __user *)&frame->puc);
 455                 regs->gpr[6] = (unsigned long) frame;
 456         } else {
 457                 regs->gpr[4] = (unsigned long)&frame->uc.uc_mcontext;
 458         }
 459         if (err)
 460                 goto badframe;
 461
 462         if (test_thread_flag(TIF_SINGLESTEP))
 463                 ptrace_notify(SIGTRAP);
 464
 465         return 1;
 466
 467 badframe:
 468 #if DEBUG_SIG
 469         printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n",
 470                regs, frame, newsp);
 471 #endif
 472         force_sigsegv(signr, current);
 473         return 0;
 474 }
 475
 476
 477 /*
 478  * OK, we're invoking a handler
 479  */
 480 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
 481                          siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
 482 {
 483         int ret;
 484
 485         /* Set up Signal Frame */
 486         ret = setup_rt_frame(sig, ka, info, oldset, regs);
 487
 488         if (ret && !(ka->sa.sa_flags & SA_NODEFER)) {
 489                 spin_lock_irq(&current->sighand->siglock);
 490                 sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
 491                 sigaddset(&current->blocked,sig);
 492                 recalc_sigpending();
 493                 spin_unlock_irq(&current->sighand->siglock);
 494         }
 495
 496         return ret;
 497 }
 498
 499 static inline void syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 500 {
 501         switch ((int)regs->result) {
 502         case -ERESTART_RESTARTBLOCK:
 503         case -ERESTARTNOHAND:
 504                 /* ERESTARTNOHAND means that the syscall should only be
 505                  * restarted if there was no handler for the signal, and since
 506                  * we only get here if there is a handler, we dont restart.
 507                  */
 508                 regs->result = -EINTR;
 509                 break;
 510         case -ERESTARTSYS:
 511                 /* ERESTARTSYS means to restart the syscall if there is no
 512                  * handler or the handler was registered with SA_RESTART
 513                  */
 514                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 515                         regs->result = -EINTR;
 516                         break;
 517                 }
 518                 /* fallthrough */
 519         case -ERESTARTNOINTR:
 520                 /* ERESTARTNOINTR means that the syscall should be
 521                  * called again after the signal handler returns.
 522                  */
 523                 regs->gpr[3] = regs->orig_gpr3;
 524                 regs->nip -= 4;
 525                 regs->result = 0;
 526                 break;
 527         }
 528 }
 529
 530 /*
 531  * Note that 'init' is a special process: it doesn't get signals it doesn't
 532  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 533  * mistake.
 534  */
 535 int do_signal(sigset_t *oldset, struct pt_regs *regs)
 536 {
 537         siginfo_t info;
 538         int signr;
 539         struct k_sigaction ka;
 540
 541         /*
 542          * If the current thread is 32 bit - invoke the
 543          * 32 bit signal handling code
 544          */
 545         if (test_thread_flag(TIF_32BIT))
 546                 return do_signal32(oldset, regs);
 547
 548         if (!oldset)
 549                 oldset = &current->blocked;
 550
 551         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 552         if (signr > 0) {
 553                 /* Whee!  Actually deliver the signal.  */
 554                 if (TRAP(regs) == 0x0C00)
 555                         syscall_restart(regs, &ka);
 556                 return handle_signal(signr, &ka, &info, oldset, regs);
 557         }
 558
 559         if (TRAP(regs) == 0x0C00) {     /* System Call! */
 560                 if ((int)regs->result == -ERESTARTNOHAND ||
 561                     (int)regs->result == -ERESTARTSYS ||
 562                     (int)regs->result == -ERESTARTNOINTR) {
 563                         regs->gpr[3] = regs->orig_gpr3;
 564                         regs->nip -= 4; /* Back up & retry system call */
 565                         regs->result = 0;
 566                 } else if ((int)regs->result == -ERESTART_RESTARTBLOCK) {
 567                         regs->gpr[0] = __NR_restart_syscall;
 568                         regs->nip -= 4;
 569                         regs->result = 0;
 570                 }
 571         }
 572
 573         return 0;
 574 }
 575 EXPORT_SYMBOL(do_signal);