| /* |
| * Copyright 1999 Egbert Eich |
| * |
| * Permission to use, copy, modify, distribute, and sell this software and its |
| * documentation for any purpose is hereby granted without fee, provided that |
| * the above copyright notice appear in all copies and that both that |
| * copyright notice and this permission notice appear in supporting |
| * documentation, and that the name of the authors not be used in |
| * advertising or publicity pertaining to distribution of the software without |
| * specific, written prior permission. The authors makes no representations |
| * about the suitability of this software for any purpose. It is provided |
| * "as is" without express or implied warranty. |
| * |
| * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO |
| * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
| * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| #include "debug.h" |
| #include <sys/vm86.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <asm/unistd.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <signal.h> |
| #include <setjmp.h> |
| #include "v86bios.h" |
| #include "AsmMacros.h" |
| |
| struct vm86_struct vm86s; |
| |
| static int vm86_GP_fault(void); |
| static int vm86_do_int(int num); |
| static void dump_code(void); |
| static void dump_registers(void); |
| static void stack_trace(void); |
| static int vm86_rep(struct vm86_struct *ptr); |
| |
| #define CPU_REG(x) (vm86s.regs.##x) |
| #define CPU_REG_LW(reg) (*((CARD16 *)&CPU_REG(reg))) |
| #define CPU_REG_HW(reg) (*((CARD16 *)&CPU_REG(reg) + 1)) |
| #define CPU_REG_LB(reg) (*(CARD8 *)&CPU_REG(e##reg)) |
| #define SEG_ADR(type, seg, reg) type((CPU_REG_LW(seg) << 4) \ |
| + CPU_REG_LW(e##reg)) |
| #define DF (1 << 10) |
| |
| struct pio P; |
| |
| |
| void |
| setup_io(void) |
| { |
| if (!Config.PrintPort && !Config.IoStatistics) { |
| P.inb = (CARD8(*)(CARD16))inb; |
| P.inw = (CARD16(*)(CARD16))inw; |
| P.inl = (CARD32(*)(CARD16))inl; |
| P.outb = (void(*)(CARD16,CARD8))outb; |
| P.outw = (void(*)(CARD16,CARD16))outw; |
| P.outl = (void(*)(CARD16,CARD32))outl; |
| } else { |
| P.inb = p_inb; |
| P.inw = p_inw; |
| P.inl = p_inl; |
| P.outb = p_outb; |
| P.outw = p_outw; |
| P.outl = p_outl; |
| } |
| } |
| |
| |
| static void |
| setup_vm86(unsigned long bios_start, i86biosRegsPtr regs) |
| { |
| CARD32 eip; |
| CARD16 cs; |
| |
| vm86s.flags = VM86_SCREEN_BITMAP; |
| vm86s.flags = 0; |
| vm86s.screen_bitmap = 0; |
| vm86s.cpu_type = CPU_586; |
| memset(&vm86s.int_revectored, 0xff,sizeof(vm86s.int_revectored)) ; |
| memset(&vm86s.int21_revectored, 0xff,sizeof(vm86s.int21_revectored)) ; |
| |
| eip = bios_start & 0xFFFF; |
| cs = (bios_start & 0xFF0000) >> 4; |
| |
| CPU_REG(eax) = regs->ax; |
| CPU_REG(ebx) = regs->bx; |
| CPU_REG(ecx) = regs->cx; |
| CPU_REG(edx) = regs->dx; |
| CPU_REG(esi) = 0; |
| CPU_REG(edi) = regs->di; |
| CPU_REG(ebp) = 0; |
| CPU_REG(eip) = eip; |
| CPU_REG(cs) = cs; |
| CPU_REG(esp) = 0x100; |
| CPU_REG(ss) = 0x30; /* This is the standard pc bios stack */ |
| CPU_REG(es) = regs->es; |
| CPU_REG(ds) = 0x40; /* standard pc ds */ |
| CPU_REG(fs) = 0; |
| CPU_REG(gs) = 0; |
| CPU_REG(eflags) |= (VIF_MASK | VIP_MASK); |
| } |
| |
| void |
| collect_bios_regs(i86biosRegsPtr regs) |
| { |
| regs->ax = CPU_REG(eax); |
| regs->bx = CPU_REG(ebx); |
| regs->cx = CPU_REG(ecx); |
| regs->dx = CPU_REG(edx); |
| regs->es = CPU_REG(es); |
| regs->ds = CPU_REG(ds); |
| regs->di = CPU_REG(edi); |
| regs->si = CPU_REG(esi); |
| } |
| |
| static int |
| do_vm86(void) |
| { |
| int retval; |
| |
| #ifdef V86BIOS_DEBUG |
| dump_registers(); |
| #endif |
| // retval = SYS_vm86old(&vm86s); |
| // retval = syscall(SYS_vm86old,&vm86s); |
| |
| retval = vm86_rep(&vm86s); |
| |
| switch (VM86_TYPE(retval)) { |
| case VM86_UNKNOWN: |
| if (!vm86_GP_fault()) return 0; |
| break; |
| case VM86_STI: |
| fprintf(stderr,"vm86_sti :-((\n"); |
| stack_trace(); |
| dump_code(); |
| return 0; |
| case VM86_INTx: |
| if (!vm86_do_int(VM86_ARG(retval))) { |
| fprintf(stderr,"\nUnknown vm86_int: %X\n\n",VM86_ARG(retval)); |
| dump_registers(); |
| return 0; |
| } |
| /* I'm not sure yet what to do if we can handle ints */ |
| break; |
| case VM86_SIGNAL: |
| fprintf(stderr,"received signal\n"); |
| return 0; |
| default: |
| fprintf(stderr,"unknown type(0x%x)=0x%x\n", |
| VM86_ARG(retval),VM86_TYPE(retval)); |
| dump_registers(); |
| dump_code(); |
| stack_trace(); |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| static jmp_buf x86_esc; |
| static void |
| vmexit(int unused) |
| { |
| longjmp(x86_esc,1); |
| } |
| |
| void |
| do_x86(unsigned long bios_start, i86biosRegsPtr regs) |
| { |
| static void (*org_handler)(int); |
| |
| setup_vm86(bios_start, regs); |
| if (setjmp(x86_esc) == 0) { |
| org_handler = signal(2,vmexit); |
| while(do_vm86()) {}; |
| signal(2,org_handler); |
| collect_bios_regs(regs); |
| } else { |
| signal(2,org_handler); |
| printf("interrupted at 0x%x\n",((CARD16)CPU_REG(cs)) << 4 |
| | (CARD16)CPU_REG(eip)); |
| } |
| } |
| |
| /* get the linear address */ |
| #define LIN_PREF_SI ((pref_seg << 4) + CPU_REG_LW(esi)) |
| |
| #define LWECX (prefix66 ^ prefix67 ? CPU_REG(ecx) : CPU_REG_LW(ecx)) |
| |
| static int |
| vm86_GP_fault(void) |
| { |
| unsigned char *csp, *lina; |
| CARD32 org_eip; |
| int pref_seg; |
| int done,is_rep,prefix66,prefix67; |
| |
| |
| csp = lina = SEG_ADR((unsigned char *), cs, ip); |
| #ifdef V86BIOS_DEBUG |
| printf("exception: \n"); |
| dump_code(); |
| #endif |
| |
| is_rep = 0; |
| prefix66 = prefix67 = 0; |
| pref_seg = -1; |
| |
| /* eat up prefixes */ |
| done = 0; |
| do { |
| switch (*(csp++)) { |
| case 0x66: /* operand prefix */ prefix66=1; break; |
| case 0x67: /* address prefix */ prefix67=1; break; |
| case 0x2e: /* CS */ pref_seg=CPU_REG(cs); break; |
| case 0x3e: /* DS */ pref_seg=CPU_REG(ds); break; |
| case 0x26: /* ES */ pref_seg=CPU_REG(es); break; |
| case 0x36: /* SS */ pref_seg=CPU_REG(ss); break; |
| case 0x65: /* GS */ pref_seg=CPU_REG(gs); break; |
| case 0x64: /* FS */ pref_seg=CPU_REG(fs); break; |
| case 0xf2: /* repnz */ |
| case 0xf3: /* rep */ is_rep=1; break; |
| default: done=1; |
| } |
| } while (!done); |
| csp--; /* oops one too many */ |
| org_eip = CPU_REG(eip); |
| CPU_REG_LW(eip) += (csp - lina); |
| |
| switch (*csp) { |
| |
| case 0x6c: /* insb */ |
| /* NOTE: ES can't be overwritten; prefixes 66,67 should use esi,edi,ecx |
| * but is anyone using extended regs in real mode? */ |
| /* WARNING: no test for DI wrapping! */ |
| CPU_REG_LW(edi) += port_rep_inb(CPU_REG_LW(edx), |
| SEG_ADR((CARD8 *),es,di), |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| if (is_rep) LWECX = 0; |
| CPU_REG_LW(eip)++; |
| break; |
| |
| case 0x6d: /* (rep) insw / insd */ |
| /* NOTE: ES can't be overwritten */ |
| /* WARNING: no test for _DI wrapping! */ |
| if (prefix66) { |
| CPU_REG_LW(edi) += port_rep_inl(CPU_REG_LW(edx), |
| SEG_ADR((CARD32 *),es,di), |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| } |
| else { |
| CPU_REG_LW(edi) += port_rep_inw(CPU_REG_LW(edx), |
| SEG_ADR((CARD16 *),es,di), |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| } |
| if (is_rep) LWECX = 0; |
| CPU_REG_LW(eip)++; |
| break; |
| |
| case 0x6e: /* (rep) outsb */ |
| if (pref_seg < 0) pref_seg = CPU_REG_LW(ds); |
| /* WARNING: no test for _SI wrapping! */ |
| CPU_REG_LW(esi) += port_rep_outb(CPU_REG_LW(edx),(CARD8*)LIN_PREF_SI, |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| if (is_rep) LWECX = 0; |
| CPU_REG_LW(eip)++; |
| break; |
| |
| case 0x6f: /* (rep) outsw / outsd */ |
| if (pref_seg < 0) pref_seg = CPU_REG_LW(ds); |
| /* WARNING: no test for _SI wrapping! */ |
| if (prefix66) { |
| CPU_REG_LW(esi) += port_rep_outl(CPU_REG_LW(edx), |
| (CARD32 *)LIN_PREF_SI, |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| } |
| else { |
| CPU_REG_LW(esi) += port_rep_outw(CPU_REG_LW(edx), |
| (CARD16 *)LIN_PREF_SI, |
| CPU_REG_LW(eflags)&DF, |
| (is_rep? LWECX:1)); |
| } |
| if (is_rep) LWECX = 0; |
| CPU_REG_LW(eip)++; |
| break; |
| |
| case 0xe5: /* inw xx, inl xx */ |
| if (prefix66) CPU_REG(eax) = P.inl((int) csp[1]); |
| else CPU_REG_LW(eax) = P.inw((int) csp[1]); |
| CPU_REG_LW(eip) += 2; |
| break; |
| case 0xe4: /* inb xx */ |
| CPU_REG_LW(eax) &= ~(CARD32)0xff; |
| CPU_REG_LB(ax) |= P.inb((int) csp[1]); |
| CPU_REG_LW(eip) += 2; |
| break; |
| case 0xed: /* inw dx, inl dx */ |
| if (prefix66) CPU_REG(eax) = P.inl(CPU_REG_LW(edx)); |
| else CPU_REG_LW(eax) = P.inw(CPU_REG_LW(edx)); |
| CPU_REG_LW(eip) += 1; |
| break; |
| case 0xec: /* inb dx */ |
| CPU_REG_LW(eax) &= ~(CARD32)0xff; |
| CPU_REG_LB(ax) |= P.inb(CPU_REG_LW(edx)); |
| CPU_REG_LW(eip) += 1; |
| break; |
| |
| case 0xe7: /* outw xx */ |
| if (prefix66) P.outl((int)csp[1], CPU_REG(eax)); |
| else P.outw((int)csp[1], CPU_REG_LW(eax)); |
| CPU_REG_LW(eip) += 2; |
| break; |
| case 0xe6: /* outb xx */ |
| P.outb((int) csp[1], CPU_REG_LB(ax)); |
| CPU_REG_LW(eip) += 2; |
| break; |
| case 0xef: /* outw dx */ |
| if (prefix66) P.outl(CPU_REG_LW(edx), CPU_REG(eax)); |
| else P.outw(CPU_REG_LW(edx), CPU_REG_LW(eax)); |
| CPU_REG_LW(eip) += 1; |
| break; |
| case 0xee: /* outb dx */ |
| P.outb(CPU_REG_LW(edx), CPU_REG_LB(ax)); |
| CPU_REG_LW(eip) += 1; |
| break; |
| |
| case 0xf4: |
| #ifdef V86BIOS_DEBUG |
| printf("hlt at %p\n", lina); |
| #endif |
| return 0; |
| |
| case 0x0f: |
| fprintf(stderr,"CPU 0x0f Trap at eip=0x%lx\n",CPU_REG(eip)); |
| goto op0ferr; |
| break; |
| |
| case 0xf0: /* lock */ |
| default: |
| fprintf(stderr,"unknown reason for exception\n"); |
| dump_registers(); |
| stack_trace(); |
| op0ferr: |
| dump_code(); |
| fprintf(stderr,"cannot continue\n"); |
| return 0; |
| } /* end of switch() */ |
| return 1; |
| } |
| |
| static int |
| vm86_do_int(int num) |
| { |
| int val; |
| struct regs86 regs; |
| |
| i_printf("int 0x%x received: ax:0x%lx",num,CPU_REG(eax)); |
| if (Config.PrintIp) |
| i_printf(" at: 0x%x\n",getIP()); |
| else |
| i_printf("\n"); |
| |
| /* try to run bios interrupt */ |
| |
| /* if not installed fall back */ |
| #define COPY(x) regs.##x = CPU_REG(x) |
| #define COPY_R(x) CPU_REG(x) = regs.##x |
| |
| COPY(eax); |
| COPY(ebx); |
| COPY(ecx); |
| COPY(edx); |
| COPY(esi); |
| COPY(edi); |
| COPY(ebp); |
| COPY(eip); |
| COPY(esp); |
| COPY(cs); |
| COPY(ss); |
| COPY(ds); |
| COPY(es); |
| COPY(fs); |
| COPY(gs); |
| COPY(eflags); |
| |
| if (!(val = int_handler(num,®s))) |
| if (!(val = run_bios_int(num,®s))) |
| return val; |
| |
| COPY_R(eax); |
| COPY_R(ebx); |
| COPY_R(ecx); |
| COPY_R(edx); |
| COPY_R(esi); |
| COPY_R(edi); |
| COPY_R(ebp); |
| COPY_R(eip); |
| COPY_R(esp); |
| COPY_R(cs); |
| COPY_R(ss); |
| COPY_R(ds); |
| COPY_R(es); |
| COPY_R(fs); |
| COPY_R(gs); |
| COPY_R(eflags); |
| |
| return val; |
| #undef COPY |
| #undef COPY_R |
| } |
| |
| static void |
| dump_code(void) |
| { |
| int i; |
| unsigned char *lina = SEG_ADR((unsigned char *), cs, ip); |
| |
| fprintf(stderr,"code at 0x%8.8x: ",(CARD32)lina); |
| for (i=0; i<0x10; i++) |
| fprintf(stderr,"%2.2x ",*(lina + i)); |
| fprintf(stderr,"\n "); |
| for (; i<0x20; i++) |
| fprintf(stderr,"%2.2x ",*(lina + i)); |
| fprintf(stderr,"\n"); |
| } |
| |
| #define PRINT(x) fprintf(stderr,#x":%4.4x ",CPU_REG_LW(x)) |
| #define PRINT_FLAGS(x) fprintf(stderr,#x":%8.8x ",CPU_REG_LW(x)) |
| static void |
| dump_registers(void) |
| { |
| PRINT(eip); |
| PRINT(eax); |
| PRINT(ebx); |
| PRINT(ecx); |
| PRINT(edx); |
| PRINT(esi); |
| PRINT(edi); |
| PRINT(ebp); |
| fprintf(stderr,"\n"); |
| PRINT(esp); |
| PRINT(cs); |
| PRINT(ss); |
| PRINT(es); |
| PRINT(ds); |
| PRINT(fs); |
| PRINT(gs); |
| PRINT_FLAGS(eflags); |
| fprintf(stderr,"\n"); |
| } |
| |
| static void |
| stack_trace(void) |
| { |
| int i; |
| unsigned char *stack = SEG_ADR((unsigned char *), ss, sp); |
| |
| fprintf(stderr,"stack at 0x%8.8lx:\n",(unsigned long)stack); |
| for (i=0; i < 0x10; i++) |
| fprintf(stderr,"%2.2x ",*(stack + i)); |
| fprintf(stderr,"\n"); |
| |
| } |
| |
| static int |
| vm86_rep(struct vm86_struct *ptr) |
| { |
| |
| int __res; |
| |
| __asm__ __volatile__("int $0x80\n" |
| :"=a" (__res):"a" ((int)113), |
| "b" ((struct vm86_struct *)ptr)); |
| |
| if ((__res) < 0) { |
| errno = -__res; |
| __res=-1; |
| } |
| else errno = 0; |
| return __res; |
| } |
| |
| #define pushw(base, ptr, val) \ |
| __asm__ __volatile__( \ |
| "decw %w0\n\t" \ |
| "movb %h2,(%1,%0)\n\t" \ |
| "decw %w0\n\t" \ |
| "movb %b2,(%1,%0)" \ |
| : "=r" (ptr) \ |
| : "r" (base), "q" (val), "0" (ptr)) |
| |
| int |
| run_bios_int(int num, struct regs86 *regs) |
| { |
| CARD16 *ssp; |
| CARD32 sp; |
| CARD32 eflags; |
| |
| #ifdef V86BIOS_DEBUG |
| static int firsttime = 1; |
| #endif |
| /* check if bios vector is initialized */ |
| if (((CARD16*)0)[(num<<1)+1] == 0x0000) { /* SYS_BIOS_SEG ?*/ |
| #ifdef V86BIOS_DEBUG |
| i_printf("card BIOS not loaded\n"); |
| #endif |
| return 0; |
| } |
| |
| #ifdef V86BIOS_DEBUG |
| if (firsttime) { |
| dprint(0,0x3D0); |
| firsttime = 0; |
| } |
| #endif |
| |
| i_printf("calling card BIOS at: "); |
| ssp = (CARD16*)(CPU_REG(ss)<<4); |
| sp = (CARD32) CPU_REG_LW(esp); |
| |
| eflags = regs->eflags; |
| eflags = ((eflags & VIF_MASK) != 0) |
| ? (eflags | IF_MASK) : (eflags & ~(CARD32) IF_MASK); |
| pushw(ssp, sp, eflags); |
| pushw(ssp, sp, regs->cs); |
| pushw(ssp, sp, (CARD16)regs->eip); |
| regs->esp -= 6; |
| regs->cs = ((CARD16 *) 0)[(num << 1) + 1]; |
| regs->eip = (regs->eip & 0xFFFF0000) | ((CARD16 *) 0)[num << 1]; |
| i_printf("0x%x:%lx\n",regs->cs,regs->eip); |
| #ifdef V86BIOS_DEBUG |
| dump_code(); |
| #endif |
| regs->eflags = regs->eflags |
| & ~(VIF_MASK | TF_MASK | IF_MASK | NT_MASK); |
| return 1; |
| } |
| |
| CARD32 |
| getIntVect(int num) |
| { |
| return ((CARD32*)0)[num]; |
| } |
| |
| CARD32 |
| getIP(void) |
| { |
| return (CPU_REG(cs) << 4) + CPU_REG(eip); |
| } |
