arch/h8300/kernel/signal.c

   1 /*
   2  *  linux/arch/h8300/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 /*
  12  * uClinux H8/300 support by Yoshinori Sato <ysato@users.sourceforge.jp>
  13  *                and David McCullough <davidm@snapgear.com>
  14  *
  15  * Based on
  16  * Linux/m68k by Hamish Macdonald
  17  */
  18
  19 /*
  20  * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  21  * Atari :-) Current limitation: Only one sigstack can be active at one time.
  22  * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  23  * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  24  * signal handlers!
  25  */
  26
  27 #include <linux/sched.h>
  28 #include <linux/mm.h>
  29 #include <linux/kernel.h>
  30 #include <linux/signal.h>
  31 #include <linux/syscalls.h>
  32 #include <linux/errno.h>
  33 #include <linux/wait.h>
  34 #include <linux/ptrace.h>
  35 #include <linux/unistd.h>
  36 #include <linux/stddef.h>
  37 #include <linux/highuid.h>
  38 #include <linux/personality.h>
  39 #include <linux/tty.h>
  40 #include <linux/binfmts.h>
  41
  42 #include <asm/setup.h>
  43 #include <asm/uaccess.h>
  44 #include <asm/pgtable.h>
  45 #include <asm/traps.h>
  46 #include <asm/ucontext.h>
  47
  48 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  49
  50 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  51
  52 /*
  53  * Atomically swap in the new signal mask, and wait for a signal.
  54  */
  55 asmlinkage int do_sigsuspend(struct pt_regs *regs)
  56 {
  57         old_sigset_t mask = regs->er3;
  58         sigset_t saveset;
  59
  60         mask &= _BLOCKABLE;
  61         spin_lock_irq(&current->sighand->siglock);
  62         saveset = current->blocked;
  63         siginitset(&current->blocked, mask);
  64         recalc_sigpending();
  65         spin_unlock_irq(&current->sighand->siglock);
  66
  67         regs->er0 = -EINTR;
  68         while (1) {
  69                 current->state = TASK_INTERRUPTIBLE;
  70                 schedule();
  71                 if (do_signal(&saveset, regs))
  72                         return -EINTR;
  73         }
  74 }
  75
  76 asmlinkage int
  77 do_rt_sigsuspend(struct pt_regs *regs)
  78 {
  79         sigset_t *unewset = (sigset_t *)regs->er1;
  80         size_t sigsetsize = (size_t)regs->er2;
  81         sigset_t saveset, newset;
  82
  83         /* XXX: Don't preclude handling different sized sigset_t's.  */
  84         if (sigsetsize != sizeof(sigset_t))
  85                 return -EINVAL;
  86
  87         if (copy_from_user(&newset, unewset, sizeof(newset)))
  88                 return -EFAULT;
  89         sigdelsetmask(&newset, ~_BLOCKABLE);
  90
  91         spin_lock_irq(&current->sighand->siglock);
  92         saveset = current->blocked;
  93         current->blocked = newset;
  94         recalc_sigpending();
  95         spin_unlock_irq(&current->sighand->siglock);
  96
  97         regs->er0 = -EINTR;
  98         while (1) {
  99                 current->state = TASK_INTERRUPTIBLE;
 100                 schedule();
 101                 if (do_signal(&saveset, regs))
 102                         return -EINTR;
 103         }
 104 }
 105
 106 asmlinkage int
 107 sys_sigaction(int sig, const struct old_sigaction *act,
 108               struct old_sigaction *oact)
 109 {
 110         struct k_sigaction new_ka, old_ka;
 111         int ret;
 112
 113         if (act) {
 114                 old_sigset_t mask;
 115                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 116                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 117                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 118                         return -EFAULT;
 119                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 120                 __get_user(mask, &act->sa_mask);
 121                 siginitset(&new_ka.sa.sa_mask, mask);
 122         }
 123
 124         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 125
 126         if (!ret && oact) {
 127                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 128                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 129                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 130                         return -EFAULT;
 131                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 132                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 133         }
 134
 135         return ret;
 136 }
 137
 138 asmlinkage int
 139 sys_sigaltstack(const stack_t *uss, stack_t *uoss)
 140 {
 141         return do_sigaltstack(uss, uoss, rdusp());
 142 }
 143
 144
 145 /*
 146  * Do a signal return; undo the signal stack.
 147  *
 148  * Keep the return code on the stack quadword aligned!
 149  * That makes the cache flush below easier.
 150  */
 151
 152 struct sigframe
 153 {
 154         long dummy_er0;
 155         long dummy_vector;
 156 #if defined(CONFIG_CPU_H8S)
 157         short dummy_exr;
 158 #endif
 159         long dummy_pc;
 160         char *pretcode;
 161         unsigned char retcode[8];
 162         unsigned long extramask[_NSIG_WORDS-1];
 163         struct sigcontext sc;
 164 } __attribute__((aligned(2),packed));
 165
 166 struct rt_sigframe
 167 {
 168         long dummy_er0;
 169         long dummy_vector;
 170 #if defined(CONFIG_CPU_H8S)
 171         short dummy_exr;
 172 #endif
 173         long dummy_pc;
 174         char *pretcode;
 175         unsigned char retcode[8];
 176         struct siginfo info;
 177         struct ucontext uc;
 178 } __attribute__((aligned(2),packed));
 179
 180 static inline int
 181 restore_sigcontext(struct pt_regs *regs, struct sigcontext *usc, void *fp,
 182                    int *pd0)
 183 {
 184         struct sigcontext context;
 185         int err = 0;
 186
 187         /* get previous context */
 188         if (copy_from_user(&context, usc, sizeof(context)))
 189                 goto badframe;
 190
 191         /* restore passed registers */
 192         regs->er1 = context.sc_er1;
 193         regs->er2 = context.sc_er2;
 194         regs->er3 = context.sc_er3;
 195         regs->er5 = context.sc_er5;
 196         regs->ccr = (regs->ccr & 0x10)|(context.sc_ccr & 0xef);
 197         regs->pc = context.sc_pc;
 198         regs->orig_er0 = -1;            /* disable syscall checks */
 199         wrusp(context.sc_usp);
 200
 201         *pd0 = context.sc_er0;
 202         return err;
 203
 204 badframe:
 205         return 1;
 206 }
 207
 208 static inline int
 209 rt_restore_ucontext(struct pt_regs *regs, struct ucontext *uc, int *pd0)
 210 {
 211         int temp;
 212         greg_t *gregs = uc->uc_mcontext.gregs;
 213         unsigned long usp;
 214         int err;
 215
 216         err = __get_user(temp, &uc->uc_mcontext.version);
 217         if (temp != MCONTEXT_VERSION)
 218                 goto badframe;
 219         /* restore passed registers */
 220         err |= __get_user(regs->er0, &gregs[0]);
 221         err |= __get_user(regs->er1, &gregs[1]);
 222         err |= __get_user(regs->er2, &gregs[2]);
 223         err |= __get_user(regs->er3, &gregs[3]);
 224         err |= __get_user(regs->er4, &gregs[4]);
 225         err |= __get_user(regs->er5, &gregs[5]);
 226         err |= __get_user(regs->er6, &gregs[6]);
 227         err |= __get_user(usp, &gregs[7]);
 228         wrusp(usp);
 229         err |= __get_user(regs->pc, &gregs[8]);
 230         err |= __get_user(temp, &gregs[9]);
 231         regs->ccr = (regs->ccr & 0x10) | (temp & 0xef);
 232         regs->orig_er0 = -1;            /* disable syscall checks */
 233
 234         if (do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
 235                 goto badframe;
 236
 237         *pd0 = regs->er0;
 238         return err;
 239
 240 badframe:
 241         return 1;
 242 }
 243
 244 asmlinkage int do_sigreturn(unsigned long __unused,...)
 245 {
 246         struct pt_regs *regs = (struct pt_regs *) (&__unused - 1);
 247         unsigned long usp = rdusp();
 248         struct sigframe *frame = (struct sigframe *)(usp - 4);
 249         sigset_t set;
 250         int er0;
 251
 252         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 253                 goto badframe;
 254         if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
 255             (_NSIG_WORDS > 1 &&
 256              __copy_from_user(&set.sig[1], &frame->extramask,
 257                               sizeof(frame->extramask))))
 258                 goto badframe;
 259
 260         sigdelsetmask(&set, ~_BLOCKABLE);
 261         spin_lock_irq(&current->sighand->siglock);
 262         current->blocked = set;
 263         recalc_sigpending();
 264         spin_unlock_irq(&current->sighand->siglock);
 265
 266         if (restore_sigcontext(regs, &frame->sc, frame + 1, &er0))
 267                 goto badframe;
 268         return er0;
 269
 270 badframe:
 271         force_sig(SIGSEGV, current);
 272         return 0;
 273 }
 274
 275 asmlinkage int do_rt_sigreturn(unsigned long __unused,...)
 276 {
 277         struct pt_regs *regs = (struct pt_regs *) &__unused;
 278         unsigned long usp = rdusp();
 279         struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4);
 280         sigset_t set;
 281         int er0;
 282
 283         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 284                 goto badframe;
 285         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 286                 goto badframe;
 287
 288         sigdelsetmask(&set, ~_BLOCKABLE);
 289         spin_unlock_irq(&current->sighand->siglock);
 290         current->blocked = set;
 291         recalc_sigpending();
 292         spin_lock_irq(&current->sighand->siglock);
 293
 294         if (rt_restore_ucontext(regs, &frame->uc, &er0))
 295                 goto badframe;
 296         return er0;
 297
 298 badframe:
 299         force_sig(SIGSEGV, current);
 300         return 0;
 301 }
 302
 303 static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 304                              unsigned long mask)
 305 {
 306         sc->sc_mask = mask;
 307         sc->sc_usp = rdusp();
 308         sc->sc_er0 = regs->er0;
 309         sc->sc_er1 = regs->er1;
 310         sc->sc_er2 = regs->er2;
 311         sc->sc_er3 = regs->er3;
 312         sc->sc_er5 = regs->er5;
 313         sc->sc_ccr = regs->ccr;
 314         sc->sc_pc = regs->pc;
 315 }
 316
 317 static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs)
 318 {
 319         greg_t *gregs = uc->uc_mcontext.gregs;
 320         int err = 0;
 321
 322         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
 323         err |= __put_user(regs->er0, &gregs[0]);
 324         err |= __put_user(regs->er1, &gregs[1]);
 325         err |= __put_user(regs->er2, &gregs[2]);
 326         err |= __put_user(regs->er3, &gregs[3]);
 327         err |= __put_user(regs->er4, &gregs[4]);
 328         err |= __put_user(regs->er5, &gregs[5]);
 329         err |= __put_user(regs->er6, &gregs[6]);
 330         err |= __put_user(rdusp(), &gregs[7]);
 331         err |= __put_user(regs->pc, &gregs[8]);
 332         err |= __put_user(regs->ccr, &gregs[9]);
 333         return err;
 334 }
 335
 336 static inline void *
 337 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 338 {
 339         unsigned long usp;
 340
 341         /* Default to using normal stack.  */
 342         usp = rdusp();
 343
 344         /* This is the X/Open sanctioned signal stack switching.  */
 345         if (ka->sa.sa_flags & SA_ONSTACK) {
 346                 if (!on_sig_stack(usp))
 347                         usp = current->sas_ss_sp + current->sas_ss_size;
 348         }
 349         return (void *)((usp - frame_size) & -8UL);
 350 }
 351
 352 static void setup_frame (int sig, struct k_sigaction *ka,
 353                          sigset_t *set, struct pt_regs *regs)
 354 {
 355         struct sigframe *frame;
 356         struct sigcontext context;
 357         int err = 0;
 358
 359         frame = get_sigframe(ka, regs, sizeof(*frame));
 360
 361         if (_NSIG_WORDS > 1)
 362                 err |= copy_to_user(frame->extramask, &set->sig[1],
 363                                     sizeof(frame->extramask));
 364
 365         setup_sigcontext(&context, regs, set->sig[0]);
 366         err |= copy_to_user (&frame->sc, &context, sizeof(context));
 367
 368         /* Set up to return from userspace.  */
 369         err |= __put_user(frame->retcode, &frame->pretcode);
 370
 371         /* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
 372         err != __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
 373                         (unsigned long *)(frame->retcode + 0));
 374         err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
 375
 376
 377         if (err)
 378                 goto give_sigsegv;
 379
 380         /* Set up registers for signal handler */
 381         wrusp ((unsigned long) frame);
 382         regs->pc = (unsigned long) ka->sa.sa_handler;
 383         regs->er0 = (current_thread_info()->exec_domain
 384                            && current_thread_info()->exec_domain->signal_invmap
 385                            && sig < 32
 386                            ? current_thread_info()->exec_domain->signal_invmap[sig]
 387                           : sig);
 388         regs->er1 = (unsigned long)&(frame->sc);
 389         regs->er5 = current->mm->start_data;    /* GOT base */
 390
 391         return;
 392
 393 give_sigsegv:
 394         force_sigsegv(sig, current);
 395 }
 396
 397 static void setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
 398                             sigset_t *set, struct pt_regs *regs)
 399 {
 400         struct rt_sigframe *frame;
 401         int err = 0;
 402
 403         frame = get_sigframe(ka, regs, sizeof(*frame));
 404
 405         err |= copy_siginfo_to_user(&frame->info, info);
 406
 407         /* Create the ucontext.  */
 408         err |= __put_user(0, &frame->uc.uc_flags);
 409         err |= __put_user(0, &frame->uc.uc_link);
 410         err |= __put_user((void *)current->sas_ss_sp,
 411                           &frame->uc.uc_stack.ss_sp);
 412         err |= __put_user(sas_ss_flags(rdusp()),
 413                           &frame->uc.uc_stack.ss_flags);
 414         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 415         err |= rt_setup_ucontext(&frame->uc, regs);
 416         err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
 417
 418         /* Set up to return from userspace.  */
 419         err |= __put_user(frame->retcode, &frame->pretcode);
 420
 421         /* sub.l er0,er0; mov.b #__NR_rt_sigreturn,r0l; trapa #0 */
 422         err != __put_user(0x1a80f800 + (__NR_rt_sigreturn & 0xff),
 423                         (long *)(frame->retcode + 0));
 424         err |= __put_user(0x5700, (short *)(frame->retcode + 4));
 425
 426         if (err)
 427                 goto give_sigsegv;
 428
 429         /* Set up registers for signal handler */
 430         wrusp ((unsigned long) frame);
 431         regs->pc  = (unsigned long) ka->sa.sa_handler;
 432         regs->er0 = (current_thread_info()->exec_domain
 433                      && current_thread_info()->exec_domain->signal_invmap
 434                      && sig < 32
 435                      ? current_thread_info()->exec_domain->signal_invmap[sig]
 436                      : sig);
 437         regs->er1 = (unsigned long)&(frame->info);
 438         regs->er2 = (unsigned long)&frame->uc;
 439         regs->er5 = current->mm->start_data;    /* GOT base */
 440
 441         return;
 442
 443 give_sigsegv:
 444         force_sigsegv(sig, current);
 445 }
 446
 447 static inline void
 448 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
 449 {
 450         switch (regs->er0) {
 451         case -ERESTARTNOHAND:
 452                 if (!has_handler)
 453                         goto do_restart;
 454                 regs->er0 = -EINTR;
 455                 break;
 456
 457         case -ERESTARTSYS:
 458                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
 459                         regs->er0 = -EINTR;
 460                         break;
 461                 }
 462         /* fallthrough */
 463         case -ERESTARTNOINTR:
 464         do_restart:
 465                 regs->er0 = regs->orig_er0;
 466                 regs->pc -= 2;
 467                 break;
 468         }
 469 }
 470
 471 /*
 472  * OK, we're invoking a handler
 473  */
 474 static void
 475 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 476               sigset_t *oldset, struct pt_regs *regs)
 477 {
 478         /* are we from a system call? */
 479         if (regs->orig_er0 >= 0)
 480                 /* If so, check system call restarting.. */
 481                 handle_restart(regs, ka, 1);
 482
 483         /* set up the stack frame */
 484         if (ka->sa.sa_flags & SA_SIGINFO)
 485                 setup_rt_frame(sig, ka, info, oldset, regs);
 486         else
 487                 setup_frame(sig, ka, oldset, regs);
 488
 489         if (ka->sa.sa_flags & SA_ONESHOT)
 490                 ka->sa.sa_handler = SIG_DFL;
 491
 492         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 493                 spin_lock_irq(&current->sighand->siglock);
 494                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 495                 sigaddset(&current->blocked,sig);
 496                 recalc_sigpending();
 497                 spin_unlock_irq(&current->sighand->siglock);
 498         }
 499 }
 500
 501 /*
 502  * Note that 'init' is a special process: it doesn't get signals it doesn't
 503  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 504  * mistake.
 505  *
 506  * Note that we go through the signals twice: once to check the signals
 507  * that the kernel can handle, and then we build all the user-level signal
 508  * handling stack-frames in one go after that.
 509  */
 510 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
 511 {
 512         siginfo_t info;
 513         struct k_sigaction *ka;
 514
 515         current->thread.esp0 = (unsigned long) regs;
 516
 517         if (!oldset)
 518                 oldset = &current->blocked;
 519
 520         for (;;) {
 521                 int signr;
 522
 523                 signr = get_signal_to_deliver(&info, regs, NULL);
 524
 525                 if (!signr)
 526                         break;
 527
 528                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
 529                         current->exit_code = signr;
 530                         current->state = TASK_STOPPED;
 531
 532                         /* Did we come from a system call? */
 533                         if (regs->orig_er0 >= 0) {
 534                                 /* Restart the system call the same way as
 535                                    if the process were not traced.  */
 536                                 struct k_sigaction *ka =
 537                                         &current->sighand->action[signr-1];
 538                                 int has_handler =
 539                                         (ka->sa.sa_handler != SIG_IGN &&
 540                                          ka->sa.sa_handler != SIG_DFL);
 541                                 handle_restart(regs, ka, has_handler);
 542                         }
 543                         notify_parent(current, SIGCHLD);
 544                         schedule();
 545
 546                         /* We're back.  Did the debugger cancel the sig?  */
 547                         if (!(signr = current->exit_code)) {
 548                         discard_frame:
 549                             continue;
 550                         }
 551                         current->exit_code = 0;
 552
 553                         /* The debugger continued.  Ignore SIGSTOP.  */
 554                         if (signr == SIGSTOP)
 555                                 goto discard_frame;
 556
 557                         /* Update the siginfo structure.  Is this good?  */
 558                         if (signr != info.si_signo) {
 559                                 info.si_signo = signr;
 560                                 info.si_errno = 0;
 561                                 info.si_code = SI_USER;
 562                                 info.si_pid = current->parent->pid;
 563                                 info.si_uid = current->parent->uid;
 564                         }
 565
 566                         /* If the (new) signal is now blocked, requeue it.  */
 567                         if (sigismember(&current->blocked, signr)) {
 568                                 send_sig_info(signr, &info, current);
 569                                 continue;
 570                         }
 571                 }
 572
 573                 ka = &current->sighand->action[signr-1];
 574                 if (ka->sa.sa_handler == SIG_IGN) {
 575                         if (signr != SIGCHLD)
 576                                 continue;
 577                         /* Check for SIGCHLD: it's special.  */
 578                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
 579                                 /* nothing */;
 580                         continue;
 581                 }
 582
 583                 if (ka->sa.sa_handler == SIG_DFL) {
 584                         int exit_code = signr;
 585
 586                         if (current->pid == 1)
 587                                 continue;
 588
 589                         switch (signr) {
 590                         case SIGCONT: case SIGCHLD:
 591                         case SIGWINCH: case SIGURG:
 592                                 continue;
 593
 594                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
 595                                 if (is_orphaned_pgrp(process_group(current)))
 596                                         continue;
 597                                 /* FALLTHRU */
 598
 599                         case SIGSTOP: {
 600                                 struct sighand_struct *sig;
 601                                 current->state = TASK_STOPPED;
 602                                 current->exit_code = signr;
 603                                 sig = current->parent->sighand;
 604                                 if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags
 605 & SA_NOCLDSTOP))
 606                                         notify_parent(current, SIGCHLD);
 607                                 schedule();
 608                                 continue;
 609                         }
 610
 611                         case SIGQUIT: case SIGILL: case SIGTRAP:
 612                         case SIGIOT: case SIGFPE: case SIGSEGV:
 613                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
 614                                 if (do_coredump(signr, exit_code, regs))
 615                                         exit_code |= 0x80;
 616                                 /* FALLTHRU */
 617
 618                         default:
 619                                 sigaddset(&current->pending.signal, signr);
 620                                 recalc_sigpending();
 621                                 current->flags |= PF_SIGNALED;
 622                                 do_exit(exit_code);
 623                                 /* NOTREACHED */
 624                         }
 625                 }
 626
 627                 /* Whee!  Actually deliver the signal.  */
 628                 handle_signal(signr, ka, &info, oldset, regs);
 629                 return 1;
 630         }
 631
 632         /* Did we come from a system call? */
 633         if (regs->orig_er0 >= 0)
 634                 /* Restart the system call - no handlers present */
 635                 handle_restart(regs, NULL, 0);
 636
 637         return 0;
 638 }