linux_machdep.c revision 1.5
1 /* $NetBSD: linux_machdep.c,v 1.5 2005/05/22 14:52:12 fvdl Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 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 34 #include <sys/cdefs.h> 35 36 __KERNEL_RCSID(0, "$NetBSD: linux_machdep.c,v 1.5 2005/05/22 14:52:12 fvdl Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/types.h> 40 #include <sys/systm.h> 41 #include <sys/signal.h> 42 #include <sys/exec.h> 43 #include <sys/proc.h> 44 #include <sys/ptrace.h> /* for process_read_fpregs() */ 45 #include <sys/user.h> 46 #include <sys/ucontext.h> 47 48 #include <machine/reg.h> 49 #include <machine/pcb.h> 50 #include <machine/fpu.h> 51 #include <machine/mcontext.h> 52 #include <machine/specialreg.h> 53 #include <machine/vmparam.h> 54 55 #include <compat/linux/common/linux_signal.h> 56 #include <compat/linux/common/linux_errno.h> 57 #include <compat/linux/common/linux_exec.h> 58 #include <compat/linux/common/linux_ioctl.h> 59 #include <compat/linux/common/linux_prctl.h> 60 #include <compat/linux/common/linux_machdep.h> 61 #include <compat/linux/linux_syscall.h> 62 #include <compat/linux/linux_syscallargs.h> 63 64 static void linux_buildcontext(struct lwp *, void *, void *); 65 66 void 67 linux_setregs(l, epp, stack) 68 struct lwp *l; 69 struct exec_package *epp; 70 u_long stack; 71 { 72 struct pcb *pcb = &l->l_addr->u_pcb; 73 struct trapframe *tf; 74 75 /* If we were using the FPU, forget about it. */ 76 if (l->l_addr->u_pcb.pcb_fpcpu != NULL) 77 fpusave_lwp(l, 0); 78 79 l->l_md.md_flags &= ~MDP_USEDFPU; 80 pcb->pcb_flags = 0; 81 pcb->pcb_savefpu.fp_fxsave.fx_fcw = __NetBSD_NPXCW__; 82 pcb->pcb_savefpu.fp_fxsave.fx_mxcsr = __INITIAL_MXCSR__; 83 pcb->pcb_savefpu.fp_fxsave.fx_mxcsr_mask = __INITIAL_MXCSR_MASK__; 84 pcb->pcb_fs = 0; 85 pcb->pcb_gs = 0; 86 87 l->l_proc->p_flag &= ~P_32; 88 89 tf = l->l_md.md_regs; 90 tf->tf_rax = 0; 91 tf->tf_rbx = 0; 92 tf->tf_rcx = epp->ep_entry; 93 tf->tf_rdx = 0; 94 tf->tf_rsi = 0; 95 tf->tf_rdi = 0; 96 tf->tf_rbp = 0; 97 tf->tf_rsp = stack; 98 tf->tf_r8 = 0; 99 tf->tf_r9 = 0; 100 tf->tf_r10 = 0; 101 tf->tf_r11 = 0; 102 tf->tf_r12 = 0; 103 tf->tf_r13 = 0; 104 tf->tf_r14 = 0; 105 tf->tf_r15 = 0; 106 tf->tf_rip = epp->ep_entry; 107 tf->tf_rflags = PSL_USERSET; 108 tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); 109 tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); 110 tf->tf_ds = 0; 111 tf->tf_es = 0; 112 tf->tf_fs = 0; 113 tf->tf_gs = 0; 114 115 return; 116 } 117 118 void 119 linux_sendsig(ksi, mask) 120 const ksiginfo_t *ksi; 121 const sigset_t *mask; 122 { 123 struct lwp *l = curlwp; 124 struct proc *p = l->l_proc; 125 struct sigacts *ps = p->p_sigacts; 126 int onstack; 127 int sig = ksi->ksi_signo; 128 struct linux_rt_sigframe *sfp, sigframe; 129 struct linux__fpstate *fpsp, fpstate; 130 struct fpreg fpregs; 131 struct trapframe *tf = l->l_md.md_regs; 132 sig_t catcher = SIGACTION(p, sig).sa_handler; 133 linux_sigset_t lmask; 134 char *sp; 135 int error; 136 137 /* Do we need to jump onto the signal stack? */ 138 onstack = 139 (p->p_sigctx.ps_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 && 140 (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0; 141 142 /* Allocate space for the signal handler context. */ 143 if (onstack) 144 sp = ((caddr_t)p->p_sigctx.ps_sigstk.ss_sp + 145 p->p_sigctx.ps_sigstk.ss_size); 146 else 147 sp = (caddr_t)tf->tf_rsp - 128; 148 149 150 /* 151 * Save FPU state, if any 152 */ 153 if (l->l_md.md_flags & MDP_USEDFPU) { 154 sp = (char *) 155 (((long)sp - sizeof(struct linux__fpstate)) & ~0xfUL); 156 fpsp = (struct linux__fpstate *)sp; 157 158 (void)process_read_fpregs(l, &fpregs); 159 bzero(&fpstate, sizeof(fpstate)); 160 161 fpstate.cwd = fpregs.fp_fcw; 162 fpstate.swd = fpregs.fp_fsw; 163 fpstate.twd = fpregs.fp_ftw; 164 fpstate.fop = fpregs.fp_fop; 165 fpstate.rip = fpregs.fp_rip; 166 fpstate.rdp = fpregs.fp_rdp; 167 fpstate.mxcsr = fpregs.fp_mxcsr; 168 fpstate.mxcsr_mask = fpregs.fp_mxcsr_mask; 169 memcpy(&fpstate.st_space, &fpregs.fp_st, 170 sizeof(fpstate.st_space)); 171 memcpy(&fpstate.xmm_space, &fpregs.fp_xmm, 172 sizeof(fpstate.xmm_space)); 173 174 if ((error = copyout(&fpstate, fpsp, sizeof(fpstate))) != 0) { 175 sigexit(l, SIGILL); 176 return; 177 } 178 } else { 179 fpsp = NULL; 180 } 181 182 /* 183 * Populate the rt_sigframe 184 */ 185 sp = (char *) 186 ((((long)sp - sizeof(struct linux_rt_sigframe)) & ~0xfUL) - 8); 187 sfp = (struct linux_rt_sigframe *)sp; 188 189 bzero(&sigframe, sizeof(sigframe)); 190 if (ps->sa_sigdesc[sig].sd_vers != 0) 191 sigframe.pretcode = (char *)ps->sa_sigdesc[sig].sd_tramp; 192 else 193 sigframe.pretcode = NULL; 194 195 /* 196 * The user context 197 */ 198 sigframe.uc.luc_flags = 0; 199 sigframe.uc.luc_link = NULL; 200 201 /* This is used regardless of SA_ONSTACK in Linux */ 202 sigframe.uc.luc_stack.ss_sp = p->p_sigctx.ps_sigstk.ss_sp; 203 sigframe.uc.luc_stack.ss_size = p->p_sigctx.ps_sigstk.ss_size; 204 sigframe.uc.luc_stack.ss_flags = 0; 205 if (p->p_sigctx.ps_sigstk.ss_flags & SS_ONSTACK) 206 sigframe.uc.luc_stack.ss_flags |= LINUX_SS_ONSTACK; 207 if (p->p_sigctx.ps_sigstk.ss_flags & SS_DISABLE) 208 sigframe.uc.luc_stack.ss_flags |= LINUX_SS_DISABLE; 209 210 sigframe.uc.luc_mcontext.r8 = tf->tf_r8; 211 sigframe.uc.luc_mcontext.r9 = tf->tf_r9; 212 sigframe.uc.luc_mcontext.r10 = tf->tf_r10; 213 sigframe.uc.luc_mcontext.r11 = tf->tf_r11; 214 sigframe.uc.luc_mcontext.r12 = tf->tf_r12; 215 sigframe.uc.luc_mcontext.r13 = tf->tf_r13; 216 sigframe.uc.luc_mcontext.r14 = tf->tf_r14; 217 sigframe.uc.luc_mcontext.r15 = tf->tf_r15; 218 sigframe.uc.luc_mcontext.rdi = tf->tf_rdi; 219 sigframe.uc.luc_mcontext.rsi = tf->tf_rsi; 220 sigframe.uc.luc_mcontext.rbp = tf->tf_rbp; 221 sigframe.uc.luc_mcontext.rbx = tf->tf_rbx; 222 sigframe.uc.luc_mcontext.rdx = tf->tf_rdx; 223 sigframe.uc.luc_mcontext.rcx = tf->tf_rcx; 224 sigframe.uc.luc_mcontext.rsp = tf->tf_rsp; 225 sigframe.uc.luc_mcontext.eflags = tf->tf_rflags; 226 sigframe.uc.luc_mcontext.cs = tf->tf_cs; 227 sigframe.uc.luc_mcontext.gs = tf->tf_gs; 228 sigframe.uc.luc_mcontext.fs = tf->tf_fs; 229 sigframe.uc.luc_mcontext.err = tf->tf_err; 230 sigframe.uc.luc_mcontext.trapno = tf->tf_trapno; 231 native_to_linux_sigset(&lmask, mask); 232 sigframe.uc.luc_mcontext.oldmask = lmask.sig[0]; 233 sigframe.uc.luc_mcontext.cr2 = (long)l->l_addr->u_pcb.pcb_onfault; 234 sigframe.uc.luc_mcontext.fpstate = fpsp; 235 native_to_linux_sigset(&sigframe.uc.luc_sigmask, mask); 236 237 /* 238 * the siginfo structure 239 */ 240 sigframe.info.lsi_signo = native_to_linux_signo[sig]; 241 sigframe.info.lsi_errno = native_to_linux_errno[ksi->ksi_errno]; 242 sigframe.info.lsi_code = ksi->ksi_code; 243 244 /* XXX This is a rought conversion, taken from i386 code */ 245 switch (sigframe.info.lsi_signo) { 246 case LINUX_SIGILL: 247 case LINUX_SIGFPE: 248 case LINUX_SIGSEGV: 249 case LINUX_SIGBUS: 250 case LINUX_SIGTRAP: 251 sigframe.info._sifields._sigfault._addr = ksi->ksi_addr; 252 break; 253 case LINUX_SIGCHLD: 254 sigframe.info._sifields._sigchld._pid = ksi->ksi_pid; 255 sigframe.info._sifields._sigchld._uid = ksi->ksi_uid; 256 sigframe.info._sifields._sigchld._status = ksi->ksi_status; 257 sigframe.info._sifields._sigchld._utime = ksi->ksi_utime; 258 sigframe.info._sifields._sigchld._stime = ksi->ksi_stime; 259 break; 260 case LINUX_SIGIO: 261 sigframe.info._sifields._sigpoll._band = ksi->ksi_band; 262 sigframe.info._sifields._sigpoll._fd = ksi->ksi_fd; 263 break; 264 default: 265 sigframe.info._sifields._sigchld._pid = ksi->ksi_pid; 266 sigframe.info._sifields._sigchld._uid = ksi->ksi_uid; 267 if ((sigframe.info.lsi_signo == LINUX_SIGALRM) || 268 (sigframe.info.lsi_signo >= LINUX_SIGRTMIN)) 269 sigframe.info._sifields._timer._sigval.sival_ptr = 270 ksi->ksi_sigval.sival_ptr; 271 break; 272 } 273 274 if ((error = copyout(&sigframe, sp, sizeof(sigframe))) != 0) { 275 sigexit(l, SIGILL); 276 return; 277 } 278 279 /* 280 * Setup registers 281 * XXX for an unknown reason, the stack is shifted of 24 bytes 282 * when the signal handler is called. The +24 below is a dirty 283 * workaround, and the real problem should be fixed. 284 */ 285 linux_buildcontext(l, catcher, sp + 24); 286 tf->tf_rdi = sigframe.info.lsi_signo; 287 tf->tf_rax = 0; 288 tf->tf_rsi = (long)&sfp->info; 289 tf->tf_rdx = (long)&sfp->uc; 290 291 /* 292 * Remember we use signal stack 293 */ 294 if (onstack) 295 p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK; 296 return; 297 } 298 299 int 300 linux_sys_modify_ldt(l, v, retval) 301 struct lwp *l; 302 void *v; 303 register_t *retval; 304 { 305 return 0; 306 } 307 308 int 309 linux_sys_iopl(l, v, retval) 310 struct lwp *l; 311 void *v; 312 register_t *retval; 313 { 314 return 0; 315 } 316 317 int 318 linux_sys_ioperm(l, v, retval) 319 struct lwp *l; 320 void *v; 321 register_t *retval; 322 { 323 return 0; 324 } 325 326 dev_t 327 linux_fakedev(dev, raw) 328 dev_t dev; 329 int raw; 330 { 331 return 0; 332 } 333 334 int 335 linux_machdepioctl(p, v, retval) 336 struct proc *p; 337 void *v; 338 register_t *retval; 339 { 340 return 0; 341 } 342 343 int 344 linux_sys_rt_sigreturn(l, v, retval) 345 struct lwp *l; 346 void *v; 347 register_t *retval; 348 { 349 struct linux_sys_rt_sigreturn_args /* { 350 syscallarg(struct linux_ucontext *) ucp; 351 } */ *uap = v; 352 struct linux_ucontext luctx; 353 struct trapframe *tf = l->l_md.md_regs; 354 struct linux_sigcontext *lsigctx; 355 struct linux__fpstate fpstate; 356 ucontext_t uctx; 357 mcontext_t *mctx; 358 struct fxsave64 *fxsave; 359 int error; 360 361 if ((error = copyin(SCARG(uap, ucp), &luctx, sizeof(luctx))) != 0) { 362 sigexit(l, SIGILL); 363 return error; 364 } 365 lsigctx = &luctx.luc_mcontext; 366 367 bzero(&uctx, sizeof(uctx)); 368 mctx = (mcontext_t *)&uctx.uc_mcontext; 369 fxsave = (struct fxsave64 *)&mctx->__fpregs; 370 371 /* 372 * Set the flags. Linux always have CPU, stack and signal state, 373 * FPU is optional. uc_flags is not used to tell what we have. 374 */ 375 uctx.uc_flags = (_UC_SIGMASK|_UC_CPU|_UC_STACK|_UC_CLRSTACK); 376 if (lsigctx->fpstate != NULL) 377 uctx.uc_flags |= _UC_FPU; 378 uctx.uc_link = NULL; 379 380 /* 381 * Signal set 382 */ 383 linux_to_native_sigset(&uctx.uc_sigmask, &luctx.luc_sigmask); 384 385 /* 386 * CPU state 387 */ 388 mctx->__gregs[_REG_R8] = lsigctx->r8; 389 mctx->__gregs[_REG_R9] = lsigctx->r9; 390 mctx->__gregs[_REG_R10] = lsigctx->r10; 391 mctx->__gregs[_REG_R11] = lsigctx->r11; 392 mctx->__gregs[_REG_R12] = lsigctx->r12; 393 mctx->__gregs[_REG_R13] = lsigctx->r13; 394 mctx->__gregs[_REG_R14] = lsigctx->r14; 395 mctx->__gregs[_REG_R15] = lsigctx->r15; 396 mctx->__gregs[_REG_RDI] = lsigctx->rdi; 397 mctx->__gregs[_REG_RSI] = lsigctx->rsi; 398 mctx->__gregs[_REG_RBP] = lsigctx->rbp; 399 mctx->__gregs[_REG_RBX] = lsigctx->rbx; 400 mctx->__gregs[_REG_RAX] = tf->tf_rax; 401 mctx->__gregs[_REG_RDX] = lsigctx->rdx; 402 mctx->__gregs[_REG_RCX] = lsigctx->rcx; 403 mctx->__gregs[_REG_RIP] = lsigctx->rip; 404 mctx->__gregs[_REG_RFL] = lsigctx->eflags; 405 mctx->__gregs[_REG_CS] = lsigctx->cs; 406 mctx->__gregs[_REG_GS] = lsigctx->gs; 407 mctx->__gregs[_REG_FS] = lsigctx->fs; 408 mctx->__gregs[_REG_ERR] = lsigctx->err; 409 mctx->__gregs[_REG_TRAPNO] = lsigctx->trapno; 410 mctx->__gregs[_REG_ES] = tf->tf_es; 411 mctx->__gregs[_REG_DS] = tf->tf_ds; 412 mctx->__gregs[_REG_URSP] = lsigctx->rsp; /* XXX */ 413 mctx->__gregs[_REG_SS] = tf->tf_ss; 414 415 /* 416 * FPU state 417 */ 418 if (lsigctx->fpstate != NULL) { 419 error = copyin(lsigctx->fpstate, &fpstate, sizeof(fpstate)); 420 if (error != 0) { 421 sigexit(l, SIGILL); 422 return error; 423 } 424 425 fxsave->fx_fcw = fpstate.cwd; 426 fxsave->fx_fsw = fpstate.swd; 427 fxsave->fx_ftw = fpstate.twd; 428 fxsave->fx_fop = fpstate.fop; 429 fxsave->fx_rip = fpstate.rip; 430 fxsave->fx_rdp = fpstate.rdp; 431 fxsave->fx_mxcsr = fpstate.mxcsr; 432 fxsave->fx_mxcsr_mask = fpstate.mxcsr_mask; 433 memcpy(&fxsave->fx_st, &fpstate.st_space, 434 sizeof(fxsave->fx_st)); 435 memcpy(&fxsave->fx_xmm, &fpstate.xmm_space, 436 sizeof(fxsave->fx_xmm)); 437 } 438 439 /* 440 * And the stack 441 */ 442 uctx.uc_stack.ss_flags = 0; 443 if (luctx.luc_stack.ss_flags & LINUX_SS_ONSTACK); 444 uctx.uc_stack.ss_flags = SS_ONSTACK; 445 446 if (luctx.luc_stack.ss_flags & LINUX_SS_DISABLE); 447 uctx.uc_stack.ss_flags = SS_DISABLE; 448 449 uctx.uc_stack.ss_sp = luctx.luc_stack.ss_sp; 450 uctx.uc_stack.ss_size = luctx.luc_stack.ss_size; 451 452 /* 453 * And let setucontext deal with that. 454 */ 455 return setucontext(l, &uctx); 456 } 457 458 int 459 linux_sys_arch_prctl(l, v, retval) 460 struct lwp *l; 461 void *v; 462 register_t *retval; 463 { 464 struct linux_sys_arch_prctl_args /* { 465 syscallarg(int) code; 466 syscallarg(unsigned long) addr; 467 } */ *uap = v; 468 struct pcb *pcb = &l->l_addr->u_pcb; 469 struct trapframe *tf = l->l_md.md_regs; 470 int error; 471 uint64_t taddr; 472 473 switch(SCARG(uap, code)) { 474 case LINUX_ARCH_SET_GS: 475 taddr = SCARG(uap, addr); 476 if (taddr >= VM_MAXUSER_ADDRESS) 477 return EINVAL; 478 pcb->pcb_gs = taddr; 479 pcb->pcb_flags |= PCB_GS64; 480 if (l == curlwp) 481 wrmsr(MSR_KERNELGSBASE, taddr); 482 break; 483 484 case LINUX_ARCH_GET_GS: 485 if (pcb->pcb_flags & PCB_GS64) 486 taddr = pcb->pcb_gs; 487 else { 488 error = memseg_baseaddr(l, tf->tf_fs, NULL, 0, &taddr); 489 if (error != 0) 490 return error; 491 } 492 error = copyout(&taddr, (char *)SCARG(uap, addr), 8); 493 if (error != 0) 494 return error; 495 break; 496 497 case LINUX_ARCH_SET_FS: 498 taddr = SCARG(uap, addr); 499 if (taddr >= VM_MAXUSER_ADDRESS) 500 return EINVAL; 501 pcb->pcb_fs = taddr; 502 pcb->pcb_flags |= PCB_FS64; 503 if (l == curlwp) 504 wrmsr(MSR_FSBASE, taddr); 505 break; 506 507 case LINUX_ARCH_GET_FS: 508 if (pcb->pcb_flags & PCB_FS64) 509 taddr = pcb->pcb_fs; 510 else { 511 error = memseg_baseaddr(l, tf->tf_fs, NULL, 0, &taddr); 512 if (error != 0) 513 return error; 514 } 515 error = copyout(&taddr, (char *)SCARG(uap, addr), 8); 516 if (error != 0) 517 return error; 518 break; 519 520 default: 521 #ifdef DEBUG_LINUX 522 printf("linux_sys_arch_prctl: unexpected code %d\n", 523 SCARG(uap, code)); 524 #endif 525 return EINVAL; 526 } 527 528 return 0; 529 } 530 531 const int linux_vsyscall_to_syscall[] = { 532 LINUX_SYS_gettimeofday, 533 LINUX_SYS_time, 534 LINUX_SYS_nosys, 535 LINUX_SYS_nosys, 536 }; 537 538 int 539 linux_usertrap(struct lwp *l, vaddr_t trapaddr, void *arg) 540 { 541 struct trapframe *tf = arg; 542 uint64_t retaddr; 543 int vsyscallnr; 544 545 /* 546 * Check for a vsyscall. %rip must be the fault address, 547 * and the address must be in the Linux vsyscall area. 548 * Also, vsyscalls are only done at 1024-byte boundaries. 549 */ 550 551 if (__predict_true(trapaddr < LINUX_VSYSCALL_START)) 552 return 0; 553 554 if (trapaddr != tf->tf_rip) 555 return 0; 556 557 if ((tf->tf_rip & (LINUX_VSYSCALL_SIZE - 1)) != 0) 558 return 0; 559 560 vsyscallnr = (tf->tf_rip - LINUX_VSYSCALL_START) / LINUX_VSYSCALL_SIZE; 561 562 if (vsyscallnr > LINUX_VSYSCALL_MAXNR) 563 return 0; 564 565 /* 566 * Get the return address from the top of the stack, 567 * and fix up the return address. 568 * This assumes the faulting instruction was callq *reg, 569 * which is the only way that vsyscalls are ever entered. 570 */ 571 if (copyin((void *)tf->tf_rsp, &retaddr, sizeof retaddr) != 0) 572 return 0; 573 tf->tf_rip = retaddr; 574 tf->tf_rax = linux_vsyscall_to_syscall[vsyscallnr]; 575 tf->tf_rsp += 8; /* "pop" the return address */ 576 577 #if 0 578 printf("usertrap: rip %p rsp %p retaddr %p vsys %d sys %d\n", 579 (void *)tf->tf_rip, (void *)tf->tf_rsp, (void *)retaddr, 580 vsyscallnr, (int)tf->tf_rax); 581 #endif 582 583 (*l->l_proc->p_md.md_syscall)(tf); 584 585 return 1; 586 } 587 588 static void 589 linux_buildcontext(struct lwp *l, void *catcher, void *f) 590 { 591 struct trapframe *tf = l->l_md.md_regs; 592 593 tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL); 594 tf->tf_rip = (u_int64_t)catcher; 595 tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL); 596 tf->tf_rflags &= ~(PSL_T|PSL_VM|PSL_AC); 597 tf->tf_rsp = (u_int64_t)f; 598 tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL); 599 } 600
Indexes created Tue Sep 30 20:09:53 GMT 2025