arch/sh64/kernel/signal.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * arch/sh64/kernel/signal.c
   7  *
   8  * Copyright (C) 2000, 2001  Paolo Alberelli
   9  * Copyright (C) 2003  Paul Mundt
  10  * Copyright (C) 2004  Richard Curnow
  11  *
  12  * Started from sh version.
  13  *
  14  */
  15 #include <linux/rwsem.h>
  16 #include <linux/sched.h>
  17 #include <linux/mm.h>
  18 #include <linux/smp.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/kernel.h>
  21 #include <linux/signal.h>
  22 #include <linux/errno.h>
  23 #include <linux/wait.h>
  24 #include <linux/personality.h>
  25 #include <linux/freezer.h>
  26 #include <linux/ptrace.h>
  27 #include <linux/unistd.h>
  28 #include <linux/stddef.h>
  29 #include <linux/personality.h>
  30 #include <asm/ucontext.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/pgtable.h>
  33
  34
  35 #define REG_RET 9
  36 #define REG_ARG1 2
  37 #define REG_ARG2 3
  38 #define REG_ARG3 4
  39 #define REG_SP 15
  40 #define REG_PR 18
  41 #define REF_REG_RET regs->regs[REG_RET]
  42 #define REF_REG_SP regs->regs[REG_SP]
  43 #define DEREF_REG_PR regs->regs[REG_PR]
  44
  45 #define DEBUG_SIG 0
  46
  47 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  48
  49 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  50
  51 /*
  52  * Atomically swap in the new signal mask, and wait for a signal.
  53  */
  54
  55 asmlinkage int
  56 sys_sigsuspend(old_sigset_t mask,
  57                unsigned long r3, unsigned long r4, unsigned long r5,
  58                unsigned long r6, unsigned long r7,
  59                struct pt_regs * regs)
  60 {
  61         sigset_t saveset;
  62
  63         mask &= _BLOCKABLE;
  64         spin_lock_irq(&current->sighand->siglock);
  65         saveset = current->blocked;
  66         siginitset(&current->blocked, mask);
  67         recalc_sigpending();
  68         spin_unlock_irq(&current->sighand->siglock);
  69
  70         REF_REG_RET = -EINTR;
  71         while (1) {
  72                 current->state = TASK_INTERRUPTIBLE;
  73                 schedule();
  74                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
  75                 if (do_signal(regs, &saveset)) {
  76                         /* pc now points at signal handler. Need to decrement
  77                            it because entry.S will increment it. */
  78                         regs->pc -= 4;
  79                         return -EINTR;
  80                 }
  81         }
  82 }
  83
  84 asmlinkage int
  85 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
  86                   unsigned long r4, unsigned long r5, unsigned long r6,
  87                   unsigned long r7,
  88                   struct pt_regs * regs)
  89 {
  90         sigset_t saveset, newset;
  91
  92         /* XXX: Don't preclude handling different sized sigset_t's.  */
  93         if (sigsetsize != sizeof(sigset_t))
  94                 return -EINVAL;
  95
  96         if (copy_from_user(&newset, unewset, sizeof(newset)))
  97                 return -EFAULT;
  98         sigdelsetmask(&newset, ~_BLOCKABLE);
  99         spin_lock_irq(&current->sighand->siglock);
 100         saveset = current->blocked;
 101         current->blocked = newset;
 102         recalc_sigpending();
 103         spin_unlock_irq(&current->sighand->siglock);
 104
 105         REF_REG_RET = -EINTR;
 106         while (1) {
 107                 current->state = TASK_INTERRUPTIBLE;
 108                 schedule();
 109                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 110                 if (do_signal(regs, &saveset)) {
 111                         /* pc now points at signal handler. Need to decrement
 112                            it because entry.S will increment it. */
 113                         regs->pc -= 4;
 114                         return -EINTR;
 115                 }
 116         }
 117 }
 118
 119 asmlinkage int
 120 sys_sigaction(int sig, const struct old_sigaction __user *act,
 121               struct old_sigaction __user *oact)
 122 {
 123         struct k_sigaction new_ka, old_ka;
 124         int ret;
 125
 126         if (act) {
 127                 old_sigset_t mask;
 128                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 129                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 130                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 131                         return -EFAULT;
 132                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 133                 __get_user(mask, &act->sa_mask);
 134                 siginitset(&new_ka.sa.sa_mask, mask);
 135         }
 136
 137         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 138
 139         if (!ret && oact) {
 140                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 141                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 142                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 143                         return -EFAULT;
 144                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 145                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 146         }
 147
 148         return ret;
 149 }
 150
 151 asmlinkage int
 152 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 153                 unsigned long r4, unsigned long r5, unsigned long r6,
 154                 unsigned long r7,
 155                 struct pt_regs * regs)
 156 {
 157         return do_sigaltstack(uss, uoss, REF_REG_SP);
 158 }
 159
 160
 161 /*
 162  * Do a signal return; undo the signal stack.
 163  */
 164
 165 struct sigframe
 166 {
 167         struct sigcontext sc;
 168         unsigned long extramask[_NSIG_WORDS-1];
 169         long long retcode[2];
 170 };
 171
 172 struct rt_sigframe
 173 {
 174         struct siginfo __user *pinfo;
 175         void *puc;
 176         struct siginfo info;
 177         struct ucontext uc;
 178         long long retcode[2];
 179 };
 180
 181 #ifdef CONFIG_SH_FPU
 182 static inline int
 183 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 184 {
 185         int err = 0;
 186         int fpvalid;
 187
 188         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 189         conditional_used_math(fpvalid);
 190         if (! fpvalid)
 191                 return err;
 192
 193         if (current == last_task_used_math) {
 194                 last_task_used_math = NULL;
 195                 regs->sr |= SR_FD;
 196         }
 197
 198         err |= __copy_from_user(&current->thread.fpu.hard, &sc->sc_fpregs[0],
 199                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 200
 201         return err;
 202 }
 203
 204 static inline int
 205 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 206 {
 207         int err = 0;
 208         int fpvalid;
 209
 210         fpvalid = !!used_math();
 211         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 212         if (! fpvalid)
 213                 return err;
 214
 215         if (current == last_task_used_math) {
 216                 grab_fpu();
 217                 fpsave(&current->thread.fpu.hard);
 218                 release_fpu();
 219                 last_task_used_math = NULL;
 220                 regs->sr |= SR_FD;
 221         }
 222
 223         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.fpu.hard,
 224                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 225         clear_used_math();
 226
 227         return err;
 228 }
 229 #else
 230 static inline int
 231 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 232 {}
 233 static inline int
 234 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 235 {}
 236 #endif
 237
 238 static int
 239 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 240 {
 241         unsigned int err = 0;
 242         unsigned long long current_sr, new_sr;
 243 #define SR_MASK 0xffff8cfd
 244
 245 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 246
 247         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 248         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 249         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 250         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 251         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 252         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 253         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 254         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 255         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 256         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 257         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 258         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 259         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 260         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 261         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 262         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 263         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 264         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 265
 266         /* Prevent the signal handler manipulating SR in a way that can
 267            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 268            modified */
 269         current_sr = regs->sr;
 270         err |= __get_user(new_sr, &sc->sc_sr);
 271         regs->sr &= SR_MASK;
 272         regs->sr |= (new_sr & ~SR_MASK);
 273
 274         COPY(pc);
 275
 276 #undef COPY
 277
 278         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 279          * has been restored above.) */
 280         err |= restore_sigcontext_fpu(regs, sc);
 281
 282         regs->syscall_nr = -1;          /* disable syscall checks */
 283         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 284         return err;
 285 }
 286
 287 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 288                                    unsigned long r4, unsigned long r5,
 289                                    unsigned long r6, unsigned long r7,
 290                                    struct pt_regs * regs)
 291 {
 292         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 293         sigset_t set;
 294         long long ret;
 295
 296         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 297                 goto badframe;
 298
 299         if (__get_user(set.sig[0], &frame->sc.oldmask)
 300             || (_NSIG_WORDS > 1
 301                 && __copy_from_user(&set.sig[1], &frame->extramask,
 302                                     sizeof(frame->extramask))))
 303                 goto badframe;
 304
 305         sigdelsetmask(&set, ~_BLOCKABLE);
 306
 307         spin_lock_irq(&current->sighand->siglock);
 308         current->blocked = set;
 309         recalc_sigpending();
 310         spin_unlock_irq(&current->sighand->siglock);
 311
 312         if (restore_sigcontext(regs, &frame->sc, &ret))
 313                 goto badframe;
 314         regs->pc -= 4;
 315
 316         return (int) ret;
 317
 318 badframe:
 319         force_sig(SIGSEGV, current);
 320         return 0;
 321 }
 322
 323 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 324                                 unsigned long r4, unsigned long r5,
 325                                 unsigned long r6, unsigned long r7,
 326                                 struct pt_regs * regs)
 327 {
 328         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 329         sigset_t set;
 330         stack_t __user st;
 331         long long ret;
 332
 333         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 334                 goto badframe;
 335
 336         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 337                 goto badframe;
 338
 339         sigdelsetmask(&set, ~_BLOCKABLE);
 340         spin_lock_irq(&current->sighand->siglock);
 341         current->blocked = set;
 342         recalc_sigpending();
 343         spin_unlock_irq(&current->sighand->siglock);
 344
 345         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 346                 goto badframe;
 347         regs->pc -= 4;
 348
 349         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 350                 goto badframe;
 351         /* It is more difficult to avoid calling this function than to
 352            call it and ignore errors.  */
 353         do_sigaltstack(&st, NULL, REF_REG_SP);
 354
 355         return (int) ret;
 356
 357 badframe:
 358         force_sig(SIGSEGV, current);
 359         return 0;
 360 }
 361
 362 /*
 363  * Set up a signal frame.
 364  */
 365
 366 static int
 367 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 368                  unsigned long mask)
 369 {
 370         int err = 0;
 371
 372         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 373         err |= setup_sigcontext_fpu(regs, sc);
 374
 375 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 376
 377         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 378         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 379         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 380         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 381         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 382         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 383         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 384         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 385         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 386         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 387         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 388         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 389         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 390         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 391         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 392         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 393         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 394         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 395         COPY(sr);       COPY(pc);
 396
 397 #undef COPY
 398
 399         err |= __put_user(mask, &sc->oldmask);
 400
 401         return err;
 402 }
 403
 404 /*
 405  * Determine which stack to use..
 406  */
 407 static inline void __user *
 408 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 409 {
 410         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 411                 sp = current->sas_ss_sp + current->sas_ss_size;
 412
 413         return (void __user *)((sp - frame_size) & -8ul);
 414 }
 415
 416 void sa_default_restorer(void);         /* See comments below */
 417 void sa_default_rt_restorer(void);      /* See comments below */
 418
 419 static void setup_frame(int sig, struct k_sigaction *ka,
 420                         sigset_t *set, struct pt_regs *regs)
 421 {
 422         struct sigframe __user *frame;
 423         int err = 0;
 424         int signal;
 425
 426         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 427
 428         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 429                 goto give_sigsegv;
 430
 431         signal = current_thread_info()->exec_domain
 432                 && current_thread_info()->exec_domain->signal_invmap
 433                 && sig < 32
 434                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 435                 : sig;
 436
 437         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 438
 439         /* Give up earlier as i386, in case */
 440         if (err)
 441                 goto give_sigsegv;
 442
 443         if (_NSIG_WORDS > 1) {
 444                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 445                                       sizeof(frame->extramask)); }
 446
 447         /* Give up earlier as i386, in case */
 448         if (err)
 449                 goto give_sigsegv;
 450
 451         /* Set up to return from userspace.  If provided, use a stub
 452            already in userspace.  */
 453         if (ka->sa.sa_flags & SA_RESTORER) {
 454                 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
 455
 456                 /*
 457                  * On SH5 all edited pointers are subject to NEFF
 458                  */
 459                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 460                                 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 461         } else {
 462                 /*
 463                  * Different approach on SH5.
 464                  * . Endianness independent asm code gets placed in entry.S .
 465                  *   This is limited to four ASM instructions corresponding
 466                  *   to two long longs in size.
 467                  * . err checking is done on the else branch only
 468                  * . flush_icache_range() is called upon __put_user() only
 469                  * . all edited pointers are subject to NEFF
 470                  * . being code, linker turns ShMedia bit on, always
 471                  *   dereference index -1.
 472                  */
 473                 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
 474                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 475                                 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 476
 477                 if (__copy_to_user(frame->retcode,
 478                         (unsigned long long)sa_default_restorer & (~1), 16) != 0)
 479                         goto give_sigsegv;
 480
 481                 /* Cohere the trampoline with the I-cache. */
 482                 flush_cache_sigtramp(DEREF_REG_PR-1, DEREF_REG_PR-1+16);
 483         }
 484
 485         /*
 486          * Set up registers for signal handler.
 487          * All edited pointers are subject to NEFF.
 488          */
 489         regs->regs[REG_SP] = (unsigned long) frame;
 490         regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
 491                          (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
 492         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 493
 494         /* FIXME:
 495            The glibc profiling support for SH-5 needs to be passed a sigcontext
 496            so it can retrieve the PC.  At some point during 2003 the glibc
 497            support was changed to receive the sigcontext through the 2nd
 498            argument, but there are still versions of libc.so in use that use
 499            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 500            through both 2nd and 3rd arguments.
 501         */
 502
 503         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 504         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 505
 506         regs->pc = (unsigned long) ka->sa.sa_handler;
 507         regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
 508
 509         set_fs(USER_DS);
 510
 511 #if DEBUG_SIG
 512         /* Broken %016Lx */
 513         printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 514                 signal,
 515                 current->comm, current->pid, frame,
 516                 regs->pc >> 32, regs->pc & 0xffffffff,
 517                 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 518 #endif
 519
 520         return;
 521
 522 give_sigsegv:
 523         force_sigsegv(sig, current);
 524 }
 525
 526 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 527                            sigset_t *set, struct pt_regs *regs)
 528 {
 529         struct rt_sigframe __user *frame;
 530         int err = 0;
 531         int signal;
 532
 533         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 534
 535         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 536                 goto give_sigsegv;
 537
 538         signal = current_thread_info()->exec_domain
 539                 && current_thread_info()->exec_domain->signal_invmap
 540                 && sig < 32
 541                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 542                 : sig;
 543
 544         err |= __put_user(&frame->info, &frame->pinfo);
 545         err |= __put_user(&frame->uc, &frame->puc);
 546         err |= copy_siginfo_to_user(&frame->info, info);
 547
 548         /* Give up earlier as i386, in case */
 549         if (err)
 550                 goto give_sigsegv;
 551
 552         /* Create the ucontext.  */
 553         err |= __put_user(0, &frame->uc.uc_flags);
 554         err |= __put_user(0, &frame->uc.uc_link);
 555         err |= __put_user((void *)current->sas_ss_sp,
 556                           &frame->uc.uc_stack.ss_sp);
 557         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
 558                           &frame->uc.uc_stack.ss_flags);
 559         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 560         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 561                                 regs, set->sig[0]);
 562         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 563
 564         /* Give up earlier as i386, in case */
 565         if (err)
 566                 goto give_sigsegv;
 567
 568         /* Set up to return from userspace.  If provided, use a stub
 569            already in userspace.  */
 570         if (ka->sa.sa_flags & SA_RESTORER) {
 571                 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
 572
 573                 /*
 574                  * On SH5 all edited pointers are subject to NEFF
 575                  */
 576                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 577                                 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 578         } else {
 579                 /*
 580                  * Different approach on SH5.
 581                  * . Endianness independent asm code gets placed in entry.S .
 582                  *   This is limited to four ASM instructions corresponding
 583                  *   to two long longs in size.
 584                  * . err checking is done on the else branch only
 585                  * . flush_icache_range() is called upon __put_user() only
 586                  * . all edited pointers are subject to NEFF
 587                  * . being code, linker turns ShMedia bit on, always
 588                  *   dereference index -1.
 589                  */
 590
 591                 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
 592                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 593                                 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 594
 595                 if (__copy_to_user(frame->retcode,
 596                         (unsigned long long)sa_default_rt_restorer & (~1), 16) != 0)
 597                         goto give_sigsegv;
 598
 599                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 600         }
 601
 602         /*
 603          * Set up registers for signal handler.
 604          * All edited pointers are subject to NEFF.
 605          */
 606         regs->regs[REG_SP] = (unsigned long) frame;
 607         regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
 608                          (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
 609         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 610         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 611         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 612         regs->pc = (unsigned long) ka->sa.sa_handler;
 613         regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
 614
 615         set_fs(USER_DS);
 616
 617 #if DEBUG_SIG
 618         /* Broken %016Lx */
 619         printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 620                 signal,
 621                 current->comm, current->pid, frame,
 622                 regs->pc >> 32, regs->pc & 0xffffffff,
 623                 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 624 #endif
 625
 626         return;
 627
 628 give_sigsegv:
 629         force_sigsegv(sig, current);
 630 }
 631
 632 /*
 633  * OK, we're invoking a handler
 634  */
 635
 636 static void
 637 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 638                 sigset_t *oldset, struct pt_regs * regs)
 639 {
 640         /* Are we from a system call? */
 641         if (regs->syscall_nr >= 0) {
 642                 /* If so, check system call restarting.. */
 643                 switch (regs->regs[REG_RET]) {
 644                         case -ERESTARTNOHAND:
 645                                 regs->regs[REG_RET] = -EINTR;
 646                                 break;
 647
 648                         case -ERESTARTSYS:
 649                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 650                                         regs->regs[REG_RET] = -EINTR;
 651                                         break;
 652                                 }
 653                         /* fallthrough */
 654                         case -ERESTARTNOINTR:
 655                                 /* Decode syscall # */
 656                                 regs->regs[REG_RET] = regs->syscall_nr;
 657                                 regs->pc -= 4;
 658                 }
 659         }
 660
 661         /* Set up the stack frame */
 662         if (ka->sa.sa_flags & SA_SIGINFO)
 663                 setup_rt_frame(sig, ka, info, oldset, regs);
 664         else
 665                 setup_frame(sig, ka, oldset, regs);
 666
 667         spin_lock_irq(&current->sighand->siglock);
 668         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 669         if (!(ka->sa.sa_flags & SA_NODEFER))
 670                 sigaddset(&current->blocked,sig);
 671         recalc_sigpending();
 672         spin_unlock_irq(&current->sighand->siglock);
 673 }
 674
 675 /*
 676  * Note that 'init' is a special process: it doesn't get signals it doesn't
 677  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 678  * mistake.
 679  *
 680  * Note that we go through the signals twice: once to check the signals that
 681  * the kernel can handle, and then we build all the user-level signal handling
 682  * stack-frames in one go after that.
 683  */
 684 int do_signal(struct pt_regs *regs, sigset_t *oldset)
 685 {
 686         siginfo_t info;
 687         int signr;
 688         struct k_sigaction ka;
 689
 690         /*
 691          * We want the common case to go fast, which
 692          * is why we may in certain cases get here from
 693          * kernel mode. Just return without doing anything
 694          * if so.
 695          */
 696         if (!user_mode(regs))
 697                 return 1;
 698
 699         if (try_to_freeze())
 700                 goto no_signal;
 701
 702         if (!oldset)
 703                 oldset = &current->blocked;
 704
 705         signr = get_signal_to_deliver(&info, &ka, regs, 0);
 706
 707         if (signr > 0) {
 708                 /* Whee!  Actually deliver the signal.  */
 709                 handle_signal(signr, &info, &ka, oldset, regs);
 710                 return 1;
 711         }
 712
 713 no_signal:
 714         /* Did we come from a system call? */
 715         if (regs->syscall_nr >= 0) {
 716                 /* Restart the system call - no handlers present */
 717                 if (regs->regs[REG_RET] == -ERESTARTNOHAND ||
 718                     regs->regs[REG_RET] == -ERESTARTSYS ||
 719                     regs->regs[REG_RET] == -ERESTARTNOINTR) {
 720                         /* Decode Syscall # */
 721                         regs->regs[REG_RET] = regs->syscall_nr;
 722                         regs->pc -= 4;
 723                 }
 724         }
 725         return 0;
 726 }