1 /* 2 * arch/s390/kernel/compat_signal.c 3 * 4 * Copyright (C) IBM Corp. 2000,2006 5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 6 * Gerhard Tonn (ton@de.ibm.com) 7 * 8 * Copyright (C) 1991, 1992 Linus Torvalds 9 * 10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 11 */ 12 13 #include <linux/compat.h> 14 #include <linux/sched.h> 15 #include <linux/mm.h> 16 #include <linux/smp.h> 17 #include <linux/kernel.h> 18 #include <linux/signal.h> 19 #include <linux/errno.h> 20 #include <linux/wait.h> 21 #include <linux/ptrace.h> 22 #include <linux/unistd.h> 23 #include <linux/stddef.h> 24 #include <linux/tty.h> 25 #include <linux/personality.h> 26 #include <linux/binfmts.h> 27 #include <asm/ucontext.h> 28 #include <asm/uaccess.h> 29 #include <asm/lowcore.h> 30 #include "compat_linux.h" 31 #include "compat_ptrace.h" 32 #include "entry.h" 33 34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 35 36 typedef struct 37 { 38 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 39 struct sigcontext32 sc; 40 _sigregs32 sregs; 41 int signo; 42 __u8 retcode[S390_SYSCALL_SIZE]; 43 } sigframe32; 44 45 typedef struct 46 { 47 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 48 __u8 retcode[S390_SYSCALL_SIZE]; 49 compat_siginfo_t info; 50 struct ucontext32 uc; 51 } rt_sigframe32; 52 53 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 54 { 55 int err; 56 57 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 58 return -EFAULT; 59 60 /* If you change siginfo_t structure, please be sure 61 this code is fixed accordingly. 62 It should never copy any pad contained in the structure 63 to avoid security leaks, but must copy the generic 64 3 ints plus the relevant union member. 65 This routine must convert siginfo from 64bit to 32bit as well 66 at the same time. */ 67 err = __put_user(from->si_signo, &to->si_signo); 68 err |= __put_user(from->si_errno, &to->si_errno); 69 err |= __put_user((short)from->si_code, &to->si_code); 70 if (from->si_code < 0) 71 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 72 else { 73 switch (from->si_code >> 16) { 74 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 75 case __SI_MESGQ >> 16: 76 err |= __put_user(from->si_int, &to->si_int); 77 /* fallthrough */ 78 case __SI_KILL >> 16: 79 err |= __put_user(from->si_pid, &to->si_pid); 80 err |= __put_user(from->si_uid, &to->si_uid); 81 break; 82 case __SI_CHLD >> 16: 83 err |= __put_user(from->si_pid, &to->si_pid); 84 err |= __put_user(from->si_uid, &to->si_uid); 85 err |= __put_user(from->si_utime, &to->si_utime); 86 err |= __put_user(from->si_stime, &to->si_stime); 87 err |= __put_user(from->si_status, &to->si_status); 88 break; 89 case __SI_FAULT >> 16: 90 err |= __put_user((unsigned long) from->si_addr, 91 &to->si_addr); 92 break; 93 case __SI_POLL >> 16: 94 err |= __put_user(from->si_band, &to->si_band); 95 err |= __put_user(from->si_fd, &to->si_fd); 96 break; 97 case __SI_TIMER >> 16: 98 err |= __put_user(from->si_tid, &to->si_tid); 99 err |= __put_user(from->si_overrun, &to->si_overrun); 100 err |= __put_user(from->si_int, &to->si_int); 101 break; 102 default: 103 break; 104 } 105 } 106 return err; 107 } 108 109 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 110 { 111 int err; 112 u32 tmp; 113 114 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t))) 115 return -EFAULT; 116 117 err = __get_user(to->si_signo, &from->si_signo); 118 err |= __get_user(to->si_errno, &from->si_errno); 119 err |= __get_user(to->si_code, &from->si_code); 120 121 if (to->si_code < 0) 122 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 123 else { 124 switch (to->si_code >> 16) { 125 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 126 case __SI_MESGQ >> 16: 127 err |= __get_user(to->si_int, &from->si_int); 128 /* fallthrough */ 129 case __SI_KILL >> 16: 130 err |= __get_user(to->si_pid, &from->si_pid); 131 err |= __get_user(to->si_uid, &from->si_uid); 132 break; 133 case __SI_CHLD >> 16: 134 err |= __get_user(to->si_pid, &from->si_pid); 135 err |= __get_user(to->si_uid, &from->si_uid); 136 err |= __get_user(to->si_utime, &from->si_utime); 137 err |= __get_user(to->si_stime, &from->si_stime); 138 err |= __get_user(to->si_status, &from->si_status); 139 break; 140 case __SI_FAULT >> 16: 141 err |= __get_user(tmp, &from->si_addr); 142 to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN); 143 break; 144 case __SI_POLL >> 16: 145 err |= __get_user(to->si_band, &from->si_band); 146 err |= __get_user(to->si_fd, &from->si_fd); 147 break; 148 case __SI_TIMER >> 16: 149 err |= __get_user(to->si_tid, &from->si_tid); 150 err |= __get_user(to->si_overrun, &from->si_overrun); 151 err |= __get_user(to->si_int, &from->si_int); 152 break; 153 default: 154 break; 155 } 156 } 157 return err; 158 } 159 160 asmlinkage long 161 sys32_sigaction(int sig, const struct old_sigaction32 __user *act, 162 struct old_sigaction32 __user *oact) 163 { 164 struct k_sigaction new_ka, old_ka; 165 unsigned long sa_handler, sa_restorer; 166 int ret; 167 168 if (act) { 169 compat_old_sigset_t mask; 170 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 171 __get_user(sa_handler, &act->sa_handler) || 172 __get_user(sa_restorer, &act->sa_restorer) || 173 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 174 __get_user(mask, &act->sa_mask)) 175 return -EFAULT; 176 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 177 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer; 178 siginitset(&new_ka.sa.sa_mask, mask); 179 } 180 181 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 182 183 if (!ret && oact) { 184 sa_handler = (unsigned long) old_ka.sa.sa_handler; 185 sa_restorer = (unsigned long) old_ka.sa.sa_restorer; 186 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 187 __put_user(sa_handler, &oact->sa_handler) || 188 __put_user(sa_restorer, &oact->sa_restorer) || 189 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 190 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 191 return -EFAULT; 192 } 193 194 return ret; 195 } 196 197 asmlinkage long 198 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, 199 struct sigaction32 __user *oact, size_t sigsetsize) 200 { 201 struct k_sigaction new_ka, old_ka; 202 unsigned long sa_handler; 203 int ret; 204 compat_sigset_t set32; 205 206 /* XXX: Don't preclude handling different sized sigset_t's. */ 207 if (sigsetsize != sizeof(compat_sigset_t)) 208 return -EINVAL; 209 210 if (act) { 211 ret = get_user(sa_handler, &act->sa_handler); 212 ret |= __copy_from_user(&set32, &act->sa_mask, 213 sizeof(compat_sigset_t)); 214 switch (_NSIG_WORDS) { 215 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] 216 | (((long)set32.sig[7]) << 32); 217 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] 218 | (((long)set32.sig[5]) << 32); 219 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] 220 | (((long)set32.sig[3]) << 32); 221 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] 222 | (((long)set32.sig[1]) << 32); 223 } 224 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 225 226 if (ret) 227 return -EFAULT; 228 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 229 } 230 231 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 232 233 if (!ret && oact) { 234 switch (_NSIG_WORDS) { 235 case 4: 236 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); 237 set32.sig[6] = old_ka.sa.sa_mask.sig[3]; 238 case 3: 239 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); 240 set32.sig[4] = old_ka.sa.sa_mask.sig[2]; 241 case 2: 242 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); 243 set32.sig[2] = old_ka.sa.sa_mask.sig[1]; 244 case 1: 245 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); 246 set32.sig[0] = old_ka.sa.sa_mask.sig[0]; 247 } 248 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler); 249 ret |= __copy_to_user(&oact->sa_mask, &set32, 250 sizeof(compat_sigset_t)); 251 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 252 } 253 254 return ret; 255 } 256 257 asmlinkage long 258 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss) 259 { 260 struct pt_regs *regs = task_pt_regs(current); 261 stack_t kss, koss; 262 unsigned long ss_sp; 263 int ret, err = 0; 264 mm_segment_t old_fs = get_fs(); 265 266 if (uss) { 267 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 268 return -EFAULT; 269 err |= __get_user(ss_sp, &uss->ss_sp); 270 err |= __get_user(kss.ss_size, &uss->ss_size); 271 err |= __get_user(kss.ss_flags, &uss->ss_flags); 272 if (err) 273 return -EFAULT; 274 kss.ss_sp = (void __user *) ss_sp; 275 } 276 277 set_fs (KERNEL_DS); 278 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL), 279 (stack_t __force __user *) (uoss ? &koss : NULL), 280 regs->gprs[15]); 281 set_fs (old_fs); 282 283 if (!ret && uoss) { 284 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 285 return -EFAULT; 286 ss_sp = (unsigned long) koss.ss_sp; 287 err |= __put_user(ss_sp, &uoss->ss_sp); 288 err |= __put_user(koss.ss_size, &uoss->ss_size); 289 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 290 if (err) 291 return -EFAULT; 292 } 293 return ret; 294 } 295 296 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 297 { 298 _s390_regs_common32 regs32; 299 int err, i; 300 301 regs32.psw.mask = PSW32_MASK_MERGE(psw32_user_bits, 302 (__u32)(regs->psw.mask >> 32)); 303 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr; 304 for (i = 0; i < NUM_GPRS; i++) 305 regs32.gprs[i] = (__u32) regs->gprs[i]; 306 save_access_regs(current->thread.acrs); 307 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs)); 308 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32)); 309 if (err) 310 return err; 311 save_fp_regs(¤t->thread.fp_regs); 312 /* s390_fp_regs and _s390_fp_regs32 are the same ! */ 313 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs, 314 sizeof(_s390_fp_regs32)); 315 } 316 317 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 318 { 319 _s390_regs_common32 regs32; 320 int err, i; 321 322 /* Alwys make any pending restarted system call return -EINTR */ 323 current_thread_info()->restart_block.fn = do_no_restart_syscall; 324 325 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32)); 326 if (err) 327 return err; 328 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask, 329 (__u64)regs32.psw.mask << 32); 330 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN); 331 for (i = 0; i < NUM_GPRS; i++) 332 regs->gprs[i] = (__u64) regs32.gprs[i]; 333 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs)); 334 restore_access_regs(current->thread.acrs); 335 336 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs, 337 sizeof(_s390_fp_regs32)); 338 current->thread.fp_regs.fpc &= FPC_VALID_MASK; 339 if (err) 340 return err; 341 342 restore_fp_regs(¤t->thread.fp_regs); 343 regs->trap = -1; /* disable syscall checks */ 344 return 0; 345 } 346 347 asmlinkage long sys32_sigreturn(void) 348 { 349 struct pt_regs *regs = task_pt_regs(current); 350 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 351 sigset_t set; 352 353 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 354 goto badframe; 355 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 356 goto badframe; 357 358 sigdelsetmask(&set, ~_BLOCKABLE); 359 spin_lock_irq(¤t->sighand->siglock); 360 current->blocked = set; 361 recalc_sigpending(); 362 spin_unlock_irq(¤t->sighand->siglock); 363 364 if (restore_sigregs32(regs, &frame->sregs)) 365 goto badframe; 366 367 return regs->gprs[2]; 368 369 badframe: 370 force_sig(SIGSEGV, current); 371 return 0; 372 } 373 374 asmlinkage long sys32_rt_sigreturn(void) 375 { 376 struct pt_regs *regs = task_pt_regs(current); 377 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 378 sigset_t set; 379 stack_t st; 380 __u32 ss_sp; 381 int err; 382 mm_segment_t old_fs = get_fs(); 383 384 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 385 goto badframe; 386 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 387 goto badframe; 388 389 sigdelsetmask(&set, ~_BLOCKABLE); 390 spin_lock_irq(¤t->sighand->siglock); 391 current->blocked = set; 392 recalc_sigpending(); 393 spin_unlock_irq(¤t->sighand->siglock); 394 395 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 396 goto badframe; 397 398 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp); 399 st.ss_sp = compat_ptr(ss_sp); 400 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size); 401 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags); 402 if (err) 403 goto badframe; 404 405 set_fs (KERNEL_DS); 406 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]); 407 set_fs (old_fs); 408 409 return regs->gprs[2]; 410 411 badframe: 412 force_sig(SIGSEGV, current); 413 return 0; 414 } 415 416 /* 417 * Set up a signal frame. 418 */ 419 420 421 /* 422 * Determine which stack to use.. 423 */ 424 static inline void __user * 425 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 426 { 427 unsigned long sp; 428 429 /* Default to using normal stack */ 430 sp = (unsigned long) A(regs->gprs[15]); 431 432 /* Overflow on alternate signal stack gives SIGSEGV. */ 433 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 434 return (void __user *) -1UL; 435 436 /* This is the X/Open sanctioned signal stack switching. */ 437 if (ka->sa.sa_flags & SA_ONSTACK) { 438 if (! sas_ss_flags(sp)) 439 sp = current->sas_ss_sp + current->sas_ss_size; 440 } 441 442 /* This is the legacy signal stack switching. */ 443 else if (!user_mode(regs) && 444 !(ka->sa.sa_flags & SA_RESTORER) && 445 ka->sa.sa_restorer) { 446 sp = (unsigned long) ka->sa.sa_restorer; 447 } 448 449 return (void __user *)((sp - frame_size) & -8ul); 450 } 451 452 static inline int map_signal(int sig) 453 { 454 if (current_thread_info()->exec_domain 455 && current_thread_info()->exec_domain->signal_invmap 456 && sig < 32) 457 return current_thread_info()->exec_domain->signal_invmap[sig]; 458 else 459 return sig; 460 } 461 462 static int setup_frame32(int sig, struct k_sigaction *ka, 463 sigset_t *set, struct pt_regs * regs) 464 { 465 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32)); 466 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32))) 467 goto give_sigsegv; 468 469 if (frame == (void __user *) -1UL) 470 goto give_sigsegv; 471 472 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32)) 473 goto give_sigsegv; 474 475 if (save_sigregs32(regs, &frame->sregs)) 476 goto give_sigsegv; 477 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs)) 478 goto give_sigsegv; 479 480 /* Set up to return from userspace. If provided, use a stub 481 already in userspace. */ 482 if (ka->sa.sa_flags & SA_RESTORER) { 483 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 484 } else { 485 regs->gprs[14] = (__u64) frame->retcode; 486 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 487 (u16 __user *)(frame->retcode))) 488 goto give_sigsegv; 489 } 490 491 /* Set up backchain. */ 492 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 493 goto give_sigsegv; 494 495 /* Set up registers for signal handler */ 496 regs->gprs[15] = (__u64) frame; 497 regs->psw.addr = (__u64) ka->sa.sa_handler; 498 499 regs->gprs[2] = map_signal(sig); 500 regs->gprs[3] = (__u64) &frame->sc; 501 502 /* We forgot to include these in the sigcontext. 503 To avoid breaking binary compatibility, they are passed as args. */ 504 regs->gprs[4] = current->thread.trap_no; 505 regs->gprs[5] = current->thread.prot_addr; 506 507 /* Place signal number on stack to allow backtrace from handler. */ 508 if (__put_user(regs->gprs[2], (int __user *) &frame->signo)) 509 goto give_sigsegv; 510 return 0; 511 512 give_sigsegv: 513 force_sigsegv(sig, current); 514 return -EFAULT; 515 } 516 517 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info, 518 sigset_t *set, struct pt_regs * regs) 519 { 520 int err = 0; 521 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32)); 522 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32))) 523 goto give_sigsegv; 524 525 if (frame == (void __user *) -1UL) 526 goto give_sigsegv; 527 528 if (copy_siginfo_to_user32(&frame->info, info)) 529 goto give_sigsegv; 530 531 /* Create the ucontext. */ 532 err |= __put_user(0, &frame->uc.uc_flags); 533 err |= __put_user(0, &frame->uc.uc_link); 534 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 535 err |= __put_user(sas_ss_flags(regs->gprs[15]), 536 &frame->uc.uc_stack.ss_flags); 537 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 538 err |= save_sigregs32(regs, &frame->uc.uc_mcontext); 539 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 540 if (err) 541 goto give_sigsegv; 542 543 /* Set up to return from userspace. If provided, use a stub 544 already in userspace. */ 545 if (ka->sa.sa_flags & SA_RESTORER) { 546 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 547 } else { 548 regs->gprs[14] = (__u64) frame->retcode; 549 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 550 (u16 __user *)(frame->retcode)); 551 } 552 553 /* Set up backchain. */ 554 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 555 goto give_sigsegv; 556 557 /* Set up registers for signal handler */ 558 regs->gprs[15] = (__u64) frame; 559 regs->psw.addr = (__u64) ka->sa.sa_handler; 560 561 regs->gprs[2] = map_signal(sig); 562 regs->gprs[3] = (__u64) &frame->info; 563 regs->gprs[4] = (__u64) &frame->uc; 564 return 0; 565 566 give_sigsegv: 567 force_sigsegv(sig, current); 568 return -EFAULT; 569 } 570 571 /* 572 * OK, we're invoking a handler 573 */ 574 575 int 576 handle_signal32(unsigned long sig, struct k_sigaction *ka, 577 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 578 { 579 int ret; 580 581 /* Set up the stack frame */ 582 if (ka->sa.sa_flags & SA_SIGINFO) 583 ret = setup_rt_frame32(sig, ka, info, oldset, regs); 584 else 585 ret = setup_frame32(sig, ka, oldset, regs); 586 587 if (ret == 0) { 588 spin_lock_irq(¤t->sighand->siglock); 589 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 590 if (!(ka->sa.sa_flags & SA_NODEFER)) 591 sigaddset(¤t->blocked,sig); 592 recalc_sigpending(); 593 spin_unlock_irq(¤t->sighand->siglock); 594 } 595 return ret; 596 } 597 598