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