arch/sh/kernel/signal_64.c

   1 /*
   2  * arch/sh/kernel/signal_64.c
   3  *
   4  * Copyright (C) 2000, 2001  Paolo Alberelli
   5  * Copyright (C) 2003  Paul Mundt
   6  * Copyright (C) 2004  Richard Curnow
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/rwsem.h>
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/kernel.h>
  17 #include <linux/signal.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/personality.h>
  21 #include <linux/freezer.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/unistd.h>
  24 #include <linux/stddef.h>
  25 #include <asm/ucontext.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/pgtable.h>
  28 #include <asm/cacheflush.h>
  29
  30 #define REG_RET 9
  31 #define REG_ARG1 2
  32 #define REG_ARG2 3
  33 #define REG_ARG3 4
  34 #define REG_SP 15
  35 #define REG_PR 18
  36 #define REF_REG_RET regs->regs[REG_RET]
  37 #define REF_REG_SP regs->regs[REG_SP]
  38 #define DEREF_REG_PR regs->regs[REG_PR]
  39
  40 #define DEBUG_SIG 0
  41
  42 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  43
  44 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  45
  46 /*
  47  * Atomically swap in the new signal mask, and wait for a signal.
  48  */
  49
  50 asmlinkage int
  51 sys_sigsuspend(old_sigset_t mask,
  52                unsigned long r3, unsigned long r4, unsigned long r5,
  53                unsigned long r6, unsigned long r7,
  54                struct pt_regs * regs)
  55 {
  56         sigset_t saveset;
  57
  58         mask &= _BLOCKABLE;
  59         spin_lock_irq(&current->sighand->siglock);
  60         saveset = current->blocked;
  61         siginitset(&current->blocked, mask);
  62         recalc_sigpending();
  63         spin_unlock_irq(&current->sighand->siglock);
  64
  65         REF_REG_RET = -EINTR;
  66         while (1) {
  67                 current->state = TASK_INTERRUPTIBLE;
  68                 schedule();
  69                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
  70                 if (do_signal(regs, &saveset)) {
  71                         /* pc now points at signal handler. Need to decrement
  72                            it because entry.S will increment it. */
  73                         regs->pc -= 4;
  74                         return -EINTR;
  75                 }
  76         }
  77 }
  78
  79 asmlinkage int
  80 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
  81                   unsigned long r4, unsigned long r5, unsigned long r6,
  82                   unsigned long r7,
  83                   struct pt_regs * regs)
  84 {
  85         sigset_t saveset, newset;
  86
  87         /* XXX: Don't preclude handling different sized sigset_t's.  */
  88         if (sigsetsize != sizeof(sigset_t))
  89                 return -EINVAL;
  90
  91         if (copy_from_user(&newset, unewset, sizeof(newset)))
  92                 return -EFAULT;
  93         sigdelsetmask(&newset, ~_BLOCKABLE);
  94         spin_lock_irq(&current->sighand->siglock);
  95         saveset = current->blocked;
  96         current->blocked = newset;
  97         recalc_sigpending();
  98         spin_unlock_irq(&current->sighand->siglock);
  99
 100         REF_REG_RET = -EINTR;
 101         while (1) {
 102                 current->state = TASK_INTERRUPTIBLE;
 103                 schedule();
 104                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 105                 if (do_signal(regs, &saveset)) {
 106                         /* pc now points at signal handler. Need to decrement
 107                            it because entry.S will increment it. */
 108                         regs->pc -= 4;
 109                         return -EINTR;
 110                 }
 111         }
 112 }
 113
 114 asmlinkage int
 115 sys_sigaction(int sig, const struct old_sigaction __user *act,
 116               struct old_sigaction __user *oact)
 117 {
 118         struct k_sigaction new_ka, old_ka;
 119         int ret;
 120
 121         if (act) {
 122                 old_sigset_t mask;
 123                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 124                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 125                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 126                         return -EFAULT;
 127                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 128                 __get_user(mask, &act->sa_mask);
 129                 siginitset(&new_ka.sa.sa_mask, mask);
 130         }
 131
 132         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 133
 134         if (!ret && oact) {
 135                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 136                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 137                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 138                         return -EFAULT;
 139                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 140                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 141         }
 142
 143         return ret;
 144 }
 145
 146 asmlinkage int
 147 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 148                 unsigned long r4, unsigned long r5, unsigned long r6,
 149                 unsigned long r7,
 150                 struct pt_regs * regs)
 151 {
 152         return do_sigaltstack(uss, uoss, REF_REG_SP);
 153 }
 154
 155
 156 /*
 157  * Do a signal return; undo the signal stack.
 158  */
 159
 160 struct sigframe
 161 {
 162         struct sigcontext sc;
 163         unsigned long extramask[_NSIG_WORDS-1];
 164         long long retcode[2];
 165 };
 166
 167 struct rt_sigframe
 168 {
 169         struct siginfo __user *pinfo;
 170         void *puc;
 171         struct siginfo info;
 172         struct ucontext uc;
 173         long long retcode[2];
 174 };
 175
 176 #ifdef CONFIG_SH_FPU
 177 static inline int
 178 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 179 {
 180         int err = 0;
 181         int fpvalid;
 182
 183         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 184         conditional_used_math(fpvalid);
 185         if (! fpvalid)
 186                 return err;
 187
 188         if (current == last_task_used_math) {
 189                 last_task_used_math = NULL;
 190                 regs->sr |= SR_FD;
 191         }
 192
 193         err |= __copy_from_user(&current->thread.fpu.hard, &sc->sc_fpregs[0],
 194                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 195
 196         return err;
 197 }
 198
 199 static inline int
 200 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 201 {
 202         int err = 0;
 203         int fpvalid;
 204
 205         fpvalid = !!used_math();
 206         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 207         if (! fpvalid)
 208                 return err;
 209
 210         if (current == last_task_used_math) {
 211                 enable_fpu();
 212                 save_fpu(current, regs);
 213                 disable_fpu();
 214                 last_task_used_math = NULL;
 215                 regs->sr |= SR_FD;
 216         }
 217
 218         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.fpu.hard,
 219                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 220         clear_used_math();
 221
 222         return err;
 223 }
 224 #else
 225 static inline int
 226 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 227 {
 228         return 0;
 229 }
 230 static inline int
 231 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 232 {
 233         return 0;
 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);
 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 -ERESTART_RESTARTBLOCK:
 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 (test_thread_flag(TIF_RESTORE_SIGMASK))
 703                 oldset = &current->saved_sigmask;
 704         else if (!oldset)
 705                 oldset = &current->blocked;
 706
 707         signr = get_signal_to_deliver(&info, &ka, regs, 0);
 708
 709         if (signr > 0) {
 710                 /* Whee!  Actually deliver the signal.  */
 711                 handle_signal(signr, &info, &ka, oldset, regs);
 712
 713                 /*
 714                  * If a signal was successfully delivered, the saved sigmask
 715                  * is in its frame, and we can clear the TIF_RESTORE_SIGMASK
 716                  * flag.
 717                  */
 718                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
 719                         clear_thread_flag(TIF_RESTORE_SIGMASK);
 720
 721                 return 1;
 722         }
 723
 724 no_signal:
 725         /* Did we come from a system call? */
 726         if (regs->syscall_nr >= 0) {
 727                 /* Restart the system call - no handlers present */
 728                 switch (regs->regs[REG_RET]) {
 729                 case -ERESTARTNOHAND:
 730                 case -ERESTARTSYS:
 731                 case -ERESTARTNOINTR:
 732                         /* Decode Syscall # */
 733                         regs->regs[REG_RET] = regs->syscall_nr;
 734                         regs->pc -= 4;
 735                         break;
 736
 737                 case -ERESTART_RESTARTBLOCK:
 738                         regs->regs[REG_RET] = __NR_restart_syscall;
 739                         regs->pc -= 4;
 740                         break;
 741                 }
 742         }
 743
 744         /* No signal to deliver -- put the saved sigmask back */
 745         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 746                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 747                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 748         }
 749
 750         return 0;
 751 }