linux32_machdep.c revision 1.31
1 /* $NetBSD: linux32_machdep.c,v 1.31 2012/07/15 15:17:56 dsl Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Emmanuel Dreyfus 17 * 4. The name of the author may not be used to endorse or promote 18 * products derived from this software without specific prior written 19 * permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS'' 22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 23 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: linux32_machdep.c,v 1.31 2012/07/15 15:17:56 dsl Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/proc.h> 38 #include <sys/exec.h> 39 40 #include <machine/vmparam.h> 41 #include <machine/cpufunc.h> 42 #include <machine/netbsd32_machdep.h> 43 44 #include <compat/netbsd32/netbsd32.h> 45 #include <compat/netbsd32/netbsd32_syscallargs.h> 46 47 #include <compat/linux/common/linux_types.h> 48 #include <compat/linux/common/linux_emuldata.h> 49 #include <compat/linux/common/linux_signal.h> 50 #include <compat/linux/common/linux_errno.h> 51 #include <compat/linux/common/linux_exec.h> 52 #include <compat/linux/common/linux_ipc.h> 53 #include <compat/linux/common/linux_sem.h> 54 #include <compat/linux/linux_syscallargs.h> 55 56 #include <compat/linux32/common/linux32_types.h> 57 #include <compat/linux32/common/linux32_errno.h> 58 #include <compat/linux32/common/linux32_machdep.h> 59 #include <compat/linux32/common/linux32_signal.h> 60 #include <compat/linux32/common/linux32_exec.h> 61 #include <compat/linux32/common/linux32_ipc.h> 62 #include <compat/linux32/common/linux32_sem.h> 63 #include <compat/linux32/linux32_syscallargs.h> 64 65 #ifdef DEBUG_LINUX 66 #define DPRINTF(a) uprintf a 67 #else 68 #define DPRINTF(a) 69 #endif 70 71 extern char linux32_sigcode[]; 72 extern char linux32_rt_sigcode[]; 73 extern char linux32_esigcode[]; 74 75 static void linux32_save_ucontext(struct lwp *, struct trapframe *, 76 const sigset_t *, struct sigaltstack *, struct linux32_ucontext *); 77 static void linux32_save_sigcontext(struct lwp *, struct trapframe *, 78 const sigset_t *, struct linux32_sigcontext *); 79 static void linux32_rt_sendsig(const ksiginfo_t *, const sigset_t *); 80 static void linux32_old_sendsig(const ksiginfo_t *, const sigset_t *); 81 static int linux32_restore_sigcontext(struct lwp *, 82 struct linux32_sigcontext *, register_t *); 83 84 void 85 linux32_sendsig(const ksiginfo_t *ksi, const sigset_t *mask) 86 { 87 if (SIGACTION(curproc, ksi->ksi_signo).sa_flags & SA_SIGINFO) 88 linux32_rt_sendsig(ksi, mask); 89 else 90 linux32_old_sendsig(ksi, mask); 91 return; 92 } 93 94 void 95 linux32_old_sendsig(const ksiginfo_t *ksi, const sigset_t *mask) 96 { 97 struct lwp *l = curlwp; 98 struct proc *p = l->l_proc; 99 struct trapframe *tf; 100 struct linux32_sigframe *fp, frame; 101 int onstack, error; 102 int sig = ksi->ksi_signo; 103 sig_t catcher = SIGACTION(p, sig).sa_handler; 104 struct sigaltstack *sas = &l->l_sigstk; 105 106 tf = l->l_md.md_regs; 107 /* Do we need to jump onto the signal stack? */ 108 onstack = (sas->ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && 109 (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; 110 111 112 /* Allocate space for the signal handler context. */ 113 if (onstack) 114 fp = (struct linux32_sigframe *)((char *)sas->ss_sp + 115 sas->ss_size); 116 else 117 fp = (struct linux32_sigframe *)tf->tf_rsp; 118 fp--; 119 120 DPRINTF(("old: onstack = %d, fp = %p sig = %d rip = 0x%lx\n", 121 onstack, fp, sig, tf->tf_rip)); 122 123 /* Build stack frame for signal trampoline. */ 124 NETBSD32PTR32(frame.sf_handler, catcher); 125 frame.sf_sig = native_to_linux32_signo[sig]; 126 127 linux32_save_sigcontext(l, tf, mask, &frame.sf_sc); 128 129 sendsig_reset(l, sig); 130 mutex_exit(p->p_lock); 131 error = copyout(&frame, fp, sizeof(frame)); 132 mutex_enter(p->p_lock); 133 134 if (error != 0) { 135 /* 136 * Process has trashed its stack; give it an illegal 137 * instruction to halt it in its tracks. 138 */ 139 sigexit(l, SIGILL); 140 /* NOTREACHED */ 141 } 142 143 /* 144 * Build context to run handler in. 145 */ 146 tf->tf_fs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 147 tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 148 tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 149 tf->tf_rip = ((long)p->p_sigctx.ps_sigcode) & 0xffffffff; 150 tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL) & 0xffffffff; 151 tf->tf_rflags &= ~PSL_CLEARSIG & 0xffffffff; 152 tf->tf_rsp = (long)fp & 0xffffffff; 153 tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 154 155 /* Remember that we're now on the signal stack. */ 156 if (onstack) 157 sas->ss_flags |= SS_ONSTACK; 158 159 return; 160 } 161 162 void 163 linux32_rt_sendsig(const ksiginfo_t *ksi, const sigset_t *mask) 164 { 165 struct lwp *l = curlwp; 166 struct proc *p = l->l_proc; 167 struct trapframe *tf; 168 struct linux32_rt_sigframe *fp, frame; 169 int onstack, error; 170 linux32_siginfo_t *lsi; 171 int sig = ksi->ksi_signo; 172 sig_t catcher = SIGACTION(p, sig).sa_handler; 173 struct sigaltstack *sas = &l->l_sigstk; 174 175 tf = l->l_md.md_regs; 176 /* Do we need to jump onto the signal stack? */ 177 onstack = (sas->ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && 178 (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; 179 180 181 /* Allocate space for the signal handler context. */ 182 if (onstack) 183 fp = (struct linux32_rt_sigframe *)((char *)sas->ss_sp + 184 sas->ss_size); 185 else 186 fp = (struct linux32_rt_sigframe *)tf->tf_rsp; 187 fp--; 188 189 /* Build stack frame for signal trampoline. */ 190 NETBSD32PTR32(frame.sf_handler, catcher); 191 frame.sf_sig = native_to_linux32_signo[sig]; 192 NETBSD32PTR32(frame.sf_sip, &fp->sf_si); 193 NETBSD32PTR32(frame.sf_ucp, &fp->sf_uc); 194 195 DPRINTF(("rt: onstack = %d, fp = %p sig = %d rip = 0x%lx\n", 196 onstack, fp, sig, tf->tf_rip)); 197 198 lsi = &frame.sf_si; 199 (void)memset(lsi, 0, sizeof(frame.sf_si)); 200 lsi->lsi_errno = native_to_linux32_errno[ksi->ksi_errno]; 201 lsi->lsi_code = native_to_linux_si_code(ksi->ksi_code); 202 lsi->lsi_signo = frame.sf_sig; 203 switch (lsi->lsi_signo) { 204 case LINUX32_SIGILL: 205 case LINUX32_SIGFPE: 206 case LINUX32_SIGSEGV: 207 case LINUX32_SIGBUS: 208 case LINUX32_SIGTRAP: 209 NETBSD32PTR32(lsi->lsi_addr, ksi->ksi_addr); 210 break; 211 case LINUX32_SIGCHLD: 212 lsi->lsi_uid = ksi->ksi_uid; 213 lsi->lsi_pid = ksi->ksi_pid; 214 lsi->lsi_utime = ksi->ksi_utime; 215 lsi->lsi_stime = ksi->ksi_stime; 216 lsi->lsi_status = native_to_linux_si_status(ksi->ksi_code, 217 ksi->ksi_status); 218 break; 219 case LINUX32_SIGIO: 220 lsi->lsi_band = ksi->ksi_band; 221 lsi->lsi_fd = ksi->ksi_fd; 222 break; 223 default: 224 lsi->lsi_uid = ksi->ksi_uid; 225 lsi->lsi_pid = ksi->ksi_pid; 226 if (lsi->lsi_signo == LINUX32_SIGALRM || 227 lsi->lsi_signo >= LINUX32_SIGRTMIN) 228 NETBSD32PTR32(lsi->lsi_value.sival_ptr, 229 ksi->ksi_value.sival_ptr); 230 break; 231 } 232 233 /* Save register context. */ 234 linux32_save_ucontext(l, tf, mask, sas, &frame.sf_uc); 235 sendsig_reset(l, sig); 236 mutex_exit(p->p_lock); 237 error = copyout(&frame, fp, sizeof(frame)); 238 mutex_enter(p->p_lock); 239 240 if (error != 0) { 241 /* 242 * Process has trashed its stack; give it an illegal 243 * instruction to halt it in its tracks. 244 */ 245 sigexit(l, SIGILL); 246 /* NOTREACHED */ 247 } 248 249 /* 250 * Build context to run handler in. 251 */ 252 tf->tf_fs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 253 tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 254 tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 255 tf->tf_rip = (((long)p->p_sigctx.ps_sigcode) + 256 (linux32_rt_sigcode - linux32_sigcode)) & 0xffffffff; 257 tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL) & 0xffffffff; 258 tf->tf_rflags &= ~PSL_CLEARSIG & 0xffffffff; 259 tf->tf_rsp = (long)fp & 0xffffffff; 260 tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff; 261 262 /* Remember that we're now on the signal stack. */ 263 if (onstack) 264 sas->ss_flags |= SS_ONSTACK; 265 266 return; 267 } 268 269 void 270 linux32_setregs(struct lwp *l, struct exec_package *pack, u_long stack) 271 { 272 struct pcb *pcb = lwp_getpcb(l); 273 struct trapframe *tf; 274 struct proc *p = l->l_proc; 275 276 /* If we were using the FPU, forget about it. */ 277 if (pcb->pcb_fpcpu != NULL) 278 fpusave_lwp(l, 0); 279 280 #if defined(USER_LDT) && 0 281 pmap_ldt_cleanup(p); 282 #endif 283 284 netbsd32_adjust_limits(p); 285 286 l->l_md.md_flags &= ~MDL_USEDFPU; 287 l->l_md.md_flags |= MDL_COMPAT32; /* Forces iret not sysret */ 288 pcb->pcb_flags = PCB_COMPAT32; 289 pcb->pcb_savefpu.fp_fxsave.fx_fcw = __Linux_NPXCW__; 290 pcb->pcb_savefpu.fp_fxsave.fx_mxcsr = __INITIAL_MXCSR__; 291 pcb->pcb_savefpu.fp_fxsave.fx_mxcsr_mask = __INITIAL_MXCSR_MASK__; 292 293 p->p_flag |= PK_32; 294 295 tf = l->l_md.md_regs; 296 tf->tf_rax = 0; 297 tf->tf_rbx = (u_int32_t)p->p_psstrp; 298 tf->tf_rcx = pack->ep_entry & 0xffffffff; 299 tf->tf_rdx = 0; 300 tf->tf_rsi = 0; 301 tf->tf_rdi = 0; 302 tf->tf_rbp = 0; 303 tf->tf_rsp = stack & 0xffffffff; 304 tf->tf_r8 = 0; 305 tf->tf_r9 = 0; 306 tf->tf_r10 = 0; 307 tf->tf_r11 = 0; 308 tf->tf_r12 = 0; 309 tf->tf_r13 = 0; 310 tf->tf_r14 = 0; 311 tf->tf_r15 = 0; 312 tf->tf_rip = pack->ep_entry & 0xffffffff; 313 tf->tf_rflags = PSL_USERSET; 314 tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL); 315 tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL); 316 tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL); 317 tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL); 318 cpu_fsgs_zero(l); 319 cpu_fsgs_reload(l, GSEL(GUDATA32_SEL, SEL_UPL), GSEL(GUDATA32_SEL, SEL_UPL)); 320 } 321 322 static void 323 linux32_save_ucontext(struct lwp *l, struct trapframe *tf, 324 const sigset_t *mask, struct sigaltstack *sas, struct linux32_ucontext *uc) 325 { 326 327 uc->uc_flags = 0; 328 NETBSD32PTR32(uc->uc_link, NULL); 329 native_to_linux32_sigaltstack(&uc->uc_stack, sas); 330 linux32_save_sigcontext(l, tf, mask, &uc->uc_mcontext); 331 native_to_linux32_sigset(&uc->uc_sigmask, mask); 332 (void)memset(&uc->uc_fpregs_mem, 0, sizeof(uc->uc_fpregs_mem)); 333 } 334 335 static void 336 linux32_save_sigcontext(struct lwp *l, struct trapframe *tf, 337 const sigset_t *mask, struct linux32_sigcontext *sc) 338 { 339 struct pcb *pcb = lwp_getpcb(l); 340 341 /* Save register context. */ 342 sc->sc_gs = tf->tf_gs; 343 sc->sc_fs = tf->tf_fs; 344 sc->sc_es = tf->tf_es; 345 sc->sc_ds = tf->tf_ds; 346 sc->sc_eflags = tf->tf_rflags; 347 sc->sc_edi = tf->tf_rdi; 348 sc->sc_esi = tf->tf_rsi; 349 sc->sc_esp = tf->tf_rsp; 350 sc->sc_ebp = tf->tf_rbp; 351 sc->sc_ebx = tf->tf_rbx; 352 sc->sc_edx = tf->tf_rdx; 353 sc->sc_ecx = tf->tf_rcx; 354 sc->sc_eax = tf->tf_rax; 355 sc->sc_eip = tf->tf_rip; 356 sc->sc_cs = tf->tf_cs; 357 sc->sc_esp_at_signal = tf->tf_rsp; 358 sc->sc_ss = tf->tf_ss; 359 sc->sc_err = tf->tf_err; 360 sc->sc_trapno = tf->tf_trapno; 361 sc->sc_cr2 = pcb->pcb_cr2; 362 NETBSD32PTR32(sc->sc_387, NULL); 363 364 /* Save signal stack. */ 365 /* Linux doesn't save the onstack flag in sigframe */ 366 367 /* Save signal mask. */ 368 native_to_linux32_old_sigset(&sc->sc_mask, mask); 369 } 370 371 int 372 linux32_sys_sigreturn(struct lwp *l, 373 const struct linux32_sys_sigreturn_args *uap, register_t *retval) 374 { 375 /* { 376 syscallarg(linux32_sigcontextp_t) scp; 377 } */ 378 struct linux32_sigcontext ctx; 379 int error; 380 381 if ((error = copyin(SCARG_P32(uap, scp), &ctx, sizeof(ctx))) != 0) 382 return error; 383 384 return linux32_restore_sigcontext(l, &ctx, retval); 385 } 386 387 int 388 linux32_sys_rt_sigreturn(struct lwp *l, 389 const struct linux32_sys_rt_sigreturn_args *uap, register_t *retval) 390 { 391 /* { 392 syscallarg(linux32_ucontextp_t) ucp; 393 } */ 394 struct linux32_ucontext ctx; 395 int error; 396 397 if ((error = copyin(SCARG_P32(uap, ucp), &ctx, sizeof(ctx))) != 0) 398 return error; 399 400 return linux32_restore_sigcontext(l, &ctx.uc_mcontext, retval); 401 } 402 403 static int 404 linux32_restore_sigcontext(struct lwp *l, struct linux32_sigcontext *scp, 405 register_t *retval) 406 { 407 struct trapframe *tf; 408 struct proc *p = l->l_proc; 409 struct sigaltstack *sas = &l->l_sigstk; 410 struct pcb *pcb; 411 sigset_t mask; 412 ssize_t ss_gap; 413 register_t fssel, gssel; 414 415 /* Restore register context. */ 416 tf = l->l_md.md_regs; 417 pcb = lwp_getpcb(l); 418 DPRINTF(("sigreturn enter rsp=0x%lx rip=0x%lx\n", tf->tf_rsp, 419 tf->tf_rip)); 420 421 /* 422 * Check for security violations. 423 */ 424 if (((scp->sc_eflags ^ tf->tf_rflags) & PSL_USERSTATIC) != 0 || 425 !USERMODE(scp->sc_cs, scp->sc_eflags)) 426 return EINVAL; 427 428 if (scp->sc_fs != 0 && !VALID_USER_DSEL32(scp->sc_fs) && 429 !(VALID_USER_FSEL32(scp->sc_fs) && pcb->pcb_fs != 0)) 430 return EINVAL; 431 432 if (scp->sc_gs != 0 && !VALID_USER_DSEL32(scp->sc_gs) && 433 !(VALID_USER_GSEL32(scp->sc_gs) && pcb->pcb_gs != 0)) 434 return EINVAL; 435 436 if (scp->sc_es != 0 && !VALID_USER_DSEL32(scp->sc_es)) 437 return EINVAL; 438 439 if (!VALID_USER_DSEL32(scp->sc_ds) || 440 !VALID_USER_DSEL32(scp->sc_ss)) 441 return EINVAL; 442 443 if (scp->sc_eip >= VM_MAXUSER_ADDRESS32) 444 return EINVAL; 445 446 gssel = (register_t)scp->sc_gs & 0xffff; 447 fssel = (register_t)scp->sc_fs & 0xffff; 448 cpu_fsgs_reload(l, fssel, gssel); 449 tf->tf_es = (register_t)scp->sc_es & 0xffff; 450 tf->tf_ds = (register_t)scp->sc_ds & 0xffff; 451 tf->tf_rflags &= ~PSL_USER; 452 tf->tf_rflags |= ((register_t)scp->sc_eflags & PSL_USER); 453 tf->tf_rdi = (register_t)scp->sc_edi & 0xffffffff; 454 tf->tf_rsi = (register_t)scp->sc_esi & 0xffffffff; 455 tf->tf_rbp = (register_t)scp->sc_ebp & 0xffffffff; 456 tf->tf_rbx = (register_t)scp->sc_ebx & 0xffffffff; 457 tf->tf_rdx = (register_t)scp->sc_edx & 0xffffffff; 458 tf->tf_rcx = (register_t)scp->sc_ecx & 0xffffffff; 459 tf->tf_rax = (register_t)scp->sc_eax & 0xffffffff; 460 tf->tf_rip = (register_t)scp->sc_eip & 0xffffffff; 461 tf->tf_cs = (register_t)scp->sc_cs & 0xffff; 462 tf->tf_rsp = (register_t)scp->sc_esp_at_signal & 0xffffffff; 463 tf->tf_ss = (register_t)scp->sc_ss & 0xffff; 464 465 mutex_enter(p->p_lock); 466 467 /* Restore signal stack. */ 468 ss_gap = (ssize_t) 469 ((char *)NETBSD32IPTR64(scp->sc_esp_at_signal) 470 - (char *)sas->ss_sp); 471 if (ss_gap >= 0 && ss_gap < sas->ss_size) 472 sas->ss_flags |= SS_ONSTACK; 473 else 474 sas->ss_flags &= ~SS_ONSTACK; 475 476 /* Restore signal mask. */ 477 linux32_old_to_native_sigset(&mask, &scp->sc_mask); 478 (void) sigprocmask1(l, SIG_SETMASK, &mask, 0); 479 480 mutex_exit(p->p_lock); 481 482 DPRINTF(("linux32_sigreturn: rip = 0x%lx, rsp = 0x%lx, flags = 0x%lx\n", 483 tf->tf_rip, tf->tf_rsp, tf->tf_rflags)); 484 return EJUSTRETURN; 485 } 486 487 int 488 linux32_sys_set_thread_area(struct lwp *l, 489 const struct linux32_sys_set_thread_area_args *uap, register_t *retval) 490 { 491 /* { 492 syscallarg(linux32_user_descp_t) desc; 493 } */ 494 495 return linux_lwp_setprivate(l, SCARG_P32(uap, desc)); 496 } 497 498 int 499 linux32_sys_get_thread_area(struct lwp *l, 500 const struct linux32_sys_get_thread_area_args *uap, register_t *retval) 501 { 502 /* { 503 syscallarg(linux32_user_descp_t) desc; 504 } */ 505 506 /* glibc doesn't actually call this. */ 507 return ENOSYS; 508 } 509 510 int 511 linux32_sys_modify_ldt(struct lwp *l, const struct linux32_sys_modify_ldt_args *uap, register_t *retval) 512 { 513 /* { 514 syscallarg(int) func; 515 syscallarg(netbsd32_charp) ptr; 516 syscallarg(netbsd32_size_t) bytecount; 517 } */ 518 struct linux_sys_modify_ldt_args ua; 519 520 NETBSD32TO64_UAP(func); 521 NETBSD32TOP_UAP(ptr, void *); 522 NETBSD32TOX_UAP(bytecount, size_t); 523 return linux_sys_modify_ldt(l, &ua, retval); 524 } 525
Indexes created Thu Sep 25 16:09:42 GMT 2025