signal_32.c revision 9e7511861c4f8d35852a3721c5bcd92661cb4c9f
1/* 2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC 3 * 4 * PowerPC version 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * Copyright (C) 2001 IBM 7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 9 * 10 * Derived from "arch/i386/kernel/signal.c" 11 * Copyright (C) 1991, 1992 Linus Torvalds 12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * as published by the Free Software Foundation; either version 17 * 2 of the License, or (at your option) any later version. 18 */ 19 20#include <linux/sched.h> 21#include <linux/mm.h> 22#include <linux/smp.h> 23#include <linux/kernel.h> 24#include <linux/signal.h> 25#include <linux/errno.h> 26#include <linux/elf.h> 27#include <linux/ptrace.h> 28#ifdef CONFIG_PPC64 29#include <linux/syscalls.h> 30#include <linux/compat.h> 31#else 32#include <linux/wait.h> 33#include <linux/unistd.h> 34#include <linux/stddef.h> 35#include <linux/tty.h> 36#include <linux/binfmts.h> 37#include <linux/freezer.h> 38#endif 39 40#include <asm/uaccess.h> 41#include <asm/cacheflush.h> 42#include <asm/syscalls.h> 43#include <asm/sigcontext.h> 44#include <asm/vdso.h> 45#ifdef CONFIG_PPC64 46#include "ppc32.h" 47#include <asm/unistd.h> 48#else 49#include <asm/ucontext.h> 50#include <asm/pgtable.h> 51#endif 52 53#include "signal.h" 54 55#undef DEBUG_SIG 56 57#ifdef CONFIG_PPC64 58#define sys_sigsuspend compat_sys_sigsuspend 59#define sys_rt_sigsuspend compat_sys_rt_sigsuspend 60#define sys_rt_sigreturn compat_sys_rt_sigreturn 61#define sys_sigaction compat_sys_sigaction 62#define sys_swapcontext compat_sys_swapcontext 63#define sys_sigreturn compat_sys_sigreturn 64 65#define old_sigaction old_sigaction32 66#define sigcontext sigcontext32 67#define mcontext mcontext32 68#define ucontext ucontext32 69 70/* 71 * Returning 0 means we return to userspace via 72 * ret_from_except and thus restore all user 73 * registers from *regs. This is what we need 74 * to do when a signal has been delivered. 75 */ 76 77#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32)) 78#undef __SIGNAL_FRAMESIZE 79#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32 80#undef ELF_NVRREG 81#define ELF_NVRREG ELF_NVRREG32 82 83/* 84 * Functions for flipping sigsets (thanks to brain dead generic 85 * implementation that makes things simple for little endian only) 86 */ 87static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set) 88{ 89 compat_sigset_t cset; 90 91 switch (_NSIG_WORDS) { 92 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull; 93 cset.sig[7] = set->sig[3] >> 32; 94 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull; 95 cset.sig[5] = set->sig[2] >> 32; 96 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull; 97 cset.sig[3] = set->sig[1] >> 32; 98 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull; 99 cset.sig[1] = set->sig[0] >> 32; 100 } 101 return copy_to_user(uset, &cset, sizeof(*uset)); 102} 103 104static inline int get_sigset_t(sigset_t *set, 105 const compat_sigset_t __user *uset) 106{ 107 compat_sigset_t s32; 108 109 if (copy_from_user(&s32, uset, sizeof(*uset))) 110 return -EFAULT; 111 112 /* 113 * Swap the 2 words of the 64-bit sigset_t (they are stored 114 * in the "wrong" endian in 32-bit user storage). 115 */ 116 switch (_NSIG_WORDS) { 117 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); 118 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); 119 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); 120 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 121 } 122 return 0; 123} 124 125static inline int get_old_sigaction(struct k_sigaction *new_ka, 126 struct old_sigaction __user *act) 127{ 128 compat_old_sigset_t mask; 129 compat_uptr_t handler, restorer; 130 131 if (get_user(handler, &act->sa_handler) || 132 __get_user(restorer, &act->sa_restorer) || 133 __get_user(new_ka->sa.sa_flags, &act->sa_flags) || 134 __get_user(mask, &act->sa_mask)) 135 return -EFAULT; 136 new_ka->sa.sa_handler = compat_ptr(handler); 137 new_ka->sa.sa_restorer = compat_ptr(restorer); 138 siginitset(&new_ka->sa.sa_mask, mask); 139 return 0; 140} 141 142#define to_user_ptr(p) ptr_to_compat(p) 143#define from_user_ptr(p) compat_ptr(p) 144 145static inline int save_general_regs(struct pt_regs *regs, 146 struct mcontext __user *frame) 147{ 148 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 149 int i; 150 151 WARN_ON(!FULL_REGS(regs)); 152 153 for (i = 0; i <= PT_RESULT; i ++) { 154 if (i == 14 && !FULL_REGS(regs)) 155 i = 32; 156 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i])) 157 return -EFAULT; 158 } 159 return 0; 160} 161 162static inline int restore_general_regs(struct pt_regs *regs, 163 struct mcontext __user *sr) 164{ 165 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 166 int i; 167 168 for (i = 0; i <= PT_RESULT; i++) { 169 if ((i == PT_MSR) || (i == PT_SOFTE)) 170 continue; 171 if (__get_user(gregs[i], &sr->mc_gregs[i])) 172 return -EFAULT; 173 } 174 return 0; 175} 176 177#else /* CONFIG_PPC64 */ 178 179#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs)) 180 181static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set) 182{ 183 return copy_to_user(uset, set, sizeof(*uset)); 184} 185 186static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset) 187{ 188 return copy_from_user(set, uset, sizeof(*uset)); 189} 190 191static inline int get_old_sigaction(struct k_sigaction *new_ka, 192 struct old_sigaction __user *act) 193{ 194 old_sigset_t mask; 195 196 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 197 __get_user(new_ka->sa.sa_handler, &act->sa_handler) || 198 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer)) 199 return -EFAULT; 200 __get_user(new_ka->sa.sa_flags, &act->sa_flags); 201 __get_user(mask, &act->sa_mask); 202 siginitset(&new_ka->sa.sa_mask, mask); 203 return 0; 204} 205 206#define to_user_ptr(p) ((unsigned long)(p)) 207#define from_user_ptr(p) ((void __user *)(p)) 208 209static inline int save_general_regs(struct pt_regs *regs, 210 struct mcontext __user *frame) 211{ 212 WARN_ON(!FULL_REGS(regs)); 213 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE); 214} 215 216static inline int restore_general_regs(struct pt_regs *regs, 217 struct mcontext __user *sr) 218{ 219 /* copy up to but not including MSR */ 220 if (__copy_from_user(regs, &sr->mc_gregs, 221 PT_MSR * sizeof(elf_greg_t))) 222 return -EFAULT; 223 /* copy from orig_r3 (the word after the MSR) up to the end */ 224 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3], 225 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t))) 226 return -EFAULT; 227 return 0; 228} 229 230#endif /* CONFIG_PPC64 */ 231 232/* 233 * Atomically swap in the new signal mask, and wait for a signal. 234 */ 235long sys_sigsuspend(old_sigset_t mask) 236{ 237 mask &= _BLOCKABLE; 238 spin_lock_irq(¤t->sighand->siglock); 239 current->saved_sigmask = current->blocked; 240 siginitset(¤t->blocked, mask); 241 recalc_sigpending(); 242 spin_unlock_irq(¤t->sighand->siglock); 243 244 current->state = TASK_INTERRUPTIBLE; 245 schedule(); 246 set_restore_sigmask(); 247 return -ERESTARTNOHAND; 248} 249 250long sys_sigaction(int sig, struct old_sigaction __user *act, 251 struct old_sigaction __user *oact) 252{ 253 struct k_sigaction new_ka, old_ka; 254 int ret; 255 256#ifdef CONFIG_PPC64 257 if (sig < 0) 258 sig = -sig; 259#endif 260 261 if (act) { 262 if (get_old_sigaction(&new_ka, act)) 263 return -EFAULT; 264 } 265 266 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 267 if (!ret && oact) { 268 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 269 __put_user(to_user_ptr(old_ka.sa.sa_handler), 270 &oact->sa_handler) || 271 __put_user(to_user_ptr(old_ka.sa.sa_restorer), 272 &oact->sa_restorer) || 273 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 274 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 275 return -EFAULT; 276 } 277 278 return ret; 279} 280 281/* 282 * When we have signals to deliver, we set up on the 283 * user stack, going down from the original stack pointer: 284 * an ABI gap of 56 words 285 * an mcontext struct 286 * a sigcontext struct 287 * a gap of __SIGNAL_FRAMESIZE bytes 288 * 289 * Each of these things must be a multiple of 16 bytes in size. The following 290 * structure represent all of this except the __SIGNAL_FRAMESIZE gap 291 * 292 */ 293struct sigframe { 294 struct sigcontext sctx; /* the sigcontext */ 295 struct mcontext mctx; /* all the register values */ 296 /* 297 * Programs using the rs6000/xcoff abi can save up to 19 gp 298 * regs and 18 fp regs below sp before decrementing it. 299 */ 300 int abigap[56]; 301}; 302 303/* We use the mc_pad field for the signal return trampoline. */ 304#define tramp mc_pad 305 306/* 307 * When we have rt signals to deliver, we set up on the 308 * user stack, going down from the original stack pointer: 309 * one rt_sigframe struct (siginfo + ucontext + ABI gap) 310 * a gap of __SIGNAL_FRAMESIZE+16 bytes 311 * (the +16 is to get the siginfo and ucontext in the same 312 * positions as in older kernels). 313 * 314 * Each of these things must be a multiple of 16 bytes in size. 315 * 316 */ 317struct rt_sigframe { 318#ifdef CONFIG_PPC64 319 compat_siginfo_t info; 320#else 321 struct siginfo info; 322#endif 323 struct ucontext uc; 324 /* 325 * Programs using the rs6000/xcoff abi can save up to 19 gp 326 * regs and 18 fp regs below sp before decrementing it. 327 */ 328 int abigap[56]; 329}; 330 331/* 332 * Save the current user registers on the user stack. 333 * We only save the altivec/spe registers if the process has used 334 * altivec/spe instructions at some point. 335 */ 336static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame, 337 int sigret) 338{ 339 unsigned long msr = regs->msr; 340 341 /* Make sure floating point registers are stored in regs */ 342 flush_fp_to_thread(current); 343 344 /* save general and floating-point registers */ 345 if (save_general_regs(regs, frame) || 346 __copy_to_user(&frame->mc_fregs, current->thread.fpr, 347 ELF_NFPREG * sizeof(double))) 348 return 1; 349 350#ifdef CONFIG_ALTIVEC 351 /* save altivec registers */ 352 if (current->thread.used_vr) { 353 flush_altivec_to_thread(current); 354 if (__copy_to_user(&frame->mc_vregs, current->thread.vr, 355 ELF_NVRREG * sizeof(vector128))) 356 return 1; 357 /* set MSR_VEC in the saved MSR value to indicate that 358 frame->mc_vregs contains valid data */ 359 msr |= MSR_VEC; 360 } 361 /* else assert((regs->msr & MSR_VEC) == 0) */ 362 363 /* We always copy to/from vrsave, it's 0 if we don't have or don't 364 * use altivec. Since VSCR only contains 32 bits saved in the least 365 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 366 * most significant bits of that same vector. --BenH 367 */ 368 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32])) 369 return 1; 370#endif /* CONFIG_ALTIVEC */ 371 372#ifdef CONFIG_SPE 373 /* save spe registers */ 374 if (current->thread.used_spe) { 375 flush_spe_to_thread(current); 376 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 377 ELF_NEVRREG * sizeof(u32))) 378 return 1; 379 /* set MSR_SPE in the saved MSR value to indicate that 380 frame->mc_vregs contains valid data */ 381 msr |= MSR_SPE; 382 } 383 /* else assert((regs->msr & MSR_SPE) == 0) */ 384 385 /* We always copy to/from spefscr */ 386 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 387 return 1; 388#endif /* CONFIG_SPE */ 389 390 if (__put_user(msr, &frame->mc_gregs[PT_MSR])) 391 return 1; 392 if (sigret) { 393 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 394 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 395 || __put_user(0x44000002UL, &frame->tramp[1])) 396 return 1; 397 flush_icache_range((unsigned long) &frame->tramp[0], 398 (unsigned long) &frame->tramp[2]); 399 } 400 401 return 0; 402} 403 404/* 405 * Restore the current user register values from the user stack, 406 * (except for MSR). 407 */ 408static long restore_user_regs(struct pt_regs *regs, 409 struct mcontext __user *sr, int sig) 410{ 411 long err; 412 unsigned int save_r2 = 0; 413 unsigned long msr; 414 415 /* 416 * restore general registers but not including MSR or SOFTE. Also 417 * take care of keeping r2 (TLS) intact if not a signal 418 */ 419 if (!sig) 420 save_r2 = (unsigned int)regs->gpr[2]; 421 err = restore_general_regs(regs, sr); 422 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 423 if (!sig) 424 regs->gpr[2] = (unsigned long) save_r2; 425 if (err) 426 return 1; 427 428 /* if doing signal return, restore the previous little-endian mode */ 429 if (sig) 430 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 431 432 /* 433 * Do this before updating the thread state in 434 * current->thread.fpr/vr/evr. That way, if we get preempted 435 * and another task grabs the FPU/Altivec/SPE, it won't be 436 * tempted to save the current CPU state into the thread_struct 437 * and corrupt what we are writing there. 438 */ 439 discard_lazy_cpu_state(); 440 441 /* force the process to reload the FP registers from 442 current->thread when it next does FP instructions */ 443 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 444 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs, 445 sizeof(sr->mc_fregs))) 446 return 1; 447 448#ifdef CONFIG_ALTIVEC 449 /* force the process to reload the altivec registers from 450 current->thread when it next does altivec instructions */ 451 regs->msr &= ~MSR_VEC; 452 if (msr & MSR_VEC) { 453 /* restore altivec registers from the stack */ 454 if (__copy_from_user(current->thread.vr, &sr->mc_vregs, 455 sizeof(sr->mc_vregs))) 456 return 1; 457 } else if (current->thread.used_vr) 458 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128)); 459 460 /* Always get VRSAVE back */ 461 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 462 return 1; 463#endif /* CONFIG_ALTIVEC */ 464 465#ifdef CONFIG_SPE 466 /* force the process to reload the spe registers from 467 current->thread when it next does spe instructions */ 468 regs->msr &= ~MSR_SPE; 469 if (msr & MSR_SPE) { 470 /* restore spe registers from the stack */ 471 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 472 ELF_NEVRREG * sizeof(u32))) 473 return 1; 474 } else if (current->thread.used_spe) 475 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 476 477 /* Always get SPEFSCR back */ 478 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 479 return 1; 480#endif /* CONFIG_SPE */ 481 482 return 0; 483} 484 485#ifdef CONFIG_PPC64 486long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act, 487 struct sigaction32 __user *oact, size_t sigsetsize) 488{ 489 struct k_sigaction new_ka, old_ka; 490 int ret; 491 492 /* XXX: Don't preclude handling different sized sigset_t's. */ 493 if (sigsetsize != sizeof(compat_sigset_t)) 494 return -EINVAL; 495 496 if (act) { 497 compat_uptr_t handler; 498 499 ret = get_user(handler, &act->sa_handler); 500 new_ka.sa.sa_handler = compat_ptr(handler); 501 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask); 502 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 503 if (ret) 504 return -EFAULT; 505 } 506 507 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 508 if (!ret && oact) { 509 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler); 510 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask); 511 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 512 } 513 return ret; 514} 515 516/* 517 * Note: it is necessary to treat how as an unsigned int, with the 518 * corresponding cast to a signed int to insure that the proper 519 * conversion (sign extension) between the register representation 520 * of a signed int (msr in 32-bit mode) and the register representation 521 * of a signed int (msr in 64-bit mode) is performed. 522 */ 523long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set, 524 compat_sigset_t __user *oset, size_t sigsetsize) 525{ 526 sigset_t s; 527 sigset_t __user *up; 528 int ret; 529 mm_segment_t old_fs = get_fs(); 530 531 if (set) { 532 if (get_sigset_t(&s, set)) 533 return -EFAULT; 534 } 535 536 set_fs(KERNEL_DS); 537 /* This is valid because of the set_fs() */ 538 up = (sigset_t __user *) &s; 539 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL, 540 sigsetsize); 541 set_fs(old_fs); 542 if (ret) 543 return ret; 544 if (oset) { 545 if (put_sigset_t(oset, &s)) 546 return -EFAULT; 547 } 548 return 0; 549} 550 551long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize) 552{ 553 sigset_t s; 554 int ret; 555 mm_segment_t old_fs = get_fs(); 556 557 set_fs(KERNEL_DS); 558 /* The __user pointer cast is valid because of the set_fs() */ 559 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize); 560 set_fs(old_fs); 561 if (!ret) { 562 if (put_sigset_t(set, &s)) 563 return -EFAULT; 564 } 565 return ret; 566} 567 568 569int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s) 570{ 571 int err; 572 573 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 574 return -EFAULT; 575 576 /* If you change siginfo_t structure, please be sure 577 * this code is fixed accordingly. 578 * It should never copy any pad contained in the structure 579 * to avoid security leaks, but must copy the generic 580 * 3 ints plus the relevant union member. 581 * This routine must convert siginfo from 64bit to 32bit as well 582 * at the same time. 583 */ 584 err = __put_user(s->si_signo, &d->si_signo); 585 err |= __put_user(s->si_errno, &d->si_errno); 586 err |= __put_user((short)s->si_code, &d->si_code); 587 if (s->si_code < 0) 588 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 589 SI_PAD_SIZE32); 590 else switch(s->si_code >> 16) { 591 case __SI_CHLD >> 16: 592 err |= __put_user(s->si_pid, &d->si_pid); 593 err |= __put_user(s->si_uid, &d->si_uid); 594 err |= __put_user(s->si_utime, &d->si_utime); 595 err |= __put_user(s->si_stime, &d->si_stime); 596 err |= __put_user(s->si_status, &d->si_status); 597 break; 598 case __SI_FAULT >> 16: 599 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 600 &d->si_addr); 601 break; 602 case __SI_POLL >> 16: 603 err |= __put_user(s->si_band, &d->si_band); 604 err |= __put_user(s->si_fd, &d->si_fd); 605 break; 606 case __SI_TIMER >> 16: 607 err |= __put_user(s->si_tid, &d->si_tid); 608 err |= __put_user(s->si_overrun, &d->si_overrun); 609 err |= __put_user(s->si_int, &d->si_int); 610 break; 611 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 612 case __SI_MESGQ >> 16: 613 err |= __put_user(s->si_int, &d->si_int); 614 /* fallthrough */ 615 case __SI_KILL >> 16: 616 default: 617 err |= __put_user(s->si_pid, &d->si_pid); 618 err |= __put_user(s->si_uid, &d->si_uid); 619 break; 620 } 621 return err; 622} 623 624#define copy_siginfo_to_user copy_siginfo_to_user32 625 626int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from) 627{ 628 memset(to, 0, sizeof *to); 629 630 if (copy_from_user(to, from, 3*sizeof(int)) || 631 copy_from_user(to->_sifields._pad, 632 from->_sifields._pad, SI_PAD_SIZE32)) 633 return -EFAULT; 634 635 return 0; 636} 637 638/* 639 * Note: it is necessary to treat pid and sig as unsigned ints, with the 640 * corresponding cast to a signed int to insure that the proper conversion 641 * (sign extension) between the register representation of a signed int 642 * (msr in 32-bit mode) and the register representation of a signed int 643 * (msr in 64-bit mode) is performed. 644 */ 645long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo) 646{ 647 siginfo_t info; 648 int ret; 649 mm_segment_t old_fs = get_fs(); 650 651 ret = copy_siginfo_from_user32(&info, uinfo); 652 if (unlikely(ret)) 653 return ret; 654 655 set_fs (KERNEL_DS); 656 /* The __user pointer cast is valid becasuse of the set_fs() */ 657 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info); 658 set_fs (old_fs); 659 return ret; 660} 661/* 662 * Start Alternate signal stack support 663 * 664 * System Calls 665 * sigaltatck compat_sys_sigaltstack 666 */ 667 668int compat_sys_sigaltstack(u32 __new, u32 __old, int r5, 669 int r6, int r7, int r8, struct pt_regs *regs) 670{ 671 stack_32_t __user * newstack = compat_ptr(__new); 672 stack_32_t __user * oldstack = compat_ptr(__old); 673 stack_t uss, uoss; 674 int ret; 675 mm_segment_t old_fs; 676 unsigned long sp; 677 compat_uptr_t ss_sp; 678 679 /* 680 * set sp to the user stack on entry to the system call 681 * the system call router sets R9 to the saved registers 682 */ 683 sp = regs->gpr[1]; 684 685 /* Put new stack info in local 64 bit stack struct */ 686 if (newstack) { 687 if (get_user(ss_sp, &newstack->ss_sp) || 688 __get_user(uss.ss_flags, &newstack->ss_flags) || 689 __get_user(uss.ss_size, &newstack->ss_size)) 690 return -EFAULT; 691 uss.ss_sp = compat_ptr(ss_sp); 692 } 693 694 old_fs = get_fs(); 695 set_fs(KERNEL_DS); 696 /* The __user pointer casts are valid because of the set_fs() */ 697 ret = do_sigaltstack( 698 newstack ? (stack_t __user *) &uss : NULL, 699 oldstack ? (stack_t __user *) &uoss : NULL, 700 sp); 701 set_fs(old_fs); 702 /* Copy the stack information to the user output buffer */ 703 if (!ret && oldstack && 704 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) || 705 __put_user(uoss.ss_flags, &oldstack->ss_flags) || 706 __put_user(uoss.ss_size, &oldstack->ss_size))) 707 return -EFAULT; 708 return ret; 709} 710#endif /* CONFIG_PPC64 */ 711 712/* 713 * Set up a signal frame for a "real-time" signal handler 714 * (one which gets siginfo). 715 */ 716int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka, 717 siginfo_t *info, sigset_t *oldset, 718 struct pt_regs *regs) 719{ 720 struct rt_sigframe __user *rt_sf; 721 struct mcontext __user *frame; 722 void __user *addr; 723 unsigned long newsp = 0; 724 725 /* Set up Signal Frame */ 726 /* Put a Real Time Context onto stack */ 727 rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf)); 728 addr = rt_sf; 729 if (unlikely(rt_sf == NULL)) 730 goto badframe; 731 732 /* Put the siginfo & fill in most of the ucontext */ 733 if (copy_siginfo_to_user(&rt_sf->info, info) 734 || __put_user(0, &rt_sf->uc.uc_flags) 735 || __put_user(0, &rt_sf->uc.uc_link) 736 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp) 737 || __put_user(sas_ss_flags(regs->gpr[1]), 738 &rt_sf->uc.uc_stack.ss_flags) 739 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size) 740 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 741 &rt_sf->uc.uc_regs) 742 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 743 goto badframe; 744 745 /* Save user registers on the stack */ 746 frame = &rt_sf->uc.uc_mcontext; 747 addr = frame; 748 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) { 749 if (save_user_regs(regs, frame, 0)) 750 goto badframe; 751 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp; 752 } else { 753 if (save_user_regs(regs, frame, __NR_rt_sigreturn)) 754 goto badframe; 755 regs->link = (unsigned long) frame->tramp; 756 } 757 758 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 759 760 /* create a stack frame for the caller of the handler */ 761 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16); 762 addr = (void __user *)regs->gpr[1]; 763 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 764 goto badframe; 765 766 /* Fill registers for signal handler */ 767 regs->gpr[1] = newsp; 768 regs->gpr[3] = sig; 769 regs->gpr[4] = (unsigned long) &rt_sf->info; 770 regs->gpr[5] = (unsigned long) &rt_sf->uc; 771 regs->gpr[6] = (unsigned long) rt_sf; 772 regs->nip = (unsigned long) ka->sa.sa_handler; 773 /* enter the signal handler in big-endian mode */ 774 regs->msr &= ~MSR_LE; 775 regs->trap = 0; 776 return 1; 777 778badframe: 779#ifdef DEBUG_SIG 780 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 781 regs, frame, newsp); 782#endif 783 if (show_unhandled_signals && printk_ratelimit()) 784 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: " 785 "%p nip %08lx lr %08lx\n", 786 current->comm, current->pid, 787 addr, regs->nip, regs->link); 788 789 force_sigsegv(sig, current); 790 return 0; 791} 792 793static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 794{ 795 sigset_t set; 796 struct mcontext __user *mcp; 797 798 if (get_sigset_t(&set, &ucp->uc_sigmask)) 799 return -EFAULT; 800#ifdef CONFIG_PPC64 801 { 802 u32 cmcp; 803 804 if (__get_user(cmcp, &ucp->uc_regs)) 805 return -EFAULT; 806 mcp = (struct mcontext __user *)(u64)cmcp; 807 /* no need to check access_ok(mcp), since mcp < 4GB */ 808 } 809#else 810 if (__get_user(mcp, &ucp->uc_regs)) 811 return -EFAULT; 812 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 813 return -EFAULT; 814#endif 815 restore_sigmask(&set); 816 if (restore_user_regs(regs, mcp, sig)) 817 return -EFAULT; 818 819 return 0; 820} 821 822long sys_swapcontext(struct ucontext __user *old_ctx, 823 struct ucontext __user *new_ctx, 824 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 825{ 826 unsigned char tmp; 827 828 /* Context size is for future use. Right now, we only make sure 829 * we are passed something we understand 830 */ 831 if (ctx_size < sizeof(struct ucontext)) 832 return -EINVAL; 833 834 if (old_ctx != NULL) { 835 struct mcontext __user *mctx; 836 837 /* 838 * old_ctx might not be 16-byte aligned, in which 839 * case old_ctx->uc_mcontext won't be either. 840 * Because we have the old_ctx->uc_pad2 field 841 * before old_ctx->uc_mcontext, we need to round down 842 * from &old_ctx->uc_mcontext to a 16-byte boundary. 843 */ 844 mctx = (struct mcontext __user *) 845 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 846 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx)) 847 || save_user_regs(regs, mctx, 0) 848 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 849 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 850 return -EFAULT; 851 } 852 if (new_ctx == NULL) 853 return 0; 854 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx)) 855 || __get_user(tmp, (u8 __user *) new_ctx) 856 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1)) 857 return -EFAULT; 858 859 /* 860 * If we get a fault copying the context into the kernel's 861 * image of the user's registers, we can't just return -EFAULT 862 * because the user's registers will be corrupted. For instance 863 * the NIP value may have been updated but not some of the 864 * other registers. Given that we have done the access_ok 865 * and successfully read the first and last bytes of the region 866 * above, this should only happen in an out-of-memory situation 867 * or if another thread unmaps the region containing the context. 868 * We kill the task with a SIGSEGV in this situation. 869 */ 870 if (do_setcontext(new_ctx, regs, 0)) 871 do_exit(SIGSEGV); 872 873 set_thread_flag(TIF_RESTOREALL); 874 return 0; 875} 876 877long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 878 struct pt_regs *regs) 879{ 880 struct rt_sigframe __user *rt_sf; 881 882 /* Always make any pending restarted system calls return -EINTR */ 883 current_thread_info()->restart_block.fn = do_no_restart_syscall; 884 885 rt_sf = (struct rt_sigframe __user *) 886 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 887 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 888 goto bad; 889 if (do_setcontext(&rt_sf->uc, regs, 1)) 890 goto bad; 891 892 /* 893 * It's not clear whether or why it is desirable to save the 894 * sigaltstack setting on signal delivery and restore it on 895 * signal return. But other architectures do this and we have 896 * always done it up until now so it is probably better not to 897 * change it. -- paulus 898 */ 899#ifdef CONFIG_PPC64 900 /* 901 * We use the compat_sys_ version that does the 32/64 bits conversion 902 * and takes userland pointer directly. What about error checking ? 903 * nobody does any... 904 */ 905 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs); 906#else 907 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]); 908#endif 909 set_thread_flag(TIF_RESTOREALL); 910 return 0; 911 912 bad: 913 if (show_unhandled_signals && printk_ratelimit()) 914 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: " 915 "%p nip %08lx lr %08lx\n", 916 current->comm, current->pid, 917 rt_sf, regs->nip, regs->link); 918 919 force_sig(SIGSEGV, current); 920 return 0; 921} 922 923#ifdef CONFIG_PPC32 924int sys_debug_setcontext(struct ucontext __user *ctx, 925 int ndbg, struct sig_dbg_op __user *dbg, 926 int r6, int r7, int r8, 927 struct pt_regs *regs) 928{ 929 struct sig_dbg_op op; 930 int i; 931 unsigned char tmp; 932 unsigned long new_msr = regs->msr; 933#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 934 unsigned long new_dbcr0 = current->thread.dbcr0; 935#endif 936 937 for (i=0; i<ndbg; i++) { 938 if (copy_from_user(&op, dbg + i, sizeof(op))) 939 return -EFAULT; 940 switch (op.dbg_type) { 941 case SIG_DBG_SINGLE_STEPPING: 942#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 943 if (op.dbg_value) { 944 new_msr |= MSR_DE; 945 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 946 } else { 947 new_msr &= ~MSR_DE; 948 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 949 } 950#else 951 if (op.dbg_value) 952 new_msr |= MSR_SE; 953 else 954 new_msr &= ~MSR_SE; 955#endif 956 break; 957 case SIG_DBG_BRANCH_TRACING: 958#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 959 return -EINVAL; 960#else 961 if (op.dbg_value) 962 new_msr |= MSR_BE; 963 else 964 new_msr &= ~MSR_BE; 965#endif 966 break; 967 968 default: 969 return -EINVAL; 970 } 971 } 972 973 /* We wait until here to actually install the values in the 974 registers so if we fail in the above loop, it will not 975 affect the contents of these registers. After this point, 976 failure is a problem, anyway, and it's very unlikely unless 977 the user is really doing something wrong. */ 978 regs->msr = new_msr; 979#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 980 current->thread.dbcr0 = new_dbcr0; 981#endif 982 983 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 984 || __get_user(tmp, (u8 __user *) ctx) 985 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 986 return -EFAULT; 987 988 /* 989 * If we get a fault copying the context into the kernel's 990 * image of the user's registers, we can't just return -EFAULT 991 * because the user's registers will be corrupted. For instance 992 * the NIP value may have been updated but not some of the 993 * other registers. Given that we have done the access_ok 994 * and successfully read the first and last bytes of the region 995 * above, this should only happen in an out-of-memory situation 996 * or if another thread unmaps the region containing the context. 997 * We kill the task with a SIGSEGV in this situation. 998 */ 999 if (do_setcontext(ctx, regs, 1)) { 1000 if (show_unhandled_signals && printk_ratelimit()) 1001 printk(KERN_INFO "%s[%d]: bad frame in " 1002 "sys_debug_setcontext: %p nip %08lx " 1003 "lr %08lx\n", 1004 current->comm, current->pid, 1005 ctx, regs->nip, regs->link); 1006 1007 force_sig(SIGSEGV, current); 1008 goto out; 1009 } 1010 1011 /* 1012 * It's not clear whether or why it is desirable to save the 1013 * sigaltstack setting on signal delivery and restore it on 1014 * signal return. But other architectures do this and we have 1015 * always done it up until now so it is probably better not to 1016 * change it. -- paulus 1017 */ 1018 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]); 1019 1020 set_thread_flag(TIF_RESTOREALL); 1021 out: 1022 return 0; 1023} 1024#endif 1025 1026/* 1027 * OK, we're invoking a handler 1028 */ 1029int handle_signal32(unsigned long sig, struct k_sigaction *ka, 1030 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 1031{ 1032 struct sigcontext __user *sc; 1033 struct sigframe __user *frame; 1034 unsigned long newsp = 0; 1035 1036 /* Set up Signal Frame */ 1037 frame = get_sigframe(ka, regs, sizeof(*frame)); 1038 if (unlikely(frame == NULL)) 1039 goto badframe; 1040 sc = (struct sigcontext __user *) &frame->sctx; 1041 1042#if _NSIG != 64 1043#error "Please adjust handle_signal()" 1044#endif 1045 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1046 || __put_user(oldset->sig[0], &sc->oldmask) 1047#ifdef CONFIG_PPC64 1048 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1049#else 1050 || __put_user(oldset->sig[1], &sc->_unused[3]) 1051#endif 1052 || __put_user(to_user_ptr(&frame->mctx), &sc->regs) 1053 || __put_user(sig, &sc->signal)) 1054 goto badframe; 1055 1056 if (vdso32_sigtramp && current->mm->context.vdso_base) { 1057 if (save_user_regs(regs, &frame->mctx, 0)) 1058 goto badframe; 1059 regs->link = current->mm->context.vdso_base + vdso32_sigtramp; 1060 } else { 1061 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn)) 1062 goto badframe; 1063 regs->link = (unsigned long) frame->mctx.tramp; 1064 } 1065 1066 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 1067 1068 /* create a stack frame for the caller of the handler */ 1069 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE; 1070 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1071 goto badframe; 1072 1073 regs->gpr[1] = newsp; 1074 regs->gpr[3] = sig; 1075 regs->gpr[4] = (unsigned long) sc; 1076 regs->nip = (unsigned long) ka->sa.sa_handler; 1077 /* enter the signal handler in big-endian mode */ 1078 regs->msr &= ~MSR_LE; 1079 regs->trap = 0; 1080 1081 return 1; 1082 1083badframe: 1084#ifdef DEBUG_SIG 1085 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1086 regs, frame, newsp); 1087#endif 1088 if (show_unhandled_signals && printk_ratelimit()) 1089 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: " 1090 "%p nip %08lx lr %08lx\n", 1091 current->comm, current->pid, 1092 frame, regs->nip, regs->link); 1093 1094 force_sigsegv(sig, current); 1095 return 0; 1096} 1097 1098/* 1099 * Do a signal return; undo the signal stack. 1100 */ 1101long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1102 struct pt_regs *regs) 1103{ 1104 struct sigcontext __user *sc; 1105 struct sigcontext sigctx; 1106 struct mcontext __user *sr; 1107 void __user *addr; 1108 sigset_t set; 1109 1110 /* Always make any pending restarted system calls return -EINTR */ 1111 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1112 1113 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1114 addr = sc; 1115 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1116 goto badframe; 1117 1118#ifdef CONFIG_PPC64 1119 /* 1120 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1121 * unused part of the signal stackframe 1122 */ 1123 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1124#else 1125 set.sig[0] = sigctx.oldmask; 1126 set.sig[1] = sigctx._unused[3]; 1127#endif 1128 restore_sigmask(&set); 1129 1130 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1131 addr = sr; 1132 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1133 || restore_user_regs(regs, sr, 1)) 1134 goto badframe; 1135 1136 set_thread_flag(TIF_RESTOREALL); 1137 return 0; 1138 1139badframe: 1140 if (show_unhandled_signals && printk_ratelimit()) 1141 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: " 1142 "%p nip %08lx lr %08lx\n", 1143 current->comm, current->pid, 1144 addr, regs->nip, regs->link); 1145 1146 force_sig(SIGSEGV, current); 1147 return 0; 1148} 1149