root/arch/i386/i386/kvm86.c

DEFINITIONS

1. kvm86_init
2. kvm86_prepare
3. kvm86_map
4. kvm86_mapbios
5. kvm86_bios_addpage
6. kvm86_bios_delpage
7. kvm86_bios_read
8. kvm86_bioscall
9. kvm86_simplecall
10. kvm86_gpfault

    1 /* $OpenBSD: kvm86.c,v 1.3 2007/02/20 21:15:01 tom Exp $ */
    2 /* $NetBSD: kvm86.c,v 1.10 2005/12/26 19:23:59 perry Exp $ */
    3 /*
    4  * Copyright (c) 2002
    5  *      Matthias Drochner.  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 AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, 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 #include <sys/cdefs.h>
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/proc.h>
   33 #include <sys/user.h>
   34 #include <sys/malloc.h>
   35 #include <sys/mutex.h>
   36 #include <sys/simplelock.h>
   37 #include <uvm/uvm_extern.h>
   38 #include <uvm/uvm.h>
   39 #include <machine/pcb.h>
   40 #include <machine/pte.h>
   41 #include <machine/pmap.h>
   42 #include <machine/kvm86.h>
   43 #include <machine/cpu.h>
   45 /* assembler functions in kvm86call.s */
   46 extern int kvm86_call(struct trapframe *);
   47 extern void kvm86_ret(struct trapframe *, int);
   49 #define PGTABLE_SIZE    ((1024 + 64) * 1024 / PAGE_SIZE)
   51 struct kvm86_data {
pt_entry_t pgtbl[PGTABLE_SIZE];
   54         struct segment_descriptor sd;
   56         struct pcb pcb;
u_long iomap[0x10000/32];
   58 };
   60 void kvm86_map(struct kvm86_data *, paddr_t, uint32_t);
   61 void kvm86_mapbios(struct kvm86_data *);
   62 void kvm86_prepare(struct kvm86_data *vmd);
   63 /*
   64  * global VM for BIOS calls
   65  */
   66 struct kvm86_data *bioscallvmd;
   67 /* page for trampoline and stack */
   68 void *bioscallscratchpage;
   69 /* where this page is mapped in the vm86 */
   70 #define BIOSCALLSCRATCHPAGE_VMVA 0x1000
   71 /* a virtual page to map in vm86 memory temporarily */
vaddr_t bioscalltmpva;
   74 struct mutex kvm86_mp_mutex;
   76 #define KVM86_IOPL3 /* not strictly necessary, saves a lot of traps */
   78 void
kvm86_init()
   80 {
size_t vmdsize;
   82         char *buf;
   83         struct kvm86_data *vmd;
   84         struct pcb *pcb;
paddr_t pa;
   86         int i;
vmdsize = round_page(sizeof(struct kvm86_data)) + PAGE_SIZE;
   90         if ((buf = (char *)uvm_km_zalloc(kernel_map, vmdsize)) == NULL)
   91                 return;
   93         /* first page is stack */
vmd = (struct kvm86_data *)(buf + PAGE_SIZE);
pcb = &vmd->pcb;
   97         /*
   98          * derive pcb and TSS from proc0
   99          * we want to access all IO ports, so we need a full-size
  100          *  permission bitmap
  101          * XXX do we really need the pcb or just the TSS?
  102          */
memcpy(pcb, &proc0.p_addr->u_pcb, sizeof(struct pcb));
pcb->pcb_tss.tss_esp0 = (int)vmd;
pcb->pcb_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL);
  106         for (i = 0; i < sizeof(vmd->iomap) / 4; i++)
vmd->iomap[i] = 0;
pcb->pcb_tss.tss_ioopt =
  109             ((caddr_t)vmd->iomap - (caddr_t)&pcb->pcb_tss) << 16;
  111         /* setup TSS descriptor (including our iomap) */
setsegment(&vmd->sd, &pcb->pcb_tss,
  113             sizeof(struct pcb) + sizeof(vmd->iomap) - 1,
SDT_SYS386TSS, SEL_KPL, 0, 0);
  116         /* prepare VM for BIOS calls */
kvm86_mapbios(vmd);
  118         if ((bioscallscratchpage = (void *)uvm_km_alloc(kernel_map, PAGE_SIZE))
  119             == 0)
  120                 return;
