palacios/src/geekos/vm.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21
  22 #include <geekos/vmm_stubs.h>
  23
  24 #include <geekos/debug.h>
  25 #include <geekos/serial.h>
  26 #include <geekos/vm.h>
  27 #include <geekos/screen.h>
  28
  29 #include <palacios/vmm.h>
  30 #include <palacios/vmm_io.h>
  31
  32
  33
  34 #define SPEAKER_PORT 0x61
  35
  36 static inline void VM_Out_Byte(ushort_t port, uchar_t value)
  37 {
  38     __asm__ __volatile__ (
  39         "outb %b0, %w1"
  40         :
  41         : "a" (value), "Nd" (port)
  42     );
  43 }
  44
  45 /*
  46  * Read a byte from an I/O port.
  47  */
  48 static inline uchar_t VM_In_Byte(ushort_t port)
  49 {
  50     uchar_t value;
  51
  52     __asm__ __volatile__ (
  53         "inb %w1, %b0"
  54         : "=a" (value)
  55         : "Nd" (port)
  56     );
  57
  58     return value;
  59 }
  60
  61
  62
  63
  64 int IO_Read(ushort_t port, void * dst, uint_t length, void * priv_data) {
  65
  66   if (length != 1) {
  67     return 0;
  68   }
  69
  70   *(uchar_t*)dst = VM_In_Byte(port);
  71   return 1;
  72 }
  73
  74
  75
  76 int IO_Write(ushort_t port, void * src, uint_t length, void * priv_data) {
  77
  78   if (length != 1) {
  79     return 0;
  80   }
  81
  82   VM_Out_Byte(port, *(uchar_t *)src);
  83
  84   return 1;
  85 }
  86
  87
  88 int IO_Read_to_Serial(ushort_t port, void * dst, uint_t length, void * priv_data) {
  89   PrintBoth("Input from Guest on port %d (0x%x) Length=%d\n", port, port, length);
  90
  91   return 0;
  92 }
  93
  94
  95 char * bochs_debug_buf = NULL;
  96 int bochs_debug_offset = 0;
  97
  98 char * bochs_info_buf = NULL;
  99 int bochs_info_offset = 0;
 100
 101
 102 int IO_BOCHS_debug(ushort_t port, void * src, uint_t length, void * priv_data) {
 103   if (!bochs_debug_buf) {
 104     bochs_debug_buf = (char*)Malloc(1024);
 105   }
 106
 107   bochs_debug_buf[bochs_debug_offset++] = *(char*)src;
 108
 109   if ((*(char*)src == 0xa) ||  (bochs_debug_offset == 1023)) {
 110     SerialPrint("BOCHSDEBUG>%s", bochs_debug_buf);
 111     memset(bochs_debug_buf, 0, 1024);
 112     bochs_debug_offset = 0;
 113   }
 114
 115   return length;
 116 }
 117
 118 int IO_BOCHS_info(ushort_t port, void * src, uint_t length, void * priv_data) {
 119   if (!bochs_info_buf) {
 120     bochs_info_buf = (char*)Malloc(1024);
 121   }
 122
 123   bochs_info_buf[bochs_info_offset++] = *(char*)src;
 124
 125   if ((*(char*)src == 0xa) ||  (bochs_info_offset == 1023)) {
 126     SerialPrint("BOCHSINFO>%s", bochs_info_buf);
 127     memset(bochs_info_buf, 0, 1024);
 128     bochs_info_offset = 0;
 129   }
 130
 131   return length;
 132 }
 133
 134
 135 int IO_Write_to_Serial(ushort_t port, void * src, uint_t length, void * priv_data) {
 136  SerialPrint("Output from Guest on port %d (0x%x) Length=%d\n", port, port, length);
 137   switch (length) {
 138
 139   case 1:
 140     SerialPrint(">0x%.2x\n", *(char*)src);
 141     break;
 142   case 2:
 143     SerialPrint(">0x%.4x\n", *(ushort_t*)src);
 144     break;
 145   case 4:
 146     SerialPrint(">0x%.8x\n", *(uint_t*)src);
 147     break;
 148   default:
 149     break;
 150   }
 151
 152   //  SerialMemDump(src, length);
 153   return length;
 154 }
 155
 156
 157
 158 void BuzzVM()
 159 {
 160   int x;
 161   int j;
 162   unsigned char init;
 163
 164 #if 0
 165   __asm__ __volatile__ (
 166     "popf"
 167     );
 168
 169 #endif
 170
 171   PrintBoth("Starting To Buzz\n");
 172
 173   init=VM_In_Byte(SPEAKER_PORT);
 174
 175   while (1) {
 176     VM_Out_Byte(SPEAKER_PORT, init|0x2);
 177     for (j=0;j<1000000;j++) {
 178       x+=j;
 179     }
 180     VM_Out_Byte(SPEAKER_PORT, init);
 181     for (j=0;j<1000000;j++) {
 182       x+=j;
 183     }
 184   }
 185 }
 186
 187
 188 /*
 189 int passthrough_mem_read(void * guest_addr, void * dst, uint_t length, void * priv_data) {
 190   memcpy(dst, (void*)guest_addr, length);
 191   return length;
 192 }
 193
 194 int passthrough_mem_write(void * guest_addr, void * src, uint_t length, void * priv_data) {
 195   memcpy((void*)guest_addr, src, length);
 196   return length;
 197 }
 198 */
 199
 200
 201 /* We need a configuration mechanism, so we can wrap this completely inside the VMM code,
 202  * with no pollution into the HOST OS
 203  */
 204
 205 int RunVMM(struct Boot_Info * bootInfo) {
 206   void * config_data;
 207
 208   struct vmm_os_hooks os_hooks;
 209   struct vmm_ctrl_ops vmm_ops;
 210   struct guest_info * vm_info = 0;
 211
 212
 213
 214
 215   memset(&os_hooks, 0, sizeof(struct vmm_os_hooks));
 216   memset(&vmm_ops, 0, sizeof(struct vmm_ctrl_ops));
 217
 218
 219   os_hooks.print_debug = &SerialPrint;
 220   os_hooks.print_info = &Print;
 221   os_hooks.print_trace = &SerialPrint;
 222   os_hooks.allocate_pages = &Allocate_VMM_Pages;
 223   os_hooks.free_page = &Free_VMM_Page;
 224   os_hooks.malloc = &VMM_Malloc;
 225   os_hooks.free = &VMM_Free;
 226   os_hooks.vaddr_to_paddr = &Identity;
 227   os_hooks.paddr_to_vaddr = &Identity;
 228   os_hooks.hook_interrupt = &geekos_hook_interrupt_new;
 229   os_hooks.ack_irq = &ack_irq;
 230   os_hooks.get_cpu_khz = &get_cpu_khz;
 231
 232
 233
 234   Init_V3(&os_hooks, &vmm_ops);
 235
 236   extern char _binary_vm_kernel_start;
 237   PrintBoth(" Guest Load Addr: 0x%x\n", &_binary_vm_kernel_start);
 238
 239   config_data = &_binary_vm_kernel_start;
 240
 241   vm_info = (vmm_ops).allocate_guest();
 242
 243   PrintBoth("Allocated Guest\n");
 244
 245   (vmm_ops).config_guest(vm_info, config_data);
 246
 247   PrintBoth("Configured guest\n");
 248
 249   v3_hook_io_port(vm_info, 0x61, &IO_Read, &IO_Write, NULL);
 250   //v3_hook_io_port(&vm_info, 0x05, &IO_Read, &IO_Write_to_Serial, NULL);
 251
 252
 253   v3_hook_io_port(vm_info, 0x400, &IO_Read, &IO_Write_to_Serial, NULL);
 254   v3_hook_io_port(vm_info, 0x401, &IO_Read, &IO_Write_to_Serial, NULL);
 255   v3_hook_io_port(vm_info, 0x402, &IO_Read, &IO_BOCHS_info, NULL);
 256   v3_hook_io_port(vm_info, 0x403, &IO_Read, &IO_BOCHS_debug, NULL);
 257
 258
 259   (vmm_ops).init_guest(vm_info);
 260   PrintBoth("Starting Guest\n");
 261   //Clear_Screen();
 262   (vmm_ops).start_guest(vm_info);
 263
 264     return 0;
 265 }