netbsd32_signal.c revision 1.45.4.1
1 /* $NetBSD: netbsd32_signal.c,v 1.45.4.1 2020/04/13 08:04:16 martin Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2001 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: netbsd32_signal.c,v 1.45.4.1 2020/04/13 08:04:16 martin Exp $"); 31 32 #if defined(_KERNEL_OPT) 33 #include "opt_ktrace.h" 34 #endif 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/mount.h> 39 #include <sys/stat.h> 40 #include <sys/time.h> 41 #include <sys/signalvar.h> 42 #include <sys/ktrace.h> 43 #include <sys/proc.h> 44 #include <sys/wait.h> 45 #include <sys/dirent.h> 46 47 #include <uvm/uvm_extern.h> 48 49 #include <compat/netbsd32/netbsd32.h> 50 #include <compat/netbsd32/netbsd32_conv.h> 51 #include <compat/netbsd32/netbsd32_syscallargs.h> 52 53 #include <compat/sys/signal.h> 54 #include <compat/sys/signalvar.h> 55 #include <compat/sys/siginfo.h> 56 #include <compat/sys/ucontext.h> 57 #include <compat/common/compat_sigaltstack.h> 58 59 int 60 netbsd32_sigaction(struct lwp *l, const struct netbsd32_sigaction_args *uap, register_t *retval) 61 { 62 /* { 63 syscallarg(int) signum; 64 syscallarg(const netbsd32_sigactionp_t) nsa; 65 syscallarg(netbsd32_sigactionp_t) osa; 66 } */ 67 struct sigaction nsa, osa; 68 struct netbsd32_sigaction13 *sa32p, sa32; 69 int error; 70 71 if (SCARG_P32(uap, nsa)) { 72 sa32p = SCARG_P32(uap, nsa); 73 if (copyin(sa32p, &sa32, sizeof(sa32))) 74 return EFAULT; 75 nsa.sa_handler = (void *)NETBSD32PTR64(sa32.netbsd32_sa_handler); 76 memset(&nsa.sa_mask, 0, sizeof(nsa.sa_mask)); 77 nsa.sa_mask.__bits[0] = sa32.netbsd32_sa_mask; 78 nsa.sa_flags = sa32.netbsd32_sa_flags; 79 } 80 error = sigaction1(l, SCARG(uap, signum), 81 SCARG_P32(uap, nsa) ? &nsa : 0, 82 SCARG_P32(uap, osa) ? &osa : 0, 83 NULL, 0); 84 85 if (error) 86 return (error); 87 88 if (SCARG_P32(uap, osa)) { 89 NETBSD32PTR32(sa32.netbsd32_sa_handler, osa.sa_handler); 90 sa32.netbsd32_sa_mask = osa.sa_mask.__bits[0]; 91 sa32.netbsd32_sa_flags = osa.sa_flags; 92 sa32p = SCARG_P32(uap, osa); 93 if (copyout(&sa32, sa32p, sizeof(sa32))) 94 return EFAULT; 95 } 96 97 return (0); 98 } 99 100 int 101 netbsd32___sigaltstack14(struct lwp *l, const struct netbsd32___sigaltstack14_args *uap, register_t *retval) 102 { 103 /* { 104 syscallarg(const netbsd32_sigaltstackp_t) nss; 105 syscallarg(netbsd32_sigaltstackp_t) oss; 106 } */ 107 compat_sigaltstack(uap, netbsd32_sigaltstack, SS_ONSTACK, SS_DISABLE); 108 } 109 110 /* ARGSUSED */ 111 int 112 netbsd32___sigaction14(struct lwp *l, const struct netbsd32___sigaction14_args *uap, register_t *retval) 113 { 114 /* { 115 syscallarg(int) signum; 116 syscallarg(const struct sigaction *) nsa; 117 syscallarg(struct sigaction *) osa; 118 } */ 119 struct netbsd32_sigaction sa32; 120 struct sigaction nsa, osa; 121 int error; 122 123 if (SCARG_P32(uap, nsa)) { 124 error = copyin(SCARG_P32(uap, nsa), &sa32, sizeof(sa32)); 125 if (error) 126 return (error); 127 nsa.sa_handler = NETBSD32PTR64(sa32.netbsd32_sa_handler); 128 nsa.sa_mask = sa32.netbsd32_sa_mask; 129 nsa.sa_flags = sa32.netbsd32_sa_flags; 130 } 131 error = sigaction1(l, SCARG(uap, signum), 132 SCARG_P32(uap, nsa) ? &nsa : 0, 133 SCARG_P32(uap, osa) ? &osa : 0, 134 NULL, 0); 135 if (error) 136 return (error); 137 if (SCARG_P32(uap, osa)) { 138 NETBSD32PTR32(sa32.netbsd32_sa_handler, osa.sa_handler); 139 sa32.netbsd32_sa_mask = osa.sa_mask; 140 sa32.netbsd32_sa_flags = osa.sa_flags; 141 error = copyout(&sa32, SCARG_P32(uap, osa), sizeof(sa32)); 142 if (error) 143 return (error); 144 } 145 return (0); 146 } 147 148 /* ARGSUSED */ 149 int 150 netbsd32___sigaction_sigtramp(struct lwp *l, const struct netbsd32___sigaction_sigtramp_args *uap, register_t *retval) 151 { 152 /* { 153 syscallarg(int) signum; 154 syscallarg(const netbsd32_sigactionp_t) nsa; 155 syscallarg(netbsd32_sigactionp_t) osa; 156 syscallarg(netbsd32_voidp) tramp; 157 syscallarg(int) vers; 158 } */ 159 struct netbsd32_sigaction sa32; 160 struct sigaction nsa, osa; 161 int error; 162 163 if (SCARG_P32(uap, nsa)) { 164 error = copyin(SCARG_P32(uap, nsa), &sa32, sizeof(sa32)); 165 if (error) 166 return (error); 167 nsa.sa_handler = NETBSD32PTR64(sa32.netbsd32_sa_handler); 168 nsa.sa_mask = sa32.netbsd32_sa_mask; 169 nsa.sa_flags = sa32.netbsd32_sa_flags; 170 } 171 error = sigaction1(l, SCARG(uap, signum), 172 SCARG_P32(uap, nsa) ? &nsa : 0, 173 SCARG_P32(uap, osa) ? &osa : 0, 174 SCARG_P32(uap, tramp), SCARG(uap, vers)); 175 if (error) 176 return (error); 177 if (SCARG_P32(uap, osa)) { 178 NETBSD32PTR32(sa32.netbsd32_sa_handler, osa.sa_handler); 179 sa32.netbsd32_sa_mask = osa.sa_mask; 180 sa32.netbsd32_sa_flags = osa.sa_flags; 181 error = copyout(&sa32, SCARG_P32(uap, osa), sizeof(sa32)); 182 if (error) 183 return (error); 184 } 185 return (0); 186 } 187 188 void 189 netbsd32_ksi32_to_ksi(struct _ksiginfo *si, const struct __ksiginfo32 *si32) 190 { 191 size_t i; 192 193 memset(si, 0, sizeof (*si)); 194 si->_signo = si32->_signo; 195 si->_code = si32->_code; 196 si->_errno = si32->_errno; 197 198 if (si32->_code == SI_NOINFO) 199 return; 200 else if (si32->_code <= 0) /* codes described in siginfo(2) */ 201 goto fill_rt; 202 203 switch (si32->_signo) { 204 case SIGILL: 205 case SIGFPE: 206 case SIGBUS: 207 case SIGSEGV: 208 fill_fault: 209 si->_reason._fault._addr = 210 NETBSD32IPTR64(si32->_reason._fault._addr); 211 si->_reason._fault._trap = si32->_reason._fault._trap; 212 break; 213 case SIGTRAP: 214 switch (si32->_code) { 215 case TRAP_EXEC: 216 break; 217 case TRAP_CHLD: 218 case TRAP_LWP: 219 si->_reason._ptrace_state._pe_report_event = 220 si32->_reason._ptrace_state._pe_report_event; 221 CTASSERT(sizeof(si->_reason._ptrace_state._option._pe_other_pid) == 222 sizeof(si->_reason._ptrace_state._option._pe_lwp)); 223 si->_reason._ptrace_state._option._pe_other_pid = 224 si32->_reason._ptrace_state._option._pe_other_pid; 225 break; 226 case TRAP_SCE: 227 case TRAP_SCX: 228 si->_reason._syscall._sysnum = 229 si32->_reason._syscall._sysnum; 230 si->_reason._syscall._retval[0] = 231 si32->_reason._syscall._retval[0]; 232 si->_reason._syscall._retval[1] = 233 si32->_reason._syscall._retval[1]; 234 si->_reason._syscall._error = 235 si32->_reason._syscall._error; 236 for (i = 0; 237 i < __arraycount(si->_reason._syscall._args); i++) 238 si->_reason._syscall._args[i] = 239 si32->_reason._syscall._args[i]; 240 break; 241 default: 242 goto fill_fault; 243 } 244 break; 245 case SIGALRM: 246 case SIGVTALRM: 247 case SIGPROF: 248 default: /* see sigqueue() and kill1() */ 249 fill_rt: 250 si->_reason._rt._pid = si32->_reason._rt._pid; 251 si->_reason._rt._uid = si32->_reason._rt._uid; 252 si->_reason._rt._value.sival_int = 253 si32->_reason._rt._value.sival_int; 254 break; 255 case SIGURG: 256 case SIGIO: 257 si->_reason._poll._band = si32->_reason._poll._band; 258 si->_reason._poll._fd = si32->_reason._poll._fd; 259 break; 260 case SIGCHLD: 261 si->_reason._child._pid = si32->_reason._child._pid; 262 si->_reason._child._uid = si32->_reason._child._uid; 263 si->_reason._child._status = si32->_reason._child._status; 264 si->_reason._child._utime = si32->_reason._child._utime; 265 si->_reason._child._stime = si32->_reason._child._stime; 266 break; 267 } 268 } 269 270 void 271 netbsd32_si32_to_si(siginfo_t *si, const siginfo32_t *si32) 272 { 273 274 memset(si, 0, sizeof (*si)); 275 netbsd32_ksi32_to_ksi(&si->_info, &si32->_info); 276 } 277 278 static void 279 netbsd32_ksi_to_ksi32(struct __ksiginfo32 *si32, const struct _ksiginfo *si) 280 { 281 size_t i; 282 283 memset(si32, 0, sizeof (*si32)); 284 si32->_signo = si->_signo; 285 si32->_code = si->_code; 286 si32->_errno = si->_errno; 287 288 if (si->_code == SI_NOINFO) 289 return; 290 else if (si->_code <= 0) /* codes described in siginfo(2) */ 291 goto fill_rt; 292 293 switch (si->_signo) { 294 case SIGILL: 295 case SIGFPE: 296 case SIGBUS: 297 case SIGSEGV: 298 fill_fault: 299 si32->_reason._fault._addr = 300 NETBSD32PTR32I(si->_reason._fault._addr); 301 si32->_reason._fault._trap = si->_reason._fault._trap; 302 break; 303 case SIGTRAP: 304 switch (si->_code) { 305 case TRAP_EXEC: 306 break; 307 case TRAP_CHLD: 308 case TRAP_LWP: 309 si32->_reason._ptrace_state._pe_report_event = 310 si->_reason._ptrace_state._pe_report_event; 311 CTASSERT(sizeof(si32->_reason._ptrace_state._option._pe_other_pid) == 312 sizeof(si32->_reason._ptrace_state._option._pe_lwp)); 313 si32->_reason._ptrace_state._option._pe_other_pid = 314 si->_reason._ptrace_state._option._pe_other_pid; 315 break; 316 case TRAP_SCE: 317 case TRAP_SCX: 318 si32->_reason._syscall._sysnum = 319 si->_reason._syscall._sysnum; 320 si32->_reason._syscall._retval[0] = 321 si->_reason._syscall._retval[0]; 322 si32->_reason._syscall._retval[1] = 323 si->_reason._syscall._retval[1]; 324 si32->_reason._syscall._error = 325 si->_reason._syscall._error; 326 for (i = 0; 327 i < __arraycount(si->_reason._syscall._args); i++) 328 si32->_reason._syscall._args[i] = 329 si->_reason._syscall._args[i]; 330 break; 331 default: 332 goto fill_fault; 333 } 334 break; 335 case SIGALRM: 336 case SIGVTALRM: 337 case SIGPROF: 338 default: /* see sigqueue() and kill1() */ 339 fill_rt: 340 si32->_reason._rt._pid = si->_reason._rt._pid; 341 si32->_reason._rt._uid = si->_reason._rt._uid; 342 si32->_reason._rt._value.sival_int = 343 si->_reason._rt._value.sival_int; 344 break; 345 case SIGURG: 346 case SIGIO: 347 si32->_reason._poll._band = si->_reason._poll._band; 348 si32->_reason._poll._fd = si->_reason._poll._fd; 349 break; 350 case SIGCHLD: 351 si32->_reason._child._pid = si->_reason._child._pid; 352 si32->_reason._child._uid = si->_reason._child._uid; 353 si32->_reason._child._status = si->_reason._child._status; 354 si32->_reason._child._utime = si->_reason._child._utime; 355 si32->_reason._child._stime = si->_reason._child._stime; 356 break; 357 } 358 } 359 360 void 361 netbsd32_si_to_si32(siginfo32_t *si32, const siginfo_t *si) 362 { 363 364 memset(si32, 0, sizeof (*si32)); 365 netbsd32_ksi_to_ksi32(&si32->_info, &si->_info); 366 } 367 368 void 369 getucontext32(struct lwp *l, ucontext32_t *ucp) 370 { 371 struct proc *p = l->l_proc; 372 373 KASSERT(mutex_owned(p->p_lock)); 374 375 ucp->uc_flags = 0; 376 ucp->uc_link = (uint32_t)(intptr_t)l->l_ctxlink; 377 ucp->uc_sigmask = l->l_sigmask; 378 ucp->uc_flags |= _UC_SIGMASK; 379 380 /* 381 * The (unsupplied) definition of the `current execution stack' 382 * in the System V Interface Definition appears to allow returning 383 * the main context stack. 384 */ 385 if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) { 386 ucp->uc_stack.ss_sp = USRSTACK32; 387 ucp->uc_stack.ss_size = ctob(p->p_vmspace->vm_ssize); 388 ucp->uc_stack.ss_flags = 0; /* XXX, def. is Very Fishy */ 389 } else { 390 /* Simply copy alternate signal execution stack. */ 391 ucp->uc_stack.ss_sp = 392 (uint32_t)(intptr_t)l->l_sigstk.ss_sp; 393 ucp->uc_stack.ss_size = l->l_sigstk.ss_size; 394 ucp->uc_stack.ss_flags = l->l_sigstk.ss_flags; 395 } 396 ucp->uc_flags |= _UC_STACK; 397 mutex_exit(p->p_lock); 398 cpu_getmcontext32(l, &ucp->uc_mcontext, &ucp->uc_flags); 399 mutex_enter(p->p_lock); 400 } 401 402 int 403 netbsd32_getcontext(struct lwp *l, const struct netbsd32_getcontext_args *uap, register_t *retval) 404 { 405 /* { 406 syscallarg(netbsd32_ucontextp) ucp; 407 } */ 408 struct proc *p = l->l_proc; 409 ucontext32_t uc; 410 411 memset(&uc, 0, sizeof(uc)); 412 413 mutex_enter(p->p_lock); 414 getucontext32(l, &uc); 415 mutex_exit(p->p_lock); 416 417 return copyout(&uc, SCARG_P32(uap, ucp), sizeof (ucontext32_t)); 418 } 419 420 int 421 setucontext32(struct lwp *l, const ucontext32_t *ucp) 422 { 423 struct proc *p = l->l_proc; 424 int error; 425 426 KASSERT(mutex_owned(p->p_lock)); 427 428 if ((ucp->uc_flags & _UC_SIGMASK) != 0) { 429 error = sigprocmask1(l, SIG_SETMASK, &ucp->uc_sigmask, NULL); 430 if (error != 0) 431 return error; 432 } 433 434 mutex_exit(p->p_lock); 435 error = cpu_setmcontext32(l, &ucp->uc_mcontext, ucp->uc_flags); 436 mutex_enter(p->p_lock); 437 if (error != 0) 438 return (error); 439 440 l->l_ctxlink = (void *)(intptr_t)ucp->uc_link; 441 442 /* 443 * If there was stack information, update whether or not we are 444 * still running on an alternate signal stack. 445 */ 446 if ((ucp->uc_flags & _UC_STACK) != 0) { 447 if (ucp->uc_stack.ss_flags & SS_ONSTACK) 448 l->l_sigstk.ss_flags |= SS_ONSTACK; 449 else 450 l->l_sigstk.ss_flags &= ~SS_ONSTACK; 451 } 452 453 return 0; 454 } 455 456 /* ARGSUSED */ 457 int 458 netbsd32_setcontext(struct lwp *l, const struct netbsd32_setcontext_args *uap, register_t *retval) 459 { 460 /* { 461 syscallarg(netbsd32_ucontextp) ucp; 462 } */ 463 ucontext32_t uc; 464 int error; 465 struct proc *p = l->l_proc; 466 467 error = copyin(SCARG_P32(uap, ucp), &uc, sizeof (uc)); 468 if (error) 469 return (error); 470 if (!(uc.uc_flags & _UC_CPU)) 471 return (EINVAL); 472 mutex_enter(p->p_lock); 473 error = setucontext32(l, &uc); 474 mutex_exit(p->p_lock); 475 if (error) 476 return (error); 477 478 return (EJUSTRETURN); 479 } 480 481 static int 482 netbsd32_sigtimedwait_put_info(const void *src, void *dst, size_t size) 483 { 484 const siginfo_t *info = src; 485 siginfo32_t info32; 486 487 netbsd32_si_to_si32(&info32, info); 488 489 return copyout(&info32, dst, sizeof(info32)); 490 } 491 492 static int 493 netbsd32_sigtimedwait_fetch_timeout(const void *src, void *dst, size_t size) 494 { 495 struct timespec *ts = dst; 496 struct netbsd32_timespec ts32; 497 int error; 498 499 error = copyin(src, &ts32, sizeof(ts32)); 500 if (error) 501 return error; 502 503 netbsd32_to_timespec(&ts32, ts); 504 return 0; 505 } 506 507 static int 508 netbsd32_sigtimedwait_put_timeout(const void *src, void *dst, size_t size) 509 { 510 const struct timespec *ts = src; 511 struct netbsd32_timespec ts32; 512 513 netbsd32_from_timespec(ts, &ts32); 514 515 return copyout(&ts32, dst, sizeof(ts32)); 516 } 517 518 int 519 netbsd32_____sigtimedwait50(struct lwp *l, const struct netbsd32_____sigtimedwait50_args *uap, register_t *retval) 520 { 521 /* { 522 syscallarg(netbsd32_sigsetp_t) set; 523 syscallarg(netbsd32_siginfop_t) info; 524 syscallarg(netbsd32_timespec50p_t) timeout; 525 } */ 526 struct sys_____sigtimedwait50_args ua; 527 528 NETBSD32TOP_UAP(set, const sigset_t); 529 NETBSD32TOP_UAP(info, siginfo_t); 530 NETBSD32TOP_UAP(timeout, struct timespec); 531 532 return sigtimedwait1(l, &ua, retval, 533 copyin, 534 netbsd32_sigtimedwait_put_info, 535 netbsd32_sigtimedwait_fetch_timeout, 536 netbsd32_sigtimedwait_put_timeout); 537 } 538 539 int 540 netbsd32_sigqueueinfo(struct lwp *l, 541 const struct netbsd32_sigqueueinfo_args *uap, register_t *retval) 542 { 543 /* { 544 syscallarg(pid_t) pid; 545 syscallarg(const netbsd32_siginfop_t) info; 546 } */ 547 struct __ksiginfo32 ksi32; 548 ksiginfo_t ksi; 549 int error; 550 551 if ((error = copyin(SCARG_P32(uap, info), &ksi32, 552 sizeof(ksi32))) != 0) 553 return error; 554 555 KSI_INIT(&ksi); 556 netbsd32_ksi32_to_ksi(&ksi.ksi_info, &ksi32); 557 558 return kill1(l, SCARG(uap, pid), &ksi, retval); 559 } 560 561 struct netbsd32_ktr_psig { 562 int signo; 563 netbsd32_pointer_t action; 564 sigset_t mask; 565 int code; 566 /* and optional siginfo_t */ 567 }; 568 569 #ifdef notyet 570 #ifdef KTRACE 571 void 572 netbsd32_ktrpsig(int sig, sig_t action, const sigset_t *mask, 573 const ksiginfo_t *ksi) 574 { 575 struct ktrace_entry *kte; 576 lwp_t *l = curlwp; 577 struct { 578 struct netbsd32_ktr_psig kp; 579 siginfo32_t si; 580 } *kbuf; 581 582 if (!KTRPOINT(l->l_proc, KTR_PSIG)) 583 return; 584 585 if (ktealloc(&kte, (void *)&kbuf, l, KTR_PSIG, sizeof(*kbuf))) 586 return; 587 588 kbuf->kp.signo = (char)sig; 589 NETBSD32PTR32(kbuf->kp.action, action); 590 kbuf->kp.mask = *mask; 591 592 if (ksi) { 593 kbuf->kp.code = KSI_TRAPCODE(ksi); 594 (void)memset(&kbuf->si, 0, sizeof(kbuf->si)); 595 netbsd32_ksi_to_ksi32(&kbuf->si._info, &ksi->ksi_info); 596 ktesethdrlen(kte, sizeof(*kbuf)); 597 } else { 598 kbuf->kp.code = 0; 599 ktesethdrlen(kte, sizeof(struct netbsd32_ktr_psig)); 600 } 601 602 ktraddentry(l, kte, KTA_WAITOK); 603 } 604 #endif 605 #endif 606
Indexes created Mon Sep 22 13:09:51 GMT 2025