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