compat_signal.c revision 03ff9a235a0602724fc54916469b6e0939c62c9b
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/smp_lock.h> 18#include <linux/kernel.h> 19#include <linux/signal.h> 20#include <linux/errno.h> 21#include <linux/wait.h> 22#include <linux/ptrace.h> 23#include <linux/unistd.h> 24#include <linux/stddef.h> 25#include <linux/tty.h> 26#include <linux/personality.h> 27#include <linux/binfmts.h> 28#include <asm/ucontext.h> 29#include <asm/uaccess.h> 30#include <asm/lowcore.h> 31#include "compat_linux.h" 32#include "compat_ptrace.h" 33 34#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 35 36typedef 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 45typedef 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 53int 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 109int 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 160asmlinkage long 161sys32_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 197asmlinkage long 198sys32_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 257asmlinkage long 258sys32_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 296static 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 317static 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 347asmlinkage 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 369badframe: 370 force_sig(SIGSEGV, current); 371 return 0; 372} 373 374asmlinkage 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 411badframe: 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 */ 424static inline void __user * 425get_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 /* This is the X/Open sanctioned signal stack switching. */ 433 if (ka->sa.sa_flags & SA_ONSTACK) { 434 if (! sas_ss_flags(sp)) 435 sp = current->sas_ss_sp + current->sas_ss_size; 436 } 437 438 /* This is the legacy signal stack switching. */ 439 else if (!user_mode(regs) && 440 !(ka->sa.sa_flags & SA_RESTORER) && 441 ka->sa.sa_restorer) { 442 sp = (unsigned long) ka->sa.sa_restorer; 443 } 444 445 return (void __user *)((sp - frame_size) & -8ul); 446} 447 448static inline int map_signal(int sig) 449{ 450 if (current_thread_info()->exec_domain 451 && current_thread_info()->exec_domain->signal_invmap 452 && sig < 32) 453 return current_thread_info()->exec_domain->signal_invmap[sig]; 454 else 455 return sig; 456} 457 458static int setup_frame32(int sig, struct k_sigaction *ka, 459 sigset_t *set, struct pt_regs * regs) 460{ 461 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32)); 462 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32))) 463 goto give_sigsegv; 464 465 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32)) 466 goto give_sigsegv; 467 468 if (save_sigregs32(regs, &frame->sregs)) 469 goto give_sigsegv; 470 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs)) 471 goto give_sigsegv; 472 473 /* Set up to return from userspace. If provided, use a stub 474 already in userspace. */ 475 if (ka->sa.sa_flags & SA_RESTORER) { 476 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 477 } else { 478 regs->gprs[14] = (__u64) frame->retcode; 479 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 480 (u16 __user *)(frame->retcode))) 481 goto give_sigsegv; 482 } 483 484 /* Set up backchain. */ 485 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 486 goto give_sigsegv; 487 488 /* Set up registers for signal handler */ 489 regs->gprs[15] = (__u64) frame; 490 regs->psw.addr = (__u64) ka->sa.sa_handler; 491 492 regs->gprs[2] = map_signal(sig); 493 regs->gprs[3] = (__u64) &frame->sc; 494 495 /* We forgot to include these in the sigcontext. 496 To avoid breaking binary compatibility, they are passed as args. */ 497 regs->gprs[4] = current->thread.trap_no; 498 regs->gprs[5] = current->thread.prot_addr; 499 500 /* Place signal number on stack to allow backtrace from handler. */ 501 if (__put_user(regs->gprs[2], (int __user *) &frame->signo)) 502 goto give_sigsegv; 503 return 0; 504 505give_sigsegv: 506 force_sigsegv(sig, current); 507 return -EFAULT; 508} 509 510static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info, 511 sigset_t *set, struct pt_regs * regs) 512{ 513 int err = 0; 514 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32)); 515 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32))) 516 goto give_sigsegv; 517 518 if (copy_siginfo_to_user32(&frame->info, info)) 519 goto give_sigsegv; 520 521 /* Create the ucontext. */ 522 err |= __put_user(0, &frame->uc.uc_flags); 523 err |= __put_user(0, &frame->uc.uc_link); 524 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 525 err |= __put_user(sas_ss_flags(regs->gprs[15]), 526 &frame->uc.uc_stack.ss_flags); 527 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 528 err |= save_sigregs32(regs, &frame->uc.uc_mcontext); 529 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 530 if (err) 531 goto give_sigsegv; 532 533 /* Set up to return from userspace. If provided, use a stub 534 already in userspace. */ 535 if (ka->sa.sa_flags & SA_RESTORER) { 536 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 537 } else { 538 regs->gprs[14] = (__u64) frame->retcode; 539 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 540 (u16 __user *)(frame->retcode)); 541 } 542 543 /* Set up backchain. */ 544 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 545 goto give_sigsegv; 546 547 /* Set up registers for signal handler */ 548 regs->gprs[15] = (__u64) frame; 549 regs->psw.addr = (__u64) ka->sa.sa_handler; 550 551 regs->gprs[2] = map_signal(sig); 552 regs->gprs[3] = (__u64) &frame->info; 553 regs->gprs[4] = (__u64) &frame->uc; 554 return 0; 555 556give_sigsegv: 557 force_sigsegv(sig, current); 558 return -EFAULT; 559} 560 561/* 562 * OK, we're invoking a handler 563 */ 564 565int 566handle_signal32(unsigned long sig, struct k_sigaction *ka, 567 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 568{ 569 int ret; 570 571 /* Set up the stack frame */ 572 if (ka->sa.sa_flags & SA_SIGINFO) 573 ret = setup_rt_frame32(sig, ka, info, oldset, regs); 574 else 575 ret = setup_frame32(sig, ka, oldset, regs); 576 577 if (ret == 0) { 578 spin_lock_irq(¤t->sighand->siglock); 579 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 580 if (!(ka->sa.sa_flags & SA_NODEFER)) 581 sigaddset(¤t->blocked,sig); 582 recalc_sigpending(); 583 spin_unlock_irq(¤t->sighand->siglock); 584 } 585 return ret; 586} 587 588