root/arch/i386/i386/process_machdep.c

DEFINITIONS

1. process_frame
2. process_fpframe
3. process_xmm_to_s87
4. process_fninit_xmm
5. process_read_regs
6. process_read_fpregs
7. process_s87_to_xmm
8. process_write_regs
9. process_write_fpregs
10. process_read_xmmregs
11. process_write_xmmregs
12. process_sstep
13. process_set_pc

    1 /*      $OpenBSD: process_machdep.c,v 1.22 2007/05/08 20:26:54 deraadt Exp $    */
    2 /*      $NetBSD: process_machdep.c,v 1.22 1996/05/03 19:42:25 christos Exp $    */
    4 /*
    5  * Copyright (c) 1995, 1996 Charles M. Hannum.  All rights reserved.
    6  * Copyright (c) 1993 The Regents of the University of California.
    7  * Copyright (c) 1993 Jan-Simon Pendry
    8  * All rights reserved.
    9  *
   10  * This code is derived from software contributed to Berkeley by
   11  * Jan-Simon Pendry.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  * From:
   38  *      Id: procfs_i386.c,v 4.1 1993/12/17 10:47:45 jsp Rel
   39  */
   41 /*
   42  * This file may seem a bit stylized, but that so that it's easier to port.
   43  * Functions to be implemented here are:
   44  *
   45  * process_read_regs(proc, regs)
   46  *      Get the current user-visible register set from the process
   47  *      and copy it into the regs structure (<machine/reg.h>).
   48  *      The process is stopped at the time read_regs is called.
   49  *
   50  * process_write_regs(proc, regs)
   51  *      Update the current register set from the passed in regs
   52  *      structure.  Take care to avoid clobbering special CPU
   53  *      registers or privileged bits in the PSL.
   54  *      The process is stopped at the time write_regs is called.
   55  *
   56  * process_sstep(proc)
   57  *      Arrange for the process to trap after executing a single instruction.
   58  *
   59  * process_set_pc(proc)
   60  *      Set the process's program counter.
   61  */
   63 #include <sys/param.h>
   64 #include <sys/systm.h>
   65 #include <sys/time.h>
   66 #include <sys/kernel.h>
   67 #include <sys/proc.h>
   68 #include <sys/user.h>
   69 #include <sys/vnode.h>
   70 #include <sys/ptrace.h>
   72 #include <machine/psl.h>
   73 #include <machine/reg.h>
   74 #include <machine/segments.h>
   76 #ifdef VM86
   77 #include <machine/vm86.h>
   78 #endif
   80 #include "npx.h"
   82 static __inline struct trapframe *process_frame(struct proc *);
   83 static __inline union savefpu *process_fpframe(struct proc *);
   84 void process_fninit_xmm(struct savexmm *);
   86 static __inline struct trapframe *
process_frame(struct proc *p)
   88 {
   90         return (p->p_md.md_regs);
   91 }
   93 static __inline union savefpu *
process_fpframe(struct proc *p)
   95 {
   97         return (&p->p_addr->u_pcb.pcb_savefpu);
   98 }
  100 void
process_xmm_to_s87(const struct savexmm *sxmm, struct save87 *s87)
  102 {
  103         int i;
  105         /* FPU control/status */
s87->sv_env.en_cw = sxmm->sv_env.en_cw;
s87->sv_env.en_sw = sxmm->sv_env.en_sw;
  108         /* tag word handled below */
s87->sv_env.en_fip = sxmm->sv_env.en_fip;
s87->sv_env.en_fcs = sxmm->sv_env.en_fcs;
s87->sv_env.en_opcode = sxmm->sv_env.en_opcode;
s87->sv_env.en_foo = sxmm->sv_env.en_foo;
s87->sv_env.en_fos = sxmm->sv_env.en_fos;
  115         /* Tag word and registers. */
  116         for (i = 0; i < 8; i++) {
  117                 if (sxmm->sv_env.en_tw & (1U << i))
s87->sv_env.en_tw &= ~(3U << (i * 2));
  119                 else
s87->sv_env.en_tw |= (3U << (i * 2));
  122                 if (sxmm->sv_ex_tw & (1U << i))
s87->sv_ex_tw &= ~(3U << (i * 2));
  124                 else
s87->sv_ex_tw |= (3U << (i * 2));
memcpy(&s87->sv_ac[i].fp_bytes, &sxmm->sv_ac[i].fp_bytes,
  128                     sizeof(s87->sv_ac[i].fp_bytes));
  129         }
s87->sv_ex_sw = sxmm->sv_ex_sw;
  132 }
  134 void
