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