signal_32.c revision a7f31841a40776605c834053ad1eb82d539bd79f
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#if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE) 423 unsigned long msr; 424#endif 425 426 /* 427 * restore general registers but not including MSR or SOFTE. Also 428 * take care of keeping r2 (TLS) intact if not a signal 429 */ 430 if (!sig) 431 save_r2 = (unsigned int)regs->gpr[2]; 432 err = restore_general_regs(regs, sr); 433 if (!sig) 434 regs->gpr[2] = (unsigned long) save_r2; 435 if (err) 436 return 1; 437 438 /* 439 * Do this before updating the thread state in 440 * current->thread.fpr/vr/evr. That way, if we get preempted 441 * and another task grabs the FPU/Altivec/SPE, it won't be 442 * tempted to save the current CPU state into the thread_struct 443 * and corrupt what we are writing there. 444 */ 445 discard_lazy_cpu_state(); 446 447 /* force the process to reload the FP registers from 448 current->thread when it next does FP instructions */ 449 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 450 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs, 451 sizeof(sr->mc_fregs))) 452 return 1; 453 454#ifdef CONFIG_ALTIVEC 455 /* force the process to reload the altivec registers from 456 current->thread when it next does altivec instructions */ 457 regs->msr &= ~MSR_VEC; 458 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) { 459 /* restore altivec registers from the stack */ 460 if (__copy_from_user(current->thread.vr, &sr->mc_vregs, 461 sizeof(sr->mc_vregs))) 462 return 1; 463 } else if (current->thread.used_vr) 464 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128)); 465 466 /* Always get VRSAVE back */ 467 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 468 return 1; 469#endif /* CONFIG_ALTIVEC */ 470 471#ifdef CONFIG_SPE 472 /* force the process to reload the spe registers from 473 current->thread when it next does spe instructions */ 474 regs->msr &= ~MSR_SPE; 475 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) { 476 /* restore spe registers from the stack */ 477 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 478 ELF_NEVRREG * sizeof(u32))) 479 return 1; 480 } else if (current->thread.used_spe) 481 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 482 483 /* Always get SPEFSCR back */ 484 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 485 return 1; 486#endif /* CONFIG_SPE */ 487 488 return 0; 489} 490 491#ifdef CONFIG_PPC64 492long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act, 493 struct sigaction32 __user *oact, size_t sigsetsize) 494{ 495 struct k_sigaction new_ka, old_ka; 496 int ret; 497 498 /* XXX: Don't preclude handling different sized sigset_t's. */ 499 if (sigsetsize != sizeof(compat_sigset_t)) 500 return -EINVAL; 501 502 if (act) { 503 compat_uptr_t handler; 504 505 ret = get_user(handler, &act->sa_handler); 506 new_ka.sa.sa_handler = compat_ptr(handler); 507 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask); 508 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 509 if (ret) 510 return -EFAULT; 511 } 512 513 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 514 if (!ret && oact) { 515 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler); 516 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask); 517 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 518 } 519 return ret; 520} 521 522/* 523 * Note: it is necessary to treat how as an unsigned int, with the 524 * corresponding cast to a signed int to insure that the proper 525 * conversion (sign extension) between the register representation 526 * of a signed int (msr in 32-bit mode) and the register representation 527 * of a signed int (msr in 64-bit mode) is performed. 528 */ 529long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set, 530 compat_sigset_t __user *oset, size_t sigsetsize) 531{ 532 sigset_t s; 533 sigset_t __user *up; 534 int ret; 535 mm_segment_t old_fs = get_fs(); 536 537 if (set) { 538 if (get_sigset_t(&s, set)) 539 return -EFAULT; 540 } 541 542 set_fs(KERNEL_DS); 543 /* This is valid because of the set_fs() */ 544 up = (sigset_t __user *) &s; 545 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL, 546 sigsetsize); 547 set_fs(old_fs); 548 if (ret) 549 return ret; 550 if (oset) { 551 if (put_sigset_t(oset, &s)) 552 return -EFAULT; 553 } 554 return 0; 555} 556 557long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize) 558{ 559 sigset_t s; 560 int ret; 561 mm_segment_t old_fs = get_fs(); 562 563 set_fs(KERNEL_DS); 564 /* The __user pointer cast is valid because of the set_fs() */ 565 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize); 566 set_fs(old_fs); 567 if (!ret) { 568 if (put_sigset_t(set, &s)) 569 return -EFAULT; 570 } 571 return ret; 572} 573 574 575int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s) 576{ 577 int err; 578 579 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 580 return -EFAULT; 581 582 /* If you change siginfo_t structure, please be sure 583 * this code is fixed accordingly. 584 * It should never copy any pad contained in the structure 585 * to avoid security leaks, but must copy the generic 586 * 3 ints plus the relevant union member. 587 * This routine must convert siginfo from 64bit to 32bit as well 588 * at the same time. 589 */ 590 err = __put_user(s->si_signo, &d->si_signo); 591 err |= __put_user(s->si_errno, &d->si_errno); 592 err |= __put_user((short)s->si_code, &d->si_code); 593 if (s->si_code < 0) 594 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 595 SI_PAD_SIZE32); 596 else switch(s->si_code >> 16) { 597 case __SI_CHLD >> 16: 598 err |= __put_user(s->si_pid, &d->si_pid); 599 err |= __put_user(s->si_uid, &d->si_uid); 600 err |= __put_user(s->si_utime, &d->si_utime); 601 err |= __put_user(s->si_stime, &d->si_stime); 602 err |= __put_user(s->si_status, &d->si_status); 603 break; 604 case __SI_FAULT >> 16: 605 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 606 &d->si_addr); 607 break; 608 case __SI_POLL >> 16: 609 err |= __put_user(s->si_band, &d->si_band); 610 err |= __put_user(s->si_fd, &d->si_fd); 611 break; 612 case __SI_TIMER >> 16: 613 err |= __put_user(s->si_tid, &d->si_tid); 614 err |= __put_user(s->si_overrun, &d->si_overrun); 615 err |= __put_user(s->si_int, &d->si_int); 616 break; 617 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 618 case __SI_MESGQ >> 16: 619 err |= __put_user(s->si_int, &d->si_int); 620 /* fallthrough */ 621 case __SI_KILL >> 16: 622 default: 623 err |= __put_user(s->si_pid, &d->si_pid); 624 err |= __put_user(s->si_uid, &d->si_uid); 625 break; 626 } 627 return err; 628} 629 630#define copy_siginfo_to_user copy_siginfo_to_user32 631 632/* 633 * Note: it is necessary to treat pid and sig as unsigned ints, with the 634 * corresponding cast to a signed int to insure that the proper conversion 635 * (sign extension) between the register representation of a signed int 636 * (msr in 32-bit mode) and the register representation of a signed int 637 * (msr in 64-bit mode) is performed. 638 */ 639long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo) 640{ 641 siginfo_t info; 642 int ret; 643 mm_segment_t old_fs = get_fs(); 644 645 if (copy_from_user (&info, uinfo, 3*sizeof(int)) || 646 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32)) 647 return -EFAULT; 648 set_fs (KERNEL_DS); 649 /* The __user pointer cast is valid becasuse of the set_fs() */ 650 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info); 651 set_fs (old_fs); 652 return ret; 653} 654/* 655 * Start Alternate signal stack support 656 * 657 * System Calls 658 * sigaltatck compat_sys_sigaltstack 659 */ 660 661int compat_sys_sigaltstack(u32 __new, u32 __old, int r5, 662 int r6, int r7, int r8, struct pt_regs *regs) 663{ 664 stack_32_t __user * newstack = compat_ptr(__new); 665 stack_32_t __user * oldstack = compat_ptr(__old); 666 stack_t uss, uoss; 667 int ret; 668 mm_segment_t old_fs; 669 unsigned long sp; 670 compat_uptr_t ss_sp; 671 672 /* 673 * set sp to the user stack on entry to the system call 674 * the system call router sets R9 to the saved registers 675 */ 676 sp = regs->gpr[1]; 677 678 /* Put new stack info in local 64 bit stack struct */ 679 if (newstack) { 680 if (get_user(ss_sp, &newstack->ss_sp) || 681 __get_user(uss.ss_flags, &newstack->ss_flags) || 682 __get_user(uss.ss_size, &newstack->ss_size)) 683 return -EFAULT; 684 uss.ss_sp = compat_ptr(ss_sp); 685 } 686 687 old_fs = get_fs(); 688 set_fs(KERNEL_DS); 689 /* The __user pointer casts are valid because of the set_fs() */ 690 ret = do_sigaltstack( 691 newstack ? (stack_t __user *) &uss : NULL, 692 oldstack ? (stack_t __user *) &uoss : NULL, 693 sp); 694 set_fs(old_fs); 695 /* Copy the stack information to the user output buffer */ 696 if (!ret && oldstack && 697 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) || 698 __put_user(uoss.ss_flags, &oldstack->ss_flags) || 699 __put_user(uoss.ss_size, &oldstack->ss_size))) 700 return -EFAULT; 701 return ret; 702} 703#endif /* CONFIG_PPC64 */ 704 705 706/* 707 * Restore the user process's signal mask 708 */ 709#ifdef CONFIG_PPC64 710extern void restore_sigmask(sigset_t *set); 711#else /* CONFIG_PPC64 */ 712static void restore_sigmask(sigset_t *set) 713{ 714 sigdelsetmask(set, ~_BLOCKABLE); 715 spin_lock_irq(¤t->sighand->siglock); 716 current->blocked = *set; 717 recalc_sigpending(); 718 spin_unlock_irq(¤t->sighand->siglock); 719} 720#endif 721 722/* 723 * Set up a signal frame for a "real-time" signal handler 724 * (one which gets siginfo). 725 */ 726static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka, 727 siginfo_t *info, sigset_t *oldset, 728 struct pt_regs *regs, unsigned long newsp) 729{ 730 struct rt_sigframe __user *rt_sf; 731 struct mcontext __user *frame; 732 unsigned long origsp = newsp; 733 734 /* Set up Signal Frame */ 735 /* Put a Real Time Context onto stack */ 736 newsp -= sizeof(*rt_sf); 737 rt_sf = (struct rt_sigframe __user *)newsp; 738 739 /* create a stack frame for the caller of the handler */ 740 newsp -= __SIGNAL_FRAMESIZE + 16; 741 742 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp)) 743 goto badframe; 744 745 /* Put the siginfo & fill in most of the ucontext */ 746 if (copy_siginfo_to_user(&rt_sf->info, info) 747 || __put_user(0, &rt_sf->uc.uc_flags) 748 || __put_user(0, &rt_sf->uc.uc_link) 749 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp) 750 || __put_user(sas_ss_flags(regs->gpr[1]), 751 &rt_sf->uc.uc_stack.ss_flags) 752 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size) 753 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 754 &rt_sf->uc.uc_regs) 755 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 756 goto badframe; 757 758 /* Save user registers on the stack */ 759 frame = &rt_sf->uc.uc_mcontext; 760 if (vdso32_rt_sigtramp && current->thread.vdso_base) { 761 if (save_user_regs(regs, frame, 0)) 762 goto badframe; 763 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp; 764 } else { 765 if (save_user_regs(regs, frame, __NR_rt_sigreturn)) 766 goto badframe; 767 regs->link = (unsigned long) frame->tramp; 768 } 769 770 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 771 772 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 773 goto badframe; 774 regs->gpr[1] = newsp; 775 regs->gpr[3] = sig; 776 regs->gpr[4] = (unsigned long) &rt_sf->info; 777 regs->gpr[5] = (unsigned long) &rt_sf->uc; 778 regs->gpr[6] = (unsigned long) rt_sf; 779 regs->nip = (unsigned long) ka->sa.sa_handler; 780 regs->trap = 0; 781 return 1; 782 783badframe: 784#ifdef DEBUG_SIG 785 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 786 regs, frame, newsp); 787#endif 788 force_sigsegv(sig, current); 789 return 0; 790} 791 792static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 793{ 794 sigset_t set; 795 struct mcontext __user *mcp; 796 797 if (get_sigset_t(&set, &ucp->uc_sigmask)) 798 return -EFAULT; 799#ifdef CONFIG_PPC64 800 { 801 u32 cmcp; 802 803 if (__get_user(cmcp, &ucp->uc_regs)) 804 return -EFAULT; 805 mcp = (struct mcontext __user *)(u64)cmcp; 806 } 807#else 808 if (__get_user(mcp, &ucp->uc_regs)) 809 return -EFAULT; 810#endif 811 restore_sigmask(&set); 812 if (restore_user_regs(regs, mcp, sig)) 813 return -EFAULT; 814 815 return 0; 816} 817 818long sys_swapcontext(struct ucontext __user *old_ctx, 819 struct ucontext __user *new_ctx, 820 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 821{ 822 unsigned char tmp; 823 824 /* Context size is for future use. Right now, we only make sure 825 * we are passed something we understand 826 */ 827 if (ctx_size < sizeof(struct ucontext)) 828 return -EINVAL; 829 830 if (old_ctx != NULL) { 831 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx)) 832 || save_user_regs(regs, &old_ctx->uc_mcontext, 0) 833 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 834 || __put_user(to_user_ptr(&old_ctx->uc_mcontext), 835 &old_ctx->uc_regs)) 836 return -EFAULT; 837 } 838 if (new_ctx == NULL) 839 return 0; 840 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx)) 841 || __get_user(tmp, (u8 __user *) new_ctx) 842 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1)) 843 return -EFAULT; 844 845 /* 846 * If we get a fault copying the context into the kernel's 847 * image of the user's registers, we can't just return -EFAULT 848 * because the user's registers will be corrupted. For instance 849 * the NIP value may have been updated but not some of the 850 * other registers. Given that we have done the access_ok 851 * and successfully read the first and last bytes of the region 852 * above, this should only happen in an out-of-memory situation 853 * or if another thread unmaps the region containing the context. 854 * We kill the task with a SIGSEGV in this situation. 855 */ 856 if (do_setcontext(new_ctx, regs, 0)) 857 do_exit(SIGSEGV); 858 859 set_thread_flag(TIF_RESTOREALL); 860 return 0; 861} 862 863long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 864 struct pt_regs *regs) 865{ 866 struct rt_sigframe __user *rt_sf; 867 868 /* Always make any pending restarted system calls return -EINTR */ 869 current_thread_info()->restart_block.fn = do_no_restart_syscall; 870 871 rt_sf = (struct rt_sigframe __user *) 872 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 873 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 874 goto bad; 875 if (do_setcontext(&rt_sf->uc, regs, 1)) 876 goto bad; 877 878 /* 879 * It's not clear whether or why it is desirable to save the 880 * sigaltstack setting on signal delivery and restore it on 881 * signal return. But other architectures do this and we have 882 * always done it up until now so it is probably better not to 883 * change it. -- paulus 884 */ 885#ifdef CONFIG_PPC64 886 /* 887 * We use the compat_sys_ version that does the 32/64 bits conversion 888 * and takes userland pointer directly. What about error checking ? 889 * nobody does any... 890 */ 891 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs); 892#else 893 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]); 894#endif 895 set_thread_flag(TIF_RESTOREALL); 896 return 0; 897 898 bad: 899 force_sig(SIGSEGV, current); 900 return 0; 901} 902 903#ifdef CONFIG_PPC32 904int sys_debug_setcontext(struct ucontext __user *ctx, 905 int ndbg, struct sig_dbg_op __user *dbg, 906 int r6, int r7, int r8, 907 struct pt_regs *regs) 908{ 909 struct sig_dbg_op op; 910 int i; 911 unsigned long new_msr = regs->msr; 912#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 913 unsigned long new_dbcr0 = current->thread.dbcr0; 914#endif 915 916 for (i=0; i<ndbg; i++) { 917 if (__copy_from_user(&op, dbg, sizeof(op))) 918 return -EFAULT; 919 switch (op.dbg_type) { 920 case SIG_DBG_SINGLE_STEPPING: 921#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 922 if (op.dbg_value) { 923 new_msr |= MSR_DE; 924 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 925 } else { 926 new_msr &= ~MSR_DE; 927 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 928 } 929#else 930 if (op.dbg_value) 931 new_msr |= MSR_SE; 932 else 933 new_msr &= ~MSR_SE; 934#endif 935 break; 936 case SIG_DBG_BRANCH_TRACING: 937#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 938 return -EINVAL; 939#else 940 if (op.dbg_value) 941 new_msr |= MSR_BE; 942 else 943 new_msr &= ~MSR_BE; 944#endif 945 break; 946 947 default: 948 return -EINVAL; 949 } 950 } 951 952 /* We wait until here to actually install the values in the 953 registers so if we fail in the above loop, it will not 954 affect the contents of these registers. After this point, 955 failure is a problem, anyway, and it's very unlikely unless 956 the user is really doing something wrong. */ 957 regs->msr = new_msr; 958#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 959 current->thread.dbcr0 = new_dbcr0; 960#endif 961 962 /* 963 * If we get a fault copying the context into the kernel's 964 * image of the user's registers, we can't just return -EFAULT 965 * because the user's registers will be corrupted. For instance 966 * the NIP value may have been updated but not some of the 967 * other registers. Given that we have done the access_ok 968 * and successfully read the first and last bytes of the region 969 * above, this should only happen in an out-of-memory situation 970 * or if another thread unmaps the region containing the context. 971 * We kill the task with a SIGSEGV in this situation. 972 */ 973 if (do_setcontext(ctx, regs, 1)) { 974 force_sig(SIGSEGV, current); 975 goto out; 976 } 977 978 /* 979 * It's not clear whether or why it is desirable to save the 980 * sigaltstack setting on signal delivery and restore it on 981 * signal return. But other architectures do this and we have 982 * always done it up until now so it is probably better not to 983 * change it. -- paulus 984 */ 985 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]); 986 987 set_thread_flag(TIF_RESTOREALL); 988 out: 989 return 0; 990} 991#endif 992 993/* 994 * OK, we're invoking a handler 995 */ 996static int handle_signal(unsigned long sig, struct k_sigaction *ka, 997 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs, 998 unsigned long newsp) 999{ 1000 struct sigcontext __user *sc; 1001 struct sigregs __user *frame; 1002 unsigned long origsp = newsp; 1003 1004 /* Set up Signal Frame */ 1005 newsp -= sizeof(struct sigregs); 1006 frame = (struct sigregs __user *) newsp; 1007 1008 /* Put a sigcontext on the stack */ 1009 newsp -= sizeof(*sc); 1010 sc = (struct sigcontext __user *) newsp; 1011 1012 /* create a stack frame for the caller of the handler */ 1013 newsp -= __SIGNAL_FRAMESIZE; 1014 1015 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp)) 1016 goto badframe; 1017 1018#if _NSIG != 64 1019#error "Please adjust handle_signal()" 1020#endif 1021 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1022 || __put_user(oldset->sig[0], &sc->oldmask) 1023#ifdef CONFIG_PPC64 1024 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1025#else 1026 || __put_user(oldset->sig[1], &sc->_unused[3]) 1027#endif 1028 || __put_user(to_user_ptr(frame), &sc->regs) 1029 || __put_user(sig, &sc->signal)) 1030 goto badframe; 1031 1032 if (vdso32_sigtramp && current->thread.vdso_base) { 1033 if (save_user_regs(regs, &frame->mctx, 0)) 1034 goto badframe; 1035 regs->link = current->thread.vdso_base + vdso32_sigtramp; 1036 } else { 1037 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn)) 1038 goto badframe; 1039 regs->link = (unsigned long) frame->mctx.tramp; 1040 } 1041 1042 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 1043 1044 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1045 goto badframe; 1046 regs->gpr[1] = newsp; 1047 regs->gpr[3] = sig; 1048 regs->gpr[4] = (unsigned long) sc; 1049 regs->nip = (unsigned long) ka->sa.sa_handler; 1050 regs->trap = 0; 1051 1052 return 1; 1053 1054badframe: 1055#ifdef DEBUG_SIG 1056 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1057 regs, frame, newsp); 1058#endif 1059 force_sigsegv(sig, current); 1060 return 0; 1061} 1062 1063/* 1064 * Do a signal return; undo the signal stack. 1065 */ 1066long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1067 struct pt_regs *regs) 1068{ 1069 struct sigcontext __user *sc; 1070 struct sigcontext sigctx; 1071 struct mcontext __user *sr; 1072 sigset_t set; 1073 1074 /* Always make any pending restarted system calls return -EINTR */ 1075 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1076 1077 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1078 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1079 goto badframe; 1080 1081#ifdef CONFIG_PPC64 1082 /* 1083 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1084 * unused part of the signal stackframe 1085 */ 1086 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1087#else 1088 set.sig[0] = sigctx.oldmask; 1089 set.sig[1] = sigctx._unused[3]; 1090#endif 1091 restore_sigmask(&set); 1092 1093 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1094 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1095 || restore_user_regs(regs, sr, 1)) 1096 goto badframe; 1097 1098 set_thread_flag(TIF_RESTOREALL); 1099 return 0; 1100 1101badframe: 1102 force_sig(SIGSEGV, current); 1103 return 0; 1104} 1105 1106/* 1107 * Note that 'init' is a special process: it doesn't get signals it doesn't 1108 * want to handle. Thus you cannot kill init even with a SIGKILL even by 1109 * mistake. 1110 */ 1111int do_signal(sigset_t *oldset, struct pt_regs *regs) 1112{ 1113 siginfo_t info; 1114 struct k_sigaction ka; 1115 unsigned int newsp; 1116 int signr, ret; 1117 1118#ifdef CONFIG_PPC32 1119 if (try_to_freeze()) { 1120 signr = 0; 1121 if (!signal_pending(current)) 1122 goto no_signal; 1123 } 1124#endif 1125 1126 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1127 oldset = ¤t->saved_sigmask; 1128 else if (!oldset) 1129 oldset = ¤t->blocked; 1130 1131 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 1132#ifdef CONFIG_PPC32 1133no_signal: 1134#endif 1135 if (TRAP(regs) == 0x0C00 /* System Call! */ 1136 && regs->ccr & 0x10000000 /* error signalled */ 1137 && ((ret = regs->gpr[3]) == ERESTARTSYS 1138 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR 1139 || ret == ERESTART_RESTARTBLOCK)) { 1140 1141 if (signr > 0 1142 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK 1143 || (ret == ERESTARTSYS 1144 && !(ka.sa.sa_flags & SA_RESTART)))) { 1145 /* make the system call return an EINTR error */ 1146 regs->result = -EINTR; 1147 regs->gpr[3] = EINTR; 1148 /* note that the cr0.SO bit is already set */ 1149 } else { 1150 regs->nip -= 4; /* Back up & retry system call */ 1151 regs->result = 0; 1152 regs->trap = 0; 1153 if (ret == ERESTART_RESTARTBLOCK) 1154 regs->gpr[0] = __NR_restart_syscall; 1155 else 1156 regs->gpr[3] = regs->orig_gpr3; 1157 } 1158 } 1159 1160 if (signr == 0) { 1161 /* No signal to deliver -- put the saved sigmask back */ 1162 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 1163 clear_thread_flag(TIF_RESTORE_SIGMASK); 1164 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 1165 } 1166 return 0; /* no signals delivered */ 1167 } 1168 1169 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size 1170 && !on_sig_stack(regs->gpr[1])) 1171 newsp = current->sas_ss_sp + current->sas_ss_size; 1172 else 1173 newsp = regs->gpr[1]; 1174 newsp &= ~0xfUL; 1175 1176#ifdef CONFIG_PPC64 1177 /* 1178 * Reenable the DABR before delivering the signal to 1179 * user space. The DABR will have been cleared if it 1180 * triggered inside the kernel. 1181 */ 1182 if (current->thread.dabr) 1183 set_dabr(current->thread.dabr); 1184#endif 1185 1186 /* Whee! Actually deliver the signal. */ 1187 if (ka.sa.sa_flags & SA_SIGINFO) 1188 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp); 1189 else 1190 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp); 1191 1192 if (ret) { 1193 spin_lock_irq(¤t->sighand->siglock); 1194 sigorsets(¤t->blocked, ¤t->blocked, 1195 &ka.sa.sa_mask); 1196 if (!(ka.sa.sa_flags & SA_NODEFER)) 1197 sigaddset(¤t->blocked, signr); 1198 recalc_sigpending(); 1199 spin_unlock_irq(¤t->sighand->siglock); 1200 /* A signal was successfully delivered; the saved sigmask is in 1201 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */ 1202 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1203 clear_thread_flag(TIF_RESTORE_SIGMASK); 1204 } 1205 1206 return ret; 1207} 1208