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