Kernel/arch/x86/vm8086.c

   1 /*
   2  * Acess2 VM8086 Driver
   3  * - By John Hodge (thePowersGang)
   4  */
   5 #include <acess.h>
   6 #include <vm8086.h>
   7 #include <modules.h>
   8
   9 // === CONSTANTS ===
  10 #define VM8086_MAGIC_CS 0xFFFF
  11 #define VM8086_MAGIC_IP 0x0010
  12 #define VM8086_STACK_SEG        0x9F00
  13 #define VM8086_STACK_OFS        0x0AFE
  14 enum eVM8086_Opcodes
  15 {
  16         VM8086_OP_PUSHF = 0x9C,
  17         VM8086_OP_POPF  = 0x9D,
  18         VM8086_OP_INT_I = 0xCD,
  19         VM8086_OP_IRET  = 0xCF
  20 };
  21 #define VM8086_PAGES_PER_INST   4
  22
  23 // === IMPORTS ===
  24  int    Proc_Clone(Uint *Err, Uint Flags);
  25
  26 // === TYPES ===
  27 struct sVM8086_InternalData
  28 {
  29         struct {
  30                 Uint32  Bitmap; // 32 sections = 128 byte blocks
  31                 tVAddr  VirtBase;
  32                 tPAddr  PhysAddr;
  33         }       AllocatedPages[VM8086_PAGES_PER_INST];
  34 };
  35
  36 // === PROTOTYPES ===
  37  int    VM8086_Install(char **Arguments);
  38 void    VM8086_GPF(tRegs *Regs);
  39 tVM8086 *VM8086_Init(void);
  40
  41 // === GLOBALS ===
  42 MODULE_DEFINE(0, 0x100, VM8086, VM8086_Install, NULL, NULL);
  43 tSpinlock       glVM8086_Process;
  44 tPID    gVM8086_WorkerPID;
  45 tTID    gVM8086_CallingThread;
  46 tVM8086 * volatile gpVM8086_State;
  47
  48 // === FUNCTIONS ===
  49 int VM8086_Install(char **Arguments)
  50 {
  51         tPID    pid;
  52
  53         // Create BIOS Call process
  54         pid = Proc_Clone(NULL, CLONE_VM);
  55         if(pid == -1)
  56         {
  57                 Log_Error("VM8086", "Unable to clone kernel into VM8086 worker");
  58                 return MODULE_ERR_MISC;
  59         }
  60         if(pid == 0)
  61         {
  62                 Uint    *stacksetup;    // Initialising Stack
  63                 Uint16  *rmstack;       // Real Mode Stack
  64                  int    i;
  65
  66                 // Set Image Name
  67                 Threads_SetName("VM8086");
  68
  69                 // Map ROM Area
  70                 for(i=0xA0;i<0x100;i++) {
  71                         MM_Map( i * 0x1000, i * 0x1000 );
  72                         MM_SetFlags( i * 0x1000, MM_PFLAG_RO, MM_PFLAG_RO );    // Set Read Only
  73                 }
  74                 MM_Map( 0, 0 ); // IVT / BDA
  75                 for(i=0x70;i<0x80;i++) {
  76                         MM_Map( i * 0x1000, i * 0x1000 );       MM_DerefPhys( i * 0x1000 );
  77                 }
  78                 MM_Map( 0x9F000, 0x9F000 );     // Stack / EBDA
  79                 MM_Allocate( 0x100000 );        // System Stack / Stub
  80
  81                 *(Uint8*)(0x100000) = VM8086_OP_IRET;
  82                 *(Uint8*)(0x100001) = 0x07;     // POP ES
  83                 *(Uint8*)(0x100002) = 0x1F;     // POP DS
  84                 *(Uint8*)(0x100003) = 0xCB;     // RET FAR
  85
  86                 rmstack = (Uint16*)(VM8086_STACK_SEG*16 + VM8086_STACK_OFS);
  87                 *rmstack-- = 0xFFFF;    //CS
  88                 *rmstack-- = 0x0010;    //IP
  89
  90                 // Setup Stack
  91                 stacksetup = (Uint*)0x101000;
  92                 *--stacksetup = VM8086_STACK_SEG;       // GS
  93                 *--stacksetup = VM8086_STACK_SEG;       // FS
  94                 *--stacksetup = VM8086_STACK_SEG;       // DS
  95                 *--stacksetup = VM8086_STACK_SEG;       // ES
  96                 *--stacksetup = VM8086_STACK_SEG;       // SS
  97                 *--stacksetup = VM8086_STACK_OFS-2;     // SP
  98                 *--stacksetup = 0x20202;        // FLAGS
  99                 *--stacksetup = 0xFFFF; // CS
 100                 *--stacksetup = 0x10;   // IP
 101                 *--stacksetup = 0xAAAA; // AX
 102                 *--stacksetup = 0xCCCC; // CX
 103                 *--stacksetup = 0xDDDD; // DX
 104                 *--stacksetup = 0xBBBB; // BX
 105                 *--stacksetup = 0x5454; // SP
 106                 *--stacksetup = 0xB4B4; // BP
 107                 *--stacksetup = 0x5151; // SI
 108                 *--stacksetup = 0xD1D1; // DI
 109                 *--stacksetup = 0x20|3; // DS - Kernel
 110                 *--stacksetup = 0x20|3; // ES - Kernel
 111                 *--stacksetup = 0x20|3; // FS
 112                 *--stacksetup = 0x20|3; // GS
 113                 __asm__ __volatile__ (
 114                 "mov %%eax,%%esp;\n\t"  // Set stack pointer
 115                 "pop %%gs;\n\t"
 116                 "pop %%fs;\n\t"
 117                 "pop %%es;\n\t"
 118                 "pop %%ds;\n\t"
 119                 "popa;\n\t"
 120                 "iret;\n\t" : : "a" (stacksetup));
 121                 for(;;);        // Shouldn't be reached
 122         }
 123
 124         gVM8086_WorkerPID = pid;
 125         Log_Log("VM8086", "gVM8086_WorkerPID = %i", pid);
 126         Threads_Yield();        // Yield to allow the child to initialise
 127
 128         return MODULE_ERR_OK;
 129 }
 130
 131 void VM8086_GPF(tRegs *Regs)
 132 {
 133         Uint8   opcode;
 134
 135         //Log_Log("VM8086", "GPF - %04x:%04x", Regs->cs, Regs->eip);
 136
 137         if(Regs->eip == VM8086_MAGIC_IP && Regs->cs == VM8086_MAGIC_CS
 138         && Threads_GetPID() == gVM8086_WorkerPID)
 139         {
 140                 if( gpVM8086_State ) {
 141                         gpVM8086_State->AX = Regs->eax; gpVM8086_State->CX = Regs->ecx;
 142                         gpVM8086_State->DX = Regs->edx; gpVM8086_State->BX = Regs->ebx;
 143                         gpVM8086_State->BP = Regs->ebp;
 144                         gpVM8086_State->SI = Regs->esi; gpVM8086_State->DI = Regs->edi;
 145                         gpVM8086_State->DS = Regs->ds;  gpVM8086_State->ES = Regs->es;
 146                         gpVM8086_State = NULL;
 147                         Threads_WakeTID(gVM8086_CallingThread);
 148                 }
 149
 150                 //Log_Log("VM8086", "Waiting for something to do");
 151                 __asm__ __volatile__ ("sti");
 152                 // Wait for a new task
 153                 while(!gpVM8086_State) {
 154                         Threads_Sleep();
 155                         //Log_Log("VM8086", "gpVM8086_State = %p", gpVM8086_State);
 156                 }
 157
 158                 //Log_Log("VM8086", "We have a task");
 159                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = VM8086_MAGIC_CS;
 160                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = VM8086_MAGIC_IP;
 161                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = gpVM8086_State->CS;
 162                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = gpVM8086_State->IP;
 163                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = gpVM8086_State->DS;
 164                 Regs->esp -= 2; *(Uint16*)( (Regs->ss<<4) + (Regs->esp&0xFFFF) ) = gpVM8086_State->ES;
 165
 166                 // Set Registers
 167                 Regs->eip = 0x11;       Regs->cs = 0xFFFF;
 168                 Regs->eax = gpVM8086_State->AX; Regs->ecx = gpVM8086_State->CX;
 169                 Regs->edx = gpVM8086_State->DX; Regs->ebx = gpVM8086_State->BX;
 170                 Regs->esi = gpVM8086_State->SI; Regs->edi = gpVM8086_State->DI;
 171                 Regs->ebp = gpVM8086_State->BP;
 172                 Regs->ds = 0x23;        Regs->es = 0x23;
 173                 Regs->fs = 0x23;        Regs->gs = 0x23;
 174                 return ;
 175         }
 176
 177         opcode = *(Uint8*)( KERNEL_BASE + (Regs->cs*16) + (Regs->eip) );
 178         Regs->eip ++;
 179         switch(opcode)
 180         {
 181         case VM8086_OP_PUSHF:   //PUSHF
 182                 Regs->esp -= 2;
 183                 *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) ) = Regs->eflags & 0xFFFF;
 184                 #if TRACE_EMU
 185                 Log_Debug("VM8086", "Emulated PUSHF");
 186                 #endif
 187                 break;
 188         case VM8086_OP_POPF:    //POPF
 189                 Regs->eflags &= 0xFFFF0002;
 190                 Regs->eflags |= *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) ) & 0xFFFD;        // Changing IF is not allowed
 191                 Regs->esp += 2;
 192                 #if TRACE_EMU
 193                 Log_Debug("VM8086", "Emulated POPF");
 194                 #endif
 195                 break;
 196
 197         case VM8086_OP_INT_I:   //INT imm8
 198                 {
 199                  int    id;
 200                 id = *(Uint8*)( Regs->cs*16 +(Regs->eip&0xFFFF));
 201                 Regs->eip ++;
 202
 203                 Regs->esp -= 2; *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) ) = Regs->cs;
 204                 Regs->esp -= 2; *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) ) = Regs->eip;
 205
 206                 Regs->cs = *(Uint16*)(4*id + 2);
 207                 Regs->eip = *(Uint16*)(4*id);
 208                 #if TRACE_EMU
 209                 Log_Debug("VM8086", "Emulated INT 0x%x", id);
 210                 #endif
 211                 }
 212                 break;
 213
 214         case 0xCF:      //IRET
 215                 Regs->eip = *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) );     Regs->esp += 2;
 216                 Regs->cs  = *(Uint16*)( Regs->ss*16 + (Regs->esp&0xFFFF) );     Regs->esp += 2;
 217                 #if TRACE_EMU
 218                 Log_Debug("VM8086", "IRET to %04x:%04x", Regs->cs, Regs->eip);
 219                 #endif
 220                 break;
 221
 222         default:
 223                 Log_Error("VM8086", "Error - Unknown opcode %02x caused a GPF at %04x:%04x",
 224                         opcode, Regs->cs, Regs->eip);
 225                 // Force an end to the call
 226                 Regs->cs = VM8086_MAGIC_CS;
 227                 Regs->eip = VM8086_MAGIC_IP;
 228                 break;
 229         }
 230 }
 231
 232 /**
 233  * \brief Create an instance of the VM8086 Emulator
 234  */
 235 tVM8086 *VM8086_Init(void)
 236 {
 237         tVM8086 *ret;
 238         ret = calloc( 1, sizeof(tVM8086) + sizeof(struct sVM8086_InternalData) );
 239         ret->Internal = (void*)((tVAddr)ret + sizeof(tVM8086));
 240         return ret;
 241 }
 242
 243 void VM8086_Free(tVM8086 *State)
 244 {
 245          int    i;
 246         for( i = VM8086_PAGES_PER_INST; i --; )
 247                 MM_UnmapHWPages( State->Internal->AllocatedPages[i].VirtBase, 1);
 248         free(State);
 249 }
 250
 251 void *VM8086_Allocate(tVM8086 *State, int Size, Uint16 *Segment, Uint16 *Offset)
 252 {
 253          int    i, j, base = 0;
 254          int    nBlocks, rem;
 255         Uint32  bmp;
 256
 257         Size = (Size + 127) & ~127;
 258         nBlocks = Size >> 7;
 259
 260         if(Size > 4096) return NULL;
 261
 262         for( i = 0; i < VM8086_PAGES_PER_INST; i++ )
 263         {
 264                 if( State->Internal->AllocatedPages[i].VirtBase == 0 )  continue;
 265                 bmp = State->Internal->AllocatedPages[i].Bitmap;
 266                 rem = nBlocks;
 267                 base = 0;
 268                 // Scan the bitmap for a free block
 269                 for( j = 0; j < 32-nBlocks; j++ ) {
 270                         if( bmp & (1 << j) ) {
 271                                 base = 0;
 272                                 rem = nBlocks;
 273                         }
 274                         else {
 275                                 rem --;
 276                                 if(rem == 0)    // Goodie, there's a gap
 277                                 {
 278                                         for( j = 0; j < nBlocks; j++ )
 279                                                 State->Internal->AllocatedPages[i].Bitmap |= 1 << (base + j);
 280                                         *Segment = State->Internal->AllocatedPages[i].PhysAddr / 16 + base * 8;
 281                                         *Offset = 0;
 282                                         return (void*)( State->Internal->AllocatedPages[i].VirtBase + base * 128 );
 283                                 }
 284                         }
 285                 }
 286         }
 287
 288         // No pages with free space?, allocate a new one
 289         for( i = 0; i < VM8086_PAGES_PER_INST; i++ )
 290         {
 291                 if( State->Internal->AllocatedPages[i].VirtBase == 0 )  break;
 292         }
 293         // Darn, we can't allocate any more
 294         if( i == VM8086_PAGES_PER_INST ) {
 295                 Log_Warning("VM8086", "Out of pages in %p", State);
 296                 return NULL;
 297         }
 298
 299         State->Internal->AllocatedPages[i].VirtBase = MM_AllocDMA(
 300                 1, 20, &State->Internal->AllocatedPages[i].PhysAddr);
 301         State->Internal->AllocatedPages[i].Bitmap = 0;
 302
 303         for( j = 0; j < nBlocks; j++ )
 304                 State->Internal->AllocatedPages[i].Bitmap |= 1 << j;
 305         *Segment = State->Internal->AllocatedPages[i].PhysAddr / 16;
 306         *Offset = 0;
 307         return (void*) State->Internal->AllocatedPages[i].VirtBase;
 308 }
 309
 310 void *VM8086_GetPointer(tVM8086 *State, Uint16 Segment, Uint16 Offset)
 311 {
 312         return (void*)( KERNEL_BASE + Segment*16 + Offset );
 313 }
 314
 315 void VM8086_Int(tVM8086 *State, Uint8 Interrupt)
 316 {
 317         State->IP = *(Uint16*)(KERNEL_BASE+4*Interrupt);
 318         State->CS = *(Uint16*)(KERNEL_BASE+4*Interrupt+2);
 319
 320         LOCK( &glVM8086_Process );
 321
 322         gpVM8086_State = State;
 323         gVM8086_CallingThread = Threads_GetTID();
 324         Threads_WakeTID( gVM8086_WorkerPID );
 325         while( gpVM8086_State != NULL )
 326                 Threads_Sleep();
 327
 328         RELEASE( &glVM8086_Process );
 329 }