arch/arm26/kernel/signal.c

   1 /*
   2  *  linux/arch/arm26/kernel/signal.c
   3  *
   4  *  Copyright (C) 1995-2002 Russell King
   5  *  Copyright (C) 2003 Ian Molton (ARM26)
   6  *
   7  * FIXME!!! This is probably very broken (13/05/2003)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/kernel.h>
  17 #include <linux/errno.h>
  18 #include <linux/signal.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/personality.h>
  22 #include <linux/tty.h>
  23 #include <linux/binfmts.h>
  24 #include <linux/elf.h>
  25
  26 #include <asm/pgalloc.h>
  27 #include <asm/ucontext.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/unistd.h>
  30
  31 #include "ptrace.h"
  32
  33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  34
  35 /*
  36  * For ARM syscalls, we encode the syscall number into the instruction.
  37  */
  38 #define SWI_SYS_SIGRETURN       (0xef000000|(__NR_sigreturn))
  39 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(__NR_rt_sigreturn))
  40
  41 static int do_signal(sigset_t *oldset, struct pt_regs * regs, int syscall);
  42
  43 /*
  44  * atomically swap in the new signal mask, and wait for a signal.
  45  */
  46 asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask, struct pt_regs *regs)
  47 {
  48         sigset_t saveset;
  49
  50         mask &= _BLOCKABLE;
  51         spin_lock_irq(&current->sighand->siglock);
  52         saveset = current->blocked;
  53         siginitset(&current->blocked, mask);
  54         recalc_sigpending();
  55         spin_unlock_irq(&current->sighand->siglock);
  56         regs->ARM_r0 = -EINTR;
  57
  58         while (1) {
  59                 current->state = TASK_INTERRUPTIBLE;
  60                 schedule();
  61                 if (do_signal(&saveset, regs, 0))
  62                         return regs->ARM_r0;
  63         }
  64 }
  65
  66 asmlinkage int
  67 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs)
  68 {
  69         sigset_t saveset, newset;
  70
  71         /* XXX: Don't preclude handling different sized sigset_t's. */
  72         if (sigsetsize != sizeof(sigset_t))
  73                 return -EINVAL;
  74
  75         if (copy_from_user(&newset, unewset, sizeof(newset)))
  76                 return -EFAULT;
  77         sigdelsetmask(&newset, ~_BLOCKABLE);
  78
  79         spin_lock_irq(&current->sighand->siglock);
  80         saveset = current->blocked;
  81         current->blocked = newset;
  82         recalc_sigpending();
  83         spin_unlock_irq(&current->sighand->siglock);
  84         regs->ARM_r0 = -EINTR;
  85
  86         while (1) {
  87                 current->state = TASK_INTERRUPTIBLE;
  88                 schedule();
  89                 if (do_signal(&saveset, regs, 0))
  90                         return regs->ARM_r0;
  91         }
  92 }
  93
  94 asmlinkage int
  95 sys_sigaction(int sig, const struct old_sigaction *act,
  96               struct old_sigaction *oact)
  97 {
  98         struct k_sigaction new_ka, old_ka;
  99         int ret;
 100
 101         if (act) {
 102                 old_sigset_t mask;
 103                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 104                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 105                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 106                         return -EFAULT;
 107                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 108                 __get_user(mask, &act->sa_mask);
 109                 siginitset(&new_ka.sa.sa_mask, mask);
 110         }
 111
 112         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 113
 114         if (!ret && oact) {
 115                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 116                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 117                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 118                         return -EFAULT;
 119                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 120                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 121         }
 122
 123         return ret;
 124 }
 125
 126 /*
 127  * Do a signal return; undo the signal stack.
 128  */
 129 struct sigframe
 130 {
 131         struct sigcontext sc;
 132         unsigned long extramask[_NSIG_WORDS-1];
 133         unsigned long retcode;
 134 };
 135
 136 struct rt_sigframe
 137 {
 138         struct siginfo *pinfo;
 139         void *puc;
 140         struct siginfo info;
 141         struct ucontext uc;
 142         unsigned long retcode;
 143 };
 144
 145 static int
 146 restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
 147 {
 148         int err = 0;
 149
 150         __get_user_error(regs->ARM_r0, &sc->arm_r0, err);
 151         __get_user_error(regs->ARM_r1, &sc->arm_r1, err);
 152         __get_user_error(regs->ARM_r2, &sc->arm_r2, err);
 153         __get_user_error(regs->ARM_r3, &sc->arm_r3, err);
 154         __get_user_error(regs->ARM_r4, &sc->arm_r4, err);
 155         __get_user_error(regs->ARM_r5, &sc->arm_r5, err);
 156         __get_user_error(regs->ARM_r6, &sc->arm_r6, err);
 157         __get_user_error(regs->ARM_r7, &sc->arm_r7, err);
 158         __get_user_error(regs->ARM_r8, &sc->arm_r8, err);
 159         __get_user_error(regs->ARM_r9, &sc->arm_r9, err);
 160         __get_user_error(regs->ARM_r10, &sc->arm_r10, err);
 161         __get_user_error(regs->ARM_fp, &sc->arm_fp, err);
 162         __get_user_error(regs->ARM_ip, &sc->arm_ip, err);
 163         __get_user_error(regs->ARM_sp, &sc->arm_sp, err);
 164         __get_user_error(regs->ARM_lr, &sc->arm_lr, err);
 165         __get_user_error(regs->ARM_pc, &sc->arm_pc, err);
 166
 167         err |= !valid_user_regs(regs);
 168
 169         return err;
 170 }
 171
 172 asmlinkage int sys_sigreturn(struct pt_regs *regs)
 173 {
 174         struct sigframe *frame;
 175         sigset_t set;
 176
 177         /*
 178          * Since we stacked the signal on a 64-bit boundary,
 179          * then 'sp' should be word aligned here.  If it's
 180          * not, then the user is trying to mess with us.
 181          */
 182         if (regs->ARM_sp & 7)
 183                 goto badframe;
 184
 185         frame = (struct sigframe *)regs->ARM_sp;
 186
 187         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
 188                 goto badframe;
 189         if (__get_user(set.sig[0], &frame->sc.oldmask)
 190             || (_NSIG_WORDS > 1
 191                 && __copy_from_user(&set.sig[1], &frame->extramask,
 192                                     sizeof(frame->extramask))))
 193                 goto badframe;
 194
 195         sigdelsetmask(&set, ~_BLOCKABLE);
 196         spin_lock_irq(&current->sighand->siglock);
 197         current->blocked = set;
 198         recalc_sigpending();
 199         spin_unlock_irq(&current->sighand->siglock);
 200
 201         if (restore_sigcontext(regs, &frame->sc))
 202                 goto badframe;
 203
 204         /* Send SIGTRAP if we're single-stepping */
 205         if (current->ptrace & PT_SINGLESTEP) {
 206                 ptrace_cancel_bpt(current);
 207                 send_sig(SIGTRAP, current, 1);
 208         }
 209
 210         return regs->ARM_r0;
 211
 212 badframe:
 213         force_sig(SIGSEGV, current);
 214         return 0;
 215 }
 216
 217 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
 218 {
 219         struct rt_sigframe *frame;
 220         sigset_t set;
 221
 222         /*
 223          * Since we stacked the signal on a 64-bit boundary,
 224          * then 'sp' should be word aligned here.  If it's
 225          * not, then the user is trying to mess with us.
 226          */
 227         if (regs->ARM_sp & 7)
 228                 goto badframe;
 229
 230         frame = (struct rt_sigframe *)regs->ARM_sp;
 231
 232         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
 233                 goto badframe;
 234         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 235                 goto badframe;
 236
 237         sigdelsetmask(&set, ~_BLOCKABLE);
 238         spin_lock_irq(&current->sighand->siglock);
 239         current->blocked = set;
 240         recalc_sigpending();
 241         spin_unlock_irq(&current->sighand->siglock);
 242
 243         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 244                 goto badframe;
 245
 246         /* Send SIGTRAP if we're single-stepping */
 247         if (current->ptrace & PT_SINGLESTEP) {
 248                 ptrace_cancel_bpt(current);
 249                 send_sig(SIGTRAP, current, 1);
 250         }
 251
 252         return regs->ARM_r0;
 253
 254 badframe:
 255         force_sig(SIGSEGV, current);
 256         return 0;
 257 }
 258
 259 static int
 260 setup_sigcontext(struct sigcontext *sc, /*struct _fpstate *fpstate,*/
 261                  struct pt_regs *regs, unsigned long mask)
 262 {
 263         int err = 0;
 264
 265         __put_user_error(regs->ARM_r0, &sc->arm_r0, err);
 266         __put_user_error(regs->ARM_r1, &sc->arm_r1, err);
 267         __put_user_error(regs->ARM_r2, &sc->arm_r2, err);
 268         __put_user_error(regs->ARM_r3, &sc->arm_r3, err);
 269         __put_user_error(regs->ARM_r4, &sc->arm_r4, err);
 270         __put_user_error(regs->ARM_r5, &sc->arm_r5, err);
 271         __put_user_error(regs->ARM_r6, &sc->arm_r6, err);
 272         __put_user_error(regs->ARM_r7, &sc->arm_r7, err);
 273         __put_user_error(regs->ARM_r8, &sc->arm_r8, err);
 274         __put_user_error(regs->ARM_r9, &sc->arm_r9, err);
 275         __put_user_error(regs->ARM_r10, &sc->arm_r10, err);
 276         __put_user_error(regs->ARM_fp, &sc->arm_fp, err);
 277         __put_user_error(regs->ARM_ip, &sc->arm_ip, err);
 278         __put_user_error(regs->ARM_sp, &sc->arm_sp, err);
 279         __put_user_error(regs->ARM_lr, &sc->arm_lr, err);
 280         __put_user_error(regs->ARM_pc, &sc->arm_pc, err);
 281
 282         __put_user_error(current->thread.trap_no, &sc->trap_no, err);
 283         __put_user_error(current->thread.error_code, &sc->error_code, err);
 284         __put_user_error(current->thread.address, &sc->fault_address, err);
 285         __put_user_error(mask, &sc->oldmask, err);
 286
 287         return err;
 288 }
 289
 290 static inline void *
 291 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
 292 {
 293         unsigned long sp = regs->ARM_sp;
 294
 295         /*
 296          * This is the X/Open sanctioned signal stack switching.
 297          */
 298         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
 299                 sp = current->sas_ss_sp + current->sas_ss_size;
 300
 301         /*
 302          * ATPCS B01 mandates 8-byte alignment
 303          */
 304         return (void *)((sp - framesize) & ~7);
 305 }
 306
 307 static int
 308 setup_return(struct pt_regs *regs, struct k_sigaction *ka,
 309              unsigned long *rc, void *frame, int usig)
 310 {
 311         unsigned long handler = (unsigned long)ka->sa.sa_handler;
 312         unsigned long retcode;
 313
 314         if (ka->sa.sa_flags & SA_RESTORER) {
 315                 retcode = (unsigned long)ka->sa.sa_restorer;
 316         } else {
 317
 318                 if (__put_user((ka->sa.sa_flags & SA_SIGINFO)?SWI_SYS_RT_SIGRETURN:SWI_SYS_SIGRETURN, rc))
 319                         return 1;
 320
 321                 retcode = ((unsigned long)rc);
 322         }
 323
 324         regs->ARM_r0 = usig;
 325         regs->ARM_sp = (unsigned long)frame;
 326         regs->ARM_lr = retcode;
 327         regs->ARM_pc = handler & ~3;
 328
 329         return 0;
 330 }
 331
 332 static int
 333 setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
 334 {
 335         struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
 336         int err = 0;
 337
 338         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 339                 return 1;
 340
 341         err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
 342
 343         if (_NSIG_WORDS > 1) {
 344                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 345                                       sizeof(frame->extramask));
 346         }
 347
 348         if (err == 0)
 349                 err = setup_return(regs, ka, &frame->retcode, frame, usig);
 350
 351         return err;
 352 }
 353
 354 static int
 355 setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
 356                sigset_t *set, struct pt_regs *regs)
 357 {
 358         struct rt_sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
 359         int err = 0;
 360
 361         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 362                 return 1;
 363
 364         __put_user_error(&frame->info, &frame->pinfo, err);
 365         __put_user_error(&frame->uc, &frame->puc, err);
 366         err |= copy_siginfo_to_user(&frame->info, info);
 367
 368         /* Clear all the bits of the ucontext we don't use.  */
 369         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 370
 371         err |= setup_sigcontext(&frame->uc.uc_mcontext, /*&frame->fpstate,*/
 372                                 regs, set->sig[0]);
 373         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 374
 375         if (err == 0)
 376                 err = setup_return(regs, ka, &frame->retcode, frame, usig);
 377
 378         if (err == 0) {
 379                 /*
 380                  * For realtime signals we must also set the second and third
 381                  * arguments for the signal handler.
 382                  *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
 383                  */
 384                 regs->ARM_r1 = (unsigned long)frame->pinfo;
 385                 regs->ARM_r2 = (unsigned long)frame->puc;
 386         }
 387
 388         return err;
 389 }
 390
 391 static inline void restart_syscall(struct pt_regs *regs)
 392 {
 393         regs->ARM_r0 = regs->ARM_ORIG_r0;
 394         regs->ARM_pc -= 4;
 395 }
 396
 397 /*
 398  * OK, we're invoking a handler
 399  */
 400 static void
 401 handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
 402               struct pt_regs * regs, int syscall)
 403 {
 404         struct thread_info *thread = current_thread_info();
 405         struct task_struct *tsk = current;
 406         struct k_sigaction *ka = &tsk->sighand->action[sig-1];
 407         int usig = sig;
 408         int ret;
 409
 410         /*
 411          * If we were from a system call, check for system call restarting...
 412          */
 413         if (syscall) {
 414                 switch (regs->ARM_r0) {
 415                 case -ERESTART_RESTARTBLOCK:
 416                         current_thread_info()->restart_block.fn =
 417                                 do_no_restart_syscall;
 418                 case -ERESTARTNOHAND:
 419                         regs->ARM_r0 = -EINTR;
 420                         break;
 421                 case -ERESTARTSYS:
 422                         if (!(ka->sa.sa_flags & SA_RESTART)) {
 423                                 regs->ARM_r0 = -EINTR;
 424                                 break;
 425                         }
 426                         /* fallthrough */
 427                 case -ERESTARTNOINTR:
 428                         restart_syscall(regs);
 429                 }
 430         }
 431
 432         /*
 433          * translate the signal
 434          */
 435         if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
 436                 usig = thread->exec_domain->signal_invmap[usig];
 437
 438         /*
 439          * Set up the stack frame
 440          */
 441         if (ka->sa.sa_flags & SA_SIGINFO)
 442                 ret = setup_rt_frame(usig, ka, info, oldset, regs);
 443         else
 444                 ret = setup_frame(usig, ka, oldset, regs);
 445
 446         /*
 447          * Check that the resulting registers are actually sane.
 448          */
 449         ret |= !valid_user_regs(regs);
 450
 451         if (ret == 0) {
 452                 if (ka->sa.sa_flags & SA_ONESHOT)
 453                         ka->sa.sa_handler = SIG_DFL;
 454
 455                 spin_lock_irq(&tsk->sighand->siglock);
 456                 sigorsets(&tsk->blocked, &tsk->blocked,
 457                           &ka->sa.sa_mask);
 458                 if (!(ka->sa.sa_flags & SA_NODEFER))
 459                         sigaddset(&tsk->blocked, sig);
 460                 recalc_sigpending();
 461                 spin_unlock_irq(&tsk->sighand->siglock);
 462                 return;
 463         }
 464
 465         force_sigsegv(sig, tsk);
 466 }
 467
 468 /*
 469  * Note that 'init' is a special process: it doesn't get signals it doesn't
 470  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 471  * mistake.
 472  *
 473  * Note that we go through the signals twice: once to check the signals that
 474  * the kernel can handle, and then we build all the user-level signal handling
 475  * stack-frames in one go after that.
 476  */
 477 static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
 478 {
 479         siginfo_t info;
 480         int signr;
 481         struct k_sigaction ka;
 482
 483         /*
 484          * We want the common case to go fast, which
 485          * is why we may in certain cases get here from
 486          * kernel mode. Just return without doing anything
 487          * if so.
 488          */
 489         if (!user_mode(regs))
 490                 return 0;
 491
 492         if (current->ptrace & PT_SINGLESTEP)
 493                 ptrace_cancel_bpt(current);
 494
 495         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 496         if (signr > 0) {
 497                 handle_signal(signr, &info, oldset, regs, syscall);
 498                 if (current->ptrace & PT_SINGLESTEP)
 499                         ptrace_set_bpt(current);
 500                 return 1;
 501         }
 502
 503         /*
 504          * No signal to deliver to the process - restart the syscall.
 505          */
 506         if (syscall) {
 507                 if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
 508                         u32 *usp;
 509
 510                         regs->ARM_sp -= 12;
 511                         usp = (u32 *)regs->ARM_sp;
 512
 513                         put_user(regs->ARM_pc, &usp[0]);
 514                         /* swi __NR_restart_syscall */
 515                         put_user(0xef000000 | __NR_restart_syscall, &usp[1]);
 516                         /* ldr  pc, [sp], #12 */
 517 // FIXME!!! is #12 correct there?
 518                         put_user(0xe49df00c, &usp[2]);
 519
 520                         regs->ARM_pc = regs->ARM_sp + 4;
 521                 }
 522                 if (regs->ARM_r0 == -ERESTARTNOHAND ||
 523                     regs->ARM_r0 == -ERESTARTSYS ||
 524                     regs->ARM_r0 == -ERESTARTNOINTR) {
 525                         restart_syscall(regs);
 526                 }
 527         }
 528         if (current->ptrace & PT_SINGLESTEP)
 529                 ptrace_set_bpt(current);
 530         return 0;
 531 }
 532
 533 asmlinkage void
 534 do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
 535 {
 536         if (thread_flags & _TIF_SIGPENDING)
 537                 do_signal(&current->blocked, regs, syscall);
 538 }