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