signal_32.c revision 22e38f29328296d9d4cc33e46fd32a63e807abaf
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 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 /* no need to check access_ok(mcp), since mcp < 4GB */ 812 } 813#else 814 if (__get_user(mcp, &ucp->uc_regs)) 815 return -EFAULT; 816 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 817 return -EFAULT; 818#endif 819 restore_sigmask(&set); 820 if (restore_user_regs(regs, mcp, sig)) 821 return -EFAULT; 822 823 return 0; 824} 825 826long sys_swapcontext(struct ucontext __user *old_ctx, 827 struct ucontext __user *new_ctx, 828 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 829{ 830 unsigned char tmp; 831 832 /* Context size is for future use. Right now, we only make sure 833 * we are passed something we understand 834 */ 835 if (ctx_size < sizeof(struct ucontext)) 836 return -EINVAL; 837 838 if (old_ctx != NULL) { 839 struct mcontext __user *mctx; 840 841 /* 842 * old_ctx might not be 16-byte aligned, in which 843 * case old_ctx->uc_mcontext won't be either. 844 * Because we have the old_ctx->uc_pad2 field 845 * before old_ctx->uc_mcontext, we need to round down 846 * from &old_ctx->uc_mcontext to a 16-byte boundary. 847 */ 848 mctx = (struct mcontext __user *) 849 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 850 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx)) 851 || save_user_regs(regs, mctx, 0) 852 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 853 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 854 return -EFAULT; 855 } 856 if (new_ctx == NULL) 857 return 0; 858 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx)) 859 || __get_user(tmp, (u8 __user *) new_ctx) 860 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1)) 861 return -EFAULT; 862 863 /* 864 * If we get a fault copying the context into the kernel's 865 * image of the user's registers, we can't just return -EFAULT 866 * because the user's registers will be corrupted. For instance 867 * the NIP value may have been updated but not some of the 868 * other registers. Given that we have done the access_ok 869 * and successfully read the first and last bytes of the region 870 * above, this should only happen in an out-of-memory situation 871 * or if another thread unmaps the region containing the context. 872 * We kill the task with a SIGSEGV in this situation. 873 */ 874 if (do_setcontext(new_ctx, regs, 0)) 875 do_exit(SIGSEGV); 876 877 set_thread_flag(TIF_RESTOREALL); 878 return 0; 879} 880 881long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 882 struct pt_regs *regs) 883{ 884 struct rt_sigframe __user *rt_sf; 885 886 /* Always make any pending restarted system calls return -EINTR */ 887 current_thread_info()->restart_block.fn = do_no_restart_syscall; 888 889 rt_sf = (struct rt_sigframe __user *) 890 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 891 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 892 goto bad; 893 if (do_setcontext(&rt_sf->uc, regs, 1)) 894 goto bad; 895 896 /* 897 * It's not clear whether or why it is desirable to save the 898 * sigaltstack setting on signal delivery and restore it on 899 * signal return. But other architectures do this and we have 900 * always done it up until now so it is probably better not to 901 * change it. -- paulus 902 */ 903#ifdef CONFIG_PPC64 904 /* 905 * We use the compat_sys_ version that does the 32/64 bits conversion 906 * and takes userland pointer directly. What about error checking ? 907 * nobody does any... 908 */ 909 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs); 910#else 911 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]); 912#endif 913 set_thread_flag(TIF_RESTOREALL); 914 return 0; 915 916 bad: 917 force_sig(SIGSEGV, current); 918 return 0; 919} 920 921#ifdef CONFIG_PPC32 922int sys_debug_setcontext(struct ucontext __user *ctx, 923 int ndbg, struct sig_dbg_op __user *dbg, 924 int r6, int r7, int r8, 925 struct pt_regs *regs) 926{ 927 struct sig_dbg_op op; 928 int i; 929 unsigned char tmp; 930 unsigned long new_msr = regs->msr; 931#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 932 unsigned long new_dbcr0 = current->thread.dbcr0; 933#endif 934 935 for (i=0; i<ndbg; i++) { 936 if (copy_from_user(&op, dbg + i, sizeof(op))) 937 return -EFAULT; 938 switch (op.dbg_type) { 939 case SIG_DBG_SINGLE_STEPPING: 940#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 941 if (op.dbg_value) { 942 new_msr |= MSR_DE; 943 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 944 } else { 945 new_msr &= ~MSR_DE; 946 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 947 } 948#else 949 if (op.dbg_value) 950 new_msr |= MSR_SE; 951 else 952 new_msr &= ~MSR_SE; 953#endif 954 break; 955 case SIG_DBG_BRANCH_TRACING: 956#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 957 return -EINVAL; 958#else 959 if (op.dbg_value) 960 new_msr |= MSR_BE; 961 else 962 new_msr &= ~MSR_BE; 963#endif 964 break; 965 966 default: 967 return -EINVAL; 968 } 969 } 970 971 /* We wait until here to actually install the values in the 972 registers so if we fail in the above loop, it will not 973 affect the contents of these registers. After this point, 974 failure is a problem, anyway, and it's very unlikely unless 975 the user is really doing something wrong. */ 976 regs->msr = new_msr; 977#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 978 current->thread.dbcr0 = new_dbcr0; 979#endif 980 981 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 982 || __get_user(tmp, (u8 __user *) ctx) 983 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 984 return -EFAULT; 985 986 /* 987 * If we get a fault copying the context into the kernel's 988 * image of the user's registers, we can't just return -EFAULT 989 * because the user's registers will be corrupted. For instance 990 * the NIP value may have been updated but not some of the 991 * other registers. Given that we have done the access_ok 992 * and successfully read the first and last bytes of the region 993 * above, this should only happen in an out-of-memory situation 994 * or if another thread unmaps the region containing the context. 995 * We kill the task with a SIGSEGV in this situation. 996 */ 997 if (do_setcontext(ctx, regs, 1)) { 998 force_sig(SIGSEGV, current); 999 goto out; 1000 } 1001 1002 /* 1003 * It's not clear whether or why it is desirable to save the 1004 * sigaltstack setting on signal delivery and restore it on 1005 * signal return. But other architectures do this and we have 1006 * always done it up until now so it is probably better not to 1007 * change it. -- paulus 1008 */ 1009 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]); 1010 1011 set_thread_flag(TIF_RESTOREALL); 1012 out: 1013 return 0; 1014} 1015#endif 1016 1017/* 1018 * OK, we're invoking a handler 1019 */ 1020static int handle_signal(unsigned long sig, struct k_sigaction *ka, 1021 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs, 1022 unsigned long newsp) 1023{ 1024 struct sigcontext __user *sc; 1025 struct sigregs __user *frame; 1026 unsigned long origsp = newsp; 1027 1028 /* Set up Signal Frame */ 1029 newsp -= sizeof(struct sigregs); 1030 frame = (struct sigregs __user *) newsp; 1031 1032 /* Put a sigcontext on the stack */ 1033 newsp -= sizeof(*sc); 1034 sc = (struct sigcontext __user *) newsp; 1035 1036 /* create a stack frame for the caller of the handler */ 1037 newsp -= __SIGNAL_FRAMESIZE; 1038 1039 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp)) 1040 goto badframe; 1041 1042#if _NSIG != 64 1043#error "Please adjust handle_signal()" 1044#endif 1045 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1046 || __put_user(oldset->sig[0], &sc->oldmask) 1047#ifdef CONFIG_PPC64 1048 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1049#else 1050 || __put_user(oldset->sig[1], &sc->_unused[3]) 1051#endif 1052 || __put_user(to_user_ptr(frame), &sc->regs) 1053 || __put_user(sig, &sc->signal)) 1054 goto badframe; 1055 1056 if (vdso32_sigtramp && current->mm->context.vdso_base) { 1057 if (save_user_regs(regs, &frame->mctx, 0)) 1058 goto badframe; 1059 regs->link = current->mm->context.vdso_base + vdso32_sigtramp; 1060 } else { 1061 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn)) 1062 goto badframe; 1063 regs->link = (unsigned long) frame->mctx.tramp; 1064 } 1065 1066 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 1067 1068 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1069 goto badframe; 1070 regs->gpr[1] = newsp; 1071 regs->gpr[3] = sig; 1072 regs->gpr[4] = (unsigned long) sc; 1073 regs->nip = (unsigned long) ka->sa.sa_handler; 1074 /* enter the signal handler in big-endian mode */ 1075 regs->msr &= ~MSR_LE; 1076 regs->trap = 0; 1077 1078 return 1; 1079 1080badframe: 1081#ifdef DEBUG_SIG 1082 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1083 regs, frame, newsp); 1084#endif 1085 force_sigsegv(sig, current); 1086 return 0; 1087} 1088 1089/* 1090 * Do a signal return; undo the signal stack. 1091 */ 1092long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1093 struct pt_regs *regs) 1094{ 1095 struct sigcontext __user *sc; 1096 struct sigcontext sigctx; 1097 struct mcontext __user *sr; 1098 sigset_t set; 1099 1100 /* Always make any pending restarted system calls return -EINTR */ 1101 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1102 1103 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1104 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1105 goto badframe; 1106 1107#ifdef CONFIG_PPC64 1108 /* 1109 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1110 * unused part of the signal stackframe 1111 */ 1112 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1113#else 1114 set.sig[0] = sigctx.oldmask; 1115 set.sig[1] = sigctx._unused[3]; 1116#endif 1117 restore_sigmask(&set); 1118 1119 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1120 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1121 || restore_user_regs(regs, sr, 1)) 1122 goto badframe; 1123 1124 set_thread_flag(TIF_RESTOREALL); 1125 return 0; 1126 1127badframe: 1128 force_sig(SIGSEGV, current); 1129 return 0; 1130} 1131 1132/* 1133 * Note that 'init' is a special process: it doesn't get signals it doesn't 1134 * want to handle. Thus you cannot kill init even with a SIGKILL even by 1135 * mistake. 1136 */ 1137int do_signal(sigset_t *oldset, struct pt_regs *regs) 1138{ 1139 siginfo_t info; 1140 struct k_sigaction ka; 1141 unsigned int newsp; 1142 int signr, ret; 1143 1144#ifdef CONFIG_PPC32 1145 if (try_to_freeze()) { 1146 signr = 0; 1147 if (!signal_pending(current)) 1148 goto no_signal; 1149 } 1150#endif 1151 1152 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1153 oldset = ¤t->saved_sigmask; 1154 else if (!oldset) 1155 oldset = ¤t->blocked; 1156 1157 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 1158#ifdef CONFIG_PPC32 1159no_signal: 1160#endif 1161 /* Is there any syscall restart business here ? */ 1162 check_syscall_restart(regs, &ka, signr > 0); 1163 1164 if (signr == 0) { 1165 /* No signal to deliver -- put the saved sigmask back */ 1166 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 1167 clear_thread_flag(TIF_RESTORE_SIGMASK); 1168 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 1169 } 1170 return 0; /* no signals delivered */ 1171 } 1172 1173 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size 1174 && !on_sig_stack(regs->gpr[1])) 1175 newsp = current->sas_ss_sp + current->sas_ss_size; 1176 else 1177 newsp = regs->gpr[1]; 1178 newsp &= ~0xfUL; 1179 1180#ifdef CONFIG_PPC64 1181 /* 1182 * Reenable the DABR before delivering the signal to 1183 * user space. The DABR will have been cleared if it 1184 * triggered inside the kernel. 1185 */ 1186 if (current->thread.dabr) 1187 set_dabr(current->thread.dabr); 1188#endif 1189 1190 /* Whee! Actually deliver the signal. */ 1191 if (ka.sa.sa_flags & SA_SIGINFO) 1192 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp); 1193 else 1194 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp); 1195 1196 if (ret) { 1197 spin_lock_irq(¤t->sighand->siglock); 1198 sigorsets(¤t->blocked, ¤t->blocked, 1199 &ka.sa.sa_mask); 1200 if (!(ka.sa.sa_flags & SA_NODEFER)) 1201 sigaddset(¤t->blocked, signr); 1202 recalc_sigpending(); 1203 spin_unlock_irq(¤t->sighand->siglock); 1204 /* A signal was successfully delivered; the saved sigmask is in 1205 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */ 1206 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1207 clear_thread_flag(TIF_RESTORE_SIGMASK); 1208 } 1209 1210 return ret; 1211} 1212