pmap_extract(pmap_kernel(), (vaddr_t)bioscallscratchpage, &pa);
kvm86_map(vmd, pa, BIOSCALLSCRATCHPAGE_VMVA);
bioscallvmd = vmd;
bioscalltmpva = uvm_km_alloc(kernel_map, PAGE_SIZE);
mtx_init(&kvm86_mp_mutex, IPL_IPI);
  127 }
  129 /*
  130  * XXX pass some stuff to the assembler code
  131  * XXX this should be done cleanly (in call argument to kvm86_call())
  132  */
  134 volatile struct pcb *vm86pcb;
  135 volatile int vm86tssd0, vm86tssd1;
  136 volatile paddr_t vm86newptd;
  137 volatile struct trapframe *vm86frame;
  138 volatile pt_entry_t *vm86pgtableva;
  140 void
kvm86_prepare(struct kvm86_data *vmd)
  142 {
vm86newptd = vtophys((vaddr_t)vmd) | PG_V | PG_RW | PG_U | PG_u;
vm86pgtableva = vmd->pgtbl;
vm86frame = (struct trapframe *)vmd - 1;
vm86pcb = &vmd->pcb;
vm86tssd0 = *(int*)&vmd->sd;
vm86tssd1 = *((int*)&vmd->sd + 1);
  149 }
  151 void
kvm86_map(struct kvm86_data *vmd, paddr_t pa, uint32_t vmva)
  153 {
vmd->pgtbl[vmva >> 12] = pa | PG_V | PG_RW | PG_U | PG_u;
  156 }
  158 void
kvm86_mapbios(struct kvm86_data *vmd)
  160 {
paddr_t pa;
  163         /* map first physical page (vector table, BIOS data) */
kvm86_map(vmd, 0, 0);
  166         /* map ISA hole */
  167         for (pa = 0xa0000; pa < 0x100000; pa += PAGE_SIZE)
kvm86_map(vmd, pa, pa);
  169 }
  171 void *
kvm86_bios_addpage(uint32_t vmva)
  173 {
  174         void *mem;
paddr_t pa;
  177         if (bioscallvmd->pgtbl[vmva >> 12]) /* allocated? */
  178                 return (NULL);
  180         if ((mem = (void *)uvm_km_alloc(kernel_map, PAGE_SIZE)) == NULL)
  181                 return (NULL);
pmap_extract(pmap_kernel(), (vaddr_t)mem, &pa); 
kvm86_map(bioscallvmd, pa, vmva);
  186         return (mem);
  187 }
  189 void
kvm86_bios_delpage(uint32_t vmva, void *kva)
  191 {
bioscallvmd->pgtbl[vmva >> 12] = 0;
uvm_km_free(kernel_map, (vaddr_t)kva, PAGE_SIZE);
  195 }
size_t
kvm86_bios_read(u_int32_t vmva, char *buf, size_t len)
  199 {
size_t todo, now;
paddr_t vmpa;
todo = len;
  204         while (todo > 0) {
now = min(todo, PAGE_SIZE - (vmva & (PAGE_SIZE - 1)));
  207                 if (!bioscallvmd->pgtbl[vmva >> 12])
  208                         break;
vmpa = bioscallvmd->pgtbl[vmva >> 12] & ~(PAGE_SIZE - 1);
pmap_kenter_pa(bioscalltmpva, vmpa, VM_PROT_READ);
pmap_update(pmap_kernel());
memcpy(buf, (void *)(bioscalltmpva + (vmva & (PAGE_SIZE - 1))),
now);
buf += now;
todo -= now;
vmva += now;
  218         }
  219         return (len - todo);
  220 }
  222 int
kvm86_bioscall(int intno, struct trapframe *tf)
  224 {
  225         static const unsigned char call[] = {
  226                 0xfa, /* CLI */
  227                 0xcd, /* INTxx */
  228                 0,
  229                 0xfb, /* STI */
  230                 0xf4  /* HLT */
  231         };
memcpy(bioscallscratchpage, call, sizeof(call));
  234         *((unsigned char *)bioscallscratchpage + 2) = intno;
tf->tf_eip = BIOSCALLSCRATCHPAGE_VMVA;
tf->tf_cs = 0;
tf->tf_esp = BIOSCALLSCRATCHPAGE_VMVA + PAGE_SIZE - 2;
tf->tf_ss = 0;
tf->tf_eflags = PSL_USERSET | PSL_VM;
  241 #ifdef KVM86_IOPL3
tf->tf_eflags |= PSL_IOPL;
  243 #endif
tf->tf_ds = tf->tf_es = tf->tf_fs = tf->tf_gs = 0;
kvm86_prepare(bioscallvmd); /* XXX */
  247         return (kvm86_call(tf));
  248 }
  250 int
