git.oblomov.eu Git - linux-2.6/blob - arch/xtensa/kernel/signal.c

   1 /*
   2  * arch/xtensa/kernel/signal.c
   3  *
   4  * Default platform functions.
   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  * Copyright (C) 2005, 2006 Tensilica Inc.
  11  * Copyright (C) 1991, 1992  Linus Torvalds
  12  * 1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  13  *
  14  * Chris Zankel <chris@zankel.net>
  15  * Joe Taylor <joe@tensilica.com>
  16  */
  17
  18 #include <linux/signal.h>
  19 #include <linux/errno.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/personality.h>
  22 #include <linux/freezer.h>
  23
  24 #include <asm/ucontext.h>
  25 #include <asm/uaccess.h>
  26 #include <asm/cacheflush.h>
  27 #include <asm/coprocessor.h>
  28 #include <asm/unistd.h>
  29
  30 #define DEBUG_SIG  0
  31
  32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  33
  34 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  35
  36 extern struct task_struct *coproc_owners[];
  37
  38 extern void release_all_cp (struct task_struct *);
  39
  40 struct rt_sigframe
  41 {
  42         struct siginfo info;
  43         struct ucontext uc;
  44         cp_state_t cpstate;
  45         unsigned char retcode[6];
  46         unsigned int window[4];
  47 };
  48
  49 /*
  50  * Flush register windows stored in pt_regs to stack.
  51  * Returns 1 for errors.
  52  *
  53  * Note that windowbase, windowstart, and wmask are not updated!
  54  */
  55
  56 int
  57 flush_window_regs_user(struct pt_regs *regs)
  58 {
  59         const unsigned long ws = regs->windowstart;
  60         const unsigned long wb = regs->windowbase;
  61         unsigned long sp = 0;
  62         unsigned long wm;
  63         int err = 1;
  64         int base;
  65
  66         /* Return if no other frames. */
  67
  68         if (regs->wmask == 1)
  69                 return 0;
  70
  71         /* Rotate windowmask and skip empty frames. */
  72
  73         wm = (ws >> wb) | (ws << (XCHAL_NUM_AREGS / 4 - wb));
  74         base = (XCHAL_NUM_AREGS / 4) - (regs->wmask >> 4);
  75
  76         /* For call8 or call12 frames, we need the previous stack pointer. */
  77
  78         if ((regs->wmask & 2) == 0)
  79                 if (__get_user(sp, (int*)(regs->areg[base * 4 + 1] - 12)))
  80                         goto errout;
  81
  82         /* Spill frames to stack. */
  83
  84         while (base < XCHAL_NUM_AREGS / 4) {
  85
  86                 int m = (wm >> base);
  87                 int inc = 0;
  88
  89                 /* Save registers a4..a7 (call8) or a4...a11 (call12) */
  90
  91                 if (m & 2) {                    /* call4 */
  92                         inc = 1;
  93
  94                 } else if (m & 4) {             /* call8 */
  95                         if (copy_to_user((void*)(sp - 32),
  96                                            &regs->areg[(base + 1) * 4], 16))
  97                                 goto errout;
  98                         inc = 2;
  99
 100                 } else if (m & 8) {     /* call12 */
 101                         if (copy_to_user((void*)(sp - 48),
 102                                            &regs->areg[(base + 1) * 4], 32))
 103                                 goto errout;
 104                         inc = 3;
 105                 }
 106
 107                 /* Save current frame a0..a3 under next SP */
 108
 109                 sp = regs->areg[((base + inc) * 4 + 1) % XCHAL_NUM_AREGS];
 110                 if (copy_to_user((void*)(sp - 16), &regs->areg[base * 4], 16))
 111                         goto errout;
 112
 113                 /* Get current stack pointer for next loop iteration. */
 114
 115                 sp = regs->areg[base * 4 + 1];
 116                 base += inc;
 117         }
 118
 119         return 0;
 120
 121 errout:
 122         return err;
 123 }
 124
 125 /*
 126  * Note: We don't copy double exception 'regs', we have to finish double exc.
 127  * first before we return to signal handler! This dbl.exc.handler might cause
 128  * another double exception, but I think we are fine as the situation is the
 129  * same as if we had returned to the signal handerl and got an interrupt
 130  * immediately...
 131  */
 132
 133 static int
 134 setup_sigcontext(struct sigcontext __user *sc, cp_state_t *cpstate,
 135                  struct pt_regs *regs, unsigned long mask)
 136 {
 137         int err = 0;
 138
 139 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
 140         COPY(pc);
 141         COPY(ps);
 142         COPY(lbeg);
 143         COPY(lend);
 144         COPY(lcount);
 145         COPY(sar);
 146 #undef COPY
 147
 148         err |= flush_window_regs_user(regs);
 149         err |= __copy_to_user (sc->sc_a, regs->areg, 16 * 4);
 150
 151         // err |= __copy_to_user (sc->sc_a, regs->areg, XCHAL_NUM_AREGS * 4)
 152
 153 #if XCHAL_HAVE_CP
 154 # error Coprocessors unsupported
 155         err |= save_cpextra(cpstate);
 156         err |= __put_user(err ? NULL : cpstate, &sc->sc_cpstate);
 157 #endif
 158         /* non-iBCS2 extensions.. */
 159         err |= __put_user(mask, &sc->oldmask);
 160
 161         return err;
 162 }
 163
 164 static int
 165 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
 166 {
 167         unsigned int err = 0;
 168         unsigned long ps;
 169
 170 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
 171         COPY(pc);
 172         COPY(lbeg);
 173         COPY(lend);
 174         COPY(lcount);
 175         COPY(sar);
 176 #undef COPY
 177
 178         /* All registers were flushed to stack. Start with a prestine frame. */
 179
 180         regs->wmask = 1;
 181         regs->windowbase = 0;
 182         regs->windowstart = 1;
 183
 184         /* For PS, restore only PS.CALLINC.
 185          * Assume that all other bits are either the same as for the signal
 186          * handler, or the user mode value doesn't matter (e.g. PS.OWB).
 187          */
 188         err |= __get_user(ps, &sc->sc_ps);
 189         regs->ps = (regs->ps & ~PS_CALLINC_MASK) | (ps & PS_CALLINC_MASK);
 190
 191         /* Additional corruption checks */
 192
 193         if ((regs->lcount > 0)
 194             && ((regs->lbeg > TASK_SIZE) || (regs->lend > TASK_SIZE)) )
 195                 err = 1;
 196
 197         err |= __copy_from_user(regs->areg, sc->sc_a, 16 * 4);
 198
 199 #if XCHAL_HAVE_CP
 200 # error Coprocessors unsupported
 201         /* The signal handler may have used coprocessors in which
 202          * case they are still enabled.  We disable them to force a
 203          * reloading of the original task's CP state by the lazy
 204          * context-switching mechanisms of CP exception handling.
 205          * Also, we essentially discard any coprocessor state that the
 206          * signal handler created. */
 207
 208         if (!err) {
 209           struct task_struct *tsk = current;
 210           release_all_cp(tsk);
 211           err |= __copy_from_user(tsk->thread.cpextra, sc->sc_cpstate,
 212                                   XTENSA_CP_EXTRA_SIZE);
 213         }
 214 #endif
 215
 216         regs->syscall = -1;             /* disable syscall checks */
 217         return err;
 218 }
 219
 220
 221
 222 /*
 223  * Do a signal return; undo the signal stack.
 224  */
 225
 226 asmlinkage long xtensa_rt_sigreturn(long a0, long a1, long a2, long a3,
 227                                     long a4, long a5, struct pt_regs *regs)
 228 {
 229         struct rt_sigframe __user *frame;
 230         sigset_t set;
 231         int ret;
 232
 233         if (regs->depc > 64)
 234                 panic("rt_sigreturn in double exception!\n");
 235
 236         frame = (struct rt_sigframe __user *) regs->areg[1];
 237
 238         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 239                 goto badframe;
 240
 241         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 242                 goto badframe;
 243
 244         sigdelsetmask(&set, ~_BLOCKABLE);
 245         spin_lock_irq(&current->sighand->siglock);
 246         current->blocked = set;
 247         recalc_sigpending();
 248         spin_unlock_irq(&current->sighand->siglock);
 249
 250         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 251                 goto badframe;
 252
 253         ret = regs->areg[2];
 254
 255         if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->areg[1]) == -EFAULT)
 256                 goto badframe;
 257
 258         return ret;
 259
 260 badframe:
 261         force_sig(SIGSEGV, current);
 262         return 0;
 263 }
 264
 265
 266
 267 /*
 268  * Set up a signal frame.
 269  */
 270
 271 static int
 272 gen_return_code(unsigned char *codemem)
 273 {
 274         int err = 0;
 275
 276         /*
 277          * The 12-bit immediate is really split up within the 24-bit MOVI
 278          * instruction.  As long as the above system call numbers fit within
 279          * 8-bits, the following code works fine. See the Xtensa ISA for
 280          * details.
 281          */
 282
 283 #if __NR_rt_sigreturn > 255
 284 # error Generating the MOVI instruction below breaks!
 285 #endif
 286
 287 #ifdef __XTENSA_EB__   /* Big Endian version */
 288         /* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
 289         err |= __put_user(0x22, &codemem[0]);
 290         err |= __put_user(0x0a, &codemem[1]);
 291         err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
 292         /* Generate instruction:  SYSCALL */
 293         err |= __put_user(0x00, &codemem[3]);
 294         err |= __put_user(0x05, &codemem[4]);
 295         err |= __put_user(0x00, &codemem[5]);
 296
 297 #elif defined __XTENSA_EL__   /* Little Endian version */
 298         /* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
 299         err |= __put_user(0x22, &codemem[0]);
 300         err |= __put_user(0xa0, &codemem[1]);
 301         err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
 302         /* Generate instruction:  SYSCALL */
 303         err |= __put_user(0x00, &codemem[3]);
 304         err |= __put_user(0x50, &codemem[4]);
 305         err |= __put_user(0x00, &codemem[5]);
 306 #else
 307 # error Must use compiler for Xtensa processors.
 308 #endif
 309
 310         /* Flush generated code out of the data cache */
 311
 312         if (err == 0) {
 313                 __invalidate_icache_range((unsigned long)codemem, 6UL);
 314                 __flush_invalidate_dcache_range((unsigned long)codemem, 6UL);
 315         }
 316
 317         return err;
 318 }
 319
 320
 321 static void setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 322                         sigset_t *set, struct pt_regs *regs)
 323 {
 324         struct rt_sigframe *frame;
 325         int err = 0;
 326         int signal;
 327         unsigned long sp, ra;
 328
 329         sp = regs->areg[1];
 330
 331         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp)) {
 332                 sp = current->sas_ss_sp + current->sas_ss_size;
 333         }
 334
 335         frame = (void *)((sp - sizeof(*frame)) & -16ul);
 336
 337         if (regs->depc > 64)
 338                 panic ("Double exception sys_sigreturn\n");
 339
 340         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
 341                 goto give_sigsegv;
 342         }
 343
 344         signal = current_thread_info()->exec_domain
 345                 && current_thread_info()->exec_domain->signal_invmap
 346                 && sig < 32
 347                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 348                 : sig;
 349
 350         if (ka->sa.sa_flags & SA_SIGINFO) {
 351                 err |= copy_siginfo_to_user(&frame->info, info);
 352         }
 353
 354         /* Create the user context.  */
 355
 356         err |= __put_user(0, &frame->uc.uc_flags);
 357         err |= __put_user(0, &frame->uc.uc_link);
 358         err |= __put_user((void *)current->sas_ss_sp,
 359                           &frame->uc.uc_stack.ss_sp);
 360         err |= __put_user(sas_ss_flags(regs->areg[1]),
 361                           &frame->uc.uc_stack.ss_flags);
 362         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 363         err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->cpstate,
 364                                 regs, set->sig[0]);
 365         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 366
 367         /* Create sys_rt_sigreturn syscall in stack frame */
 368
 369         err |= gen_return_code(frame->retcode);
 370
 371         if (err) {
 372                 goto give_sigsegv;
 373         }
 374
 375
 376         /*
 377          * Create signal handler execution context.
 378          * Return context not modified until this point.
 379          */
 380
 381         /* Set up registers for signal handler */
 382         start_thread(regs, (unsigned long) ka->sa.sa_handler,
 383                      (unsigned long) frame);
 384
 385         /* Set up a stack frame for a call4
 386          * Note: PS.CALLINC is set to one by start_thread
 387          */
 388         ra = (unsigned long) frame->retcode;
 389         regs->areg[4] = (((unsigned long) ra) & 0x3fffffff) | 0x40000000;
 390         regs->areg[6] = (unsigned long) signal;
 391         regs->areg[7] = (unsigned long) &frame->info;
 392         regs->areg[8] = (unsigned long) &frame->uc;
 393
 394         /* Set access mode to USER_DS.  Nomenclature is outdated, but
 395          * functionality is used in uaccess.h
 396          */
 397         set_fs(USER_DS);
 398
 399 #if DEBUG_SIG
 400         printk("SIG rt deliver (%s:%d): signal=%d sp=%p pc=%08x\n",
 401                 current->comm, current->pid, signal, frame, regs->pc);
 402 #endif
 403
 404         return;
 405
 406 give_sigsegv:
 407         if (sig == SIGSEGV)
 408                 ka->sa.sa_handler = SIG_DFL;
 409         force_sig(SIGSEGV, current);
 410 }
 411
 412 /*
 413  * Atomically swap in the new signal mask, and wait for a signal.
 414  */
 415
 416 asmlinkage long xtensa_rt_sigsuspend(sigset_t __user *unewset,
 417                                      size_t sigsetsize,
 418                                      long a2, long a3, long a4, long a5,
 419                                      struct pt_regs *regs)
 420 {
 421         sigset_t saveset, newset;
 422
 423         /* XXX: Don't preclude handling different sized sigset_t's.  */
 424         if (sigsetsize != sizeof(sigset_t))
 425                 return -EINVAL;
 426
 427         if (copy_from_user(&newset, unewset, sizeof(newset)))
 428                 return -EFAULT;
 429
 430         sigdelsetmask(&newset, ~_BLOCKABLE);
 431         spin_lock_irq(&current->sighand->siglock);
 432         saveset = current->blocked;
 433         current->blocked = newset;
 434         recalc_sigpending();
 435         spin_unlock_irq(&current->sighand->siglock);
 436
 437         regs->areg[2] = -EINTR;
 438         while (1) {
 439                 current->state = TASK_INTERRUPTIBLE;
 440                 schedule();
 441                 if (do_signal(regs, &saveset))
 442                         return -EINTR;
 443         }
 444 }
 445
 446 asmlinkage long xtensa_sigaltstack(const stack_t __user *uss,
 447                                    stack_t __user *uoss,
 448                                    long a2, long a3, long a4, long a5,
 449                                    struct pt_regs *regs)
 450 {
 451         return do_sigaltstack(uss, uoss, regs->areg[1]);
 452 }
 453
 454
 455
 456 /*
 457  * Note that 'init' is a special process: it doesn't get signals it doesn't
 458  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 459  * mistake.
 460  *
 461  * Note that we go through the signals twice: once to check the signals that
 462  * the kernel can handle, and then we build all the user-level signal handling
 463  * stack-frames in one go after that.
 464  */
 465 int do_signal(struct pt_regs *regs, sigset_t *oldset)
 466 {
 467         siginfo_t info;
 468         int signr;
 469         struct k_sigaction ka;
 470
 471         if (!user_mode(regs))
 472                 return 0;
 473
 474         if (try_to_freeze())
 475                 goto no_signal;
 476
 477         if (!oldset)
 478                 oldset = &current->blocked;
 479
 480         task_pt_regs(current)->icountlevel = 0;
 481
 482         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 483
 484         if (signr > 0) {
 485
 486                 /* Are we from a system call? */
 487
 488                 if ((signed)regs->syscall >= 0) {
 489
 490                         /* If so, check system call restarting.. */
 491
 492                         switch (regs->areg[2]) {
 493                                 case -ERESTARTNOHAND:
 494                                 case -ERESTART_RESTARTBLOCK:
 495                                         regs->areg[2] = -EINTR;
 496                                         break;
 497
 498                                 case -ERESTARTSYS:
 499                                         if (!(ka.sa.sa_flags & SA_RESTART)) {
 500                                                 regs->areg[2] = -EINTR;
 501                                                 break;
 502                                         }
 503                                         /* fallthrough */
 504                                 case -ERESTARTNOINTR:
 505                                         regs->areg[2] = regs->syscall;
 506                                         regs->pc -= 3;
 507                                         break;
 508
 509                                 default:
 510                                         /* nothing to do */
 511                                         if (regs->areg[2] != 0)
 512                                         break;
 513                         }
 514                 }
 515
 516                 /* Whee!  Actually deliver the signal.  */
 517                 /* Set up the stack frame */
 518                 setup_frame(signr, &ka, &info, oldset, regs);
 519
 520                 if (ka.sa.sa_flags & SA_ONESHOT)
 521                         ka.sa.sa_handler = SIG_DFL;
 522
 523                 spin_lock_irq(&current->sighand->siglock);
 524                 sigorsets(&current->blocked, &current->blocked, &ka.sa.sa_mask);
 525                 if (!(ka.sa.sa_flags & SA_NODEFER))
 526                         sigaddset(&current->blocked, signr);
 527                 recalc_sigpending();
 528                 spin_unlock_irq(&current->sighand->siglock);
 529                 if (current->ptrace & PT_SINGLESTEP)
 530                         task_pt_regs(current)->icountlevel = 1;
 531
 532                 return 1;
 533         }
 534
 535 no_signal:
 536         /* Did we come from a system call? */
 537         if ((signed) regs->syscall >= 0) {
 538                 /* Restart the system call - no handlers present */
 539                 switch (regs->areg[2]) {
 540                 case -ERESTARTNOHAND:
 541                 case -ERESTARTSYS:
 542                 case -ERESTARTNOINTR:
 543                         regs->areg[2] = regs->syscall;
 544                         regs->pc -= 3;
 545                         break;
 546                 case -ERESTART_RESTARTBLOCK:
 547                         regs->areg[2] = __NR_restart_syscall;
 548                         regs->pc -= 3;
 549                         break;
 550                 }
 551         }
 552         if (current->ptrace & PT_SINGLESTEP)
 553                 task_pt_regs(current)->icountlevel = 1;
 554         return 0;
 555 }
 556