process_fninit_xmm(struct savexmm *sxmm)
  136 {
  137         /*
  138          * The initial control word was already set by setregs(), so
  139          * save it temporarily.
  140          */
uint32_t mxcsr = sxmm->sv_env.en_mxcsr;
uint16_t cw = sxmm->sv_env.en_cw;
  144         /* XXX Don't zero XMM regs? */
memset(sxmm, 0, sizeof(*sxmm));
sxmm->sv_env.en_cw = cw;
sxmm->sv_env.en_mxcsr = mxcsr;
sxmm->sv_env.en_sw = 0x0000;
sxmm->sv_env.en_tw = 0x00;
  150 }
  152 int
process_read_regs(struct proc *p, struct reg *regs)
  154 {
  155         struct trapframe *tf = process_frame(p);
  157 #ifdef VM86
  158         if (tf->tf_eflags & PSL_VM) {
regs->r_gs = tf->tf_vm86_gs & 0xffff;
regs->r_fs = tf->tf_vm86_fs & 0xffff;
regs->r_es = tf->tf_vm86_es & 0xffff;
regs->r_ds = tf->tf_vm86_ds & 0xffff;
regs->r_eflags = get_vflags(p);
  164         } else
  165 #endif
  166         {
regs->r_gs = tf->tf_gs & 0xffff;
regs->r_fs = tf->tf_fs & 0xffff;
regs->r_es = tf->tf_es & 0xffff;
regs->r_ds = tf->tf_ds & 0xffff;
regs->r_eflags = tf->tf_eflags;
  172         }
regs->r_edi = tf->tf_edi;
regs->r_esi = tf->tf_esi;
regs->r_ebp = tf->tf_ebp;
regs->r_ebx = tf->tf_ebx;
regs->r_edx = tf->tf_edx;
regs->r_ecx = tf->tf_ecx;
regs->r_eax = tf->tf_eax;
regs->r_eip = tf->tf_eip;
regs->r_cs = tf->tf_cs & 0xffff;
regs->r_esp = tf->tf_esp;
regs->r_ss = tf->tf_ss & 0xffff;
  185         return (0);
  186 }
  188 int
process_read_fpregs(struct proc *p, struct fpreg *regs)
  190 {
  191         union savefpu *frame = process_fpframe(p);
  193         if (p->p_md.md_flags & MDP_USEDFPU) {
  194 #if NNPX > 0
npxsave_proc(p, 1);
  196 #endif
  197         } else {
  198                 /* Fake a FNINIT. */
  199                 if (i386_use_fxsave) {
process_fninit_xmm(&frame->sv_xmm);
  201                 } else {
  202                         /*
  203                          * The initial control word was already set by
  204                          * setregs(), so save it temporarily.
  205                          */
uint16_t cw = frame->sv_87.sv_env.en_cw;
memset(&frame->sv_87, 0, sizeof(frame->sv_87));
frame->sv_87.sv_env.en_cw = cw;
frame->sv_87.sv_env.en_sw = 0x0000;
frame->sv_87.sv_env.en_tw = 0xffff;
  212                 }
p->p_md.md_flags |= MDP_USEDFPU;
  214         }
  216         if (i386_use_fxsave) {
  217                 struct save87 s87;
  219                 /* XXX Yuck */
process_xmm_to_s87(&frame->sv_xmm, &s87);
memcpy(regs, &s87, sizeof(*regs));
  222         } else
memcpy(regs, &frame->sv_87, sizeof(*regs));
  225         return (0);
  226 }
  228 #ifdef PTRACE
  230 void
process_s87_to_xmm(const struct save87 *s87, struct savexmm *sxmm)
  232 {
  233         int i;
  235         /* FPU control/status */
sxmm->sv_env.en_cw = s87->sv_env.en_cw;
sxmm->sv_env.en_sw = s87->sv_env.en_sw;
  238         /* tag word handled below */
sxmm->sv_env.en_fip = s87->sv_env.en_fip;
sxmm->sv_env.en_fcs = s87->sv_env.en_fcs;
sxmm->sv_env.en_opcode = s87->sv_env.en_opcode;
sxmm->sv_env.en_foo = s87->sv_env.en_foo;
sxmm->sv_env.en_fos = s87->sv_env.en_fos;
  245         /* Tag word and registers. */
  246         for (i = 0; i < 8; i++) {
  247                 if (((s87->sv_env.en_tw >> (i * 2)) & 3) == 3)
sxmm->sv_env.en_tw &= ~(1U << i);
  249                 else
sxmm->sv_env.en_tw |= (1U << i);
  252                 if (((s87->sv_ex_tw >> (i * 2)) & 3) == 3)
sxmm->sv_ex_tw &= ~(1U << i);
  254                 else
sxmm->sv_ex_tw |= (1U << i);
memcpy(&sxmm->sv_ac[i].fp_bytes, &s87->sv_ac[i].fp_bytes,
  258                     sizeof(sxmm->sv_ac[i].fp_bytes));
  259         }
sxmm->sv_ex_sw = s87->sv_ex_sw;
  262 }
  264 int
