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