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