1 /* 2 * Copyright IBM Corp. 2000, 2006 3 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 4 * Gerhard Tonn (ton@de.ibm.com) 5 * 6 * Copyright (C) 1991, 1992 Linus Torvalds 7 * 8 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 9 */ 10 11 #include <linux/compat.h> 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/smp.h> 15 #include <linux/kernel.h> 16 #include <linux/signal.h> 17 #include <linux/errno.h> 18 #include <linux/wait.h> 19 #include <linux/ptrace.h> 20 #include <linux/unistd.h> 21 #include <linux/stddef.h> 22 #include <linux/tty.h> 23 #include <linux/personality.h> 24 #include <linux/binfmts.h> 25 #include <asm/ucontext.h> 26 #include <asm/uaccess.h> 27 #include <asm/lowcore.h> 28 #include <asm/switch_to.h> 29 #include "compat_linux.h" 30 #include "compat_ptrace.h" 31 #include "entry.h" 32 33 typedef struct 34 { 35 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 36 struct sigcontext32 sc; 37 _sigregs32 sregs; 38 int signo; 39 __u32 gprs_high[NUM_GPRS]; 40 __u8 retcode[S390_SYSCALL_SIZE]; 41 } sigframe32; 42 43 typedef struct 44 { 45 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 46 __u8 retcode[S390_SYSCALL_SIZE]; 47 compat_siginfo_t info; 48 struct ucontext32 uc; 49 __u32 gprs_high[NUM_GPRS]; 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 __force __user *) 142 (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 new_ka.sa.sa_mask.sig[0] = 215 set32.sig[0] | (((long)set32.sig[1]) << 32); 216 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 217 218 if (ret) 219 return -EFAULT; 220 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 221 } 222 223 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 224 225 if (!ret && oact) { 226 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); 227 set32.sig[0] = old_ka.sa.sa_mask.sig[0]; 228 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler); 229 ret |= __copy_to_user(&oact->sa_mask, &set32, 230 sizeof(compat_sigset_t)); 231 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 232 } 233 234 return ret; 235 } 236 237 asmlinkage long 238 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss) 239 { 240 struct pt_regs *regs = task_pt_regs(current); 241 stack_t kss, koss; 242 unsigned long ss_sp; 243 int ret, err = 0; 244 mm_segment_t old_fs = get_fs(); 245 246 if (uss) { 247 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 248 return -EFAULT; 249 err |= __get_user(ss_sp, &uss->ss_sp); 250 err |= __get_user(kss.ss_size, &uss->ss_size); 251 err |= __get_user(kss.ss_flags, &uss->ss_flags); 252 if (err) 253 return -EFAULT; 254 kss.ss_sp = (void __user *) ss_sp; 255 } 256 257 set_fs (KERNEL_DS); 258 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL), 259 (stack_t __force __user *) (uoss ? &koss : NULL), 260 regs->gprs[15]); 261 set_fs (old_fs); 262 263 if (!ret && uoss) { 264 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 265 return -EFAULT; 266 ss_sp = (unsigned long) koss.ss_sp; 267 err |= __put_user(ss_sp, &uoss->ss_sp); 268 err |= __put_user(koss.ss_size, &uoss->ss_size); 269 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 270 if (err) 271 return -EFAULT; 272 } 273 return ret; 274 } 275 276 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 277 { 278 _s390_regs_common32 regs32; 279 int err, i; 280 281 regs32.psw.mask = psw32_user_bits | 282 ((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER); 283 regs32.psw.addr = (__u32) regs->psw.addr | 284 (__u32)(regs->psw.mask & PSW_MASK_BA); 285 for (i = 0; i < NUM_GPRS; i++) 286 regs32.gprs[i] = (__u32) regs->gprs[i]; 287 save_access_regs(current->thread.acrs); 288 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs)); 289 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32)); 290 if (err) 291 return err; 292 save_fp_regs(¤t->thread.fp_regs); 293 /* s390_fp_regs and _s390_fp_regs32 are the same ! */ 294 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs, 295 sizeof(_s390_fp_regs32)); 296 } 297 298 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 299 { 300 _s390_regs_common32 regs32; 301 int err, i; 302 303 /* Alwys make any pending restarted system call return -EINTR */ 304 current_thread_info()->restart_block.fn = do_no_restart_syscall; 305 306 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32)); 307 if (err) 308 return err; 309 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) | 310 (__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 | 311 (__u64)(regs32.psw.addr & PSW32_ADDR_AMODE); 312 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN); 313 for (i = 0; i < NUM_GPRS; i++) 314 regs->gprs[i] = (__u64) regs32.gprs[i]; 315 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs)); 316 restore_access_regs(current->thread.acrs); 317 318 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs, 319 sizeof(_s390_fp_regs32)); 320 current->thread.fp_regs.fpc &= FPC_VALID_MASK; 321 if (err) 322 return err; 323 324 restore_fp_regs(¤t->thread.fp_regs); 325 clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */ 326 return 0; 327 } 328 329 static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs) 330 { 331 __u32 gprs_high[NUM_GPRS]; 332 int i; 333 334 for (i = 0; i < NUM_GPRS; i++) 335 gprs_high[i] = regs->gprs[i] >> 32; 336 337 return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high)); 338 } 339 340 static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs) 341 { 342 __u32 gprs_high[NUM_GPRS]; 343 int err, i; 344 345 err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high)); 346 if (err) 347 return err; 348 for (i = 0; i < NUM_GPRS; i++) 349 *(__u32 *)®s->gprs[i] = gprs_high[i]; 350 return 0; 351 } 352 353 asmlinkage long sys32_sigreturn(void) 354 { 355 struct pt_regs *regs = task_pt_regs(current); 356 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 357 sigset_t set; 358 359 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 360 goto badframe; 361 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 362 goto badframe; 363 set_current_blocked(&set); 364 if (restore_sigregs32(regs, &frame->sregs)) 365 goto badframe; 366 if (restore_sigregs_gprs_high(regs, frame->gprs_high)) 367 goto badframe; 368 return regs->gprs[2]; 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 set_current_blocked(&set); 389 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 390 goto badframe; 391 if (restore_sigregs_gprs_high(regs, frame->gprs_high)) 392 goto badframe; 393 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp); 394 st.ss_sp = compat_ptr(ss_sp); 395 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size); 396 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags); 397 if (err) 398 goto badframe; 399 set_fs (KERNEL_DS); 400 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]); 401 set_fs (old_fs); 402 return regs->gprs[2]; 403 badframe: 404 force_sig(SIGSEGV, current); 405 return 0; 406 } 407 408 /* 409 * Set up a signal frame. 410 */ 411 412 413 /* 414 * Determine which stack to use.. 415 */ 416 static inline void __user * 417 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 418 { 419 unsigned long sp; 420 421 /* Default to using normal stack */ 422 sp = (unsigned long) A(regs->gprs[15]); 423 424 /* Overflow on alternate signal stack gives SIGSEGV. */ 425 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 426 return (void __user *) -1UL; 427 428 /* This is the X/Open sanctioned signal stack switching. */ 429 if (ka->sa.sa_flags & SA_ONSTACK) { 430 if (! sas_ss_flags(sp)) 431 sp = current->sas_ss_sp + current->sas_ss_size; 432 } 433 434 return (void __user *)((sp - frame_size) & -8ul); 435 } 436 437 static inline int map_signal(int sig) 438 { 439 if (current_thread_info()->exec_domain 440 && current_thread_info()->exec_domain->signal_invmap 441 && sig < 32) 442 return current_thread_info()->exec_domain->signal_invmap[sig]; 443 else 444 return sig; 445 } 446 447 static int setup_frame32(int sig, struct k_sigaction *ka, 448 sigset_t *set, struct pt_regs * regs) 449 { 450 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32)); 451 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32))) 452 goto give_sigsegv; 453 454 if (frame == (void __user *) -1UL) 455 goto give_sigsegv; 456 457 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32)) 458 goto give_sigsegv; 459 460 if (save_sigregs32(regs, &frame->sregs)) 461 goto give_sigsegv; 462 if (save_sigregs_gprs_high(regs, frame->gprs_high)) 463 goto give_sigsegv; 464 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs)) 465 goto give_sigsegv; 466 467 /* Set up to return from userspace. If provided, use a stub 468 already in userspace. */ 469 if (ka->sa.sa_flags & SA_RESTORER) { 470 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE; 471 } else { 472 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE; 473 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 474 (u16 __force __user *)(frame->retcode))) 475 goto give_sigsegv; 476 } 477 478 /* Set up backchain. */ 479 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 480 goto give_sigsegv; 481 482 /* Set up registers for signal handler */ 483 regs->gprs[15] = (__force __u64) frame; 484 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */ 485 regs->psw.addr = (__force __u64) ka->sa.sa_handler; 486 487 regs->gprs[2] = map_signal(sig); 488 regs->gprs[3] = (__force __u64) &frame->sc; 489 490 /* We forgot to include these in the sigcontext. 491 To avoid breaking binary compatibility, they are passed as args. */ 492 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 493 sig == SIGTRAP || sig == SIGFPE) { 494 /* set extra registers only for synchronous signals */ 495 regs->gprs[4] = regs->int_code & 127; 496 regs->gprs[5] = regs->int_parm_long; 497 } 498 499 /* Place signal number on stack to allow backtrace from handler. */ 500 if (__put_user(regs->gprs[2], (int __force __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 (frame == (void __user *) -1UL) 518 goto give_sigsegv; 519 520 if (copy_siginfo_to_user32(&frame->info, info)) 521 goto give_sigsegv; 522 523 /* Create the ucontext. */ 524 err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags); 525 err |= __put_user(0, &frame->uc.uc_link); 526 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 527 err |= __put_user(sas_ss_flags(regs->gprs[15]), 528 &frame->uc.uc_stack.ss_flags); 529 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 530 err |= save_sigregs32(regs, &frame->uc.uc_mcontext); 531 err |= save_sigregs_gprs_high(regs, frame->gprs_high); 532 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 533 if (err) 534 goto give_sigsegv; 535 536 /* Set up to return from userspace. If provided, use a stub 537 already in userspace. */ 538 if (ka->sa.sa_flags & SA_RESTORER) { 539 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE; 540 } else { 541 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE; 542 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 543 (u16 __force __user *)(frame->retcode)); 544 } 545 546 /* Set up backchain. */ 547 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 548 goto give_sigsegv; 549 550 /* Set up registers for signal handler */ 551 regs->gprs[15] = (__force __u64) frame; 552 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */ 553 regs->psw.addr = (__u64) ka->sa.sa_handler; 554 555 regs->gprs[2] = map_signal(sig); 556 regs->gprs[3] = (__force __u64) &frame->info; 557 regs->gprs[4] = (__force __u64) &frame->uc; 558 return 0; 559 560 give_sigsegv: 561 force_sigsegv(sig, current); 562 return -EFAULT; 563 } 564 565 /* 566 * OK, we're invoking a handler 567 */ 568 569 void handle_signal32(unsigned long sig, struct k_sigaction *ka, 570 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 571 { 572 int ret; 573 574 /* Set up the stack frame */ 575 if (ka->sa.sa_flags & SA_SIGINFO) 576 ret = setup_rt_frame32(sig, ka, info, oldset, regs); 577 else 578 ret = setup_frame32(sig, ka, oldset, regs); 579 if (ret) 580 return; 581 signal_delivered(sig, info, ka, regs, 582 test_thread_flag(TIF_SINGLE_STEP)); 583 } 584 585