#include <palacios/vmm_io.h>
+
extern void * g_ramdiskImage;
extern ulong_t s_ramdiskSize;
int RunVMM(struct Boot_Info * bootInfo) {
- struct vmm_os_hooks os_hooks;
- struct vmm_ctrl_ops vmm_ops;
+ struct v3_os_hooks os_hooks;
+ struct v3_ctrl_ops v3_ops;
struct guest_info * vm_info = 0;
struct v3_vm_config vm_config;
-
-
- memset(&os_hooks, 0, sizeof(struct vmm_os_hooks));
- memset(&vmm_ops, 0, sizeof(struct vmm_ctrl_ops));
+ memset(&os_hooks, 0, sizeof(struct v3_os_hooks));
+ memset(&v3_ops, 0, sizeof(struct v3_ctrl_ops));
memset(&vm_config, 0, sizeof(struct v3_vm_config));
- Init_V3(&os_hooks, &vmm_ops);
+ Init_V3(&os_hooks, &v3_ops);
extern char _binary___palacios_vm_kernel_start;
- vm_info = (vmm_ops).allocate_guest();
+ vm_info = (v3_ops).allocate_guest();
Init_Stubs(vm_info);
PrintBoth("Allocated Guest\n");
- (vmm_ops).config_guest(vm_info, &vm_config);
+ (v3_ops).config_guest(vm_info, &vm_config);
PrintBoth("Configured guest\n");
- (vmm_ops).init_guest(vm_info);
+ (v3_ops).init_guest(vm_info);
PrintBoth("Starting Guest\n");
//Clear_Screen();
- (vmm_ops).start_guest(vm_info);
+ (v3_ops).start_guest(vm_info);
return 0;
}
#include <palacios/vm_dev.h>
-struct vm_device * create_dma();
+struct vm_device * v3_create_dma();
#endif // ! __V3VEE__
#include <palacios/vm_dev.h>
-struct vm_device * create_pit();
+struct vm_device * v3_create_pit();
#include <palacios/vm_dev.h>
-struct vm_device * create_pic();
+struct vm_device * v3_create_pic();
#include <palacios/vm_dev.h>
-struct vm_device * create_bochs_debug();
+struct vm_device * v3_create_bochs_debug();
#endif // ! __V3VEE__
int v3_generic_add_irq_range(struct vm_device * dev, uint_t start, uint_t end, uint_t type);
// The lists given are null terminated
-struct vm_device * create_generic();
+struct vm_device * v3_create_generic();
#endif // ! __V3VEE__
#include <palacios/vm_dev.h>
-struct vm_device *create_keyboard();
+struct vm_device * v3_create_keyboard();
#include <palacios/vm_dev.h>
-struct vm_device *create_nvram();
+struct vm_device * v3_create_nvram();
int v3_ramdisk_register_cdrom(struct vm_device * ide_dev, uint_t busID, uint_t driveID, struct cdrom_ops * cd, void * private_data);
-struct vm_device * create_ramdisk();
+struct vm_device * v3_create_ramdisk();
#endif // ! __V3VEE__
#include <palacios/vm_dev.h>
-struct vm_device * create_serial();
+struct vm_device * v3_create_serial();
#include <palacios/vm_dev.h>
-struct vm_device * create_simple_pic();
+struct vm_device * v3_create_simple_pic();
#endif // ! __V3VEE__
#include <palacios/vm_dev.h>
-struct vm_device * create_timer();
+struct vm_device * v3_create_timer();
-void Init_SVM(struct vmm_ctrl_ops * vmm_ops);
-int is_svm_capable();
+void v3_init_SVM(struct v3_ctrl_ops * vmm_ops);
+int v3_is_svm_capable();
#endif
#include <palacios/vmm.h>
-int handle_svm_halt(struct guest_info * info);
+int v3_handle_svm_halt(struct guest_info * info);
#endif // ! __V3VEE__
/******************************************/
-
-
-static const uchar_t VMEXIT_CR0_READ_STR[] = "VMEXIT_CR0_READ";
-static const uchar_t VMEXIT_CR1_READ_STR[] = "VMEXIT_CR1_READ";
-static const uchar_t VMEXIT_CR2_READ_STR[] = "VMEXIT_CR2_READ";
-static const uchar_t VMEXIT_CR3_READ_STR[] = "VMEXIT_CR3_READ";
-static const uchar_t VMEXIT_CR4_READ_STR[] = "VMEXIT_CR4_READ";
-static const uchar_t VMEXIT_CR5_READ_STR[] = "VMEXIT_CR5_READ";
-static const uchar_t VMEXIT_CR6_READ_STR[] = "VMEXIT_CR6_READ";
-static const uchar_t VMEXIT_CR7_READ_STR[] = "VMEXIT_CR7_READ";
-static const uchar_t VMEXIT_CR8_READ_STR[] = "VMEXIT_CR8_READ";
-static const uchar_t VMEXIT_CR9_READ_STR[] = "VMEXIT_CR9_READ";
-static const uchar_t VMEXIT_CR10_READ_STR[] = "VMEXIT_CR10_READ";
-static const uchar_t VMEXIT_CR11_READ_STR[] = "VMEXIT_CR11_READ";
-static const uchar_t VMEXIT_CR12_READ_STR[] = "VMEXIT_CR12_READ";
-static const uchar_t VMEXIT_CR13_READ_STR[] = "VMEXIT_CR13_READ";
-static const uchar_t VMEXIT_CR14_READ_STR[] = "VMEXIT_CR14_READ";
-static const uchar_t VMEXIT_CR15_READ_STR[] = "VMEXIT_CR15_READ";
-static const uchar_t VMEXIT_CR0_WRITE_STR[] = "VMEXIT_CR0_WRITE";
-static const uchar_t VMEXIT_CR1_WRITE_STR[] = "VMEXIT_CR1_WRITE";
-static const uchar_t VMEXIT_CR2_WRITE_STR[] = "VMEXIT_CR2_WRITE";
-static const uchar_t VMEXIT_CR3_WRITE_STR[] = "VMEXIT_CR3_WRITE";
-static const uchar_t VMEXIT_CR4_WRITE_STR[] = "VMEXIT_CR4_WRITE";
-static const uchar_t VMEXIT_CR5_WRITE_STR[] = "VMEXIT_CR5_WRITE";
-static const uchar_t VMEXIT_CR6_WRITE_STR[] = "VMEXIT_CR6_WRITE";
-static const uchar_t VMEXIT_CR7_WRITE_STR[] = "VMEXIT_CR7_WRITE";
-static const uchar_t VMEXIT_CR8_WRITE_STR[] = "VMEXIT_CR8_WRITE";
-static const uchar_t VMEXIT_CR9_WRITE_STR[] = "VMEXIT_CR9_WRITE";
-static const uchar_t VMEXIT_CR10_WRITE_STR[] = "VMEXIT_CR10_WRITE";
-static const uchar_t VMEXIT_CR11_WRITE_STR[] = "VMEXIT_CR11_WRITE";
-static const uchar_t VMEXIT_CR12_WRITE_STR[] = "VMEXIT_CR12_WRITE";
-static const uchar_t VMEXIT_CR13_WRITE_STR[] = "VMEXIT_CR13_WRITE";
-static const uchar_t VMEXIT_CR14_WRITE_STR[] = "VMEXIT_CR14_WRITE";
-static const uchar_t VMEXIT_CR15_WRITE_STR[] = "VMEXIT_CR15_WRITE";
-static const uchar_t VMEXIT_DR0_READ_STR[] = "VMEXIT_DR0_READ";
-static const uchar_t VMEXIT_DR1_READ_STR[] = "VMEXIT_DR1_READ";
-static const uchar_t VMEXIT_DR2_READ_STR[] = "VMEXIT_DR2_READ";
-static const uchar_t VMEXIT_DR3_READ_STR[] = "VMEXIT_DR3_READ";
-static const uchar_t VMEXIT_DR4_READ_STR[] = "VMEXIT_DR4_READ";
-static const uchar_t VMEXIT_DR5_READ_STR[] = "VMEXIT_DR5_READ";
-static const uchar_t VMEXIT_DR6_READ_STR[] = "VMEXIT_DR6_READ";
-static const uchar_t VMEXIT_DR7_READ_STR[] = "VMEXIT_DR7_READ";
-static const uchar_t VMEXIT_DR8_READ_STR[] = "VMEXIT_DR8_READ";
-static const uchar_t VMEXIT_DR9_READ_STR[] = "VMEXIT_DR9_READ";
-static const uchar_t VMEXIT_DR10_READ_STR[] = "VMEXIT_DR10_READ";
-static const uchar_t VMEXIT_DR11_READ_STR[] = "VMEXIT_DR11_READ";
-static const uchar_t VMEXIT_DR12_READ_STR[] = "VMEXIT_DR12_READ";
-static const uchar_t VMEXIT_DR13_READ_STR[] = "VMEXIT_DR13_READ";
-static const uchar_t VMEXIT_DR14_READ_STR[] = "VMEXIT_DR14_READ";
-static const uchar_t VMEXIT_DR15_READ_STR[] = "VMEXIT_DR15_READ";
-static const uchar_t VMEXIT_DR0_WRITE_STR[] = "VMEXIT_DR0_WRITE";
-static const uchar_t VMEXIT_DR1_WRITE_STR[] = "VMEXIT_DR1_WRITE";
-static const uchar_t VMEXIT_DR2_WRITE_STR[] = "VMEXIT_DR2_WRITE";
-static const uchar_t VMEXIT_DR3_WRITE_STR[] = "VMEXIT_DR3_WRITE";
-static const uchar_t VMEXIT_DR4_WRITE_STR[] = "VMEXIT_DR4_WRITE";
-static const uchar_t VMEXIT_DR5_WRITE_STR[] = "VMEXIT_DR5_WRITE";
-static const uchar_t VMEXIT_DR6_WRITE_STR[] = "VMEXIT_DR6_WRITE";
-static const uchar_t VMEXIT_DR7_WRITE_STR[] = "VMEXIT_DR7_WRITE";
-static const uchar_t VMEXIT_DR8_WRITE_STR[] = "VMEXIT_DR8_WRITE";
-static const uchar_t VMEXIT_DR9_WRITE_STR[] = "VMEXIT_DR9_WRITE";
-static const uchar_t VMEXIT_DR10_WRITE_STR[] = "VMEXIT_DR10_WRITE";
-static const uchar_t VMEXIT_DR11_WRITE_STR[] = "VMEXIT_DR11_WRITE";
-static const uchar_t VMEXIT_DR12_WRITE_STR[] = "VMEXIT_DR12_WRITE";
-static const uchar_t VMEXIT_DR13_WRITE_STR[] = "VMEXIT_DR13_WRITE";
-static const uchar_t VMEXIT_DR14_WRITE_STR[] = "VMEXIT_DR14_WRITE";
-static const uchar_t VMEXIT_DR15_WRITE_STR[] = "VMEXIT_DR15_WRITE";
-static const uchar_t VMEXIT_EXCP0_STR[] = "VMEXIT_EXCP0";
-static const uchar_t VMEXIT_EXCP1_STR[] = "VMEXIT_EXCP1";
-static const uchar_t VMEXIT_EXCP2_STR[] = "VMEXIT_EXCP2";
-static const uchar_t VMEXIT_EXCP3_STR[] = "VMEXIT_EXCP3";
-static const uchar_t VMEXIT_EXCP4_STR[] = "VMEXIT_EXCP4";
-static const uchar_t VMEXIT_EXCP5_STR[] = "VMEXIT_EXCP5";
-static const uchar_t VMEXIT_EXCP6_STR[] = "VMEXIT_EXCP6";
-static const uchar_t VMEXIT_EXCP7_STR[] = "VMEXIT_EXCP7";
-static const uchar_t VMEXIT_EXCP8_STR[] = "VMEXIT_EXCP8";
-static const uchar_t VMEXIT_EXCP9_STR[] = "VMEXIT_EXCP9";
-static const uchar_t VMEXIT_EXCP10_STR[] = "VMEXIT_EXCP10";
-static const uchar_t VMEXIT_EXCP11_STR[] = "VMEXIT_EXCP11";
-static const uchar_t VMEXIT_EXCP12_STR[] = "VMEXIT_EXCP12";
-static const uchar_t VMEXIT_EXCP13_STR[] = "VMEXIT_EXCP13";
-static const uchar_t VMEXIT_EXCP14_STR[] = "VMEXIT_EXCP14";
-static const uchar_t VMEXIT_EXCP15_STR[] = "VMEXIT_EXCP15";
-static const uchar_t VMEXIT_EXCP16_STR[] = "VMEXIT_EXCP16";
-static const uchar_t VMEXIT_EXCP17_STR[] = "VMEXIT_EXCP17";
-static const uchar_t VMEXIT_EXCP18_STR[] = "VMEXIT_EXCP18";
-static const uchar_t VMEXIT_EXCP19_STR[] = "VMEXIT_EXCP19";
-static const uchar_t VMEXIT_EXCP20_STR[] = "VMEXIT_EXCP20";
-static const uchar_t VMEXIT_EXCP21_STR[] = "VMEXIT_EXCP21";
-static const uchar_t VMEXIT_EXCP22_STR[] = "VMEXIT_EXCP22";
-static const uchar_t VMEXIT_EXCP23_STR[] = "VMEXIT_EXCP23";
-static const uchar_t VMEXIT_EXCP24_STR[] = "VMEXIT_EXCP24";
-static const uchar_t VMEXIT_EXCP25_STR[] = "VMEXIT_EXCP25";
-static const uchar_t VMEXIT_EXCP26_STR[] = "VMEXIT_EXCP26";
-static const uchar_t VMEXIT_EXCP27_STR[] = "VMEXIT_EXCP27";
-static const uchar_t VMEXIT_EXCP28_STR[] = "VMEXIT_EXCP28";
-static const uchar_t VMEXIT_EXCP29_STR[] = "VMEXIT_EXCP29";
-static const uchar_t VMEXIT_EXCP30_STR[] = "VMEXIT_EXCP30";
-static const uchar_t VMEXIT_EXCP31_STR[] = "VMEXIT_EXCP31";
-static const uchar_t VMEXIT_INTR_STR[] = "VMEXIT_INTR";
-static const uchar_t VMEXIT_NMI_STR[] = "VMEXIT_NMI";
-static const uchar_t VMEXIT_SMI_STR[] = "VMEXIT_SMI";
-static const uchar_t VMEXIT_INIT_STR[] = "VMEXIT_INIT";
-static const uchar_t VMEXIT_VINITR_STR[] = "VMEXIT_VINITR";
-static const uchar_t VMEXIT_CR0_SEL_WRITE_STR[] = "VMEXIT_CR0_SEL_WRITE";
-static const uchar_t VMEXIT_IDTR_READ_STR[] = "VMEXIT_IDTR_READ";
-static const uchar_t VMEXIT_GDTR_READ_STR[] = "VMEXIT_GDTR_READ";
-static const uchar_t VMEXIT_LDTR_READ_STR[] = "VMEXIT_LDTR_READ";
-static const uchar_t VMEXIT_TR_READ_STR[] = "VMEXIT_TR_READ";
-static const uchar_t VMEXIT_IDTR_WRITE_STR[] = "VMEXIT_IDTR_WRITE";
-static const uchar_t VMEXIT_GDTR_WRITE_STR[] = "VMEXIT_GDTR_WRITE";
-static const uchar_t VMEXIT_LDTR_WRITE_STR[] = "VMEXIT_LDTR_WRITE";
-static const uchar_t VMEXIT_TR_WRITE_STR[] = "VMEXIT_TR_WRITE";
-static const uchar_t VMEXIT_RDTSC_STR[] = "VMEXIT_RDTSC";
-static const uchar_t VMEXIT_RDPMC_STR[] = "VMEXIT_RDPMC";
-static const uchar_t VMEXIT_PUSHF_STR[] = "VMEXIT_PUSHF";
-static const uchar_t VMEXIT_POPF_STR[] = "VMEXIT_POPF";
-static const uchar_t VMEXIT_CPUID_STR[] = "VMEXIT_CPUID";
-static const uchar_t VMEXIT_RSM_STR[] = "VMEXIT_RSM";
-static const uchar_t VMEXIT_IRET_STR[] = "VMEXIT_IRET";
-static const uchar_t VMEXIT_SWINT_STR[] = "VMEXIT_SWINT";
-static const uchar_t VMEXIT_INVD_STR[] = "VMEXIT_INVD";
-static const uchar_t VMEXIT_PAUSE_STR[] = "VMEXIT_PAUSE";
-static const uchar_t VMEXIT_HLT_STR[] = "VMEXIT_HLT";
-static const uchar_t VMEXIT_INVLPG_STR[] = "VMEXIT_INVLPG";
-static const uchar_t VMEXIT_INVLPGA_STR[] = "VMEXIT_INVLPGA";
-static const uchar_t VMEXIT_IOIO_STR[] = "VMEXIT_IOIO";
-static const uchar_t VMEXIT_MSR_STR[] = "VMEXIT_MSR";
-static const uchar_t VMEXIT_TASK_SWITCH_STR[] = "VMEXIT_TASK_SWITCH";
-static const uchar_t VMEXIT_FERR_FREEZE_STR[] = "VMEXIT_FERR_FREEZE";
-static const uchar_t VMEXIT_SHUTDOWN_STR[] = "VMEXIT_SHUTDOWN";
-static const uchar_t VMEXIT_VMRUN_STR[] = "VMEXIT_VMRUN";
-static const uchar_t VMEXIT_VMMCALL_STR[] = "VMEXIT_VMMCALL";
-static const uchar_t VMEXIT_VMLOAD_STR[] = "VMEXIT_VMLOAD";
-static const uchar_t VMEXIT_VMSAVE_STR[] = "VMEXIT_VMSAVE";
-static const uchar_t VMEXIT_STGI_STR[] = "VMEXIT_STGI";
-static const uchar_t VMEXIT_CLGI_STR[] = "VMEXIT_CLGI";
-static const uchar_t VMEXIT_SKINIT_STR[] = "VMEXIT_SKINIT";
-static const uchar_t VMEXIT_RDTSCP_STR[] = "VMEXIT_RDTSCP";
-static const uchar_t VMEXIT_ICEBP_STR[] = "VMEXIT_ICEBP";
-static const uchar_t VMEXIT_WBINVD_STR[] = "VMEXIT_WBINVD";
-static const uchar_t VMEXIT_MONITOR_STR[] = "VMEXIT_MONITOR";
-static const uchar_t VMEXIT_MWAIT_STR[] = "VMEXIT_MWAIT";
-static const uchar_t VMEXIT_MWAIT_CONDITIONAL_STR[] = "VMEXIT_MWAIT_CONDITIONAL";
-static const uchar_t VMEXIT_NPF_STR[] = "VMEXIT_NPF";
-static const uchar_t VMEXIT_INVALID_VMCB_STR[] = "VMEXIT_INVALID_VMCB";
-
-
-const uchar_t * vmexit_code_to_str(uint_t exit_code);
-
-
-
-int handle_shadow_paging(struct guest_info * info);
-
-int handle_svm_intr(struct guest_info * info);
-
-int handle_svm_exit(struct guest_info * info);
+int v3_handle_svm_exit(struct guest_info * info);
#endif // ! __V3VEE__
};
-int handle_svm_io_in(struct guest_info * info);
-int handle_svm_io_ins(struct guest_info * info);
-int handle_svm_io_out(struct guest_info * info);
-int handle_svm_io_outs(struct guest_info * info);
+int v3_handle_svm_io_in(struct guest_info * info);
+int v3_handle_svm_io_ins(struct guest_info * info);
+int v3_handle_svm_io_out(struct guest_info * info);
+int v3_handle_svm_io_outs(struct guest_info * info);
#endif // !__V3VEE__
#include <palacios/vmm.h>
-int handle_svm_pause(struct guest_info * info);
+int v3_handle_svm_pause(struct guest_info * info);
#endif // ! __V3VEE__
#include <palacios/vmm.h>
-int handle_svm_wbinvd(struct guest_info * info);
+int v3_handle_svm_wbinvd(struct guest_info * info);
#endif // ! __V3VEE__
-struct vm_device * allocate_device();
-struct vm_device * create_device(char * name, struct vm_device_ops * ops, void * private_data);
-void free_device(struct vm_device * dev);
+struct vm_device * v3_create_device(char * name, struct vm_device_ops * ops, void * private_data);
+void v3_free_device(struct vm_device * dev);
-int dev_hook_io(struct vm_device *dev,
+
+int v3_dev_hook_io(struct vm_device *dev,
ushort_t port,
int (*read)(ushort_t port, void * dst, uint_t length, struct vm_device * dev),
int (*write)(ushort_t port, void * src, uint_t length, struct vm_device * dev));
-int dev_unhook_io(struct vm_device *dev,
+int v3_dev_unhook_io(struct vm_device *dev,
ushort_t port);
-int dev_hook_mem(struct vm_device *dev,
+int v3_dev_hook_mem(struct vm_device *dev,
void *start,
void *end);
-int dev_unhook_mem(struct vm_device * dev,
+int v3_dev_unhook_mem(struct vm_device * dev,
void * start,
void * end);
-int dev_hook_irq(struct vm_device * dev,
+int v3_dev_hook_irq(struct vm_device * dev,
uint_t irq,
int (*handler)(uint_t irq, struct vm_device * dev));
-int dev_unhook_irq(struct vm_device * dev, uint_t irq);
+int v3_dev_unhook_irq(struct vm_device * dev, uint_t irq);
-typedef enum {SHADOW_PAGING, NESTED_PAGING} vmm_paging_mode_t;
-typedef enum {VM_RUNNING, VM_STOPPED, VM_SUSPENDED, VM_ERROR, VM_EMULATING} vm_operating_mode_t;
+typedef enum {SHADOW_PAGING, NESTED_PAGING} v3_paging_mode_t;
+typedef enum {VM_RUNNING, VM_STOPPED, VM_SUSPENDED, VM_ERROR, VM_EMULATING} v3_vm_operating_mode_t;
-typedef enum {REAL, /*UNREAL,*/ PROTECTED, PROTECTED_PAE, LONG, LONG_32_COMPAT, LONG_16_COMPAT} vm_cpu_mode_t;
-typedef enum {PHYSICAL_MEM, VIRTUAL_MEM} vm_mem_mode_t;
+typedef enum {REAL, /*UNREAL,*/ PROTECTED, PROTECTED_PAE, LONG, LONG_32_COMPAT, LONG_16_COMPAT} v3_vm_cpu_mode_t;
+typedef enum {PHYSICAL_MEM, VIRTUAL_MEM} v3_vm_mem_mode_t;
struct vm_time time_state;
- vmm_paging_mode_t shdw_pg_mode;
+ v3_paging_mode_t shdw_pg_mode;
struct shadow_page_state shdw_pg_state;
addr_t direct_map_pt;
// nested_paging_t nested_page_state;
struct v3_host_events host_event_hooks;
- vm_cpu_mode_t cpu_mode;
- vm_mem_mode_t mem_mode;
+ v3_vm_cpu_mode_t cpu_mode;
+ v3_vm_mem_mode_t mem_mode;
struct v3_gprs vm_regs;
struct emulation_state emulator;
- vm_operating_mode_t run_state;
+ v3_vm_operating_mode_t run_state;
void * vmm_data;
/* TEMP */
};
-vm_cpu_mode_t get_cpu_mode(struct guest_info * info);
-vm_mem_mode_t get_mem_mode(struct guest_info * info);
+v3_vm_cpu_mode_t v3_get_cpu_mode(struct guest_info * info);
+v3_vm_mem_mode_t v3_get_mem_mode(struct guest_info * info);
-void PrintV3Segments(struct guest_info * info);
-void PrintV3CtrlRegs(struct guest_info * info);
-void PrintV3GPRs(struct guest_info * info);
+void v3_print_segments(struct guest_info * info);
+void v3_print_ctrl_regs(struct guest_info * info);
+void v3_print_GPRs(struct guest_info * info);
#endif // ! __V3VEE__
* redistribute, and modify it as specified in the file "V3VEE_LICENSE".
*/
-#ifndef __VMM_H
-#define __VMM_H
+#ifndef __VMM_H__
+#define __VMM_H__
#include <palacios/vm_guest.h>
#ifdef VMM_DEBUG
#define PrintDebug(fmt, args...) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->print_debug) { \
(os_hooks)->print_debug((fmt), ##args); \
} \
#define PrintError(fmt, args...) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->print_debug) { \
(os_hooks)->print_debug("%s(%d): " fmt, __FILE__, __LINE__, ##args); \
} \
#ifdef VMM_INFO
#define PrintInfo(fmt, args...) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->print_info) { \
(os_hooks)->print_info((fmt), ##args); \
} \
#ifdef VMM_TRACE
#define PrintTrace(fmt, args...) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->print_trace) { \
(os_hooks)->print_trace(fmt, ##args); \
} \
#define V3_AllocPages(num_pages) \
({ \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
void * ptr = 0; \
if ((os_hooks) && (os_hooks)->allocate_pages) { \
ptr = (os_hooks)->allocate_pages(num_pages); \
#define V3_FreePage(page) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->free_page) { \
(os_hooks)->free_page(page); \
} \
#define V3_Malloc(size) ({ \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
void * var = 0; \
if ((os_hooks) && (os_hooks)->malloc) { \
var = (os_hooks)->malloc(size); \
// We need to check the hook structure at runtime to ensure its SAFE
#define V3_Free(addr) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->free) { \
(os_hooks)->free(addr); \
} \
#define V3_CPU_KHZ() \
({ \
unsigned int khz = 0; \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->get_cpu_khz) { \
khz = (os_hooks)->get_cpu_khz(); \
} \
#define V3_Hook_Interrupt(irq, opaque) \
({ \
int ret = 0; \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->hook_interrupt) { \
ret = (os_hooks)->hook_interrupt(irq, opaque); \
} \
#define V3_Yield(addr) \
do { \
- extern struct vmm_os_hooks * os_hooks; \
+ extern struct v3_os_hooks * os_hooks; \
if ((os_hooks) && (os_hooks)->yield_cpu) { \
(os_hooks)->yield_cpu(); \
} \
struct guest_info;
/* This will contain function pointers that provide OS services */
-struct vmm_os_hooks {
+struct v3_os_hooks {
void (*print_info)(const char * format, ...);
void (*print_debug)(const char * format, ...);
void (*print_trace)(const char * format, ...);
/* This will contain Function pointers that control the VMs */
-struct vmm_ctrl_ops {
+struct v3_ctrl_ops {
struct guest_info *(*allocate_guest)();
int (*config_guest)(struct guest_info * info, struct v3_vm_config * config_ptr);
-void Init_V3(struct vmm_os_hooks * hooks, struct vmm_ctrl_ops * vmm_ops);
+void Init_V3(struct v3_os_hooks * hooks, struct v3_ctrl_ops * vmm_ops);
int v3_deliver_irq(struct guest_info * vm, struct v3_interrupt * intr);
int v3_deliver_keyboard_evt(struct guest_info * vm);
-int config_guest(struct guest_info * info, struct v3_vm_config * config_ptr);
+int v3_config_guest(struct guest_info * info, struct v3_vm_config * config_ptr);
#endif // ! __V3VEE__
};
-int dev_mgr_init(struct guest_info * info);
-int dev_mgr_deinit(struct guest_info * info);
+int v3_init_dev_mgr(struct guest_info * info);
+int v3_dev_mgr_deinit(struct guest_info * info);
void PrintDebugDevMgr(struct guest_info * info);
void PrintDebugDev(struct vm_device * dev);
.stop = NULL,
};
-struct vm_device * create_dma() {
+struct vm_device * v3_create_dma() {
struct dma_state * dma = NULL;
dma = (struct dma_state *)V3_Malloc(sizeof(struct dma_state));
V3_ASSERT(dma != NULL);
- struct vm_device * dev = create_device("DMA", &dev_ops, dma);
+ struct vm_device * dev = v3_create_device("DMA", &dev_ops, dma);
return dma;
}
uint_t cpu_khz = V3_CPU_KHZ();
ullong_t reload_val = (ullong_t)cpu_khz * 1000;
- dev_hook_io(dev, CHANNEL0_PORT, &pit_read_channel, &pit_write_channel);
- dev_hook_io(dev, CHANNEL1_PORT, &pit_read_channel, &pit_write_channel);
- dev_hook_io(dev, CHANNEL2_PORT, &pit_read_channel, &pit_write_channel);
- dev_hook_io(dev, COMMAND_PORT, NULL, &pit_write_command);
+ v3_dev_hook_io(dev, CHANNEL0_PORT, &pit_read_channel, &pit_write_channel);
+ v3_dev_hook_io(dev, CHANNEL1_PORT, &pit_read_channel, &pit_write_channel);
+ v3_dev_hook_io(dev, CHANNEL2_PORT, &pit_read_channel, &pit_write_channel);
+ v3_dev_hook_io(dev, COMMAND_PORT, NULL, &pit_write_command);
#ifdef DEBUG_PIT
PrintDebug("8254 PIT: OSC_HZ=%d, reload_val=", OSC_HZ);
};
-struct vm_device * create_pit() {
+struct vm_device * v3_create_pit() {
struct pit * pit_state = NULL;
pit_state = (struct pit *)V3_Malloc(sizeof(struct pit));
V3_ASSERT(pit_state != NULL);
- struct vm_device * dev = create_device("PIT", &dev_ops, pit_state);
+ struct vm_device * dev = v3_create_device("PIT", &dev_ops, pit_state);
return dev;
}
-int read_master_port1(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
+static int read_master_port1(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
if (length != 1) {
return 1;
}
-int read_master_port2(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
+static int read_master_port2(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
if (length != 1) {
}
-int read_slave_port1(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
+static int read_slave_port1(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
if (length != 1) {
return 1;
}
-int read_slave_port2(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
+static int read_slave_port2(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
if (length != 1) {
}
-int write_master_port1(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
+static int write_master_port1(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
uchar_t cw = *(uchar_t *)src;
return 1;
}
-int write_master_port2(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
+static int write_master_port2(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
uchar_t cw = *(uchar_t *)src;
return 1;
}
-int write_slave_port1(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
+static int write_slave_port1(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
uchar_t cw = *(uchar_t *)src;
return 1;
}
-int write_slave_port2(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
+static int write_slave_port2(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
uchar_t cw = *(uchar_t *)src;
-int pic_init(struct vm_device * dev) {
+static int pic_init(struct vm_device * dev) {
struct pic_internal * state = (struct pic_internal*)dev->private_data;
set_intr_controller(dev->vm, &intr_ops, state);
state->slave_state = ICW1;
- dev_hook_io(dev, MASTER_PORT1, &read_master_port1, &write_master_port1);
- dev_hook_io(dev, MASTER_PORT2, &read_master_port2, &write_master_port2);
- dev_hook_io(dev, SLAVE_PORT1, &read_slave_port1, &write_slave_port1);
- dev_hook_io(dev, SLAVE_PORT2, &read_slave_port2, &write_slave_port2);
+ v3_dev_hook_io(dev, MASTER_PORT1, &read_master_port1, &write_master_port1);
+ v3_dev_hook_io(dev, MASTER_PORT2, &read_master_port2, &write_master_port2);
+ v3_dev_hook_io(dev, SLAVE_PORT1, &read_slave_port1, &write_slave_port1);
+ v3_dev_hook_io(dev, SLAVE_PORT2, &read_slave_port2, &write_slave_port2);
return 0;
}
-int pic_deinit(struct vm_device * dev) {
- dev_unhook_io(dev, MASTER_PORT1);
- dev_unhook_io(dev, MASTER_PORT2);
- dev_unhook_io(dev, SLAVE_PORT1);
- dev_unhook_io(dev, SLAVE_PORT2);
+static int pic_deinit(struct vm_device * dev) {
+ v3_dev_unhook_io(dev, MASTER_PORT1);
+ v3_dev_unhook_io(dev, MASTER_PORT2);
+ v3_dev_unhook_io(dev, SLAVE_PORT1);
+ v3_dev_unhook_io(dev, SLAVE_PORT2);
return 0;
}
};
-struct vm_device * create_pic() {
+struct vm_device * v3_create_pic() {
struct pic_internal * state = NULL;
state = (struct pic_internal *)V3_Malloc(sizeof(struct pic_internal));
V3_ASSERT(state != NULL);
- struct vm_device *device = create_device("8259A", &dev_ops, state);
+ struct vm_device *device = v3_create_device("8259A", &dev_ops, state);
return device;
}
memset(state->info_buf, 0, BUF_SIZE);
- dev_hook_io(dev, BOCHS_PORT1, NULL, &handle_gen_write);
- dev_hook_io(dev, BOCHS_PORT2, NULL, &handle_gen_write);
- dev_hook_io(dev, BOCHS_INFO_PORT, NULL, &handle_info_write);
- dev_hook_io(dev, BOCHS_DEBUG_PORT, NULL, &handle_debug_write);
+ v3_dev_hook_io(dev, BOCHS_PORT1, NULL, &handle_gen_write);
+ v3_dev_hook_io(dev, BOCHS_PORT2, NULL, &handle_gen_write);
+ v3_dev_hook_io(dev, BOCHS_INFO_PORT, NULL, &handle_info_write);
+ v3_dev_hook_io(dev, BOCHS_DEBUG_PORT, NULL, &handle_debug_write);
return 0;
}
static int debug_deinit(struct vm_device * dev) {
- dev_unhook_io(dev, BOCHS_PORT1);
- dev_unhook_io(dev, BOCHS_PORT2);
- dev_unhook_io(dev, BOCHS_INFO_PORT);
- dev_unhook_io(dev, BOCHS_DEBUG_PORT);
+ v3_dev_unhook_io(dev, BOCHS_PORT1);
+ v3_dev_unhook_io(dev, BOCHS_PORT2);
+ v3_dev_unhook_io(dev, BOCHS_INFO_PORT);
+ v3_dev_unhook_io(dev, BOCHS_DEBUG_PORT);
return 0;
};
};
-struct vm_device * create_bochs_debug() {
+struct vm_device * v3_create_bochs_debug() {
struct debug_state * state = NULL;
state = (struct debug_state *)V3_Malloc(sizeof(struct debug_state));
V3_ASSERT(state != NULL);
PrintDebug("Creating Bochs Debug Device\n");
- struct vm_device * device = create_device("BOCHS Debug", &dev_ops, state);
+ struct vm_device * device = v3_create_device("BOCHS Debug", &dev_ops, state);
PrintDebug("Creating RamDISK CDROM\n");
- struct vm_device * cd_dev = create_device("Ram Based CD", &dev_ops, cd);
+ struct vm_device * cd_dev = v3_create_device("Ram Based CD", &dev_ops, cd);
return cd_dev;
}
-int generic_reset_device(struct vm_device * dev)
-{
+static int generic_reset_device(struct vm_device * dev) {
PrintDebug("generic: reset device\n");
-
return 0;
-
}
-int generic_start_device(struct vm_device * dev)
-{
+static int generic_start_device(struct vm_device * dev) {
PrintDebug("generic: start device\n");
return 0;
}
-int generic_stop_device(struct vm_device * dev)
-{
+static int generic_stop_device(struct vm_device * dev) {
PrintDebug("generic: stop device\n");
return 0;
}
-int generic_write_port_passthrough(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
-{
+static int generic_write_port_passthrough(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
uint_t i;
PrintDebug("generic: writing 0x");
return length;
}
-int generic_read_port_passthrough(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
-{
+static int generic_read_port_passthrough(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
uint_t i;
PrintDebug("generic: reading 0x%x bytes from port 0x%x ...", length, port);
return length;
}
-int generic_write_port_ignore(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
-{
+static int generic_write_port_ignore(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
uint_t i;
PrintDebug("generic: writing 0x");
return length;
}
-int generic_read_port_ignore(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
-{
+static int generic_read_port_ignore(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
PrintDebug("generic: reading 0x%x bytes from port 0x%x ...", length, port);
-int generic_interrupt(uint_t irq, struct vm_device * dev) {
+static int generic_interrupt(uint_t irq, struct vm_device * dev) {
PrintDebug("generic: interrupt 0x%x - injecting into VM\n", irq);
- dev->vm->vm_ops.raise_irq(dev->vm, irq);
+ v3_raise_irq(dev->vm, irq);
return 0;
}
-int generic_init_device(struct vm_device * dev) {
+static int generic_init_device(struct vm_device * dev) {
struct generic_internal * state = (struct generic_internal *)(dev->private_data);
PrintDebug("generic: init_device\n");
for (i = tmp->start; i <= tmp->end; i++) {
if (tmp->type == GENERIC_PRINT_AND_PASSTHROUGH) {
- if (dev_hook_io(dev, i, &generic_read_port_passthrough, &generic_write_port_passthrough)) {
+ if (v3_dev_hook_io(dev, i, &generic_read_port_passthrough, &generic_write_port_passthrough)) {
PrintDebug("generic: can't hook port 0x%x (already hooked?)\n", i);
}
} else if (tmp->type == GENERIC_PRINT_AND_IGNORE) {
- if (dev_hook_io(dev, i, &generic_read_port_ignore, &generic_write_port_ignore)) {
+ if (v3_dev_hook_io(dev, i, &generic_read_port_ignore, &generic_write_port_ignore)) {
PrintDebug("generic: can't hook port 0x%x (already hooked?)\n", i);
}
}
tmp->start, tmp->end);
- if (dev_hook_mem(dev, tmp->start, tmp->end)) {
+ if (v3_dev_hook_mem(dev, tmp->start, tmp->end)) {
PrintDebug("generic: Can't hook addresses 0x%x to 0x%x (already hooked?)\n",
tmp->start, tmp->end);
}
tmp->start, tmp->end);
for (i = tmp->start; i <= tmp->end; i++) {
- if (dev_hook_irq(dev, i, &generic_interrupt)) {
+ if (v3_dev_hook_irq(dev, i, &generic_interrupt)) {
PrintDebug("generic: can't hook irq 0x%x (already hooked?)\n", i);
}
}
return 0;
}
-int generic_deinit_device(struct vm_device * dev) {
+static int generic_deinit_device(struct vm_device * dev) {
struct generic_internal * state = (struct generic_internal *)(dev->private_data);
for (i = cur->start; i <= cur->end; i++) {
- if (dev_unhook_irq(dev, i)) {
+ if (v3_dev_unhook_irq(dev, i)) {
PrintDebug("generic: can't unhook irq 0x%x (already unhooked?)\n", i);
}
}
PrintDebug("generic: unhooking addresses 0x%x to 0x%x\n",
cur->start, cur->end);
- if (dev_unhook_mem(dev, cur->start, cur->end)) {
+ if (v3_dev_unhook_mem(dev, cur->start, cur->end)) {
PrintDebug("generic: Can't unhook addresses 0x%x to 0x%x (already unhooked?)\n",
cur->start, cur->end);
}
cur->start, cur->end);
for (i = cur->start; i <= cur->end; i++) {
- if (dev_unhook_io(dev, i)) {
+ if (v3_dev_unhook_io(dev, i)) {
PrintDebug("generic: can't unhook port 0x%x (already unhooked?)\n", i);
}
}
-struct vm_device * create_generic() {
+struct vm_device * v3_create_generic() {
struct generic_internal * generic_state = (struct generic_internal *)V3_Malloc(sizeof(struct generic_internal));
generic_state->num_port_ranges = 0;
INIT_LIST_HEAD(&(generic_state->mem_list));
INIT_LIST_HEAD(&(generic_state->irq_list));
- struct vm_device * device = create_device("GENERIC", &dev_ops, generic_state);
+ struct vm_device * device = v3_create_device("GENERIC", &dev_ops, generic_state);
return device;
}
-int keyboard_interrupt(struct vm_device * dev, uint_t irq) {
+static int keyboard_interrupt(struct vm_device * dev, uint_t irq) {
PrintDebug("keyboard: interrupt 0x%x\n", irq);
v3_raise_irq(dev->vm, irq);
-int key_event_handler(struct guest_info * info,
- struct v3_keyboard_event * evt,
- void * private_data) {
+static int key_event_handler(struct guest_info * info,
+ struct v3_keyboard_event * evt,
+ void * private_data) {
struct vm_device * dev = (struct vm_device *)private_data;
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
}
-int mouse_event_handler(struct guest_info * info,
- struct v3_mouse_event * evt,
- void * private_data) {
+static int mouse_event_handler(struct guest_info * info,
+ struct v3_mouse_event * evt,
+ void * private_data) {
struct vm_device * dev = (struct vm_device *)private_data;
struct keyboard_internal * state = (struct keyboard_internal *)(dev->private_data);
}
-int keyboard_reset_device(struct vm_device * dev)
+static int keyboard_reset_device(struct vm_device * dev)
{
struct keyboard_internal *data = (struct keyboard_internal *)(dev->private_data);
-int keyboard_start_device(struct vm_device *dev)
+static int keyboard_start_device(struct vm_device *dev)
{
PrintDebug("keyboard: start device\n");
return 0;
}
-int keyboard_stop_device(struct vm_device *dev)
+static int keyboard_stop_device(struct vm_device *dev)
{
PrintDebug("keyboard: stop device\n");
return 0;
}
-int mouse_read_input(struct vm_device *dev)
+static int mouse_read_input(struct vm_device *dev)
{
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
}
}
-int mouse_write_output(struct vm_device * dev, uchar_t data)
+static int mouse_write_output(struct vm_device * dev, uchar_t data)
{
struct keyboard_internal * state = (struct keyboard_internal *)(dev->private_data);
#if KEYBOARD_DEBUG_80H
-int keyboard_write_delay(ushort_t port,
+static int keyboard_write_delay(ushort_t port,
void * src,
uint_t length,
struct vm_device * dev)
}
}
-int keyboard_read_delay(ushort_t port,
+static int keyboard_read_delay(ushort_t port,
void * dest,
uint_t length,
struct vm_device * dev)
-int keyboard_write_command(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
+static int keyboard_write_command(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev)
{
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
uchar_t cmd;
}
-int keyboard_read_status(ushort_t port,
- void * dest,
- uint_t length,
- struct vm_device * dev)
+static int keyboard_read_status(ushort_t port,
+ void * dest,
+ uint_t length,
+ struct vm_device * dev)
{
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
}
}
-int keyboard_write_output(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev)
+static int keyboard_write_output(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev)
{
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
return 1;
}
-int keyboard_read_input(ushort_t port,
- void * dest,
- uint_t length,
- struct vm_device * dev)
+static int keyboard_read_input(ushort_t port,
+ void * dest,
+ uint_t length,
+ struct vm_device * dev)
{
struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
-int keyboard_init_device(struct vm_device * dev)
+static int keyboard_init_device(struct vm_device * dev)
{
// struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
keyboard_reset_device(dev);
// hook ports
- dev_hook_io(dev, KEYBOARD_64H, &keyboard_read_status, &keyboard_write_command);
- dev_hook_io(dev, KEYBOARD_60H, &keyboard_read_input, &keyboard_write_output);
+ v3_dev_hook_io(dev, KEYBOARD_64H, &keyboard_read_status, &keyboard_write_command);
+ v3_dev_hook_io(dev, KEYBOARD_60H, &keyboard_read_input, &keyboard_write_output);
v3_hook_host_event(dev->vm, HOST_KEYBOARD_EVT, V3_HOST_EVENT_HANDLER(key_event_handler), dev);
v3_hook_host_event(dev->vm, HOST_MOUSE_EVT, V3_HOST_EVENT_HANDLER(mouse_event_handler), dev);
#if KEYBOARD_DEBUG_80H
- dev_hook_io(dev, KEYBOARD_DELAY_80H, &keyboard_read_delay, &keyboard_write_delay);
+ v3_dev_hook_io(dev, KEYBOARD_DELAY_80H, &keyboard_read_delay, &keyboard_write_delay);
#endif
return 0;
}
-int keyboard_deinit_device(struct vm_device *dev)
+static int keyboard_deinit_device(struct vm_device *dev)
{
- dev_unhook_io(dev, KEYBOARD_60H);
- dev_unhook_io(dev, KEYBOARD_64H);
+ v3_dev_unhook_io(dev, KEYBOARD_60H);
+ v3_dev_unhook_io(dev, KEYBOARD_64H);
#if KEYBOARD_DEBUG_80H
- dev_unhook_io(dev, KEYBOARD_DELAY_80H);
+ v3_dev_unhook_io(dev, KEYBOARD_DELAY_80H);
#endif
keyboard_reset_device(dev);
return 0;
-struct vm_device *create_keyboard() {
+struct vm_device * v3_create_keyboard() {
struct keyboard_internal * keyboard_state = NULL;
keyboard_state = (struct keyboard_internal *)V3_Malloc(sizeof(struct keyboard_internal));
- struct vm_device *device = create_device("KEYBOARD", &dev_ops, keyboard_state);
+ struct vm_device *device = v3_create_device("KEYBOARD", &dev_ops, keyboard_state);
return device;
}
-int handle_timer_event(struct guest_info * info,
+static int handle_timer_event(struct guest_info * info,
struct v3_timer_event * evt,
void * priv_data) {
}
-int nvram_reset_device(struct vm_device * dev) {
+static int nvram_reset_device(struct vm_device * dev) {
struct nvram_internal * data = (struct nvram_internal *) dev->private_data;
PrintDebug("nvram: reset device\n");
-int nvram_start_device(struct vm_device * dev) {
+static int nvram_start_device(struct vm_device * dev) {
PrintDebug("nvram: start device\n");
return 0;
}
-int nvram_stop_device(struct vm_device * dev) {
+static int nvram_stop_device(struct vm_device * dev) {
PrintDebug("nvram: stop device\n");
return 0;
}
-int nvram_write_reg_port(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev) {
+static int nvram_write_reg_port(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
struct nvram_internal * data = (struct nvram_internal *)dev->private_data;
memcpy(&(data->thereg), src, 1);
return 1;
}
-int nvram_read_data_port(ushort_t port,
- void * dst,
- uint_t length,
- struct vm_device * dev) {
+static int nvram_read_data_port(ushort_t port,
+ void * dst,
+ uint_t length,
+ struct vm_device * dev) {
struct nvram_internal * data = (struct nvram_internal *)dev->private_data;
memcpy(dst, &(data->mem_state[data->thereg]), 1);
return 1;
}
-int nvram_write_data_port(ushort_t port,
- void * src,
- uint_t length,
- struct vm_device * dev) {
+static int nvram_write_data_port(ushort_t port,
+ void * src,
+ uint_t length,
+ struct vm_device * dev) {
struct nvram_internal * data = (struct nvram_internal *)dev->private_data;
memcpy(&(data->mem_state[data->thereg]), src, 1);
-int nvram_init_device(struct vm_device * dev) {
+static int nvram_init_device(struct vm_device * dev) {
struct nvram_internal * data = (struct nvram_internal *)dev->private_data;
nvram_reset_device(dev);
// hook ports
- dev_hook_io(dev, NVRAM_REG_PORT, NULL, &nvram_write_reg_port);
- dev_hook_io(dev, NVRAM_DATA_PORT, &nvram_read_data_port, &nvram_write_data_port);
+ v3_dev_hook_io(dev, NVRAM_REG_PORT, NULL, &nvram_write_reg_port);
+ v3_dev_hook_io(dev, NVRAM_DATA_PORT, &nvram_read_data_port, &nvram_write_data_port);
v3_hook_host_event(dev->vm, HOST_TIMER_EVT, V3_HOST_EVENT_HANDLER(handle_timer_event), dev);
return 0;
}
-int nvram_deinit_device(struct vm_device * dev) {
- dev_unhook_io(dev, NVRAM_REG_PORT);
- dev_unhook_io(dev, NVRAM_DATA_PORT);
+static int nvram_deinit_device(struct vm_device * dev) {
+ v3_dev_unhook_io(dev, NVRAM_REG_PORT);
+ v3_dev_unhook_io(dev, NVRAM_DATA_PORT);
nvram_reset_device(dev);
return 0;
-struct vm_device * create_nvram() {
+struct vm_device * v3_create_nvram() {
struct nvram_internal * nvram_state = NULL;
nvram_state = (struct nvram_internal *)V3_Malloc(sizeof(struct nvram_internal) + 1000);
PrintDebug("nvram: internal at %x\n", nvram_state);
- struct vm_device * device = create_device("NVRAM", &dev_ops, nvram_state);
+ struct vm_device * device = v3_create_device("NVRAM", &dev_ops, nvram_state);
return device;
}
rd_init_hardware(ramdisk);
- dev_hook_io(dev, PRI_CTRL_PORT,
- &read_status_port, &write_ctrl_port);
-
- dev_hook_io(dev, PRI_DATA_PORT,
- &read_data_port, &write_data_port);
- dev_hook_io(dev, PRI_FEATURES_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_SECT_CNT_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_SECT_ADDR1_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_SECT_ADDR2_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_SECT_ADDR3_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_DRV_SEL_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_CMD_PORT,
- &read_status_port, &write_cmd_port);
-
-
- dev_hook_io(dev, SEC_CTRL_PORT,
- &read_status_port, &write_ctrl_port);
-
- dev_hook_io(dev, SEC_DATA_PORT,
- &read_data_port, &write_data_port);
- dev_hook_io(dev, SEC_FEATURES_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_SECT_CNT_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_SECT_ADDR1_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_SECT_ADDR2_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_SECT_ADDR3_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_DRV_SEL_PORT,
- &read_general_port, &write_general_port);
- dev_hook_io(dev, SEC_CMD_PORT,
- &read_status_port, &write_cmd_port);
-
+ v3_dev_hook_io(dev, PRI_CTRL_PORT,
+ &read_status_port, &write_ctrl_port);
+
+ v3_dev_hook_io(dev, PRI_DATA_PORT,
+ &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, PRI_FEATURES_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_SECT_CNT_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_SECT_ADDR1_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_SECT_ADDR2_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_SECT_ADDR3_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_DRV_SEL_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_CMD_PORT,
+ &read_status_port, &write_cmd_port);
+
+
+ v3_dev_hook_io(dev, SEC_CTRL_PORT,
+ &read_status_port, &write_ctrl_port);
+
+ v3_dev_hook_io(dev, SEC_DATA_PORT,
+ &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, SEC_FEATURES_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_SECT_CNT_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_SECT_ADDR1_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_SECT_ADDR2_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_SECT_ADDR3_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_DRV_SEL_PORT,
+ &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_CMD_PORT,
+ &read_status_port, &write_cmd_port);
+
- dev_hook_io(dev, SEC_ADDR_REG_PORT,
- &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, SEC_ADDR_REG_PORT,
+ &read_general_port, &write_general_port);
- dev_hook_io(dev, PRI_ADDR_REG_PORT,
- &read_general_port, &write_general_port);
+ v3_dev_hook_io(dev, PRI_ADDR_REG_PORT,
+ &read_general_port, &write_general_port);
-struct vm_device *create_ramdisk()
+struct vm_device * v3_create_ramdisk()
{
struct ramdisk_t *ramdisk;
PrintDebug("[create_ramdisk]\n");
- struct vm_device *device = create_device("RAMDISK", &dev_ops, ramdisk);
+ struct vm_device * device = v3_create_device("RAMDISK", &dev_ops, ramdisk);
return device;
}
init_serial_port(&(state->com3));
init_serial_port(&(state->com4));
- dev_hook_io(dev, COM1_DATA_PORT, &read_data_port, &write_data_port);
- dev_hook_io(dev, COM1_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM1_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM1_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM1_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM1_LINE_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM1_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM1_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
-
- dev_hook_io(dev, COM2_DATA_PORT, &read_data_port, &write_data_port);
- dev_hook_io(dev, COM2_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM2_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM2_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM2_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM2_LINE_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM2_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM2_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
-
- dev_hook_io(dev, COM3_DATA_PORT, &read_data_port, &write_data_port);
- dev_hook_io(dev, COM3_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM3_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM3_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM3_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM3_LINE_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM3_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM3_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
-
- dev_hook_io(dev, COM4_DATA_PORT, &read_data_port, &write_data_port);
- dev_hook_io(dev, COM4_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM4_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM4_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM4_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
- dev_hook_io(dev, COM4_LINE_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM4_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
- dev_hook_io(dev, COM4_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM1_DATA_PORT, &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, COM1_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM1_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM1_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM1_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM1_LINE_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM1_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM1_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
+
+ v3_dev_hook_io(dev, COM2_DATA_PORT, &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, COM2_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM2_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM2_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM2_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM2_LINE_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM2_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM2_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
+
+ v3_dev_hook_io(dev, COM3_DATA_PORT, &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, COM3_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM3_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM3_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM3_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM3_LINE_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM3_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM3_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
+
+ v3_dev_hook_io(dev, COM4_DATA_PORT, &read_data_port, &write_data_port);
+ v3_dev_hook_io(dev, COM4_IRQ_ENABLE_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM4_FIFO_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM4_LINE_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM4_MODEM_CTRL_PORT, &read_ctrl_port, &write_ctrl_port);
+ v3_dev_hook_io(dev, COM4_LINE_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM4_MODEM_STATUS_PORT, &read_status_port, &write_status_port);
+ v3_dev_hook_io(dev, COM4_SCRATCH_PORT, &read_ctrl_port, &write_ctrl_port);
return 0;
}
static int serial_deinit(struct vm_device * dev) {
- dev_unhook_io(dev, COM1_DATA_PORT);
- dev_unhook_io(dev, COM1_IRQ_ENABLE_PORT);
- dev_unhook_io(dev, COM1_FIFO_CTRL_PORT);
- dev_unhook_io(dev, COM1_LINE_CTRL_PORT);
- dev_unhook_io(dev, COM1_MODEM_CTRL_PORT);
- dev_unhook_io(dev, COM1_LINE_STATUS_PORT);
- dev_unhook_io(dev, COM1_MODEM_STATUS_PORT);
- dev_unhook_io(dev, COM1_SCRATCH_PORT);
-
- dev_unhook_io(dev, COM2_DATA_PORT);
- dev_unhook_io(dev, COM2_IRQ_ENABLE_PORT);
- dev_unhook_io(dev, COM2_FIFO_CTRL_PORT);
- dev_unhook_io(dev, COM2_LINE_CTRL_PORT);
- dev_unhook_io(dev, COM2_MODEM_CTRL_PORT);
- dev_unhook_io(dev, COM2_LINE_STATUS_PORT);
- dev_unhook_io(dev, COM2_MODEM_STATUS_PORT);
- dev_unhook_io(dev, COM2_SCRATCH_PORT);
-
- dev_unhook_io(dev, COM3_DATA_PORT);
- dev_unhook_io(dev, COM3_IRQ_ENABLE_PORT);
- dev_unhook_io(dev, COM3_FIFO_CTRL_PORT);
- dev_unhook_io(dev, COM3_LINE_CTRL_PORT);
- dev_unhook_io(dev, COM3_MODEM_CTRL_PORT);
- dev_unhook_io(dev, COM3_LINE_STATUS_PORT);
- dev_unhook_io(dev, COM3_MODEM_STATUS_PORT);
- dev_unhook_io(dev, COM3_SCRATCH_PORT);
-
- dev_unhook_io(dev, COM4_DATA_PORT);
- dev_unhook_io(dev, COM4_IRQ_ENABLE_PORT);
- dev_unhook_io(dev, COM4_FIFO_CTRL_PORT);
- dev_unhook_io(dev, COM4_LINE_CTRL_PORT);
- dev_unhook_io(dev, COM4_MODEM_CTRL_PORT);
- dev_unhook_io(dev, COM4_LINE_STATUS_PORT);
- dev_unhook_io(dev, COM4_MODEM_STATUS_PORT);
- dev_unhook_io(dev, COM4_SCRATCH_PORT);
+ v3_dev_unhook_io(dev, COM1_DATA_PORT);
+ v3_dev_unhook_io(dev, COM1_IRQ_ENABLE_PORT);
+ v3_dev_unhook_io(dev, COM1_FIFO_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM1_LINE_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM1_MODEM_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM1_LINE_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM1_MODEM_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM1_SCRATCH_PORT);
+
+ v3_dev_unhook_io(dev, COM2_DATA_PORT);
+ v3_dev_unhook_io(dev, COM2_IRQ_ENABLE_PORT);
+ v3_dev_unhook_io(dev, COM2_FIFO_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM2_LINE_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM2_MODEM_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM2_LINE_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM2_MODEM_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM2_SCRATCH_PORT);
+
+ v3_dev_unhook_io(dev, COM3_DATA_PORT);
+ v3_dev_unhook_io(dev, COM3_IRQ_ENABLE_PORT);
+ v3_dev_unhook_io(dev, COM3_FIFO_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM3_LINE_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM3_MODEM_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM3_LINE_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM3_MODEM_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM3_SCRATCH_PORT);
+
+ v3_dev_unhook_io(dev, COM4_DATA_PORT);
+ v3_dev_unhook_io(dev, COM4_IRQ_ENABLE_PORT);
+ v3_dev_unhook_io(dev, COM4_FIFO_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM4_LINE_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM4_MODEM_CTRL_PORT);
+ v3_dev_unhook_io(dev, COM4_LINE_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM4_MODEM_STATUS_PORT);
+ v3_dev_unhook_io(dev, COM4_SCRATCH_PORT);
return 0;
}
};
-struct vm_device * create_serial(int num_ports) {
+struct vm_device * v3_create_serial(int num_ports) {
struct serial_state * state = NULL;
state = (struct serial_state *)V3_Malloc(sizeof(struct serial_state));
V3_ASSERT(state != NULL);
- struct vm_device * device = create_device("Serial UART", &dev_ops, state);
+ struct vm_device * device = v3_create_device("Serial UART", &dev_ops, state);
return device;
}
-int pic_init_device(struct vm_device * dev) {
+static int pic_init_device(struct vm_device * dev) {
struct pic_internal * data = (struct pic_internal *)dev->private_data;
set_intr_controller(dev->vm, &intr_ops, data);
data->pending_irq = 0;
}
-int pic_deinit_device(struct vm_device * dev) {
+static int pic_deinit_device(struct vm_device * dev) {
return 0;
}
};
-struct vm_device * create_simple_pic() {
+struct vm_device * v3_create_simple_pic() {
struct pic_internal * state = NULL;
state = (struct pic_internal *)V3_Malloc(sizeof(struct pic_internal));
V3_ASSERT(state != NULL);
- struct vm_device * pic_dev = create_device("Simple Pic", &dev_ops, state);
+ struct vm_device * pic_dev = v3_create_device("Simple Pic", &dev_ops, state);
return pic_dev;
};
-
-int irq_handler(uint_t irq, struct vm_device * dev) {
+/*
+static int irq_handler(uint_t irq, struct vm_device * dev) {
PrintDebug("Timer interrupt\n");
return 0;
}
+*/
-int timer_init(struct vm_device * dev) {
+static int timer_init(struct vm_device * dev) {
//dev_hook_irq(dev, TIMER_IRQ, &irq_handler);
return 0;
}
-int timer_deinit(struct vm_device * dev) {
+static int timer_deinit(struct vm_device * dev) {
return 0;
}
};
-struct vm_device * create_timer() {
+struct vm_device * v3_create_timer() {
struct timer_state * timer = NULL;
timer = (struct timer_state *)V3_Malloc( sizeof(struct timer_state));
V3_ASSERT(timer != NULL);
- struct vm_device * dev = create_device("Timer", &dev_ops, timer);
+ struct vm_device * dev = v3_create_device("Timer", &dev_ops, timer);
return dev;
static vmcb_t * Allocate_VMCB() {
vmcb_t * vmcb_page = (vmcb_t *)V3_AllocPages(1);
-
memset(vmcb_page, 0, 4096);
return vmcb_page;
// can we start a kernel thread here...
- int start_svm_guest(struct guest_info *info) {
+static int start_svm_guest(struct guest_info *info) {
vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
uint_t num_exits = 0;
}
- if (handle_svm_exit(info) != 0) {
+ if (v3_handle_svm_exit(info) != 0) {
addr_t host_addr;
addr_t linear_addr = 0;
PrintDebug("RIP Linear: %x\n", linear_addr);
- PrintV3Segments(info);
- PrintV3CtrlRegs(info);
- PrintV3GPRs(info);
+ v3_print_segments(info);
+ v3_print_ctrl_regs(info);
+ v3_print_GPRs(info);
if (info->mem_mode == PHYSICAL_MEM) {
guest_pa_to_host_pa(info, linear_addr, &host_addr);
/* Checks machine SVM capability */
/* Implemented from: AMD Arch Manual 3, sect 15.4 */
-int is_svm_capable() {
+int v3_is_svm_capable() {
#if 1
// Dinda
}
-int has_svm_nested_paging() {
+static int has_svm_nested_paging() {
uint32_t ret;
ret = cpuid_edx(CPUID_SVM_REV_AND_FEATURE_IDS);
-void Init_SVM(struct vmm_ctrl_ops * vmm_ops) {
+void v3_init_SVM(struct v3_ctrl_ops * vmm_ops) {
reg_ex_t msr;
void * host_state;
// This should trigger a #GP if cpl!=0, otherwise, yield to host
//
-int handle_svm_halt(struct guest_info * info)
+int v3_handle_svm_halt(struct guest_info * info)
{
if (info->cpl!=0) {
v3_raise_exception(info, GPF_EXCEPTION);
#include <palacios/vmm_intr.h>
#include <palacios/vmm_emulator.h>
-int handle_svm_exit(struct guest_info * info) {
+
+
+
+static const uchar_t * vmexit_code_to_str(uint_t exit_code);
+
+
+int v3_handle_svm_exit(struct guest_info * info) {
vmcb_ctrl_t * guest_ctrl = 0;
vmcb_saved_state_t * guest_state = 0;
ulong_t exit_code = 0;
info->ctrl_regs.efer = guest_state->efer;
get_vmcb_segments((vmcb_t*)(info->vmm_data), &(info->segments));
- info->cpu_mode = get_cpu_mode(info);
- info->mem_mode = get_mem_mode(info);
+ info->cpu_mode = v3_get_cpu_mode(info);
+ info->mem_mode = v3_get_mem_mode(info);
exit_code = guest_ctrl->exit_code;
if (io_info->type == 0) {
if (io_info->str) {
- if (handle_svm_io_outs(info) == -1 ) {
+ if (v3_handle_svm_io_outs(info) == -1 ) {
return -1;
}
} else {
- if (handle_svm_io_out(info) == -1) {
+ if (v3_handle_svm_io_out(info) == -1) {
return -1;
}
}
} else {
if (io_info->str) {
- if (handle_svm_io_ins(info) == -1) {
+ if (v3_handle_svm_io_ins(info) == -1) {
return -1;
}
} else {
- if (handle_svm_io_in(info) == -1) {
+ if (v3_handle_svm_io_in(info) == -1) {
return -1;
}
}
case VMEXIT_INTR: {
- // handle_svm_intr(info); // handled by interrupt dispatch earlier
+ // handled by interrupt dispatch earlier
}
break;
#ifdef DEBUG_HALT
PrintDebug("Guest halted\n");
#endif
- if (handle_svm_halt(info) == -1) {
+ if (v3_handle_svm_halt(info) == -1) {
return -1;
}
}
case VMEXIT_PAUSE: {
//PrintDebug("Guest paused\n");
- if (handle_svm_pause(info) == -1) {
+ if (v3_handle_svm_pause(info) == -1) {
return -1;
}
}
#ifdef DEBUG_EMULATOR
PrintDebug("WBINVD\n");
#endif
- if (!handle_svm_wbinvd(info)) {
+ if (!v3_handle_svm_wbinvd(info)) {
return -1;
}
break;
}
+static const uchar_t VMEXIT_CR0_READ_STR[] = "VMEXIT_CR0_READ";
+static const uchar_t VMEXIT_CR1_READ_STR[] = "VMEXIT_CR1_READ";
+static const uchar_t VMEXIT_CR2_READ_STR[] = "VMEXIT_CR2_READ";
+static const uchar_t VMEXIT_CR3_READ_STR[] = "VMEXIT_CR3_READ";
+static const uchar_t VMEXIT_CR4_READ_STR[] = "VMEXIT_CR4_READ";
+static const uchar_t VMEXIT_CR5_READ_STR[] = "VMEXIT_CR5_READ";
+static const uchar_t VMEXIT_CR6_READ_STR[] = "VMEXIT_CR6_READ";
+static const uchar_t VMEXIT_CR7_READ_STR[] = "VMEXIT_CR7_READ";
+static const uchar_t VMEXIT_CR8_READ_STR[] = "VMEXIT_CR8_READ";
+static const uchar_t VMEXIT_CR9_READ_STR[] = "VMEXIT_CR9_READ";
+static const uchar_t VMEXIT_CR10_READ_STR[] = "VMEXIT_CR10_READ";
+static const uchar_t VMEXIT_CR11_READ_STR[] = "VMEXIT_CR11_READ";
+static const uchar_t VMEXIT_CR12_READ_STR[] = "VMEXIT_CR12_READ";
+static const uchar_t VMEXIT_CR13_READ_STR[] = "VMEXIT_CR13_READ";
+static const uchar_t VMEXIT_CR14_READ_STR[] = "VMEXIT_CR14_READ";
+static const uchar_t VMEXIT_CR15_READ_STR[] = "VMEXIT_CR15_READ";
+static const uchar_t VMEXIT_CR0_WRITE_STR[] = "VMEXIT_CR0_WRITE";
+static const uchar_t VMEXIT_CR1_WRITE_STR[] = "VMEXIT_CR1_WRITE";
+static const uchar_t VMEXIT_CR2_WRITE_STR[] = "VMEXIT_CR2_WRITE";
+static const uchar_t VMEXIT_CR3_WRITE_STR[] = "VMEXIT_CR3_WRITE";
+static const uchar_t VMEXIT_CR4_WRITE_STR[] = "VMEXIT_CR4_WRITE";
+static const uchar_t VMEXIT_CR5_WRITE_STR[] = "VMEXIT_CR5_WRITE";
+static const uchar_t VMEXIT_CR6_WRITE_STR[] = "VMEXIT_CR6_WRITE";
+static const uchar_t VMEXIT_CR7_WRITE_STR[] = "VMEXIT_CR7_WRITE";
+static const uchar_t VMEXIT_CR8_WRITE_STR[] = "VMEXIT_CR8_WRITE";
+static const uchar_t VMEXIT_CR9_WRITE_STR[] = "VMEXIT_CR9_WRITE";
+static const uchar_t VMEXIT_CR10_WRITE_STR[] = "VMEXIT_CR10_WRITE";
+static const uchar_t VMEXIT_CR11_WRITE_STR[] = "VMEXIT_CR11_WRITE";
+static const uchar_t VMEXIT_CR12_WRITE_STR[] = "VMEXIT_CR12_WRITE";
+static const uchar_t VMEXIT_CR13_WRITE_STR[] = "VMEXIT_CR13_WRITE";
+static const uchar_t VMEXIT_CR14_WRITE_STR[] = "VMEXIT_CR14_WRITE";
+static const uchar_t VMEXIT_CR15_WRITE_STR[] = "VMEXIT_CR15_WRITE";
+static const uchar_t VMEXIT_DR0_READ_STR[] = "VMEXIT_DR0_READ";
+static const uchar_t VMEXIT_DR1_READ_STR[] = "VMEXIT_DR1_READ";
+static const uchar_t VMEXIT_DR2_READ_STR[] = "VMEXIT_DR2_READ";
+static const uchar_t VMEXIT_DR3_READ_STR[] = "VMEXIT_DR3_READ";
+static const uchar_t VMEXIT_DR4_READ_STR[] = "VMEXIT_DR4_READ";
+static const uchar_t VMEXIT_DR5_READ_STR[] = "VMEXIT_DR5_READ";
+static const uchar_t VMEXIT_DR6_READ_STR[] = "VMEXIT_DR6_READ";
+static const uchar_t VMEXIT_DR7_READ_STR[] = "VMEXIT_DR7_READ";
+static const uchar_t VMEXIT_DR8_READ_STR[] = "VMEXIT_DR8_READ";
+static const uchar_t VMEXIT_DR9_READ_STR[] = "VMEXIT_DR9_READ";
+static const uchar_t VMEXIT_DR10_READ_STR[] = "VMEXIT_DR10_READ";
+static const uchar_t VMEXIT_DR11_READ_STR[] = "VMEXIT_DR11_READ";
+static const uchar_t VMEXIT_DR12_READ_STR[] = "VMEXIT_DR12_READ";
+static const uchar_t VMEXIT_DR13_READ_STR[] = "VMEXIT_DR13_READ";
+static const uchar_t VMEXIT_DR14_READ_STR[] = "VMEXIT_DR14_READ";
+static const uchar_t VMEXIT_DR15_READ_STR[] = "VMEXIT_DR15_READ";
+static const uchar_t VMEXIT_DR0_WRITE_STR[] = "VMEXIT_DR0_WRITE";
+static const uchar_t VMEXIT_DR1_WRITE_STR[] = "VMEXIT_DR1_WRITE";
+static const uchar_t VMEXIT_DR2_WRITE_STR[] = "VMEXIT_DR2_WRITE";
+static const uchar_t VMEXIT_DR3_WRITE_STR[] = "VMEXIT_DR3_WRITE";
+static const uchar_t VMEXIT_DR4_WRITE_STR[] = "VMEXIT_DR4_WRITE";
+static const uchar_t VMEXIT_DR5_WRITE_STR[] = "VMEXIT_DR5_WRITE";
+static const uchar_t VMEXIT_DR6_WRITE_STR[] = "VMEXIT_DR6_WRITE";
+static const uchar_t VMEXIT_DR7_WRITE_STR[] = "VMEXIT_DR7_WRITE";
+static const uchar_t VMEXIT_DR8_WRITE_STR[] = "VMEXIT_DR8_WRITE";
+static const uchar_t VMEXIT_DR9_WRITE_STR[] = "VMEXIT_DR9_WRITE";
+static const uchar_t VMEXIT_DR10_WRITE_STR[] = "VMEXIT_DR10_WRITE";
+static const uchar_t VMEXIT_DR11_WRITE_STR[] = "VMEXIT_DR11_WRITE";
+static const uchar_t VMEXIT_DR12_WRITE_STR[] = "VMEXIT_DR12_WRITE";
+static const uchar_t VMEXIT_DR13_WRITE_STR[] = "VMEXIT_DR13_WRITE";
+static const uchar_t VMEXIT_DR14_WRITE_STR[] = "VMEXIT_DR14_WRITE";
+static const uchar_t VMEXIT_DR15_WRITE_STR[] = "VMEXIT_DR15_WRITE";
+static const uchar_t VMEXIT_EXCP0_STR[] = "VMEXIT_EXCP0";
+static const uchar_t VMEXIT_EXCP1_STR[] = "VMEXIT_EXCP1";
+static const uchar_t VMEXIT_EXCP2_STR[] = "VMEXIT_EXCP2";
+static const uchar_t VMEXIT_EXCP3_STR[] = "VMEXIT_EXCP3";
+static const uchar_t VMEXIT_EXCP4_STR[] = "VMEXIT_EXCP4";
+static const uchar_t VMEXIT_EXCP5_STR[] = "VMEXIT_EXCP5";
+static const uchar_t VMEXIT_EXCP6_STR[] = "VMEXIT_EXCP6";
+static const uchar_t VMEXIT_EXCP7_STR[] = "VMEXIT_EXCP7";
+static const uchar_t VMEXIT_EXCP8_STR[] = "VMEXIT_EXCP8";
+static const uchar_t VMEXIT_EXCP9_STR[] = "VMEXIT_EXCP9";
+static const uchar_t VMEXIT_EXCP10_STR[] = "VMEXIT_EXCP10";
+static const uchar_t VMEXIT_EXCP11_STR[] = "VMEXIT_EXCP11";
+static const uchar_t VMEXIT_EXCP12_STR[] = "VMEXIT_EXCP12";
+static const uchar_t VMEXIT_EXCP13_STR[] = "VMEXIT_EXCP13";
+static const uchar_t VMEXIT_EXCP14_STR[] = "VMEXIT_EXCP14";
+static const uchar_t VMEXIT_EXCP15_STR[] = "VMEXIT_EXCP15";
+static const uchar_t VMEXIT_EXCP16_STR[] = "VMEXIT_EXCP16";
+static const uchar_t VMEXIT_EXCP17_STR[] = "VMEXIT_EXCP17";
+static const uchar_t VMEXIT_EXCP18_STR[] = "VMEXIT_EXCP18";
+static const uchar_t VMEXIT_EXCP19_STR[] = "VMEXIT_EXCP19";
+static const uchar_t VMEXIT_EXCP20_STR[] = "VMEXIT_EXCP20";
+static const uchar_t VMEXIT_EXCP21_STR[] = "VMEXIT_EXCP21";
+static const uchar_t VMEXIT_EXCP22_STR[] = "VMEXIT_EXCP22";
+static const uchar_t VMEXIT_EXCP23_STR[] = "VMEXIT_EXCP23";
+static const uchar_t VMEXIT_EXCP24_STR[] = "VMEXIT_EXCP24";
+static const uchar_t VMEXIT_EXCP25_STR[] = "VMEXIT_EXCP25";
+static const uchar_t VMEXIT_EXCP26_STR[] = "VMEXIT_EXCP26";
+static const uchar_t VMEXIT_EXCP27_STR[] = "VMEXIT_EXCP27";
+static const uchar_t VMEXIT_EXCP28_STR[] = "VMEXIT_EXCP28";
+static const uchar_t VMEXIT_EXCP29_STR[] = "VMEXIT_EXCP29";
+static const uchar_t VMEXIT_EXCP30_STR[] = "VMEXIT_EXCP30";
+static const uchar_t VMEXIT_EXCP31_STR[] = "VMEXIT_EXCP31";
+static const uchar_t VMEXIT_INTR_STR[] = "VMEXIT_INTR";
+static const uchar_t VMEXIT_NMI_STR[] = "VMEXIT_NMI";
+static const uchar_t VMEXIT_SMI_STR[] = "VMEXIT_SMI";
+static const uchar_t VMEXIT_INIT_STR[] = "VMEXIT_INIT";
+static const uchar_t VMEXIT_VINITR_STR[] = "VMEXIT_VINITR";
+static const uchar_t VMEXIT_CR0_SEL_WRITE_STR[] = "VMEXIT_CR0_SEL_WRITE";
+static const uchar_t VMEXIT_IDTR_READ_STR[] = "VMEXIT_IDTR_READ";
+static const uchar_t VMEXIT_GDTR_READ_STR[] = "VMEXIT_GDTR_READ";
+static const uchar_t VMEXIT_LDTR_READ_STR[] = "VMEXIT_LDTR_READ";
+static const uchar_t VMEXIT_TR_READ_STR[] = "VMEXIT_TR_READ";
+static const uchar_t VMEXIT_IDTR_WRITE_STR[] = "VMEXIT_IDTR_WRITE";
+static const uchar_t VMEXIT_GDTR_WRITE_STR[] = "VMEXIT_GDTR_WRITE";
+static const uchar_t VMEXIT_LDTR_WRITE_STR[] = "VMEXIT_LDTR_WRITE";
+static const uchar_t VMEXIT_TR_WRITE_STR[] = "VMEXIT_TR_WRITE";
+static const uchar_t VMEXIT_RDTSC_STR[] = "VMEXIT_RDTSC";
+static const uchar_t VMEXIT_RDPMC_STR[] = "VMEXIT_RDPMC";
+static const uchar_t VMEXIT_PUSHF_STR[] = "VMEXIT_PUSHF";
+static const uchar_t VMEXIT_POPF_STR[] = "VMEXIT_POPF";
+static const uchar_t VMEXIT_CPUID_STR[] = "VMEXIT_CPUID";
+static const uchar_t VMEXIT_RSM_STR[] = "VMEXIT_RSM";
+static const uchar_t VMEXIT_IRET_STR[] = "VMEXIT_IRET";
+static const uchar_t VMEXIT_SWINT_STR[] = "VMEXIT_SWINT";
+static const uchar_t VMEXIT_INVD_STR[] = "VMEXIT_INVD";
+static const uchar_t VMEXIT_PAUSE_STR[] = "VMEXIT_PAUSE";
+static const uchar_t VMEXIT_HLT_STR[] = "VMEXIT_HLT";
+static const uchar_t VMEXIT_INVLPG_STR[] = "VMEXIT_INVLPG";
+static const uchar_t VMEXIT_INVLPGA_STR[] = "VMEXIT_INVLPGA";
+static const uchar_t VMEXIT_IOIO_STR[] = "VMEXIT_IOIO";
+static const uchar_t VMEXIT_MSR_STR[] = "VMEXIT_MSR";
+static const uchar_t VMEXIT_TASK_SWITCH_STR[] = "VMEXIT_TASK_SWITCH";
+static const uchar_t VMEXIT_FERR_FREEZE_STR[] = "VMEXIT_FERR_FREEZE";
+static const uchar_t VMEXIT_SHUTDOWN_STR[] = "VMEXIT_SHUTDOWN";
+static const uchar_t VMEXIT_VMRUN_STR[] = "VMEXIT_VMRUN";
+static const uchar_t VMEXIT_VMMCALL_STR[] = "VMEXIT_VMMCALL";
+static const uchar_t VMEXIT_VMLOAD_STR[] = "VMEXIT_VMLOAD";
+static const uchar_t VMEXIT_VMSAVE_STR[] = "VMEXIT_VMSAVE";
+static const uchar_t VMEXIT_STGI_STR[] = "VMEXIT_STGI";
+static const uchar_t VMEXIT_CLGI_STR[] = "VMEXIT_CLGI";
+static const uchar_t VMEXIT_SKINIT_STR[] = "VMEXIT_SKINIT";
+static const uchar_t VMEXIT_RDTSCP_STR[] = "VMEXIT_RDTSCP";
+static const uchar_t VMEXIT_ICEBP_STR[] = "VMEXIT_ICEBP";
+static const uchar_t VMEXIT_WBINVD_STR[] = "VMEXIT_WBINVD";
+static const uchar_t VMEXIT_MONITOR_STR[] = "VMEXIT_MONITOR";
+static const uchar_t VMEXIT_MWAIT_STR[] = "VMEXIT_MWAIT";
+static const uchar_t VMEXIT_MWAIT_CONDITIONAL_STR[] = "VMEXIT_MWAIT_CONDITIONAL";
+static const uchar_t VMEXIT_NPF_STR[] = "VMEXIT_NPF";
+static const uchar_t VMEXIT_INVALID_VMCB_STR[] = "VMEXIT_INVALID_VMCB";
+
const uchar_t * vmexit_code_to_str(uint_t exit_code) {
#endif
+
+
+
// This should package up an IO request and call vmm_handle_io
-int handle_svm_io_in(struct guest_info * info) {
+int v3_handle_svm_io_in(struct guest_info * info) {
vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t *)(info->vmm_data));
// vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
struct svm_io_info * io_info = (struct svm_io_info *)&(ctrl_area->exit_info1);
/* We might not handle wrap around of the RDI register correctly...
* In that if we do wrap around the effect will manifest in the higher bits of the register
*/
-int handle_svm_io_ins(struct guest_info * info) {
+int v3_handle_svm_io_ins(struct guest_info * info) {
vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t *)(info->vmm_data));
vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
return 0;
}
-int handle_svm_io_out(struct guest_info * info) {
+int v3_handle_svm_io_out(struct guest_info * info) {
vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t *)(info->vmm_data));
// vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
struct svm_io_info * io_info = (struct svm_io_info *)&(ctrl_area->exit_info1);
* In that if we do wrap around the effect will manifest in the higher bits of the register
*/
-int handle_svm_io_outs(struct guest_info * info) {
+int v3_handle_svm_io_outs(struct guest_info * info) {
vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t *)(info->vmm_data));
vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
#include <palacios/vmm_intr.h>
-int handle_svm_pause(struct guest_info * info)
+int v3_handle_svm_pause(struct guest_info * info)
{
// handled as a nop
// should raise #GP if CPL is not zero
// Otherwise execute
-int handle_svm_wbinvd(struct guest_info * info)
+int v3_handle_svm_wbinvd(struct guest_info * info)
{
if (info->cpl!=0) {
PrintDebug("WBINVD: cpl!=0, injecting GPF\n");
-struct vm_device * allocate_device() {
+static struct vm_device * v3_allocate_device() {
struct vm_device * dev = NULL;
dev = (struct vm_device*)V3_Malloc(sizeof(struct vm_device));
return dev;
}
-struct vm_device * create_device(char * name, struct vm_device_ops * ops, void * private_data) {
- struct vm_device * dev = allocate_device();
+struct vm_device * v3_create_device(char * name, struct vm_device_ops * ops, void * private_data) {
+ struct vm_device * dev = v3_allocate_device();
strncpy(dev->name, name, 32);
dev->ops = ops;
return dev;
}
-void free_device(struct vm_device * dev) {
+void v3_free_device(struct vm_device * dev) {
V3_Free(dev);
}
#include <palacios/vmm.h>
-vm_cpu_mode_t get_cpu_mode(struct guest_info * info) {
+v3_vm_cpu_mode_t v3_get_cpu_mode(struct guest_info * info) {
struct cr0_32 * cr0;
struct cr4_32 * cr4 = (struct cr4_32 *)&(info->ctrl_regs.cr4);
struct efer_64 * efer = (struct efer_64 *)&(info->ctrl_regs.efer);
}
}
-vm_mem_mode_t get_mem_mode(struct guest_info * info) {
+v3_vm_mem_mode_t v3_get_mem_mode(struct guest_info * info) {
struct cr0_32 * cr0;
if (info->shdw_pg_mode == SHADOW_PAGING) {
}
-void PrintV3Segments(struct guest_info * info) {
+void v3_print_segments(struct guest_info * info) {
struct v3_segments * segs = &(info->segments);
int i = 0;
struct v3_segment * seg_ptr;
}
-void PrintV3CtrlRegs(struct guest_info * info) {
+void v3_print_ctrl_regs(struct guest_info * info) {
struct v3_ctrl_regs * regs = &(info->ctrl_regs);
int i = 0;
v3_reg_t * reg_ptr;
}
-void PrintV3GPRs(struct guest_info * info) {
+void v3_print_GPRs(struct guest_info * info) {
struct v3_gprs * regs = &(info->vm_regs);
int i = 0;
v3_reg_t * reg_ptr;
#include <palacios/vmm.h>
#include <palacios/vmm_paging.h>
-extern struct vmm_os_hooks * os_hooks;
+extern struct v3_os_hooks * os_hooks;
/**********************************/
#include <palacios/vmm_decoder.h>
v3_cpu_arch_t v3_cpu_type;
-struct vmm_os_hooks * os_hooks = NULL;
+struct v3_os_hooks * os_hooks = NULL;
-struct guest_info * allocate_guest() {
+static struct guest_info * allocate_guest() {
void * info = V3_Malloc(sizeof(struct guest_info));
memset(info, 0, sizeof(struct guest_info));
return info;
-void Init_V3(struct vmm_os_hooks * hooks, struct vmm_ctrl_ops * vmm_ops) {
+void Init_V3(struct v3_os_hooks * hooks, struct v3_ctrl_ops * vmm_ops) {
os_hooks = hooks;
v3_cpu_type = V3_INVALID_CPU;
init_decoder();
- if (is_svm_capable()) {
+ if (v3_is_svm_capable()) {
PrintDebug("Machine is SVM Capable\n");
vmm_ops->allocate_guest = &allocate_guest;
- vmm_ops->config_guest = &config_guest;
- Init_SVM(vmm_ops);
+ vmm_ops->config_guest = &v3_config_guest;
+ v3_init_SVM(vmm_ops);
/*
} else if (is_vmx_capable()) {
-int config_guest(struct guest_info * info, struct v3_vm_config * config_ptr) {
+int v3_config_guest(struct guest_info * info, struct v3_vm_config * config_ptr) {
struct guest_mem_layout * layout = (struct guest_mem_layout *)config_ptr->vm_kernel;
extern v3_cpu_arch_t v3_cpu_type;
init_vmm_io_map(info);
init_interrupt_state(info);
- dev_mgr_init(info);
+ v3_init_dev_mgr(info);
init_emulator(info);
{
struct vm_device * ramdisk = NULL;
struct vm_device * cdrom = NULL;
- struct vm_device * nvram = create_nvram();
- //struct vm_device * timer = create_timer();
- struct vm_device * pic = create_pic();
- struct vm_device * keyboard = create_keyboard();
- struct vm_device * pit = create_pit();
- struct vm_device * bochs_debug = create_bochs_debug();
-
- //struct vm_device * serial = create_serial();
+ struct vm_device * nvram = v3_create_nvram();
+ //struct vm_device * timer = v3_create_timer();
+ struct vm_device * pic = v3_create_pic();
+ struct vm_device * keyboard = v3_create_keyboard();
+ struct vm_device * pit = v3_create_pit();
+ struct vm_device * bochs_debug = v3_create_bochs_debug();
+
+ //struct vm_device * serial = v3_create_serial();
struct vm_device * generic = NULL;
if (use_ramdisk) {
PrintDebug("Creating Ramdisk\n");
- ramdisk = create_ramdisk();
+ ramdisk = v3_create_ramdisk();
cdrom = v3_create_cdrom(ramdisk, config_ptr->ramdisk, config_ptr->ramdisk_size);
}
if (use_generic) {
PrintDebug("Creating Generic Device\n");
- generic = create_generic();
+ generic = v3_create_generic();
// Make the DMA controller invisible
v3_generic_add_port_range(generic, 0x00, 0x07, GENERIC_PRINT_AND_IGNORE); // DMA 1 channels 0,1,2,3 (address, counter)
*shadow_cr0 = *new_cr0;
shadow_cr0->et = 1;
- if (get_mem_mode(info) == VIRTUAL_MEM) {
+ if (v3_get_mem_mode(info) == VIRTUAL_MEM) {
struct cr3_32 * shadow_cr3 = (struct cr3_32 *)&(info->shdw_pg_state.shadow_cr3);
info->ctrl_regs.cr3 = *(addr_t*)shadow_cr3;
-int dev_mgr_init(struct guest_info * info) {
+int v3_init_dev_mgr(struct guest_info * info) {
struct vmm_dev_mgr * mgr = &(info->dev_mgr);
INIT_LIST_HEAD(&(mgr->dev_list));
mgr->num_devs = 0;
}
-int dev_mgr_deinit(struct guest_info * info) {
+int v3_dev_mgr_deinit(struct guest_info * info) {
struct vm_device * dev;
struct vmm_dev_mgr * mgr = &(info->dev_mgr);
struct vm_device * tmp;
list_for_each_entry_safe(dev, tmp, &(mgr->dev_list), dev_link) {
v3_unattach_device(dev);
- free_device(dev);
+ v3_free_device(dev);
}
return 0;
/* IO HOOKS */
-int dev_mgr_add_io_hook(struct vmm_dev_mgr * mgr, struct dev_io_hook * hook) {
+static int dev_mgr_add_io_hook(struct vmm_dev_mgr * mgr, struct dev_io_hook * hook) {
list_add(&(hook->mgr_list), &(mgr->io_hooks));
mgr->num_io_hooks++;
return 0;
}
-int dev_mgr_remove_io_hook(struct vmm_dev_mgr * mgr, struct dev_io_hook * hook) {
+static int dev_mgr_remove_io_hook(struct vmm_dev_mgr * mgr, struct dev_io_hook * hook) {
list_del(&(hook->mgr_list));
mgr->num_io_hooks--;
}
-int dev_add_io_hook(struct vm_device * dev, struct dev_io_hook * hook) {
+static int dev_add_io_hook(struct vm_device * dev, struct dev_io_hook * hook) {
list_add(&(hook->dev_list), &(dev->io_hooks));
dev->num_io_hooks++;
return 0;
}
-int dev_remove_io_hook(struct vm_device * dev, struct dev_io_hook * hook) {
+static int dev_remove_io_hook(struct vm_device * dev, struct dev_io_hook * hook) {
list_del(&(hook->dev_list));
dev->num_io_hooks--;
-struct dev_io_hook * dev_mgr_find_io_hook(struct vmm_dev_mgr * mgr, ushort_t port) {
+static struct dev_io_hook * dev_mgr_find_io_hook(struct vmm_dev_mgr * mgr, ushort_t port) {
struct dev_io_hook * tmp = NULL;
list_for_each_entry(tmp, &(mgr->io_hooks), mgr_list) {
return NULL;
}
-struct dev_io_hook * dev_find_io_hook(struct vm_device * dev, ushort_t port) {
+
+/*
+static struct dev_io_hook * dev_find_io_hook(struct vm_device * dev, ushort_t port) {
struct dev_io_hook * tmp = NULL;
list_for_each_entry(tmp, &(dev->io_hooks), dev_list) {
}
return NULL;
}
+*/
-
-int dev_hook_io(struct vm_device *dev,
- ushort_t port,
- int (*read)(ushort_t port, void * dst, uint_t length, struct vm_device * dev),
- int (*write)(ushort_t port, void * src, uint_t length, struct vm_device * dev)) {
-
+int v3_dev_hook_io(struct vm_device *dev,
+ ushort_t port,
+ int (*read)(ushort_t port, void * dst, uint_t length, struct vm_device * dev),
+ int (*write)(ushort_t port, void * src, uint_t length, struct vm_device * dev)) {
+
struct dev_io_hook *hook = (struct dev_io_hook *)V3_Malloc(sizeof(struct dev_io_hook));
if (!hook) {
}
-int dev_unhook_io(struct vm_device *dev,
+int v3_dev_unhook_io(struct vm_device *dev,
ushort_t port) {
struct vmm_dev_mgr * mgr = &(dev->vm->dev_mgr);
-
-int dev_mgr_hook_mem(struct guest_info *vm,
- struct vm_device *device,
- void *start,
- void *end)
+#if 0
+static int dev_mgr_hook_mem(struct guest_info *vm,
+ struct vm_device *device,
+ void *start,
+ void *end)
{
struct dev_mem_hook * hook = (struct dev_mem_hook*)V3_Malloc(sizeof(struct dev_mem_hook));
}
-int dev_mgr_unhook_mem(struct vm_device *dev,
- addr_t start,
- addr_t end) {
+static int dev_mgr_unhook_mem(struct vm_device *dev,
+ addr_t start,
+ addr_t end) {
/*
struct vmm_dev_mgr * mgr = &(dev->vm->dev_mgr);
struct dev_mem_hook *hook = dev_mgr_find_mem_hook(mgr, start, end);
*/
return -1;
}
-
+#endif
#ifdef DEBUG_DEV_MGR
#include <palacios/vmm.h>
-extern struct vmm_os_hooks * os_hooks;
+extern struct v3_os_hooks * os_hooks;
void PrintTraceHex(unsigned char x) {