v86_x86emu.c

   1 #include <stdarg.h>
   2 #include <string.h>
   3 #include <x86emu.h>
   4 #include "v86.h"
   5 #include "v86_x86emu.h"
   6
   7 u32 stack;
   8 u32 halt;
   9
  10 __BUILDIO(b,b,u8);
  11 __BUILDIO(w,w,u16);
  12 __BUILDIO(l,,u32);
  13
  14 void printk(const char *fmt, ...)
  15 {
  16         va_list argptr;
  17         va_start(argptr, fmt);
  18         vsyslog(LOG_INFO, fmt, argptr);
  19         va_end(argptr);
  20 }
  21
  22 void pushw(u16 val)
  23 {
  24         X86_ESP -= 2;
  25         v_wrw(((u32) X86_SS << 4) + X86_SP, val);
  26 }
  27
  28 static void x86emu_do_int(int num)
  29 {
  30         u32 eflags;
  31
  32         eflags = X86_EFLAGS;
  33
  34         /* Return address and flags */
  35         pushw(eflags);
  36         pushw(X86_CS);
  37         pushw(X86_IP);
  38
  39         X86_EFLAGS = X86_EFLAGS & ~(X86_VIF_MASK | X86_TF_MASK);
  40         X86_CS = v_rdw((num << 2) + 2);
  41         X86_IP = v_rdw((num << 2));
  42 }
  43
  44 int v86_init()
  45 {
  46         X86EMU_intrFuncs intFuncs[256];
  47         X86EMU_pioFuncs pioFuncs = {
  48                 .inb = &x_inb,
  49                 .inw = &x_inw,
  50                 .inl = &x_inl,
  51                 .outb = &x_outb,
  52                 .outw = &x_outw,
  53                 .outl = &x_outl,
  54         };
  55
  56         X86EMU_memFuncs memFuncs = {
  57                 .rdb = &v_rdb,
  58                 .rdw = &v_rdw,
  59                 .rdl = &v_rdl,
  60                 .wrb = &v_wrb,
  61                 .wrw = &v_wrw,
  62                 .wrl = &v_wrl,
  63         };
  64
  65         int i;
  66
  67         if (v86_mem_init()) {
  68                 ulog(LOG_ERR, "v86 memory initialization failed.");
  69                 return -1;
  70         }
  71
  72         stack = v86_mem_alloc(DEFAULT_STACK_SIZE);
  73         if (!stack) {
  74                 ulog(LOG_ERR, "v86 memory allocation failed.");
  75                 return -1;
  76         }
  77
  78         X86_SS = stack >> 4;
  79         X86_ESP = DEFAULT_STACK_SIZE;
  80
  81         halt = v86_mem_alloc(0x100);
  82         if (!halt) {
  83                 ulog(LOG_ERR, "v86 memory alocation failed.");
  84                 return -1;
  85         }
  86         v_wrb(halt, 0xF4);
  87
  88         X86EMU_setupPioFuncs(&pioFuncs);
  89         X86EMU_setupMemFuncs(&memFuncs);
  90
  91         /* Setup interrupt handlers */
  92         for (i = 0; i < 256; i++) {
  93                 intFuncs[i] = x86emu_do_int;
  94         }
  95         X86EMU_setupIntrFuncs(intFuncs);
  96
  97         /* Set the default flags */
  98         X86_EFLAGS = X86_IF_MASK | X86_IOPL_MASK;
  99
 100         ioperm(0, 1024, 1);
 101         iopl(3);
 102
 103         return 0;
 104 }
 105
 106 void v86_cleanup()
 107 {
 108         v86_mem_cleanup();
 109 }
 110
 111 void rconv_v86_to_x86emu(struct v86_regs *rs)
 112 {
 113         X86_EAX = rs->eax;
 114         X86_EBX = rs->ebx;
 115         X86_ECX = rs->ecx;
 116         X86_EDX = rs->edx;
 117         X86_EDI = rs->edi;
 118         X86_ESI = rs->esi;
 119         X86_EBP = rs->ebp;
 120         X86_ESP = rs->esp;
 121         X86_EFLAGS = rs->eflags;
 122         X86_EIP = rs->eip;
 123         X86_CS  = rs->cs;
 124         X86_DS  = rs->ds;
 125         X86_ES  = rs->es;
 126         X86_FS  = rs->fs;
 127         X86_GS  = rs->gs;
 128 }
 129
 130 void rconv_x86emu_to_v86(struct v86_regs *rd)
 131 {
 132         rd->eax = X86_EAX;
 133         rd->ebx = X86_EBX;
 134         rd->ecx = X86_ECX;
 135         rd->edx = X86_EDX;
 136         rd->edi = X86_EDI;
 137         rd->esi = X86_ESI;
 138         rd->ebp = X86_EBP;
 139         rd->esp = X86_ESP;
 140         rd->eflags = X86_EFLAGS;
 141         rd->eip = X86_EIP;
 142         rd->cs  = X86_CS;
 143         rd->ds  = X86_DS;
 144         rd->es  = X86_ES;
 145         rd->fs  = X86_FS;
 146         rd->gs  = X86_GS;
 147 }
 148
 149 /*
 150  * Perform a simulated interrupt call.
 151  */
 152 int v86_int(int num, struct v86_regs *regs)
 153 {
 154         rconv_v86_to_x86emu(regs);
 155
 156         X86_GS = 0;
 157         X86_FS = 0;
 158         X86_DS = 0x0040;
 159         X86_CS  = v_rdw((num << 2) + 2);
 160         X86_EIP = v_rdw((num << 2));
 161         X86_SS = stack >> 4;
 162         X86_ESP = DEFAULT_STACK_SIZE;
 163         X86_EFLAGS = X86_IF_MASK | X86_IOPL_MASK;
 164
 165         pushw(X86_EFLAGS);
 166         pushw((halt >> 4));
 167         pushw(0x0);
 168
 169         X86EMU_exec();
 170
 171         rconv_x86emu_to_v86(regs);
 172         return 0;
 173 }
 174
 175 void v86_dump_regs()
 176 {
 177         ulog(LOG_DEBUG,
 178                 "EAX=0x%8.8lx, EBX=0x%8.8lx, ECX=0x%8.8lx, EDX=0x%8.8lx\n",
 179                 (unsigned long)X86_EAX, (unsigned long)X86_EBX,
 180                 (unsigned long)X86_ECX, (unsigned long)X86_EDX);
 181         ulog(LOG_DEBUG,
 182                 "ESP=0x%8.8lx, EBP=0x%8.8lx, ESI=0x%8.8lx, EDI=0x%8.8lx\n",
 183                 (unsigned long)X86_ESP, (unsigned long)X86_EBP,
 184                 (unsigned long)X86_ESI, (unsigned long)X86_EDI);
 185     ulog(LOG_DEBUG,
 186                 "CS=0x%4.4x, SS=0x%4.4x,"
 187                 " DS=0x%4.4x, ES=0x%4.4x, FS=0x%4.4x, GS=0x%4.4x\n",
 188                 X86_CS, X86_SS, X86_DS, X86_ES, X86_FS, X86_GS);
 189     ulog(LOG_DEBUG,
 190                 "EIP=0x%8.8lx, EFLAGS=0x%8.8lx\n",
 191                 (unsigned long)X86_EIP, (unsigned long)X86_EFLAGS);
 192 }
 193