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