signal_32.c revision 69d15f6b352a681f1db9bc70219a3e8e9d503dbf
1/* 2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC 3 * 4 * PowerPC version 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * Copyright (C) 2001 IBM 7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 9 * 10 * Derived from "arch/i386/kernel/signal.c" 11 * Copyright (C) 1991, 1992 Linus Torvalds 12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * as published by the Free Software Foundation; either version 17 * 2 of the License, or (at your option) any later version. 18 */ 19 20#include <linux/sched.h> 21#include <linux/mm.h> 22#include <linux/smp.h> 23#include <linux/kernel.h> 24#include <linux/signal.h> 25#include <linux/errno.h> 26#include <linux/elf.h> 27#ifdef CONFIG_PPC64 28#include <linux/syscalls.h> 29#include <linux/compat.h> 30#include <linux/ptrace.h> 31#else 32#include <linux/wait.h> 33#include <linux/ptrace.h> 34#include <linux/unistd.h> 35#include <linux/stddef.h> 36#include <linux/tty.h> 37#include <linux/binfmts.h> 38#include <linux/freezer.h> 39#endif 40 41#include <asm/uaccess.h> 42#include <asm/cacheflush.h> 43#include <asm/syscalls.h> 44#include <asm/sigcontext.h> 45#include <asm/vdso.h> 46#ifdef CONFIG_PPC64 47#include "ppc32.h" 48#include <asm/unistd.h> 49#else 50#include <asm/ucontext.h> 51#include <asm/pgtable.h> 52#endif 53 54#include "signal.h" 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 256long sys_sigaction(int sig, struct old_sigaction __user *act, 257 struct old_sigaction __user *oact) 258{ 259 struct k_sigaction new_ka, old_ka; 260 int ret; 261 262#ifdef CONFIG_PPC64 263 if (sig < 0) 264 sig = -sig; 265#endif 266 267 if (act) { 268 if (get_old_sigaction(&new_ka, act)) 269 return -EFAULT; 270 } 271 272 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 273 if (!ret && oact) { 274 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 275 __put_user(to_user_ptr(old_ka.sa.sa_handler), 276 &oact->sa_handler) || 277 __put_user(to_user_ptr(old_ka.sa.sa_restorer), 278 &oact->sa_restorer) || 279 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 280 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 281 return -EFAULT; 282 } 283 284 return ret; 285} 286 287/* 288 * When we have signals to deliver, we set up on the 289 * user stack, going down from the original stack pointer: 290 * a sigregs struct 291 * a sigcontext struct 292 * a gap of __SIGNAL_FRAMESIZE bytes 293 * 294 * Each of these things must be a multiple of 16 bytes in size. 295 * 296 */ 297struct sigregs { 298 struct mcontext mctx; /* all the register values */ 299 /* 300 * Programs using the rs6000/xcoff abi can save up to 19 gp 301 * regs and 18 fp regs below sp before decrementing it. 302 */ 303 int abigap[56]; 304}; 305 306/* We use the mc_pad field for the signal return trampoline. */ 307#define tramp mc_pad 308 309/* 310 * When we have rt signals to deliver, we set up on the 311 * user stack, going down from the original stack pointer: 312 * one rt_sigframe struct (siginfo + ucontext + ABI gap) 313 * a gap of __SIGNAL_FRAMESIZE+16 bytes 314 * (the +16 is to get the siginfo and ucontext in the same 315 * positions as in older kernels). 316 * 317 * Each of these things must be a multiple of 16 bytes in size. 318 * 319 */ 320struct rt_sigframe { 321#ifdef CONFIG_PPC64 322 compat_siginfo_t info; 323#else 324 struct siginfo info; 325#endif 326 struct ucontext uc; 327 /* 328 * Programs using the rs6000/xcoff abi can save up to 19 gp 329 * regs and 18 fp regs below sp before decrementing it. 330 */ 331 int abigap[56]; 332}; 333 334/* 335 * Save the current user registers on the user stack. 336 * We only save the altivec/spe registers if the process has used 337 * altivec/spe instructions at some point. 338 */ 339static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame, 340 int sigret) 341{ 342 /* Make sure floating point registers are stored in regs */ 343 flush_fp_to_thread(current); 344 345 /* save general and floating-point registers */ 346 if (save_general_regs(regs, frame) || 347 __copy_to_user(&frame->mc_fregs, current->thread.fpr, 348 ELF_NFPREG * sizeof(double))) 349 return 1; 350 351#ifdef CONFIG_ALTIVEC 352 /* save altivec registers */ 353 if (current->thread.used_vr) { 354 flush_altivec_to_thread(current); 355 if (__copy_to_user(&frame->mc_vregs, current->thread.vr, 356 ELF_NVRREG * sizeof(vector128))) 357 return 1; 358 /* set MSR_VEC in the saved MSR value to indicate that 359 frame->mc_vregs contains valid data */ 360 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR])) 361 return 1; 362 } 363 /* else assert((regs->msr & MSR_VEC) == 0) */ 364 365 /* We always copy to/from vrsave, it's 0 if we don't have or don't 366 * use altivec. Since VSCR only contains 32 bits saved in the least 367 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 368 * most significant bits of that same vector. --BenH 369 */ 370 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32])) 371 return 1; 372#endif /* CONFIG_ALTIVEC */ 373 374#ifdef CONFIG_SPE 375 /* save spe registers */ 376 if (current->thread.used_spe) { 377 flush_spe_to_thread(current); 378 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 379 ELF_NEVRREG * sizeof(u32))) 380 return 1; 381 /* set MSR_SPE in the saved MSR value to indicate that 382 frame->mc_vregs contains valid data */ 383 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR])) 384 return 1; 385 } 386 /* else assert((regs->msr & MSR_SPE) == 0) */ 387 388 /* We always copy to/from spefscr */ 389 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 390 return 1; 391#endif /* CONFIG_SPE */ 392 393 if (sigret) { 394 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 395 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 396 || __put_user(0x44000002UL, &frame->tramp[1])) 397 return 1; 398 flush_icache_range((unsigned long) &frame->tramp[0], 399 (unsigned long) &frame->tramp[2]); 400 } 401 402 return 0; 403} 404 405/* 406 * Restore the current user register values from the user stack, 407 * (except for MSR). 408 */ 409static long restore_user_regs(struct pt_regs *regs, 410 struct mcontext __user *sr, int sig) 411{ 412 long err; 413 unsigned int save_r2 = 0; 414 unsigned long msr; 415 416 /* 417 * restore general registers but not including MSR or SOFTE. Also 418 * take care of keeping r2 (TLS) intact if not a signal 419 */ 420 if (!sig) 421 save_r2 = (unsigned int)regs->gpr[2]; 422 err = restore_general_regs(regs, sr); 423 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 424 if (!sig) 425 regs->gpr[2] = (unsigned long) save_r2; 426 if (err) 427 return 1; 428 429 /* if doing signal return, restore the previous little-endian mode */ 430 if (sig) 431 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 432 433 /* 434 * Do this before updating the thread state in 435 * current->thread.fpr/vr/evr. That way, if we get preempted 436 * and another task grabs the FPU/Altivec/SPE, it won't be 437 * tempted to save the current CPU state into the thread_struct 438 * and corrupt what we are writing there. 439 */ 440 discard_lazy_cpu_state(); 441 442 /* force the process to reload the FP registers from 443 current->thread when it next does FP instructions */ 444 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 445 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs, 446 sizeof(sr->mc_fregs))) 447 return 1; 448 449#ifdef CONFIG_ALTIVEC 450 /* force the process to reload the altivec registers from 451 current->thread when it next does altivec instructions */ 452 regs->msr &= ~MSR_VEC; 453 if (msr & MSR_VEC) { 454 /* restore altivec registers from the stack */ 455 if (__copy_from_user(current->thread.vr, &sr->mc_vregs, 456 sizeof(sr->mc_vregs))) 457 return 1; 458 } else if (current->thread.used_vr) 459 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128)); 460 461 /* Always get VRSAVE back */ 462 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 463 return 1; 464#endif /* CONFIG_ALTIVEC */ 465 466#ifdef CONFIG_SPE 467 /* force the process to reload the spe registers from 468 current->thread when it next does spe instructions */ 469 regs->msr &= ~MSR_SPE; 470 if (msr & MSR_SPE) { 471 /* restore spe registers from the stack */ 472 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 473 ELF_NEVRREG * sizeof(u32))) 474 return 1; 475 } else if (current->thread.used_spe) 476 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 477 478 /* Always get SPEFSCR back */ 479 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 480 return 1; 481#endif /* CONFIG_SPE */ 482 483 return 0; 484} 485 486#ifdef CONFIG_PPC64 487long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act, 488 struct sigaction32 __user *oact, size_t sigsetsize) 489{ 490 struct k_sigaction new_ka, old_ka; 491 int ret; 492 493 /* XXX: Don't preclude handling different sized sigset_t's. */ 494 if (sigsetsize != sizeof(compat_sigset_t)) 495 return -EINVAL; 496 497 if (act) { 498 compat_uptr_t handler; 499 500 ret = get_user(handler, &act->sa_handler); 501 new_ka.sa.sa_handler = compat_ptr(handler); 502 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask); 503 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 504 if (ret) 505 return -EFAULT; 506 } 507 508 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 509 if (!ret && oact) { 510 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler); 511 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask); 512 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 513 } 514 return ret; 515} 516 517/* 518 * Note: it is necessary to treat how as an unsigned int, with the 519 * corresponding cast to a signed int to insure that the proper 520 * conversion (sign extension) between the register representation 521 * of a signed int (msr in 32-bit mode) and the register representation 522 * of a signed int (msr in 64-bit mode) is performed. 523 */ 524long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set, 525 compat_sigset_t __user *oset, size_t sigsetsize) 526{ 527 sigset_t s; 528 sigset_t __user *up; 529 int ret; 530 mm_segment_t old_fs = get_fs(); 531 532 if (set) { 533 if (get_sigset_t(&s, set)) 534 return -EFAULT; 535 } 536 537 set_fs(KERNEL_DS); 538 /* This is valid because of the set_fs() */ 539 up = (sigset_t __user *) &s; 540 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL, 541 sigsetsize); 542 set_fs(old_fs); 543 if (ret) 544 return ret; 545 if (oset) { 546 if (put_sigset_t(oset, &s)) 547 return -EFAULT; 548 } 549 return 0; 550} 551 552long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize) 553{ 554 sigset_t s; 555 int ret; 556 mm_segment_t old_fs = get_fs(); 557 558 set_fs(KERNEL_DS); 559 /* The __user pointer cast is valid because of the set_fs() */ 560 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize); 561 set_fs(old_fs); 562 if (!ret) { 563 if (put_sigset_t(set, &s)) 564 return -EFAULT; 565 } 566 return ret; 567} 568 569 570int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s) 571{ 572 int err; 573 574 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 575 return -EFAULT; 576 577 /* If you change siginfo_t structure, please be sure 578 * this code is fixed accordingly. 579 * It should never copy any pad contained in the structure 580 * to avoid security leaks, but must copy the generic 581 * 3 ints plus the relevant union member. 582 * This routine must convert siginfo from 64bit to 32bit as well 583 * at the same time. 584 */ 585 err = __put_user(s->si_signo, &d->si_signo); 586 err |= __put_user(s->si_errno, &d->si_errno); 587 err |= __put_user((short)s->si_code, &d->si_code); 588 if (s->si_code < 0) 589 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 590 SI_PAD_SIZE32); 591 else switch(s->si_code >> 16) { 592 case __SI_CHLD >> 16: 593 err |= __put_user(s->si_pid, &d->si_pid); 594 err |= __put_user(s->si_uid, &d->si_uid); 595 err |= __put_user(s->si_utime, &d->si_utime); 596 err |= __put_user(s->si_stime, &d->si_stime); 597 err |= __put_user(s->si_status, &d->si_status); 598 break; 599 case __SI_FAULT >> 16: 600 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 601 &d->si_addr); 602 break; 603 case __SI_POLL >> 16: 604 err |= __put_user(s->si_band, &d->si_band); 605 err |= __put_user(s->si_fd, &d->si_fd); 606 break; 607 case __SI_TIMER >> 16: 608 err |= __put_user(s->si_tid, &d->si_tid); 609 err |= __put_user(s->si_overrun, &d->si_overrun); 610 err |= __put_user(s->si_int, &d->si_int); 611 break; 612 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 613 case __SI_MESGQ >> 16: 614 err |= __put_user(s->si_int, &d->si_int); 615 /* fallthrough */ 616 case __SI_KILL >> 16: 617 default: 618 err |= __put_user(s->si_pid, &d->si_pid); 619 err |= __put_user(s->si_uid, &d->si_uid); 620 break; 621 } 622 return err; 623} 624 625#define copy_siginfo_to_user copy_siginfo_to_user32 626 627/* 628 * Note: it is necessary to treat pid and sig as unsigned ints, with the 629 * corresponding cast to a signed int to insure that the proper conversion 630 * (sign extension) between the register representation of a signed int 631 * (msr in 32-bit mode) and the register representation of a signed int 632 * (msr in 64-bit mode) is performed. 633 */ 634long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo) 635{ 636 siginfo_t info; 637 int ret; 638 mm_segment_t old_fs = get_fs(); 639 640 if (copy_from_user (&info, uinfo, 3*sizeof(int)) || 641 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32)) 642 return -EFAULT; 643 set_fs (KERNEL_DS); 644 /* The __user pointer cast is valid becasuse of the set_fs() */ 645 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info); 646 set_fs (old_fs); 647 return ret; 648} 649/* 650 * Start Alternate signal stack support 651 * 652 * System Calls 653 * sigaltatck compat_sys_sigaltstack 654 */ 655 656int compat_sys_sigaltstack(u32 __new, u32 __old, int r5, 657 int r6, int r7, int r8, struct pt_regs *regs) 658{ 659 stack_32_t __user * newstack = compat_ptr(__new); 660 stack_32_t __user * oldstack = compat_ptr(__old); 661 stack_t uss, uoss; 662 int ret; 663 mm_segment_t old_fs; 664 unsigned long sp; 665 compat_uptr_t ss_sp; 666 667 /* 668 * set sp to the user stack on entry to the system call 669 * the system call router sets R9 to the saved registers 670 */ 671 sp = regs->gpr[1]; 672 673 /* Put new stack info in local 64 bit stack struct */ 674 if (newstack) { 675 if (get_user(ss_sp, &newstack->ss_sp) || 676 __get_user(uss.ss_flags, &newstack->ss_flags) || 677 __get_user(uss.ss_size, &newstack->ss_size)) 678 return -EFAULT; 679 uss.ss_sp = compat_ptr(ss_sp); 680 } 681 682 old_fs = get_fs(); 683 set_fs(KERNEL_DS); 684 /* The __user pointer casts are valid because of the set_fs() */ 685 ret = do_sigaltstack( 686 newstack ? (stack_t __user *) &uss : NULL, 687 oldstack ? (stack_t __user *) &uoss : NULL, 688 sp); 689 set_fs(old_fs); 690 /* Copy the stack information to the user output buffer */ 691 if (!ret && oldstack && 692 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) || 693 __put_user(uoss.ss_flags, &oldstack->ss_flags) || 694 __put_user(uoss.ss_size, &oldstack->ss_size))) 695 return -EFAULT; 696 return ret; 697} 698#endif /* CONFIG_PPC64 */ 699 700 701/* 702 * Restore the user process's signal mask 703 */ 704#ifdef CONFIG_PPC64 705extern void restore_sigmask(sigset_t *set); 706#else /* CONFIG_PPC64 */ 707static void restore_sigmask(sigset_t *set) 708{ 709 sigdelsetmask(set, ~_BLOCKABLE); 710 spin_lock_irq(¤t->sighand->siglock); 711 current->blocked = *set; 712 recalc_sigpending(); 713 spin_unlock_irq(¤t->sighand->siglock); 714} 715#endif 716 717/* 718 * Set up a signal frame for a "real-time" signal handler 719 * (one which gets siginfo). 720 */ 721static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka, 722 siginfo_t *info, sigset_t *oldset, 723 struct pt_regs *regs, unsigned long newsp) 724{ 725 struct rt_sigframe __user *rt_sf; 726 struct mcontext __user *frame; 727 unsigned long origsp = newsp; 728 729 /* Set up Signal Frame */ 730 /* Put a Real Time Context onto stack */ 731 newsp -= sizeof(*rt_sf); 732 rt_sf = (struct rt_sigframe __user *)newsp; 733 734 /* create a stack frame for the caller of the handler */ 735 newsp -= __SIGNAL_FRAMESIZE + 16; 736 737 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp)) 738 goto badframe; 739 740 /* Put the siginfo & fill in most of the ucontext */ 741 if (copy_siginfo_to_user(&rt_sf->info, info) 742 || __put_user(0, &rt_sf->uc.uc_flags) 743 || __put_user(0, &rt_sf->uc.uc_link) 744 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp) 745 || __put_user(sas_ss_flags(regs->gpr[1]), 746 &rt_sf->uc.uc_stack.ss_flags) 747 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size) 748 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 749 &rt_sf->uc.uc_regs) 750 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 751 goto badframe; 752 753 /* Save user registers on the stack */ 754 frame = &rt_sf->uc.uc_mcontext; 755 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) { 756 if (save_user_regs(regs, frame, 0)) 757 goto badframe; 758 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp; 759 } else { 760 if (save_user_regs(regs, frame, __NR_rt_sigreturn)) 761 goto badframe; 762 regs->link = (unsigned long) frame->tramp; 763 } 764 765 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 766 767 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 768 goto badframe; 769 regs->gpr[1] = newsp; 770 regs->gpr[3] = sig; 771 regs->gpr[4] = (unsigned long) &rt_sf->info; 772 regs->gpr[5] = (unsigned long) &rt_sf->uc; 773 regs->gpr[6] = (unsigned long) rt_sf; 774 regs->nip = (unsigned long) ka->sa.sa_handler; 775 /* enter the signal handler in big-endian mode */ 776 regs->msr &= ~MSR_LE; 777 regs->trap = 0; 778 return 1; 779 780badframe: 781#ifdef DEBUG_SIG 782 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 783 regs, frame, newsp); 784#endif 785 force_sigsegv(sig, current); 786 return 0; 787} 788 789static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 790{ 791 sigset_t set; 792 struct mcontext __user *mcp; 793 794 if (get_sigset_t(&set, &ucp->uc_sigmask)) 795 return -EFAULT; 796#ifdef CONFIG_PPC64 797 { 798 u32 cmcp; 799 800 if (__get_user(cmcp, &ucp->uc_regs)) 801 return -EFAULT; 802 mcp = (struct mcontext __user *)(u64)cmcp; 803 /* no need to check access_ok(mcp), since mcp < 4GB */ 804 } 805#else 806 if (__get_user(mcp, &ucp->uc_regs)) 807 return -EFAULT; 808 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 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 struct mcontext __user *mctx; 832 833 /* 834 * old_ctx might not be 16-byte aligned, in which 835 * case old_ctx->uc_mcontext won't be either. 836 * Because we have the old_ctx->uc_pad2 field 837 * before old_ctx->uc_mcontext, we need to round down 838 * from &old_ctx->uc_mcontext to a 16-byte boundary. 839 */ 840 mctx = (struct mcontext __user *) 841 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 842 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx)) 843 || save_user_regs(regs, mctx, 0) 844 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 845 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 846 return -EFAULT; 847 } 848 if (new_ctx == NULL) 849 return 0; 850 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx)) 851 || __get_user(tmp, (u8 __user *) new_ctx) 852 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1)) 853 return -EFAULT; 854 855 /* 856 * If we get a fault copying the context into the kernel's 857 * image of the user's registers, we can't just return -EFAULT 858 * because the user's registers will be corrupted. For instance 859 * the NIP value may have been updated but not some of the 860 * other registers. Given that we have done the access_ok 861 * and successfully read the first and last bytes of the region 862 * above, this should only happen in an out-of-memory situation 863 * or if another thread unmaps the region containing the context. 864 * We kill the task with a SIGSEGV in this situation. 865 */ 866 if (do_setcontext(new_ctx, regs, 0)) 867 do_exit(SIGSEGV); 868 869 set_thread_flag(TIF_RESTOREALL); 870 return 0; 871} 872 873long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 874 struct pt_regs *regs) 875{ 876 struct rt_sigframe __user *rt_sf; 877 878 /* Always make any pending restarted system calls return -EINTR */ 879 current_thread_info()->restart_block.fn = do_no_restart_syscall; 880 881 rt_sf = (struct rt_sigframe __user *) 882 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 883 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 884 goto bad; 885 if (do_setcontext(&rt_sf->uc, regs, 1)) 886 goto bad; 887 888 /* 889 * It's not clear whether or why it is desirable to save the 890 * sigaltstack setting on signal delivery and restore it on 891 * signal return. But other architectures do this and we have 892 * always done it up until now so it is probably better not to 893 * change it. -- paulus 894 */ 895#ifdef CONFIG_PPC64 896 /* 897 * We use the compat_sys_ version that does the 32/64 bits conversion 898 * and takes userland pointer directly. What about error checking ? 899 * nobody does any... 900 */ 901 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs); 902#else 903 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]); 904#endif 905 set_thread_flag(TIF_RESTOREALL); 906 return 0; 907 908 bad: 909 force_sig(SIGSEGV, current); 910 return 0; 911} 912 913#ifdef CONFIG_PPC32 914int sys_debug_setcontext(struct ucontext __user *ctx, 915 int ndbg, struct sig_dbg_op __user *dbg, 916 int r6, int r7, int r8, 917 struct pt_regs *regs) 918{ 919 struct sig_dbg_op op; 920 int i; 921 unsigned char tmp; 922 unsigned long new_msr = regs->msr; 923#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 924 unsigned long new_dbcr0 = current->thread.dbcr0; 925#endif 926 927 for (i=0; i<ndbg; i++) { 928 if (copy_from_user(&op, dbg + i, sizeof(op))) 929 return -EFAULT; 930 switch (op.dbg_type) { 931 case SIG_DBG_SINGLE_STEPPING: 932#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 933 if (op.dbg_value) { 934 new_msr |= MSR_DE; 935 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 936 } else { 937 new_msr &= ~MSR_DE; 938 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 939 } 940#else 941 if (op.dbg_value) 942 new_msr |= MSR_SE; 943 else 944 new_msr &= ~MSR_SE; 945#endif 946 break; 947 case SIG_DBG_BRANCH_TRACING: 948#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 949 return -EINVAL; 950#else 951 if (op.dbg_value) 952 new_msr |= MSR_BE; 953 else 954 new_msr &= ~MSR_BE; 955#endif 956 break; 957 958 default: 959 return -EINVAL; 960 } 961 } 962 963 /* We wait until here to actually install the values in the 964 registers so if we fail in the above loop, it will not 965 affect the contents of these registers. After this point, 966 failure is a problem, anyway, and it's very unlikely unless 967 the user is really doing something wrong. */ 968 regs->msr = new_msr; 969#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 970 current->thread.dbcr0 = new_dbcr0; 971#endif 972 973 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 974 || __get_user(tmp, (u8 __user *) ctx) 975 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 976 return -EFAULT; 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->mm->context.vdso_base) { 1049 if (save_user_regs(regs, &frame->mctx, 0)) 1050 goto badframe; 1051 regs->link = current->mm->context.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 /* enter the signal handler in big-endian mode */ 1067 regs->msr &= ~MSR_LE; 1068 regs->trap = 0; 1069 1070 return 1; 1071 1072badframe: 1073#ifdef DEBUG_SIG 1074 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1075 regs, frame, newsp); 1076#endif 1077 force_sigsegv(sig, current); 1078 return 0; 1079} 1080 1081/* 1082 * Do a signal return; undo the signal stack. 1083 */ 1084long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1085 struct pt_regs *regs) 1086{ 1087 struct sigcontext __user *sc; 1088 struct sigcontext sigctx; 1089 struct mcontext __user *sr; 1090 sigset_t set; 1091 1092 /* Always make any pending restarted system calls return -EINTR */ 1093 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1094 1095 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1096 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1097 goto badframe; 1098 1099#ifdef CONFIG_PPC64 1100 /* 1101 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1102 * unused part of the signal stackframe 1103 */ 1104 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1105#else 1106 set.sig[0] = sigctx.oldmask; 1107 set.sig[1] = sigctx._unused[3]; 1108#endif 1109 restore_sigmask(&set); 1110 1111 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1112 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1113 || restore_user_regs(regs, sr, 1)) 1114 goto badframe; 1115 1116 set_thread_flag(TIF_RESTOREALL); 1117 return 0; 1118 1119badframe: 1120 force_sig(SIGSEGV, current); 1121 return 0; 1122} 1123 1124/* 1125 * Note that 'init' is a special process: it doesn't get signals it doesn't 1126 * want to handle. Thus you cannot kill init even with a SIGKILL even by 1127 * mistake. 1128 */ 1129int do_signal(sigset_t *oldset, struct pt_regs *regs) 1130{ 1131 siginfo_t info; 1132 struct k_sigaction ka; 1133 unsigned int newsp; 1134 int signr, ret; 1135 1136#ifdef CONFIG_PPC32 1137 if (try_to_freeze()) { 1138 signr = 0; 1139 if (!signal_pending(current)) 1140 goto no_signal; 1141 } 1142#endif 1143 1144 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1145 oldset = ¤t->saved_sigmask; 1146 else if (!oldset) 1147 oldset = ¤t->blocked; 1148 1149 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 1150#ifdef CONFIG_PPC32 1151no_signal: 1152#endif 1153 /* Is there any syscall restart business here ? */ 1154 check_syscall_restart(regs, &ka, signr > 0); 1155 1156 if (signr == 0) { 1157 /* No signal to deliver -- put the saved sigmask back */ 1158 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 1159 clear_thread_flag(TIF_RESTORE_SIGMASK); 1160 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 1161 } 1162 return 0; /* no signals delivered */ 1163 } 1164 1165 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size 1166 && !on_sig_stack(regs->gpr[1])) 1167 newsp = current->sas_ss_sp + current->sas_ss_size; 1168 else 1169 newsp = regs->gpr[1]; 1170 newsp &= ~0xfUL; 1171 1172#ifdef CONFIG_PPC64 1173 /* 1174 * Reenable the DABR before delivering the signal to 1175 * user space. The DABR will have been cleared if it 1176 * triggered inside the kernel. 1177 */ 1178 if (current->thread.dabr) 1179 set_dabr(current->thread.dabr); 1180#endif 1181 1182 /* Whee! Actually deliver the signal. */ 1183 if (ka.sa.sa_flags & SA_SIGINFO) 1184 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp); 1185 else 1186 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp); 1187 1188 if (ret) { 1189 spin_lock_irq(¤t->sighand->siglock); 1190 sigorsets(¤t->blocked, ¤t->blocked, 1191 &ka.sa.sa_mask); 1192 if (!(ka.sa.sa_flags & SA_NODEFER)) 1193 sigaddset(¤t->blocked, signr); 1194 recalc_sigpending(); 1195 spin_unlock_irq(¤t->sighand->siglock); 1196 /* A signal was successfully delivered; the saved sigmask is in 1197 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */ 1198 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1199 clear_thread_flag(TIF_RESTORE_SIGMASK); 1200 } 1201 1202 return ret; 1203} 1204