process_write_regs(struct proc *p, struct reg *regs)
  266 {
  267         struct trapframe *tf = process_frame(p);
  269 #ifdef VM86
  270         if (tf->tf_eflags & PSL_VM) {
tf->tf_vm86_gs = regs->r_gs & 0xffff;
tf->tf_vm86_fs = regs->r_fs & 0xffff;
tf->tf_vm86_es = regs->r_es & 0xffff;
tf->tf_vm86_ds = regs->r_ds & 0xffff;
set_vflags(p, regs->r_eflags);
  276         } else
  277 #endif
  278         {
  279                 /*
  280                  * Check for security violations.
  281                  */
  282                 if (((regs->r_eflags ^ tf->tf_eflags) & PSL_USERSTATIC) != 0 ||
  283                     !USERMODE(regs->r_cs, regs->r_eflags))
  284                         return (EINVAL);
tf->tf_gs = regs->r_gs & 0xffff;
tf->tf_fs = regs->r_fs & 0xffff;
tf->tf_es = regs->r_es & 0xffff;
tf->tf_ds = regs->r_ds & 0xffff;
tf->tf_eflags = regs->r_eflags;
  291         }
tf->tf_edi = regs->r_edi;
tf->tf_esi = regs->r_esi;
tf->tf_ebp = regs->r_ebp;
tf->tf_ebx = regs->r_ebx;
tf->tf_edx = regs->r_edx;
tf->tf_ecx = regs->r_ecx;
tf->tf_eax = regs->r_eax;
tf->tf_eip = regs->r_eip;
tf->tf_cs = regs->r_cs & 0xffff;
tf->tf_esp = regs->r_esp;
tf->tf_ss = regs->r_ss & 0xffff;
  304         return (0);
  305 }
  307 int
process_write_fpregs(struct proc *p, struct fpreg *regs)
  309 {
  310         union savefpu *frame = process_fpframe(p);
  312         if (p->p_md.md_flags & MDP_USEDFPU) {
  313 #if NNPX > 0
npxsave_proc(p, 0);
  315 #endif
  316         } else
p->p_md.md_flags |= MDP_USEDFPU;
  319         if (i386_use_fxsave) {
  320                 struct save87 s87;
  322                 /* XXX Yuck. */
memcpy(&s87, regs, sizeof(*regs));
process_s87_to_xmm(&s87, &frame->sv_xmm);
  325         } else
memcpy(&frame->sv_87, regs, sizeof(*regs));
  328         return (0);
  329 }
  331 int
process_read_xmmregs(struct proc *p, struct xmmregs *regs)
  333 {
  334         union savefpu *frame = process_fpframe(p);
  336         if (!i386_use_fxsave)
  337                 return (EINVAL);
  339         if (p->p_md.md_flags & MDP_USEDFPU) {
  340 #if NNPX > 0
npxsave_proc(p, 1);
  342 #endif
  343         } else {
  344                 /* Fake a FNINIT. */
process_fninit_xmm(&frame->sv_xmm);
p->p_md.md_flags |= MDP_USEDFPU;
  347         }
memcpy(regs, &frame->sv_xmm, sizeof(*regs));
  350         return (0);
  351 }
  353 int
process_write_xmmregs(struct proc *p, const struct xmmregs *regs)
  355 {
  356         union savefpu *frame = process_fpframe(p);
  358         if (!i386_use_fxsave)
  359                 return (EINVAL);
  361         if (p->p_md.md_flags & MDP_USEDFPU) {
  362 #if NNPX > 0
npxsave_proc(p, 0);
  364 #endif
  365         } else
p->p_md.md_flags |= MDP_USEDFPU;
memcpy(&frame->sv_xmm, regs, sizeof(*regs));
  369         return (0);
  370 }
  372 int
process_sstep(struct proc *p, int sstep)
  374 {
  375         struct trapframe *tf = process_frame(p);
  377         if (sstep)
tf->tf_eflags |= PSL_T;
  379         else
tf->tf_eflags &= ~PSL_T;
  382         return (0);
  383 }
  385 int
process_set_pc(struct proc *p, caddr_t addr)
  387 {
  388         struct trapframe *tf = process_frame(p);
tf->tf_eip = (int)addr;
  392         return (0);
  393 }
  395 #endif  /* PTRACE */