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 33typedef struct 34{ 35 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 36 struct sigcontext32 sc; 37 _sigregs32 sregs; 38 int signo; 39 _sigregs_ext32 sregs_ext; 40 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ 41} sigframe32; 42 43typedef struct 44{ 45 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 46 __u16 svc_insn; 47 compat_siginfo_t info; 48 struct ucontext32 uc; 49} rt_sigframe32; 50 51static inline void sigset_to_sigset32(unsigned long *set64, 52 compat_sigset_word *set32) 53{ 54 set32[0] = (compat_sigset_word) set64[0]; 55 set32[1] = (compat_sigset_word)(set64[0] >> 32); 56} 57 58static inline void sigset32_to_sigset(compat_sigset_word *set32, 59 unsigned long *set64) 60{ 61 set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32); 62} 63 64int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from) 65{ 66 int err; 67 68 /* If you change siginfo_t structure, please be sure 69 this code is fixed accordingly. 70 It should never copy any pad contained in the structure 71 to avoid security leaks, but must copy the generic 72 3 ints plus the relevant union member. 73 This routine must convert siginfo from 64bit to 32bit as well 74 at the same time. */ 75 err = __put_user(from->si_signo, &to->si_signo); 76 err |= __put_user(from->si_errno, &to->si_errno); 77 err |= __put_user((short)from->si_code, &to->si_code); 78 if (from->si_code < 0) 79 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 80 else { 81 switch (from->si_code >> 16) { 82 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 83 case __SI_MESGQ >> 16: 84 err |= __put_user(from->si_int, &to->si_int); 85 /* fallthrough */ 86 case __SI_KILL >> 16: 87 err |= __put_user(from->si_pid, &to->si_pid); 88 err |= __put_user(from->si_uid, &to->si_uid); 89 break; 90 case __SI_CHLD >> 16: 91 err |= __put_user(from->si_pid, &to->si_pid); 92 err |= __put_user(from->si_uid, &to->si_uid); 93 err |= __put_user(from->si_utime, &to->si_utime); 94 err |= __put_user(from->si_stime, &to->si_stime); 95 err |= __put_user(from->si_status, &to->si_status); 96 break; 97 case __SI_FAULT >> 16: 98 err |= __put_user((unsigned long) from->si_addr, 99 &to->si_addr); 100 break; 101 case __SI_POLL >> 16: 102 err |= __put_user(from->si_band, &to->si_band); 103 err |= __put_user(from->si_fd, &to->si_fd); 104 break; 105 case __SI_TIMER >> 16: 106 err |= __put_user(from->si_tid, &to->si_tid); 107 err |= __put_user(from->si_overrun, &to->si_overrun); 108 err |= __put_user(from->si_int, &to->si_int); 109 break; 110 default: 111 break; 112 } 113 } 114 return err ? -EFAULT : 0; 115} 116 117int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 118{ 119 int err; 120 u32 tmp; 121 122 err = __get_user(to->si_signo, &from->si_signo); 123 err |= __get_user(to->si_errno, &from->si_errno); 124 err |= __get_user(to->si_code, &from->si_code); 125 126 if (to->si_code < 0) 127 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 128 else { 129 switch (to->si_code >> 16) { 130 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 131 case __SI_MESGQ >> 16: 132 err |= __get_user(to->si_int, &from->si_int); 133 /* fallthrough */ 134 case __SI_KILL >> 16: 135 err |= __get_user(to->si_pid, &from->si_pid); 136 err |= __get_user(to->si_uid, &from->si_uid); 137 break; 138 case __SI_CHLD >> 16: 139 err |= __get_user(to->si_pid, &from->si_pid); 140 err |= __get_user(to->si_uid, &from->si_uid); 141 err |= __get_user(to->si_utime, &from->si_utime); 142 err |= __get_user(to->si_stime, &from->si_stime); 143 err |= __get_user(to->si_status, &from->si_status); 144 break; 145 case __SI_FAULT >> 16: 146 err |= __get_user(tmp, &from->si_addr); 147 to->si_addr = (void __force __user *) 148 (u64) (tmp & PSW32_ADDR_INSN); 149 break; 150 case __SI_POLL >> 16: 151 err |= __get_user(to->si_band, &from->si_band); 152 err |= __get_user(to->si_fd, &from->si_fd); 153 break; 154 case __SI_TIMER >> 16: 155 err |= __get_user(to->si_tid, &from->si_tid); 156 err |= __get_user(to->si_overrun, &from->si_overrun); 157 err |= __get_user(to->si_int, &from->si_int); 158 break; 159 default: 160 break; 161 } 162 } 163 return err ? -EFAULT : 0; 164} 165 166/* Store registers needed to create the signal frame */ 167static void store_sigregs(void) 168{ 169 int i; 170 171 save_access_regs(current->thread.acrs); 172 save_fp_ctl(¤t->thread.fp_regs.fpc); 173 if (current->thread.vxrs) { 174 save_vx_regs(current->thread.vxrs); 175 for (i = 0; i < __NUM_FPRS; i++) 176 current->thread.fp_regs.fprs[i] = 177 *(freg_t *)(current->thread.vxrs + i); 178 } else 179 save_fp_regs(current->thread.fp_regs.fprs); 180} 181 182/* Load registers after signal return */ 183static void load_sigregs(void) 184{ 185 int i; 186 187 restore_access_regs(current->thread.acrs); 188 /* restore_fp_ctl is done in restore_sigregs */ 189 if (current->thread.vxrs) { 190 for (i = 0; i < __NUM_FPRS; i++) 191 *(freg_t *)(current->thread.vxrs + i) = 192 current->thread.fp_regs.fprs[i]; 193 restore_vx_regs(current->thread.vxrs); 194 } else 195 restore_fp_regs(current->thread.fp_regs.fprs); 196} 197 198static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 199{ 200 _sigregs32 user_sregs; 201 int i; 202 203 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32); 204 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI; 205 user_sregs.regs.psw.mask |= PSW32_USER_BITS; 206 user_sregs.regs.psw.addr = (__u32) regs->psw.addr | 207 (__u32)(regs->psw.mask & PSW_MASK_BA); 208 for (i = 0; i < NUM_GPRS; i++) 209 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i]; 210 memcpy(&user_sregs.regs.acrs, current->thread.acrs, 211 sizeof(user_sregs.regs.acrs)); 212 memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs, 213 sizeof(user_sregs.fpregs)); 214 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32))) 215 return -EFAULT; 216 return 0; 217} 218 219static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 220{ 221 _sigregs32 user_sregs; 222 int i; 223 224 /* Alwys make any pending restarted system call return -EINTR */ 225 current->restart_block.fn = do_no_restart_syscall; 226 227 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs))) 228 return -EFAULT; 229 230 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI)) 231 return -EINVAL; 232 233 /* Loading the floating-point-control word can fail. Do that first. */ 234 if (restore_fp_ctl(&user_sregs.fpregs.fpc)) 235 return -EINVAL; 236 237 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */ 238 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) | 239 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 | 240 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 | 241 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE); 242 /* Check for invalid user address space control. */ 243 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) 244 regs->psw.mask = PSW_ASC_PRIMARY | 245 (regs->psw.mask & ~PSW_MASK_ASC); 246 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN); 247 for (i = 0; i < NUM_GPRS; i++) 248 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i]; 249 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, 250 sizeof(current->thread.acrs)); 251 252 memcpy(¤t->thread.fp_regs, &user_sregs.fpregs, 253 sizeof(current->thread.fp_regs)); 254 255 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */ 256 return 0; 257} 258 259static int save_sigregs_ext32(struct pt_regs *regs, 260 _sigregs_ext32 __user *sregs_ext) 261{ 262 __u32 gprs_high[NUM_GPRS]; 263 __u64 vxrs[__NUM_VXRS_LOW]; 264 int i; 265 266 /* Save high gprs to signal stack */ 267 for (i = 0; i < NUM_GPRS; i++) 268 gprs_high[i] = regs->gprs[i] >> 32; 269 if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high, 270 sizeof(sregs_ext->gprs_high))) 271 return -EFAULT; 272 273 /* Save vector registers to signal stack */ 274 if (current->thread.vxrs) { 275 for (i = 0; i < __NUM_VXRS_LOW; i++) 276 vxrs[i] = *((__u64 *)(current->thread.vxrs + i) + 1); 277 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs, 278 sizeof(sregs_ext->vxrs_low)) || 279 __copy_to_user(&sregs_ext->vxrs_high, 280 current->thread.vxrs + __NUM_VXRS_LOW, 281 sizeof(sregs_ext->vxrs_high))) 282 return -EFAULT; 283 } 284 return 0; 285} 286 287static int restore_sigregs_ext32(struct pt_regs *regs, 288 _sigregs_ext32 __user *sregs_ext) 289{ 290 __u32 gprs_high[NUM_GPRS]; 291 __u64 vxrs[__NUM_VXRS_LOW]; 292 int i; 293 294 /* Restore high gprs from signal stack */ 295 if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high, 296 sizeof(sregs_ext->gprs_high))) 297 return -EFAULT; 298 for (i = 0; i < NUM_GPRS; i++) 299 *(__u32 *)®s->gprs[i] = gprs_high[i]; 300 301 /* Restore vector registers from signal stack */ 302 if (current->thread.vxrs) { 303 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low, 304 sizeof(sregs_ext->vxrs_low)) || 305 __copy_from_user(current->thread.vxrs + __NUM_VXRS_LOW, 306 &sregs_ext->vxrs_high, 307 sizeof(sregs_ext->vxrs_high))) 308 return -EFAULT; 309 for (i = 0; i < __NUM_VXRS_LOW; i++) 310 *((__u64 *)(current->thread.vxrs + i) + 1) = vxrs[i]; 311 } 312 return 0; 313} 314 315COMPAT_SYSCALL_DEFINE0(sigreturn) 316{ 317 struct pt_regs *regs = task_pt_regs(current); 318 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 319 compat_sigset_t cset; 320 sigset_t set; 321 322 if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 323 goto badframe; 324 sigset32_to_sigset(cset.sig, set.sig); 325 set_current_blocked(&set); 326 if (restore_sigregs32(regs, &frame->sregs)) 327 goto badframe; 328 if (restore_sigregs_ext32(regs, &frame->sregs_ext)) 329 goto badframe; 330 load_sigregs(); 331 return regs->gprs[2]; 332badframe: 333 force_sig(SIGSEGV, current); 334 return 0; 335} 336 337COMPAT_SYSCALL_DEFINE0(rt_sigreturn) 338{ 339 struct pt_regs *regs = task_pt_regs(current); 340 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 341 compat_sigset_t cset; 342 sigset_t set; 343 344 if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset))) 345 goto badframe; 346 sigset32_to_sigset(cset.sig, set.sig); 347 set_current_blocked(&set); 348 if (compat_restore_altstack(&frame->uc.uc_stack)) 349 goto badframe; 350 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 351 goto badframe; 352 if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 353 goto badframe; 354 load_sigregs(); 355 return regs->gprs[2]; 356badframe: 357 force_sig(SIGSEGV, current); 358 return 0; 359} 360 361/* 362 * Set up a signal frame. 363 */ 364 365 366/* 367 * Determine which stack to use.. 368 */ 369static inline void __user * 370get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 371{ 372 unsigned long sp; 373 374 /* Default to using normal stack */ 375 sp = (unsigned long) A(regs->gprs[15]); 376 377 /* Overflow on alternate signal stack gives SIGSEGV. */ 378 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 379 return (void __user *) -1UL; 380 381 /* This is the X/Open sanctioned signal stack switching. */ 382 if (ka->sa.sa_flags & SA_ONSTACK) { 383 if (! sas_ss_flags(sp)) 384 sp = current->sas_ss_sp + current->sas_ss_size; 385 } 386 387 return (void __user *)((sp - frame_size) & -8ul); 388} 389 390static int setup_frame32(struct ksignal *ksig, sigset_t *set, 391 struct pt_regs *regs) 392{ 393 int sig = ksig->sig; 394 sigframe32 __user *frame; 395 struct sigcontext32 sc; 396 unsigned long restorer; 397 size_t frame_size; 398 399 /* 400 * gprs_high are always present for 31-bit compat tasks. 401 * The space for vector registers is only allocated if 402 * the machine supports it 403 */ 404 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved); 405 if (!MACHINE_HAS_VX) 406 frame_size -= sizeof(frame->sregs_ext.vxrs_low) + 407 sizeof(frame->sregs_ext.vxrs_high); 408 frame = get_sigframe(&ksig->ka, regs, frame_size); 409 if (frame == (void __user *) -1UL) 410 return -EFAULT; 411 412 /* Set up backchain. */ 413 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 414 return -EFAULT; 415 416 /* Create struct sigcontext32 on the signal stack */ 417 sigset_to_sigset32(set->sig, sc.oldmask); 418 sc.sregs = (__u32)(unsigned long __force) &frame->sregs; 419 if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc))) 420 return -EFAULT; 421 422 /* Store registers needed to create the signal frame */ 423 store_sigregs(); 424 425 /* Create _sigregs32 on the signal stack */ 426 if (save_sigregs32(regs, &frame->sregs)) 427 return -EFAULT; 428 429 /* Place signal number on stack to allow backtrace from handler. */ 430 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo)) 431 return -EFAULT; 432 433 /* Create _sigregs_ext32 on the signal stack */ 434 if (save_sigregs_ext32(regs, &frame->sregs_ext)) 435 return -EFAULT; 436 437 /* Set up to return from userspace. If provided, use a stub 438 already in userspace. */ 439 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 440 restorer = (unsigned long __force) 441 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 442 } else { 443 /* Signal frames without vectors registers are short ! */ 444 __u16 __user *svc = (void __user *) frame + frame_size - 2; 445 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc)) 446 return -EFAULT; 447 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 448 } 449 450 /* Set up registers for signal handler */ 451 regs->gprs[14] = restorer; 452 regs->gprs[15] = (__force __u64) frame; 453 /* Force 31 bit amode and default user address space control. */ 454 regs->psw.mask = PSW_MASK_BA | 455 (PSW_USER_BITS & PSW_MASK_ASC) | 456 (regs->psw.mask & ~PSW_MASK_ASC); 457 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler; 458 459 regs->gprs[2] = sig; 460 regs->gprs[3] = (__force __u64) &frame->sc; 461 462 /* We forgot to include these in the sigcontext. 463 To avoid breaking binary compatibility, they are passed as args. */ 464 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 465 sig == SIGTRAP || sig == SIGFPE) { 466 /* set extra registers only for synchronous signals */ 467 regs->gprs[4] = regs->int_code & 127; 468 regs->gprs[5] = regs->int_parm_long; 469 regs->gprs[6] = task_thread_info(current)->last_break; 470 } 471 472 return 0; 473} 474 475static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set, 476 struct pt_regs *regs) 477{ 478 compat_sigset_t cset; 479 rt_sigframe32 __user *frame; 480 unsigned long restorer; 481 size_t frame_size; 482 u32 uc_flags; 483 484 frame_size = sizeof(*frame) - 485 sizeof(frame->uc.uc_mcontext_ext.__reserved); 486 /* 487 * gprs_high are always present for 31-bit compat tasks. 488 * The space for vector registers is only allocated if 489 * the machine supports it 490 */ 491 uc_flags = UC_GPRS_HIGH; 492 if (MACHINE_HAS_VX) { 493 if (current->thread.vxrs) 494 uc_flags |= UC_VXRS; 495 } else 496 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) + 497 sizeof(frame->uc.uc_mcontext_ext.vxrs_high); 498 frame = get_sigframe(&ksig->ka, regs, frame_size); 499 if (frame == (void __user *) -1UL) 500 return -EFAULT; 501 502 /* Set up backchain. */ 503 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 504 return -EFAULT; 505 506 /* Set up to return from userspace. If provided, use a stub 507 already in userspace. */ 508 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 509 restorer = (unsigned long __force) 510 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 511 } else { 512 __u16 __user *svc = &frame->svc_insn; 513 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc)) 514 return -EFAULT; 515 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 516 } 517 518 /* Create siginfo on the signal stack */ 519 if (copy_siginfo_to_user32(&frame->info, &ksig->info)) 520 return -EFAULT; 521 522 /* Store registers needed to create the signal frame */ 523 store_sigregs(); 524 525 /* Create ucontext on the signal stack. */ 526 sigset_to_sigset32(set->sig, cset.sig); 527 if (__put_user(uc_flags, &frame->uc.uc_flags) || 528 __put_user(0, &frame->uc.uc_link) || 529 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || 530 save_sigregs32(regs, &frame->uc.uc_mcontext) || 531 __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) || 532 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 533 return -EFAULT; 534 535 /* Set up registers for signal handler */ 536 regs->gprs[14] = restorer; 537 regs->gprs[15] = (__force __u64) frame; 538 /* Force 31 bit amode and default user address space control. */ 539 regs->psw.mask = PSW_MASK_BA | 540 (PSW_USER_BITS & PSW_MASK_ASC) | 541 (regs->psw.mask & ~PSW_MASK_ASC); 542 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler; 543 544 regs->gprs[2] = ksig->sig; 545 regs->gprs[3] = (__force __u64) &frame->info; 546 regs->gprs[4] = (__force __u64) &frame->uc; 547 regs->gprs[5] = task_thread_info(current)->last_break; 548 return 0; 549} 550 551/* 552 * OK, we're invoking a handler 553 */ 554 555void handle_signal32(struct ksignal *ksig, sigset_t *oldset, 556 struct pt_regs *regs) 557{ 558 int ret; 559 560 /* Set up the stack frame */ 561 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 562 ret = setup_rt_frame32(ksig, oldset, regs); 563 else 564 ret = setup_frame32(ksig, oldset, regs); 565 566 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); 567} 568 569