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