kvm86_simplecall(int no, struct kvm86regs *regs)
  252 {
  253         struct trapframe tf;
  254         int res;
memset(&tf, 0, sizeof(struct trapframe));
tf.tf_eax = regs->eax;
tf.tf_ebx = regs->ebx;
tf.tf_ecx = regs->ecx;
tf.tf_edx = regs->edx;
tf.tf_esi = regs->esi;
tf.tf_edi = regs->edi;
tf.tf_vm86_es = regs->es;
mtx_enter(&kvm86_mp_mutex);     
res = kvm86_bioscall(no, &tf);
mtx_leave(&kvm86_mp_mutex);
regs->eax = tf.tf_eax;
regs->ebx = tf.tf_ebx;
regs->ecx = tf.tf_ecx;
regs->edx = tf.tf_edx;
regs->esi = tf.tf_esi;
regs->edi = tf.tf_edi;
regs->es = tf.tf_vm86_es;
regs->eflags = tf.tf_eflags;
  278         return (res);
  279 }
  281 void
kvm86_gpfault(struct trapframe *tf)
  283 {
  284         unsigned char *kva, insn, trapno;
uint16_t *sp;
kva = (unsigned char *)((tf->tf_cs << 4) + tf->tf_eip);
insn = *kva;
  289 #ifdef KVM86DEBUG
printf("kvm86_gpfault: cs=%x, eip=%x, insn=%x, eflags=%x\n",
tf->tf_cs, tf->tf_eip, insn, tf->tf_eflags);
  292 #endif
KASSERT(tf->tf_eflags & PSL_VM);
  296         switch (insn) {
  297         case 0xf4: /* HLT - normal exit */
kvm86_ret(tf, 0);
  299                 break;
  300         case 0xcd: /* INTxx */
  301                 /* fake a return stack frame and call real mode handler */
trapno = *(kva + 1);
sp = (uint16_t *)((tf->tf_ss << 4) + tf->tf_esp);
  304                 *(--sp) = tf->tf_eflags;
  305                 *(--sp) = tf->tf_cs;
  306                 *(--sp) = tf->tf_eip + 2;
tf->tf_esp -= 6;
tf->tf_cs = *(uint16_t *)(trapno * 4 + 2);
tf->tf_eip = *(uint16_t *)(trapno * 4);
  310                 break;
  311         case 0xcf: /* IRET */
sp = (uint16_t *)((tf->tf_ss << 4) + tf->tf_esp);
tf->tf_eip = *(sp++);
tf->tf_cs = *(sp++);
tf->tf_eflags = *(sp++);
tf->tf_esp += 6;
tf->tf_eflags |= PSL_VM; /* outside of 16bit flag reg */
  318                 break;
  319 #ifndef KVM86_IOPL3 /* XXX check VME? */
  320         case 0xfa: /* CLI */
  321         case 0xfb: /* STI */
  322                 /* XXX ignore for now */
tf->tf_eip++;
  324                 break;
  325         case 0x9c: /* PUSHF */
sp = (uint16_t *)((tf->tf_ss << 4) + tf->tf_esp);
  327                 *(--sp) = tf->tf_eflags;
tf->tf_esp -= 2;
tf->tf_eip++;
  330                 break;
  331         case 0x9d: /* POPF */
sp = (uint16_t *)((tf->tf_ss << 4) + tf->tf_esp);
tf->tf_eflags = *(sp++);
tf->tf_esp += 2;
tf->tf_eip++;
tf->tf_eflags |= PSL_VM; /* outside of 16bit flag reg */
  337                 break;
  338 #endif
  339         default:
  340 #ifdef KVM86DEBUG
printf("kvm86_gpfault: unhandled\n");
  342 #else
printf("kvm86_gpfault: cs=%x, eip=%x, insn=%x, eflags=%x\n",
tf->tf_cs, tf->tf_eip, insn, tf->tf_eflags);
  345 #endif
  346                 /*
  347                  * signal error to caller
  348                  */
kvm86_ret(tf, -1);
  350                 break;
  351         }
  352 }