arch/cris/arch-v32/kernel/signal.c

   1 /*
   2  * Copyright (C) 2003, Axis Communications AB.
   3  */
   4
   5 #include <linux/sched.h>
   6 #include <linux/mm.h>
   7 #include <linux/slab.h>
   8 #include <linux/kernel.h>
   9 #include <linux/signal.h>
  10 #include <linux/errno.h>
  11 #include <linux/wait.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/unistd.h>
  14 #include <linux/stddef.h>
  15 #include <linux/syscalls.h>
  16 #include <linux/vmalloc.h>
  17
  18 #include <asm/io.h>
  19 #include <asm/processor.h>
  20 #include <asm/ucontext.h>
  21 #include <asm/uaccess.h>
  22 #include <arch/ptrace.h>
  23 #include <arch/hwregs/cpu_vect.h>
  24
  25 extern unsigned long cris_signal_return_page;
  26
  27 /*
  28  * A syscall in CRIS is really a "break 13" instruction, which is 2
  29  * bytes. The registers is manipulated so upon return the instruction
  30  * will be executed again.
  31  *
  32  * This relies on that PC points to the instruction after the break call.
  33  */
  34 #define RESTART_CRIS_SYS(regs) regs->r10 = regs->orig_r10; regs->erp -= 2;
  35
  36 /* Signal frames. */
  37 struct signal_frame {
  38         struct sigcontext sc;
  39         unsigned long extramask[_NSIG_WORDS - 1];
  40         unsigned char retcode[8];       /* Trampoline code. */
  41 };
  42
  43 struct rt_signal_frame {
  44         struct siginfo *pinfo;
  45         void *puc;
  46         struct siginfo info;
  47         struct ucontext uc;
  48         unsigned char retcode[8];       /* Trampoline code. */
  49 };
  50
  51 void do_signal(int restart, struct pt_regs *regs);
  52 void keep_debug_flags(unsigned long oldccs, unsigned long oldspc,
  53                       struct pt_regs *regs);
  54
  55 static int
  56 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
  57 {
  58         unsigned int err = 0;
  59         unsigned long old_usp;
  60
  61         /* Always make any pending restarted system calls return -EINTR */
  62         current->restart_block.fn = do_no_restart_syscall;
  63
  64         /*
  65          * Restore the registers from &sc->regs. sc is already checked
  66          * for VERIFY_READ since the signal_frame was previously
  67          * checked in sys_sigreturn().
  68          */
  69         if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))
  70                 goto badframe;
  71
  72         /* Make that the user-mode flag is set. */
  73         regs->ccs |= (1 << (U_CCS_BITNR + CCS_SHIFT));
  74
  75         /* Don't perform syscall restarting */
  76         regs->exs = -1;
  77
  78         /* Restore the old USP. */
  79         err |= __get_user(old_usp, &sc->usp);
  80         wrusp(old_usp);
  81
  82         return err;
  83
  84 badframe:
  85         return 1;
  86 }
  87
  88 asmlinkage int sys_sigreturn(void)
  89 {
  90         struct pt_regs *regs = current_pt_regs();
  91         sigset_t set;
  92         struct signal_frame __user *frame;
  93         unsigned long oldspc = regs->spc;
  94         unsigned long oldccs = regs->ccs;
  95
  96         frame = (struct signal_frame *) rdusp();
  97
  98         /*
  99          * Since the signal is stacked on a dword boundary, the frame
 100          * should be dword aligned here as well. It it's not, then the
 101          * user is trying some funny business.
 102          */
 103         if (((long)frame) & 3)
 104                 goto badframe;
 105
 106         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 107                 goto badframe;
 108
 109         if (__get_user(set.sig[0], &frame->sc.oldmask) ||
 110             (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1],
 111                                                  frame->extramask,
 112                                                  sizeof(frame->extramask))))
 113                 goto badframe;
 114
 115         set_current_blocked(&set);
 116
 117         if (restore_sigcontext(regs, &frame->sc))
 118                 goto badframe;
 119
 120         keep_debug_flags(oldccs, oldspc, regs);
 121
 122         return regs->r10;
 123
 124 badframe:
 125         force_sig(SIGSEGV, current);
 126         return 0;
 127 }
 128
 129 asmlinkage int sys_rt_sigreturn(void)
 130 {
 131         struct pt_regs *regs = current_pt_regs();
 132         sigset_t set;
 133         struct rt_signal_frame __user *frame;
 134         unsigned long oldspc = regs->spc;
 135         unsigned long oldccs = regs->ccs;
 136
 137         frame = (struct rt_signal_frame *) rdusp();
 138
 139         /*
 140          * Since the signal is stacked on a dword boundary, the frame
 141          * should be dword aligned here as well. It it's not, then the
 142          * user is trying some funny business.
 143          */
 144         if (((long)frame) & 3)
 145                 goto badframe;
 146
 147         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 148                 goto badframe;
 149
 150         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 151                 goto badframe;
 152
 153         set_current_blocked(&set);
 154
 155         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 156                 goto badframe;
 157
 158         if (restore_altstack(&frame->uc.uc_stack))
 159                 goto badframe;
 160
 161         keep_debug_flags(oldccs, oldspc, regs);
 162
 163         return regs->r10;
 164
 165 badframe:
 166         force_sig(SIGSEGV, current);
 167         return 0;
 168 }
 169
 170 /* Setup a signal frame. */
 171 static int
 172 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 173                  unsigned long mask)
 174 {
 175         int err;
 176         unsigned long usp;
 177
 178         err = 0;
 179         usp = rdusp();
 180
 181         /*
 182          * Copy the registers. They are located first in sc, so it's
 183          * possible to use sc directly.
 184          */
 185         err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));
 186
 187         err |= __put_user(mask, &sc->oldmask);
 188         err |= __put_user(usp, &sc->usp);
 189
 190         return err;
 191 }
 192
 193 /* Figure out where to put the new signal frame - usually on the stack. */
 194 static inline void __user *
 195 get_sigframe(struct ksignal *ksig, size_t frame_size)
 196 {
 197         unsigned long sp = sigsp(rdusp(), ksig);
 198
 199         /* Make sure the frame is dword-aligned. */
 200         sp &= ~3;
 201
 202         return (void __user *)(sp - frame_size);
 203 }
 204
 205 /* Grab and setup a signal frame.
 206  *
 207  * Basically a lot of state-info is stacked, and arranged for the
 208  * user-mode program to return to the kernel using either a trampiline
 209  * which performs the syscall sigreturn(), or a provided user-mode
 210  * trampoline.
 211   */
 212 static int
 213 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 214 {
 215         int err;
 216         unsigned long return_ip;
 217         struct signal_frame __user *frame;
 218
 219         err = 0;
 220         frame = get_sigframe(ksig, sizeof(*frame));
 221
 222         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 223                 return -EFAULT;
 224
 225         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 226
 227         if (err)
 228                 return -EFAULT;
 229
 230         if (_NSIG_WORDS > 1) {
 231                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 232                                       sizeof(frame->extramask));
 233         }
 234
 235         if (err)
 236                 return -EFAULT;
 237
 238         /*
 239          * Set up to return from user-space. If provided, use a stub
 240          * already located in user-space.
 241          */
 242         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 243                 return_ip = (unsigned long)ksig->ka.sa.sa_restorer;
 244         } else {
 245                 /* Trampoline - the desired return ip is in the signal return page. */
 246                 return_ip = cris_signal_return_page;
 247
 248                 /*
 249                  * This is movu.w __NR_sigreturn, r9; break 13;
 250                  *
 251                  * WE DO NOT USE IT ANY MORE! It's only left here for historical
 252                  * reasons and because gdb uses it as a signature to notice
 253                  * signal handler stack frames.
 254                  */
 255                 err |= __put_user(0x9c5f,         (short __user*)(frame->retcode+0));
 256                 err |= __put_user(__NR_sigreturn, (short __user*)(frame->retcode+2));
 257                 err |= __put_user(0xe93d,         (short __user*)(frame->retcode+4));
 258         }
 259
 260         if (err)
 261                 return -EFAULT;
 262
 263         /*
 264          * Set up registers for signal handler.
 265          *
 266          * Where the code enters now.
 267          * Where the code enter later.
 268          * First argument, signo.
 269          */
 270         regs->erp = (unsigned long) ksig->ka.sa.sa_handler;
 271         regs->srp = return_ip;
 272         regs->r10 = ksig->sig;
 273
 274         /* Actually move the USP to reflect the stacked frame. */
 275         wrusp((unsigned long)frame);
 276
 277         return 0;
 278 }
 279
 280 static int
 281 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 282 {
 283         int err;
 284         unsigned long return_ip;
 285         struct rt_signal_frame __user *frame;
 286
 287         err = 0;
 288         frame = get_sigframe(ksig, sizeof(*frame));
 289
 290         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 291                 return -EFAULT;
 292
 293         /* TODO: what is the current->exec_domain stuff and invmap ? */
 294
 295         err |= __put_user(&frame->info, &frame->pinfo);
 296         err |= __put_user(&frame->uc, &frame->puc);
 297         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 298
 299         if (err)
 300                 return -EFAULT;
 301
 302         /* Clear all the bits of the ucontext we don't use.  */
 303         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 304         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
 305         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 306         err |= __save_altstack(&frame->uc.uc_stack, rdusp());
 307
 308         if (err)
 309                 return -EFAULT;
 310
 311         /*
 312          * Set up to return from user-space. If provided, use a stub
 313          * already located in user-space.
 314          */
 315         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 316                 return_ip = (unsigned long) ksig->ka.sa.sa_restorer;
 317         } else {
 318                 /* Trampoline - the desired return ip is in the signal return page. */
 319                 return_ip = cris_signal_return_page + 6;
 320
 321                 /*
 322                  * This is movu.w __NR_rt_sigreturn, r9; break 13;
 323                  *
 324                  * WE DO NOT USE IT ANY MORE! It's only left here for historical
 325                  * reasons and because gdb uses it as a signature to notice
 326                  * signal handler stack frames.
 327                  */
 328                 err |= __put_user(0x9c5f, (short __user*)(frame->retcode+0));
 329
 330                 err |= __put_user(__NR_rt_sigreturn,
 331                                   (short __user*)(frame->retcode+2));
 332
 333                 err |= __put_user(0xe93d, (short __user*)(frame->retcode+4));
 334         }
 335
 336         if (err)
 337                 return -EFAULT;
 338
 339         /*
 340          * Set up registers for signal handler.
 341          *
 342          * Where the code enters now.
 343          * Where the code enters later.
 344          * First argument is signo.
 345          * Second argument is (siginfo_t *).
 346          * Third argument is unused.
 347          */
 348         regs->erp = (unsigned long) ksig->ka.sa.sa_handler;
 349         regs->srp = return_ip;
 350         regs->r10 = ksig->sig;
 351         regs->r11 = (unsigned long) &frame->info;
 352         regs->r12 = 0;
 353
 354         /* Actually move the usp to reflect the stacked frame. */
 355         wrusp((unsigned long)frame);
 356
 357         return 0;
 358 }
 359
 360 /* Invoke a signal handler to, well, handle the signal. */
 361 static inline void
 362 handle_signal(int canrestart, struct ksignal *ksig, struct pt_regs *regs)
 363 {
 364         sigset_t *oldset = sigmask_to_save();
 365         int ret;
 366
 367         /* Check if this got called from a system call. */
 368         if (canrestart) {
 369                 /* If so, check system call restarting. */
 370                 switch (regs->r10) {
 371                         case -ERESTART_RESTARTBLOCK:
 372                         case -ERESTARTNOHAND:
 373                                 /*
 374                                  * This means that the syscall should
 375                                  * only be restarted if there was no
 376                                  * handler for the signal, and since
 377                                  * this point isn't reached unless
 378                                  * there is a handler, there's no need
 379                                  * to restart.
 380                                  */
 381                                 regs->r10 = -EINTR;
 382                                 break;
 383
 384                         case -ERESTARTSYS:
 385                                 /*
 386                                  * This means restart the syscall if
 387                                  * there is no handler, or the handler
 388                                  * was registered with SA_RESTART.
 389                                  */
 390                                 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
 391                                         regs->r10 = -EINTR;
 392                                         break;
 393                                 }
 394
 395                                 /* Fall through. */
 396
 397                         case -ERESTARTNOINTR:
 398                                 /*
 399                                  * This means that the syscall should
 400                                  * be called again after the signal
 401                                  * handler returns.
 402                                  */
 403                                 RESTART_CRIS_SYS(regs);
 404                                 break;
 405                 }
 406         }
 407
 408         /* Set up the stack frame. */
 409         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 410                 ret = setup_rt_frame(ksig, oldset, regs);
 411         else
 412                 ret = setup_frame(ksig, oldset, regs);
 413
 414         signal_setup_done(ret, ksig, 0);
 415 }
 416
 417 /*
 418  * Note that 'init' is a special process: it doesn't get signals it doesn't
 419  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 420  * mistake.
 421  *
 422  * Also note that the regs structure given here as an argument, is the latest
 423  * pushed pt_regs. It may or may not be the same as the first pushed registers
 424  * when the initial usermode->kernelmode transition took place. Therefore
 425  * we can use user_mode(regs) to see if we came directly from kernel or user
 426  * mode below.
 427  */
 428 void
 429 do_signal(int canrestart, struct pt_regs *regs)
 430 {
 431         struct ksignal ksig;
 432
 433         canrestart = canrestart && ((int)regs->exs >= 0);
 434
 435         /*
 436          * The common case should go fast, which is why this point is
 437          * reached from kernel-mode. If that's the case, just return
 438          * without doing anything.
 439          */
 440         if (!user_mode(regs))
 441                 return;
 442
 443         if (get_signal(&ksig)) {
 444                 /* Whee!  Actually deliver the signal.  */
 445                 handle_signal(canrestart, &ksig, regs);
 446                 return;
 447         }
 448
 449         /* Got here from a system call? */
 450         if (canrestart) {
 451                 /* Restart the system call - no handlers present. */
 452                 if (regs->r10 == -ERESTARTNOHAND ||
 453                     regs->r10 == -ERESTARTSYS ||
 454                     regs->r10 == -ERESTARTNOINTR) {
 455                         RESTART_CRIS_SYS(regs);
 456                 }
 457
 458                 if (regs->r10 == -ERESTART_RESTARTBLOCK){
 459                         regs->r9 = __NR_restart_syscall;
 460                         regs->erp -= 2;
 461                 }
 462         }
 463
 464         /* if there's no signal to deliver, we just put the saved sigmask
 465          * back */
 466         restore_saved_sigmask();
 467 }
 468
 469 asmlinkage void
 470 ugdb_trap_user(struct thread_info *ti, int sig)
 471 {
 472         if (((user_regs(ti)->exs & 0xff00) >> 8) != SINGLE_STEP_INTR_VECT) {
 473                 /* Zero single-step PC if the reason we stopped wasn't a single
 474                    step exception. This is to avoid relying on it when it isn't
 475                    reliable. */
 476                 user_regs(ti)->spc = 0;
 477         }
 478         /* FIXME: Filter out false h/w breakpoint hits (i.e. EDA
 479            not within any configured h/w breakpoint range). Synchronize with
 480            what already exists for kernel debugging.  */
 481         if (((user_regs(ti)->exs & 0xff00) >> 8) == BREAK_8_INTR_VECT) {
 482                 /* Break 8: subtract 2 from ERP unless in a delay slot. */
 483                 if (!(user_regs(ti)->erp & 0x1))
 484                         user_regs(ti)->erp -= 2;
 485         }
 486         sys_kill(ti->task->pid, sig);
 487 }
 488
 489 void
 490 keep_debug_flags(unsigned long oldccs, unsigned long oldspc,
 491                  struct pt_regs *regs)
 492 {
 493         if (oldccs & (1 << Q_CCS_BITNR)) {
 494                 /* Pending single step due to single-stepping the break 13
 495                    in the signal trampoline: keep the Q flag. */
 496                 regs->ccs |= (1 << Q_CCS_BITNR);
 497                 /* S flag should be set - complain if it's not. */
 498                 if (!(oldccs & (1 << (S_CCS_BITNR + CCS_SHIFT)))) {
 499                         printk("Q flag but no S flag?");
 500                 }
 501                 regs->ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
 502                 /* Assume the SPC is valid and interesting. */
 503                 regs->spc = oldspc;
 504
 505         } else if (oldccs & (1 << (S_CCS_BITNR + CCS_SHIFT))) {
 506                 /* If a h/w bp was set in the signal handler we need
 507                    to keep the S flag. */
 508                 regs->ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
 509                 /* Don't keep the old SPC though; if we got here due to
 510                    a single-step, the Q flag should have been set. */
 511         } else if (regs->spc) {
 512                 /* If we were single-stepping *before* the signal was taken,
 513                    we don't want to restore that state now, because GDB will
 514                    have forgotten all about it. */
 515                 regs->spc = 0;
 516                 regs->ccs &= ~(1 << (S_CCS_BITNR + CCS_SHIFT));
 517         }
 518 }
 519
 520 /* Set up the trampolines on the signal return page. */
 521 int __init
 522 cris_init_signal(void)
 523 {
 524         u16* data = kmalloc(PAGE_SIZE, GFP_KERNEL);
 525
 526         /* This is movu.w __NR_sigreturn, r9; break 13; */
 527         data[0] = 0x9c5f;
 528         data[1] = __NR_sigreturn;
 529         data[2] = 0xe93d;
 530         /* This is movu.w __NR_rt_sigreturn, r9; break 13; */
 531         data[3] = 0x9c5f;
 532         data[4] = __NR_rt_sigreturn;
 533         data[5] = 0xe93d;
 534
 535         /* Map to userspace with appropriate permissions (no write access...) */
 536         cris_signal_return_page = (unsigned long)
 537           __ioremap_prot(virt_to_phys(data), PAGE_SIZE, PAGE_SIGNAL_TRAMPOLINE);
 538
 539         return 0;
 540 }
 541
 542 __initcall(cris_init_signal);