From: Jack Lange Date: Sat, 18 Jun 2011 16:07:08 +0000 (-0400) Subject: reverted syscall changes X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=commitdiff_plain;h=382829fe58cb541af371547325c5502e37032ecd;p=palacios.git reverted syscall changes --- diff --git a/Kconfig b/Kconfig index acf7ebf..71f5f9b 100644 --- a/Kconfig +++ b/Kconfig @@ -163,15 +163,6 @@ config EXPERIMENTAL The purpose of this option is to allow features under development to be committed to the mainline to more easily track changes and provide access to multiple developers - -config INSPECTOR - bool "Enable VM inspection" - depends on EXPERIMENTAL - default n - help - Enable inspection framework for vm internal state - - endmenu @@ -411,16 +402,6 @@ config DEBUG_DEV_MGR help This turns on debugging for the device manager - -config DEBUG_SYSCALL_HIJACK - bool "Enable Syscall Hijack Debug in Palacios" - default n - depends on DEBUG_ON && SYSCALL_HIJACK - help - Enable Debugging printouts for syscall hijacking - code in Palacios - - endmenu diff --git a/palacios/include/palacios/vm_guest.h b/palacios/include/palacios/vm_guest.h index 5792543..4360a64 100644 --- a/palacios/include/palacios/vm_guest.h +++ b/palacios/include/palacios/vm_guest.h @@ -50,11 +50,6 @@ struct v3_sym_core_state; #endif -#ifdef V3_CONFIG_SYSCALL_HIJACK -#include -#include -#endif - #include @@ -95,12 +90,6 @@ struct guest_info { /* This structure is how we get exceptions for the guest */ struct v3_excp_state excp_state; -#ifdef V3_CONFIG_SYSCALL_HIJACK - struct v3_syscall_hook_map sc_hook_map; - struct v3_execve_varchunk var_dump; - struct v3_exec_hooks exec_hooks; -#endif - v3_cpu_mode_t cpu_mode; v3_mem_mode_t mem_mode; diff --git a/palacios/include/palacios/vm_guest_mem.h b/palacios/include/palacios/vm_guest_mem.h index 6d983ae..db6a6a0 100644 --- a/palacios/include/palacios/vm_guest_mem.h +++ b/palacios/include/palacios/vm_guest_mem.h @@ -99,9 +99,6 @@ int v3_hva_to_gva(struct guest_info * guest_info, addr_t host_va, addr_t * gues -// KCH -// Check if pte for this gva has certain permissions -int v3_gva_can_access(struct guest_info * core, addr_t gva); diff --git a/palacios/include/palacios/vmm_ctrl_regs.h b/palacios/include/palacios/vmm_ctrl_regs.h index 0b3336a..e072a04 100644 --- a/palacios/include/palacios/vmm_ctrl_regs.h +++ b/palacios/include/palacios/vmm_ctrl_regs.h @@ -27,20 +27,6 @@ #define EFER_MSR 0xc0000080 -// KCH: for system-call interposition -#define STAR_MSR 0xc0000081 /* Legacy mode SYSCALL target */ -#define LSTAR_MSR 0xc0000082 /* Long mode SYSCALL target */ -#define CSTAR_MSR 0xc0000083 /* compat mode SYSCALL target */ -#define SF_MASK_MSR 0xc0000084 /* EFLAGS mask for syscall */ -#define FS_BASE_MSR 0xc0000100 /* 64-bit FS base */ -#define GS_BASE_MSR 0xc0000101 /* 64-bit GS base */ -#define KERN_GS_BASE_MSR 0xc0000102 /* swapGS GS shadow */ - -/* Intel specific */ -#define IA32_SYSENTER_CS_MSR 0x00000174 -#define IA32_SYSENTER_ESP_MSR 0x00000175 -#define IA32_SYSENTER_EIP_MSR 0x00000176 - struct cr0_real { uint_t pe : 1; uint_t mp : 1; @@ -229,16 +215,6 @@ int v3_handle_cr4_read(struct guest_info * info); int v3_handle_efer_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); int v3_handle_efer_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); -int v3_handle_star_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); -int v3_handle_star_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); -int v3_handle_lstar_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); -int v3_handle_lstar_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); -int v3_handle_cstar_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); -int v3_handle_cstar_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); - -int v3_handle_seeip_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); -int v3_handle_seeip_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); - int v3_handle_vm_cr_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data); int v3_handle_vm_cr_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data); diff --git a/palacios/include/palacios/vmm_decoder.h b/palacios/include/palacios/vmm_decoder.h index 7f33fde..7b703a8 100644 --- a/palacios/include/palacios/vmm_decoder.h +++ b/palacios/include/palacios/vmm_decoder.h @@ -34,7 +34,7 @@ typedef enum { V3_INVALID_OP, V3_OP_SETB, V3_OP_SETBE, V3_OP_SETL, V3_OP_SETLE, V3_OP_SETNB, V3_OP_SETNBE, V3_OP_SETNL, V3_OP_SETNLE, V3_OP_SETNO, V3_OP_SETNP, V3_OP_SETNS, V3_OP_SETNZ, V3_OP_SETO, V3_OP_SETP, V3_OP_SETS, - V3_OP_SETZ, V3_OP_MOVS, V3_OP_STOS, V3_OP_MOVZX, V3_OP_MOVSX, V3_OP_INT } v3_op_type_t; + V3_OP_SETZ, V3_OP_MOVS, V3_OP_STOS, V3_OP_MOVZX, V3_OP_MOVSX } v3_op_type_t; typedef enum {INVALID_OPERAND, REG_OPERAND, MEM_OPERAND, IMM_OPERAND} v3_operand_type_t; diff --git a/palacios/include/palacios/vmm_execve_hook.h b/palacios/include/palacios/vmm_execve_hook.h deleted file mode 100644 index 4341a30..0000000 --- a/palacios/include/palacios/vmm_execve_hook.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - - -#ifndef __VMM_EXECVE_HOOK_H__ -#define __VMM_EXECVE_HOOK_H__ - -#ifdef __V3VEE__ - - -struct v3_exec_hooks { - struct list_head hook_list; - struct hashtable * bin_table; -}; - -struct exec_hook { - int (*handler)(struct guest_info * core, void * priv_data); - struct list_head hook_node; - void * priv_data; -}; - - -int v3_init_exec_hooks (struct guest_info * core); -int v3_deinit_exec_hooks (struct guest_info * core); - -int v3_hook_executable (struct guest_info * core, - const uchar_t * binfile, - int (*handler)(struct guest_info * core, void * priv_data), - void * priv_data); - - -#endif - - -#endif diff --git a/palacios/include/palacios/vmm_instr_decoder.h b/palacios/include/palacios/vmm_instr_decoder.h index d690af9..2e26457 100644 --- a/palacios/include/palacios/vmm_instr_decoder.h +++ b/palacios/include/palacios/vmm_instr_decoder.h @@ -28,7 +28,6 @@ typedef enum { SMSW, CLTS, INVLPG, - INT, // KCH: adding software interrupts MOV_CR2, MOV_2CR, @@ -311,7 +310,6 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr, return -1; } - case INT: // KCH case MOV_DR2: case MOV_2DR: case MOV_CR2: @@ -1332,10 +1330,7 @@ static op_form_t op_code_to_form(uint8_t * instr, int * length) { case 0xf4: return HLT; - - // KCH - case 0xcd: - return INT; + case 0xf6: { struct modrm_byte * modrm = (struct modrm_byte *)&(instr[1]); @@ -1498,7 +1493,6 @@ static char * op_form_to_str(op_form_t form) { case SETO: return "SETO"; case STOS_8: return "STOS_8"; case STOS: return "STOS"; - case INT: return "INT"; // KCH case INVALID_INSTR: default: diff --git a/palacios/include/palacios/vmm_intr.h b/palacios/include/palacios/vmm_intr.h index 62c8667..626b98b 100644 --- a/palacios/include/palacios/vmm_intr.h +++ b/palacios/include/palacios/vmm_intr.h @@ -41,13 +41,6 @@ struct v3_irq_hook { void * priv_data; }; -// KCH -struct v3_swintr_hook { - int (*handler)(struct guest_info * core, uint8_t vector, void * priv_data); - void * priv_data; -}; - - #define MAX_IRQ 256 @@ -65,11 +58,6 @@ struct v3_intr_core_state { uint_t irq_started; uint_t irq_vector; - // KCH: for injecting SW Interrupts - uint_t swintr_posted; - uint_t swintr_vector; - struct v3_swintr_hook * swintr_hooks[256]; - uint8_t virq_map[MAX_IRQ / 8]; v3_lock_t irq_lock; @@ -106,6 +94,7 @@ struct intr_router_ops { void v3_clear_pending_intr(struct guest_info * core); + void * v3_register_intr_controller(struct guest_info * info, struct intr_ctrl_ops * ops, void * priv_data); void * v3_register_intr_router(struct v3_vm_info * vm, struct intr_router_ops * ops, void * priv_data); @@ -124,6 +113,7 @@ int v3_injecting_intr(struct guest_info * info, uint_t intr_num, v3_intr_type_t */ + int v3_hook_irq(struct v3_vm_info * vm, uint_t irq, int (*handler)(struct v3_vm_info * vm, struct v3_interrupt * intr, void * priv_data), @@ -132,16 +122,6 @@ int v3_hook_irq(struct v3_vm_info * vm, int v3_hook_passthrough_irq(struct v3_vm_info * vm, uint_t irq); -int v3_hook_swintr(struct guest_info * core, - uint8_t vector, - int (*handler)(struct guest_info * core, uint8_t vector, void * priv_data), - void * priv_data); - -int v3_hook_passthrough_swintr(struct guest_info * core, uint8_t vector); - - -int v3_signal_swintr(struct guest_info * core, int vec); -int v3_handle_swintr(struct guest_info * core); #endif // !__V3VEE__ diff --git a/palacios/include/palacios/vmm_linux_syscall_map.h b/palacios/include/palacios/vmm_linux_syscall_map.h deleted file mode 100644 index 0a40146..0000000 --- a/palacios/include/palacios/vmm_linux_syscall_map.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#ifndef __VMM_LINUX_SYSCALL_MAP_H__ -#define __VMM_LINUX_SYSCALL_MAP_H__ - -#ifdef __V3VEE__ - -#include - -char * get_linux_syscall_name32 (uint_t syscall_nr); -char * get_linux_syscall_name64 (uint_t syscall_nr); - -#endif - -#endif diff --git a/palacios/include/palacios/vmm_mpi_accel.h b/palacios/include/palacios/vmm_mpi_accel.h deleted file mode 100644 index 5958e4b..0000000 --- a/palacios/include/palacios/vmm_mpi_accel.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#ifndef __VMM_MPI_ACCEL_H__ -#define __VMM_MPI_ACCEL_H__ - - -#ifdef __V3VEE__ - -int v3_init_mpi_accel (struct guest_info * core); -int v3_deinit_mpi_accel (struct guest_info * core); -int v3_mpi_preload_handler (struct guest_info * core, void * priv_data); - - -#endif - -#endif diff --git a/palacios/include/palacios/vmm_process_environment.h b/palacios/include/palacios/vmm_process_environment.h deleted file mode 100644 index f3cfb10..0000000 --- a/palacios/include/palacios/vmm_process_environment.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#ifndef __VMM_PROCESS_ENVIRONMENT_H__ -#define __VMM_PROCESS_ENVIRONMENT_H__ - -#ifdef __V3VEE__ - - -#include -#include -#include - - -int v3_replace_arg (struct guest_info * core, uint_t argnum, const char * newval); -int v3_replace_env (struct guest_info * core, const char * envname, const char * newval); - -int v3_inject_strings (struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt); - -addr_t v3_prepare_guest_stack (struct guest_info * core, uint_t bytes_needed); - -#endif - -#endif - diff --git a/palacios/include/palacios/vmm_syscall_hijack.h b/palacios/include/palacios/vmm_syscall_hijack.h deleted file mode 100644 index 14e00f8..0000000 --- a/palacios/include/palacios/vmm_syscall_hijack.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#ifndef __VMM_SYSCALL_HIJACK_H__ -#define __VMM_SYSCALL_HIJACK_H__ - - -#ifdef __V3VEE__ - - -struct v3_syscall_hook_map { - /* 512 is an arbitrary number, I'm not sure that - there is a hard limit on the number of syscalls - an OS can provide */ - struct v3_syscall_hook * syscall_hooks[512]; -}; - -struct v3_syscall_hook { - int (*handler)(struct guest_info * core, uint_t syscall_nr, void * priv_data); - void * priv_data; -}; - - -struct v3_execve_varchunk { - char ** argv; - char ** envp; - uint_t argc; - uint_t envc; - uint_t bytes; - int active; -}; - - -int v3_syscall_handler (struct guest_info * core, uint8_t vector, void * priv_data); - - -int v3_hook_syscall (struct guest_info * core, - uint_t syscall_nr, - int (*handler)(struct guest_info * core, uint_t syscall_nr, void * priv_data), - void * priv_data); - -int v3_hook_passthrough_syscall (struct guest_info * core, uint_t syscall_nr); - -int v3_sysopen_handler (struct guest_info * core, uint_t syscall_nr, void * priv_data); -int v3_sysmount_handler (struct guest_info * core, uint_t syscall_nr, void * priv_data); -int v3_sysexecve_handler (struct guest_info * core, uint_t syscall_nr, void * priv_data); - - -#endif - -#endif diff --git a/palacios/src/extensions/Kconfig b/palacios/src/extensions/Kconfig index 9e3a905..158ed42 100644 --- a/palacios/src/extensions/Kconfig +++ b/palacios/src/extensions/Kconfig @@ -44,48 +44,4 @@ config EXT_INSPECTOR help Provides the inspection extension -config SW_INTERRUPTS - bool "Enable interception and hooking of software interrupts" - default n - help - This feature will cause the VMM to intercept the execution - of software interrupts (i.e. the INTn instruction) and enable - any INT vector to be hooked - -config SWINTR_PASSTHROUGH - bool "Hook all unhandled sofware interrupts for passthrough" - depends on SW_INTERRUPTS - default n - help - If enabled, this will cause all software interrupts - (INT instruction vectors) to be hooked for passthrough. - May reduce performance but useful for debugging. - -config SYSCALL_HIJACK - bool "Enable System Call Hijacking" - depends on SW_INTERRUPTS - default n - help - Enable the VMM to hijack system calls executed by the guest. - If enabled, the VMM will hook execution of INT 80 - (support for Fast-System Calls coming soon) - -config SYSCALL_PASSTHROUGH - bool "Hook all unhandled system calls for passthrough" - depends on SYSCALL_HIJACK - default n - help - If enabled, this option will cause all system calls - that are not explicitly hooked to be hooked for - passthrough. This is useful for debugging. - -config HIJACK_SYSCALL_MSR - bool "Intercept Syscall-related MSR reads & writes" - depends on SYSCALL_HIJACK - default n - help - Allow the VMM to intercept reads and writes to MSRs - related to SYSCALL and SYSENTER instructions. Specifically, - it will intercept R/W to STAR, CSTAR, and LSTAR. - endmenu diff --git a/palacios/src/extensions/Makefile b/palacios/src/extensions/Makefile index 4c8d6a8..abf382a 100644 --- a/palacios/src/extensions/Makefile +++ b/palacios/src/extensions/Makefile @@ -3,12 +3,5 @@ obj-$(V3_CONFIG_EXT_MTRRS) += ext_mtrr.o obj-$(V3_CONFIG_EXT_VTSC) += ext_vtsc.o obj-$(V3_CONFIG_EXT_VTIME) += ext_vtime.o obj-$(V3_CONFIG_EXT_INSPECTOR) += ext_inspector.o - -obj-$(V3_CONFIG_SYSCALL_HIJACK) += vmm_syscall_hijack.o -obj-$(V3_CONFIG_SYSCALL_HIJACK) += vmm_linux_syscall_map.o -obj-$(V3_CONFIG_SYSCALL_HIJACK) += vmm_mpi_accel.o -obj-$(V3_CONFIG_SYSCALL_HIJACK) += vmm_process_environment.o -obj-$(V3_CONFIG_SYSCALL_HIJACK) += vmm_execve_hook.o - obj-$(V3_CONFIG_EXT_MACH_CHECK) += ext_mcheck.o diff --git a/palacios/src/extensions/vmm_execve_hook.c b/palacios/src/extensions/vmm_execve_hook.c deleted file mode 100644 index e78052e..0000000 --- a/palacios/src/extensions/vmm_execve_hook.c +++ /dev/null @@ -1,94 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - - -#include -#include -#include -#include -#include -#include - - - -static int free_hook (struct guest_info * core, struct exec_hook * hook) { - list_del(&(hook->hook_node)); - V3_Free(hook); - return 0; -} - -static uint_t exec_hash_fn (addr_t key) { - return v3_hash_long(key, sizeof(void *) * 8); -} - - -static int exec_eq_fn (addr_t key1, addr_t key2) { - return (key1 == key2); -} - - -int v3_init_exec_hooks (struct guest_info * core) { - struct v3_exec_hooks * hooks = &(core->exec_hooks); - - INIT_LIST_HEAD(&(hooks->hook_list)); - - hooks->bin_table = v3_create_htable(0, exec_hash_fn, exec_eq_fn); - return 0; -} - - -int v3_deinit_exec_hooks (struct guest_info * core) { - struct v3_exec_hooks * hooks = &(core->exec_hooks); - struct exec_hook * hook = NULL; - struct exec_hook * tmp = NULL; - - list_for_each_entry_safe(hook, tmp, &(hooks->hook_list), hook_node) { - free_hook(core, hook); - } - - v3_free_htable(hooks->bin_table, 0, 0); - - return 0; -} - - -int v3_hook_executable (struct guest_info * core, - const uchar_t * binfile, - int (*handler)(struct guest_info * core, void * priv_data), - void * priv_data) -{ - struct exec_hook * hook = V3_Malloc(sizeof(struct exec_hook)); - struct v3_exec_hooks * hooks = &(core->exec_hooks); - addr_t key; - - memset(hook, 0, sizeof(struct exec_hook)); - - hook->handler = handler; - hook->priv_data = priv_data; - - // we hash the name of the file to produce a key - key = v3_hash_buffer((uchar_t*)binfile, strlen(binfile)); - - v3_htable_insert(hooks->bin_table, key, (addr_t)hook); - list_add(&(hook->hook_node), &(hooks->hook_list)); - - return 0; -} - - diff --git a/palacios/src/extensions/vmm_linux_syscall_map.c b/palacios/src/extensions/vmm_linux_syscall_map.c deleted file mode 100644 index 578450d..0000000 --- a/palacios/src/extensions/vmm_linux_syscall_map.c +++ /dev/null @@ -1,672 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - - -#include - - -char * get_linux_syscall_name32 (uint_t syscall_nr) { - - switch (syscall_nr) { - - case 0: return "restart_syscall"; break; - case 1: return "exit"; break; - case 2: return "fork"; break; - case 3: return "read"; break; - case 4: return "write"; break; - case 5: return "open"; break; - case 6: return "close"; break; - case 7: return "waitpid"; break; - case 8: return "creat"; break; - case 9: return "link"; break; - case 10: return "unlink"; break; - case 11: return "execve"; break; - case 12: return "chdir"; break; - case 13: return "time"; break; - case 14: return "mknod"; break; - case 15: return "chmod"; break; - case 16: return "lchown"; break; - case 17: return "break"; break; - case 18: return "oldstat"; break; - case 19: return "lseek"; break; - case 20: return "getpid"; break; - case 21: return "mount"; break; - case 22: return "umount"; break; - case 23: return "setuid"; break; - case 24: return "getuid"; break; - case 25: return "stime"; break; - case 26: return "ptrace"; break; - case 27: return "alarm"; break; - case 28: return "oldfstat"; break; - case 29: return "pause"; break; - case 30: return "utime"; break; - case 31: return "stty"; break; - case 32: return "gtty"; break; - case 33: return "access"; break; - case 34: return "nice"; break; - case 35: return "ftime"; break; - case 36: return "sync"; break; - case 37: return "kill"; break; - case 38: return "rename"; break; - case 39: return "mkdir"; break; - case 40: return "rmdir"; break; - case 41: return "dup"; break; - case 42: return "pipe"; break; - case 43: return "times"; break; - case 44: return "prof"; break; - case 45: return "brk"; break; - case 46: return "setgid"; break; - case 47: return "getgid"; break; - case 48: return "signal"; break; - case 49: return "geteuid"; break; - case 50: return "getegid"; break; - case 51: return "acct"; break; - case 52: return "umount2"; break; - case 53: return "lock"; break; - case 54: return "ioctl"; break; - case 55: return "fcntl"; break; - case 56: return "mpx"; break; - case 57: return "setpgid"; break; - case 58: return "ulimit"; break; - case 59: return "oldolduname"; break; - case 60: return "umask"; break; - case 61: return "chroot"; break; - case 62: return "ustat"; break; - case 63: return "dup2"; break; - case 64: return "getppid"; break; - case 65: return "getpgrp"; break; - case 66: return "setsid"; break; - case 67: return "sigaction"; break; - case 68: return "sgetmask"; break; - case 69: return "ssetmask"; break; - case 70: return "setreuid"; break; - case 71: return "setregid"; break; - case 72: return "sigsuspend"; break; - case 73: return "sigpending"; break; - case 74: return "sethostname"; break; - case 75: return "setrlimit"; break; - case 76: return "getrlimit"; break; - case 77: return "getrusage"; break; - case 78: return "gettimeofday"; break; - case 79: return "settimeofday"; break; - case 80: return "getgroups"; break; - case 81: return "setgroups"; break; - case 82: return "select"; break; - case 83: return "symlink"; break; - case 84: return "oldlstat"; break; - case 85: return "readlink"; break; - case 86: return "uselib"; break; - case 87: return "swapon"; break; - case 88: return "reboot"; break; - case 89: return "readdir"; break; - case 90: return "mmap"; break; - case 91: return "munmap"; break; - case 92: return "truncate"; break; - case 93: return "ftruncate"; break; - case 94: return "fchmod"; break; - case 95: return "fchown"; break; - case 96: return "getpriority"; break; - case 97: return "setpriority"; break; - case 98: return "profil"; break; - case 99: return "statfs"; break; - case 100: return "fstatfs"; break; - case 101: return "ioperm"; break; - case 102: return "socketcall"; break; - case 103: return "syslog"; break; - case 104: return "setitimer"; break; - case 105: return "getitimer"; break; - case 106: return "stat"; break; - case 107: return "lstat"; break; - case 108: return "fstat"; break; - case 109: return "olduname"; break; - case 110: return "iopl"; break; - case 111: return "vhangup"; break; - case 112: return "idle"; break; - case 113: return "vm86old"; break; - case 114: return "wait4"; break; - case 115: return "swapoff"; break; - case 116: return "sysinfo"; break; - case 117: return "ipc"; break; - case 118: return "fsync"; break; - case 119: return "sigreturn"; break; - case 120: return "clone"; break; - case 121: return "setdomainname"; break; - case 122: return "uname"; break; - case 123: return "modify_ldt"; break; - case 124: return "adjtimex"; break; - case 125: return "mprotect"; break; - case 126: return "sigprocmask"; break; - case 127: return "create_module"; break; - case 128: return "init_module"; break; - case 129: return "delete_module"; break; - case 130: return "get_kernel_syms"; break; - case 131: return "quotactl"; break; - case 132: return "getpgid"; break; - case 133: return "fchdir"; break; - case 134: return "bdflush"; break; - case 135: return "sysfs"; break; - case 136: return "personality"; break; - case 137: return "afs_syscall"; break; - case 138: return "setfsuid"; break; - case 139: return "setfsgid"; break; - case 140: return "_llseek"; break; - case 141: return "getdents"; break; - case 142: return "_newselect"; break; - case 143: return "flock"; break; - case 144: return "msync"; break; - case 145: return "readv"; break; - case 146: return "writev"; break; - case 147: return "getsid"; break; - case 148: return "fdatasync"; break; - case 149: return "_sysctl"; break; - case 150: return "mlock"; break; - case 151: return "munlock"; break; - case 152: return "mlockall"; break; - case 153: return "munlockall"; break; - case 154: return "sched_setparam"; break; - case 155: return "sched_getparam"; break; - case 156: return "sched_setscheduler"; break; - case 157: return "sched_getscheduler"; break; - case 158: return "sched_yield"; break; - case 159: return "sched_get_priority_max"; break; - case 160: return "sched_get_priority_min"; break; - case 161: return "sched_rr_get_interval"; break; - case 162: return "nanosleep"; break; - case 163: return "mremap"; break; - case 164: return "setresuid"; break; - case 165: return "getresuid"; break; - case 166: return "vm86"; break; - case 167: return "query_module"; break; - case 168: return "poll"; break; - case 169: return "nfsservctl"; break; - case 170: return "setresgid"; break; - case 171: return "getresgid"; break; - case 172: return "prctl"; break; - case 173: return "rt_sigreturn"; break; - case 174: return "rt_sigaction"; break; - case 175: return "rt_sigprocmask"; break; - case 176: return "rt_sigpending"; break; - case 177: return "rt_sigtimedwait"; break; - case 178: return "rt_sigqueueinfo"; break; - case 179: return "rt_sigsuspend"; break; - case 180: return "pread64"; break; - case 181: return "pwrite64"; break; - case 182: return "chown"; break; - case 183: return "getcwd"; break; - case 184: return "capget"; break; - case 185: return "capset"; break; - case 186: return "sigaltstack"; break; - case 187: return "sendfile"; break; - case 188: return "getpmsg"; break; - case 189: return "putpmsg"; break; - case 190: return "vfork"; break; - case 191: return "ugetrlimit"; break; - case 192: return "mmap2"; break; - case 193: return "truncate64"; break; - case 194: return "ftruncate64"; break; - case 195: return "stat64"; break; - case 196: return "lstat64"; break; - case 197: return "fstat64"; break; - case 198: return "lchown32"; break; - case 199: return "getuid32"; break; - case 200: return "getgid32"; break; - case 201: return "geteuid32"; break; - case 202: return "getegid32"; break; - case 203: return "setreuid32"; break; - case 204: return "setregid32"; break; - case 205: return "getgroups32"; break; - case 206: return "setgroups32"; break; - case 207: return "fchown32"; break; - case 208: return "setresuid32"; break; - case 209: return "getresuid32"; break; - case 210: return "setresgid32"; break; - case 211: return "getresgid32"; break; - case 212: return "chown32"; break; - case 213: return "setuid32"; break; - case 214: return "setgid32"; break; - case 215: return "setfsuid32"; break; - case 216: return "setfsgid32"; break; - case 217: return "pivot_root"; break; - case 218: return "mincore"; break; - case 219: return "madvise1"; break; - case 220: return "getdents64"; break; - case 221: return "fcntl64"; break; - case 224: return "gettid"; break; - case 225: return "readahead"; break; - case 226: return "setxattr"; break; - case 227: return "lsetxattr"; break; - case 228: return "fsetxattr"; break; - case 229: return "getxattr"; break; - case 230: return "lgetxattr"; break; - case 231: return "fgetxattr"; break; - case 232: return "listxattr"; break; - case 233: return "llistxattr"; break; - case 234: return "flistxattr"; break; - case 235: return "removexattr"; break; - case 236: return "lremovexattr"; break; - case 237: return "fremovexattr"; break; - case 238: return "tkill"; break; - case 239: return "sendfile64"; break; - case 240: return "futex"; break; - case 241: return "sched_setaffinity"; break; - case 242: return "sched_getaffinity"; break; - case 243: return "set_thread_area"; break; - case 244: return "get_thread_area"; break; - case 245: return "io_setup"; break; - case 246: return "io_destroy"; break; - case 247: return "io_getevents"; break; - case 248: return "io_submit"; break; - case 249: return "io_cancel"; break; - case 250: return "fadvise64"; break; - case 252: return "exit_group"; break; - case 253: return "lookup_dcookie"; break; - case 254: return "epoll_create"; break; - case 255: return "epoll_ctl"; break; - case 256: return "epoll_wait"; break; - case 257: return "remap_file_pages"; break; - case 258: return "set_tid_address"; break; - case 259: return "timer_create"; break; - case 260: return "timer_settime"; break; - case 261: return "timer_gettime"; break; - case 262: return "timer_getoverrun"; break; - case 263: return "timer_delete"; break; - case 264: return "clock_settime"; break; - case 265: return "clock_gettime"; break; - case 266: return "clock_getres"; break; - case 267: return "clock_nanosleep"; break; - case 268: return "statfs64"; break; - case 269: return "fstatfs64"; break; - case 270: return "tgkill"; break; - case 271: return "utimes"; break; - case 272: return "fadvise64_64"; break; - case 273: return "vserver"; break; - case 274: return "mbind"; break; - case 275: return "get_mempolicy"; break; - case 276: return "set_mempolicy"; break; - case 277: return "mq_open"; break; - case 278: return "mq_unlink"; break; - case 279: return "mq_timedsend"; break; - case 280: return "mq_timedreceive"; break; - case 281: return "mq_notify"; break; - case 282: return "mq_getsetattr"; break; - case 283: return "kexec_load"; break; - case 284: return "waitid"; break; - case 285: return "sys_setaltroot"; break; - case 286: return "add_key"; break; - case 287: return "request_key"; break; - case 288: return "keyctl"; break; - case 289: return "ioprio_set"; break; - case 290: return "ioprio_get"; break; - case 291: return "inotify_init"; break; - case 292: return "inotify_add_watch"; break; - case 293: return "inotify_rm_watch"; break; - case 294: return "migrate_pages"; break; - case 295: return "openat"; break; - case 296: return "mkdirat"; break; - case 297: return "mknodat"; break; - case 298: return "fchownat"; break; - case 299: return "futimesat"; break; - case 300: return "fstatat64"; break; - case 301: return "unlinkat"; break; - case 302: return "renameat"; break; - case 303: return "linkat"; break; - case 304: return "symlinkat"; break; - case 305: return "readlinkat"; break; - case 306: return "fchmodat"; break; - case 307: return "faccessat"; break; - case 308: return "pselect6"; break; - case 309: return "ppoll"; break; - case 310: return "unshare"; break; - case 311: return "set_robust_list"; break; - case 312: return "get_robust_list"; break; - case 313: return "splice"; break; - case 314: return "sync_file_range"; break; - case 315: return "tee"; break; - case 316: return "vmsplice"; break; - case 317: return "move_pages"; break; - case 318: return "getcpu"; break; - case 319: return "epoll_pwait"; break; - case 320: return "utimensat"; break; - case 321: return "signalfd"; break; - case 322: return "timerfd_create"; break; - case 323: return "eventfd"; break; - case 324: return "fallocate"; break; - case 325: return "timerfd_settime"; break; - case 326: return "timerfd_gettime"; break; - case 327: return "signalfd4"; break; - case 328: return "eventfd2"; break; - case 329: return "epoll_create1"; break; - case 330: return "dup3"; break; - case 331: return "pipe2"; break; - case 332: return "inotify_init1"; break; - case 333: return "preadv"; break; - case 334: return "pwritev"; break; - case 335: return "rt_tgsigqueueinfo"; break; - case 336: return "perf_event_open"; break; - default: return "UNKNOWN"; break; - } -} - - -char * get_linux_syscall_name64 (uint_t syscall_nr) { - - switch (syscall_nr) { - - case 0: return "read"; break; - case 1: return "write"; break; - case 2: return "open"; break; - case 3: return "close"; break; - case 4: return "stat"; break; - case 5: return "fstat"; break; - case 6: return "lstat"; break; - case 7: return "poll"; break; - case 8: return "lseek"; break; - case 9: return "mmap"; break; - case 10: return "mprotect"; break; - case 11: return "munmap"; break; - case 12: return "brk"; break; - case 13: return "rt_sigaction"; break; - case 14: return "rt_sigprocmask"; break; - case 15: return "rt_sigreturn"; break; - case 16: return "ioctl"; break; - case 17: return "pread64"; break; - case 18: return "pwrite64"; break; - case 19: return "readv"; break; - case 20: return "writev"; break; - case 21: return "access"; break; - case 22: return "pipe"; break; - case 23: return "select"; break; - case 24: return "sched_yield"; break; - case 25: return "mremap"; break; - case 26: return "msync"; break; - case 27: return "mincore"; break; - case 28: return "madvise"; break; - case 29: return "shmget"; break; - case 30: return "shmat"; break; - case 31: return "shmctl"; break; - case 32: return "dup"; break; - case 33: return "dup2"; break; - case 34: return "pause"; break; - case 35: return "nanosleep"; break; - case 36: return "getitimer"; break; - case 37: return "alarm"; break; - case 38: return "setitimer"; break; - case 39: return "getpid"; break; - case 40: return "sendfile"; break; - case 41: return "socket"; break; - case 42: return "connect"; break; - case 43: return "accept"; break; - case 44: return "sendto"; break; - case 45: return "recvfrom"; break; - case 46: return "sendmsg"; break; - case 47: return "recvmsg"; break; - case 48: return "shutdown"; break; - case 49: return "bind"; break; - case 50: return "listen"; break; - case 51: return "getsockname"; break; - case 52: return "getpeername"; break; - case 53: return "socketpair"; break; - case 54: return "setsockopt"; break; - case 55: return "getsockopt"; break; - case 56: return "clone"; break; - case 57: return "fork"; break; - case 58: return "vfork"; break; - case 59: return "execve"; break; - case 60: return "exit"; break; - case 61: return "wait4"; break; - case 62: return "kill"; break; - case 63: return "uname"; break; - case 64: return "semget"; break; - case 65: return "semop"; break; - case 66: return "semctl"; break; - case 67: return "shmdt"; break; - case 68: return "msgget"; break; - case 69: return "msgsnd"; break; - case 70: return "msgrcv"; break; - case 71: return "msgctl"; break; - case 72: return "fcntl"; break; - case 73: return "flock"; break; - case 74: return "fsync"; break; - case 75: return "fdatasync"; break; - case 76: return "truncate"; break; - case 77: return "ftruncate"; break; - case 78: return "getdents"; break; - case 79: return "getcwd"; break; - case 80: return "chdir"; break; - case 81: return "fchdir"; break; - case 82: return "rename"; break; - case 83: return "mkdir"; break; - case 84: return "rmdir"; break; - case 85: return "creat"; break; - case 86: return "link"; break; - case 87: return "unlink"; break; - case 88: return "symlink"; break; - case 89: return "readlink"; break; - case 90: return "chmod"; break; - case 91: return "fchmod"; break; - case 92: return "chown"; break; - case 93: return "fchown"; break; - case 94: return "lchown"; break; - case 95: return "umask"; break; - case 96: return "gettimeofday"; break; - case 97: return "getrlimit"; break; - case 98: return "getrusage"; break; - case 99: return "sysinfo"; break; - case 100: return "times"; break; - case 101: return "ptrace"; break; - case 102: return "getuid"; break; - case 103: return "syslog"; break; - case 104: return "getgid"; break; - case 105: return "setuid"; break; - case 106: return "setgid"; break; - case 107: return "geteuid"; break; - case 108: return "getegid"; break; - case 109: return "setpgid"; break; - case 110: return "getppid"; break; - case 111: return "getpgrp"; break; - case 112: return "setsid"; break; - case 113: return "setreuid"; break; - case 114: return "setregid"; break; - case 115: return "getgroups"; break; - case 116: return "setgroups"; break; - case 117: return "setresuid"; break; - case 118: return "getresuid"; break; - case 119: return "setresgid"; break; - case 120: return "getresgid"; break; - case 121: return "getpgid"; break; - case 122: return "setfsuid"; break; - case 123: return "setfsgid"; break; - case 124: return "getsid"; break; - case 125: return "capget"; break; - case 126: return "capset"; break; - case 127: return "rt_sigpending"; break; - case 128: return "rt_sigtimedwait"; break; - case 129: return "rt_sigqueueinfo"; break; - case 130: return "rt_sigsuspend"; break; - case 131: return "sigaltstack"; break; - case 132: return "utime"; break; - case 133: return "mknod"; break; - case 134: return "uselib"; break; - case 135: return "personality"; break; - case 136: return "ustat"; break; - case 137: return "statfs"; break; - case 138: return "fstatfs"; break; - case 139: return "sysfs"; break; - case 140: return "getpriority"; break; - case 141: return "setpriority"; break; - case 142: return "sched_setparam"; break; - case 143: return "sched_getparam"; break; - case 144: return "sched_setscheduler"; break; - case 145: return "sched_getscheduler"; break; - case 146: return "sched_get_priority_max"; break; - case 147: return "sched_get_priority_min"; break; - case 148: return "sched_rr_get_interval"; break; - case 149: return "mlock"; break; - case 150: return "munlock"; break; - case 151: return "mlockall"; break; - case 152: return "munlockall"; break; - case 153: return "vhangup"; break; - case 154: return "modify_ldt"; break; - case 155: return "pivot_root"; break; - case 156: return "_sysctl"; break; - case 157: return "prctl"; break; - case 158: return "arch_prctl"; break; - case 159: return "adjtimex"; break; - case 160: return "setrlimit"; break; - case 161: return "chroot"; break; - case 162: return "sync"; break; - case 163: return "acct"; break; - case 164: return "settimeofday"; break; - case 165: return "mount"; break; - case 166: return "umount2"; break; - case 167: return "swapon"; break; - case 168: return "swapoff"; break; - case 169: return "reboot"; break; - case 170: return "sethostname"; break; - case 171: return "setdomainname"; break; - case 172: return "iopl"; break; - case 173: return "ioperm"; break; - case 174: return "create_module"; break; - case 175: return "init_module"; break; - case 176: return "delete_module"; break; - case 177: return "get_kernel_syms"; break; - case 178: return "query_module"; break; - case 179: return "quotactl"; break; - case 180: return "nfsservctl"; break; - case 181: return "getpmsg"; break; - case 182: return "putpmsg"; break; - case 183: return "afs_syscall"; break; - case 184: return "tuxcall"; break; - case 185: return "security"; break; - case 186: return "gettid"; break; - case 187: return "readahead"; break; - case 188: return "setxattr"; break; - case 189: return "lsetxattr"; break; - case 190: return "fsetxattr"; break; - case 191: return "getxattr"; break; - case 192: return "lgetxattr"; break; - case 193: return "fgetxattr"; break; - case 194: return "listxattr"; break; - case 195: return "llistxattr"; break; - case 196: return "flistxattr"; break; - case 197: return "removexattr"; break; - case 198: return "lremovexattr"; break; - case 199: return "fremovexattr"; break; - case 200: return "tkill"; break; - case 201: return "time"; break; - case 202: return "futex"; break; - case 203: return "sched_setaffinity"; break; - case 204: return "sched_getaffinity"; break; - case 205: return "set_thread_area"; break; - case 206: return "io_setup"; break; - case 207: return "io_destroy"; break; - case 208: return "io_getevents"; break; - case 209: return "io_submit"; break; - case 210: return "io_cancel"; break; - case 211: return "get_thread_area"; break; - case 212: return "lookup_dcookie"; break; - case 213: return "epoll_create"; break; - case 214: return "epoll_ctl_old"; break; - case 215: return "epoll_wait_old"; break; - case 216: return "remap_file_pages"; break; - case 217: return "getdents64"; break; - case 218: return "set_tid_address"; break; - case 219: return "restart_syscall"; break; - case 220: return "semtimedop"; break; - case 221: return "fadvise64"; break; - case 222: return "timer_create"; break; - case 223: return "timer_settime"; break; - case 224: return "timer_gettime"; break; - case 225: return "timer_getoverrun"; break; - case 226: return "timer_delete"; break; - case 227: return "clock_settime"; break; - case 228: return "clock_gettime"; break; - case 229: return "clock_getres"; break; - case 230: return "clock_nanosleep"; break; - case 231: return "exit_group"; break; - case 232: return "epoll_wait"; break; - case 233: return "epoll_ctl"; break; - case 234: return "tgkill"; break; - case 235: return "utimes"; break; - case 236: return "vserver"; break; - case 237: return "mbind"; break; - case 238: return "set_mempolicy"; break; - case 239: return "get_mempolicy"; break; - case 240: return "mq_open"; break; - case 241: return "mq_unlink"; break; - case 242: return "mq_timedsend"; break; - case 243: return "mq_timedreceive"; break; - case 244: return "mq_notify"; break; - case 245: return "mq_getsetattr"; break; - case 246: return "kexec_load"; break; - case 247: return "waitid"; break; - case 248: return "add_key"; break; - case 249: return "request_key"; break; - case 250: return "keyctl"; break; - case 251: return "ioprio_set"; break; - case 252: return "ioprio_get"; break; - case 253: return "inotify_init"; break; - case 254: return "inotify_add_watch"; break; - case 255: return "inotify_rm_watch"; break; - case 256: return "migrate_pages"; break; - case 257: return "openat"; break; - case 258: return "mkdirat"; break; - case 259: return "mknodat"; break; - case 260: return "fchownat"; break; - case 261: return "futimesat"; break; - case 262: return "newfstatat"; break; - case 263: return "unlinkat"; break; - case 264: return "renameat"; break; - case 265: return "linkat"; break; - case 266: return "symlinkat"; break; - case 267: return "readlinkat"; break; - case 268: return "fchmodat"; break; - case 269: return "faccessat"; break; - case 270: return "pselect6"; break; - case 271: return "ppoll"; break; - case 272: return "unshare"; break; - case 273: return "set_robust_list"; break; - case 274: return "get_robust_list"; break; - case 275: return "splice"; break; - case 276: return "tee"; break; - case 277: return "sync_file_range"; break; - case 278: return "vmsplice"; break; - case 279: return "move_pages"; break; - case 280: return "utimensat"; break; - case 281: return "epoll_pwait"; break; - case 282: return "signalfd"; break; - case 283: return "timerfd_create"; break; - case 284: return "eventfd"; break; - case 285: return "fallocate"; break; - case 286: return "timerfd_settime"; break; - case 287: return "timerfd_gettime"; break; - case 288: return "accept4"; break; - case 289: return "signalfd4"; break; - case 290: return "eventfd2"; break; - case 291: return "epoll_create1"; break; - case 292: return "dup3"; break; - case 293: return "pipe2"; break; - case 294: return "inotify_init1"; break; - case 295: return "preadv"; break; - case 296: return "pwritev"; break; - case 297: return "rt_tgsigqueueinfo"; break; - case 298: return "perf_event_open"; break; - default: return "UNKNOWN"; break; - } -} diff --git a/palacios/src/extensions/vmm_mpi_accel.c b/palacios/src/extensions/vmm_mpi_accel.c deleted file mode 100644 index 24326ef..0000000 --- a/palacios/src/extensions/vmm_mpi_accel.c +++ /dev/null @@ -1,64 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - - -#include -#include -#include -#include -#include -#include -#include - - -int v3_init_mpi_accel (struct guest_info * core) { - //binfile = "./envtest"; - //args[1] = "LD_PRELOAD=./libcwrap.so"; - - v3_hook_swintr(core, 0x80, v3_syscall_handler, NULL); - v3_hook_syscall(core, 11, v3_sysexecve_handler, NULL); - v3_hook_executable(core, "./envtest", v3_mpi_preload_handler, NULL); - - return 0; -} - - -int v3_deinit_mpi_accel (struct guest_info * core) { - - return 0; -} - - -int v3_mpi_preload_handler (struct guest_info * core, void * priv_data) { - - char * a[3]; - a[0] = "TEST=HITHERE"; - a[1] = "TEST2=/blah/blah/blah"; - a[2] = "LD_PRELOAD=./libcwrap.so"; - - int ret = v3_inject_strings(core, (const char**)NULL, (const char**)a, 0, 3); - if (ret == -1) { - PrintDebug("Error injecting strings in execve handler\n"); - return -1; - } - - return 0; -} - - diff --git a/palacios/src/extensions/vmm_process_environment.c b/palacios/src/extensions/vmm_process_environment.c deleted file mode 100644 index 15f04a0..0000000 --- a/palacios/src/extensions/vmm_process_environment.c +++ /dev/null @@ -1,589 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#include -#include -#include -#include -#include - -static int v3_copy_chunk_guest32(struct guest_info * core, addr_t gva, uint_t argcnt, uint_t envcnt) { - - int ret = 0, i = 0; - addr_t hva; - uint32_t tmp_args[core->var_dump.argc]; - uint32_t tmp_envs[core->var_dump.envc]; - - PrintDebug("Initiating copy into guest (32bit)\n"); - - ret = v3_gva_to_hva(core, get_addr_linear(core, gva, &(core->segments.ds)), &hva); - if (ret == -1) { - PrintDebug("Error translating gva in v3_copy_chunk_2guest\n"); - return -1; - } - - // copy the env strings (we're moving top-down through the stack) - char * host_cursor = (char*) hva; - uint32_t guest_cursor = (uint32_t) gva; - host_cursor -= strlen(core->var_dump.envp[i]) + 1; - guest_cursor -= strlen(core->var_dump.envp[i]) + 1; - while (i < core->var_dump.envc) { - //PrintDebug("Copying envvar#%d: %s\n", i, core->var_dump.envp[i]); - strcpy(host_cursor, core->var_dump.envp[i]); - tmp_envs[i] = guest_cursor; - i++; - if (i != core->var_dump.envc) { - host_cursor -= strlen(core->var_dump.envp[i]) + 1; - guest_cursor -= strlen(core->var_dump.envp[i]) + 1; - } - } - - // then the arg strings - i = 0; - host_cursor -= strlen(core->var_dump.argv[i]) + 1; - guest_cursor -= strlen(core->var_dump.argv[i]) + 1; - while (i < core->var_dump.argc) { - //PrintDebug("Copying arg #%d: %s\n", i, core->var_dump.argv[i]); - strcpy(host_cursor, core->var_dump.argv[i]); - tmp_args[i] = guest_cursor; - i++; - if (i != core->var_dump.argc) { - host_cursor -= strlen(core->var_dump.argv[i]) + 1; - guest_cursor -= strlen(core->var_dump.argv[i]) + 1; - } - } - - - // padding - host_cursor--; - guest_cursor--; - while ((long)host_cursor % 4) { - *host_cursor = 0; - host_cursor--; - guest_cursor--; - } - - // null ptr - host_cursor -= 4; - guest_cursor -= 4; - *((uint32_t*)host_cursor) = 0; - - host_cursor -= 4; - guest_cursor -= 4; - for (i = 0; i < core->var_dump.envc; i++) { - *((uint32_t*)host_cursor) = tmp_envs[i]; - host_cursor -= 4; - guest_cursor -= 4; - } - - core->vm_regs.rdx = guest_cursor + 4; - - *((uint32_t*)host_cursor) = 0; - host_cursor -= 4; - guest_cursor -= 4; - for (i = 0; i < core->var_dump.argc; i++) { - *((uint32_t*)host_cursor) = tmp_args[i]; - host_cursor -= 4; - guest_cursor -= 4; - } - - core->vm_regs.rcx = guest_cursor + 4; - - // free up our temporary storage in the VMM - for (i = 0; i < core->var_dump.argc; i++) { - V3_Free(core->var_dump.argv[i]); - } - for (i = 0; i < core->var_dump.envc; i++) { - V3_Free(core->var_dump.envp[i]); - } - - V3_Free(core->var_dump.envp); - V3_Free(core->var_dump.argv); - return 0; -} - - -static int v3_copy_chunk_vmm32(struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt) { - - addr_t envp, argv; - uint_t argc = 0, envc = 0, bytes = 0; - char * cursor; - - PrintDebug("Initiating copy into vmm\n"); - - int ret = v3_gva_to_hva(core, get_addr_linear(core, core->vm_regs.rdx, &(core->segments.ds)), &envp); - if (ret == -1) { - PrintDebug("Error translating address in rdx\n"); - return 0; - } - - ret = v3_gva_to_hva(core, get_addr_linear(core, core->vm_regs.rcx, &(core->segments.ds)), &argv); - if (ret == -1) { - PrintDebug("Error translating address in rcx\n"); - return 0; - } - - cursor = (char*)argv; - while (*((uint32_t*)cursor) != 0) { - addr_t argvn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint32_t*)cursor), &(core->segments.ds)), &argvn); - if (ret == -1) { - PrintDebug("Error translating address for argvn\n"); - } - argc++; - cursor += 4; - } - - /* account for new args */ - argc += argcnt; - core->var_dump.argv = (char**)V3_Malloc(sizeof(char*)*argc); - core->var_dump.argc = argc; - bytes += sizeof(uint32_t)*argc; - - cursor = (char*)argv; - int i = 0; - while (*((uint32_t*)cursor) != 0) { - addr_t argvn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint32_t*)cursor), &(core->segments.ds)), &argvn); - if (ret == -1) { - PrintDebug("Error translating argvn address\n"); - } - - /* malloc room for the string */ - char * tmpstr = (char*)V3_Malloc(strlen((char*)argvn) + 1); - - /* copy the pointer */ - core->var_dump.argv[i] = tmpstr; - - /* copy the string */ - strncpy(tmpstr, (char*)argvn, strlen((char*)argvn) + 1); - i++; - cursor += 4; - bytes += strlen((char*)argvn) + 1; - } - - /* stick in new arg strings */ - int j = 0; - while (j < argcnt) { - char * tmpstr = (char*)V3_Malloc(strlen(argstrs[j]) + 1); - strncpy(tmpstr, argstrs[i], strlen(argstrs[j]) + 1); - core->var_dump.argv[i] = tmpstr; - bytes += strlen(argstrs[j]) + 1; - i++; j++; - } - - - cursor = (char*)envp; - while (*((uint32_t*)cursor) != 0) { - addr_t envpn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint32_t*)cursor), &(core->segments.ds)), &envpn); - if (ret == -1) { - PrintDebug("Error translating address for envpn\n"); - } - envc++; - cursor += 4; - } - - envc += envcnt; - core->var_dump.envp = (char**)V3_Malloc(sizeof(char*)*envc); - core->var_dump.envc = envc; - bytes += sizeof(uint32_t)*envc; - - cursor = (char*)envp; - i = 0; - while (*((uint32_t*)cursor) != 0) { - addr_t envpn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint32_t*)cursor), &(core->segments.ds)), &envpn); - if (ret == -1) { - PrintDebug("Error translating address for envpn\n"); - } - - /* malloc room for the string */ - char * tmpstr = (char*)V3_Malloc(strlen((char*)envpn) + 1); - - /* copy the pointer */ - core->var_dump.envp[i] = tmpstr; - - /* deepcopy the string */ - strncpy(tmpstr, (char*)envpn, strlen((char*)envpn) + 1); - i++; - cursor += 4; - bytes += strlen((char*)envpn) + 1; - } - - /* put in our new env strings */ - j = 0; - while (j < envcnt) { - char * tmpstr = (char*)V3_Malloc(strlen(envstrs[j]) + 1); - strncpy(tmpstr, envstrs[j], strlen(envstrs[j]) + 1); - core->var_dump.envp[i] = tmpstr; - bytes += strlen(envstrs[j]) + 1; - i++; j++; - } - - - /* account for padding for strings - and 2 null pointers */ - bytes += (bytes % 4) + 8; - core->var_dump.bytes = bytes; - return bytes; -} - - -static int v3_inject_strings32 (struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt) { - - addr_t inject_gva; - uint_t bytes_needed = 0; - - /* copy out all of the arguments and the environment to the VMM */ - if ((bytes_needed = v3_copy_chunk_vmm32(core, argstrs, envstrs, argcnt, envcnt)) == -1) { - PrintDebug("Error copying out environment and arguments\n"); - return -1; - } - - PrintDebug("environment successfully copied into VMM\n"); - - inject_gva = v3_prepare_guest_stack(core, bytes_needed); - if (!inject_gva) { - PrintDebug("Not enough space on user stack\n"); - return -1; - } - - v3_copy_chunk_guest32(core, inject_gva, argcnt, envcnt); - - return 0; -} - - -static int v3_copy_chunk_guest64(struct guest_info * core, addr_t gva, uint_t argcnt, uint_t envcnt) { - - int ret = 0, i = 0; - addr_t hva; - uint64_t tmp_args[core->var_dump.argc]; - uint64_t tmp_envs[core->var_dump.envc]; - - PrintDebug("Initiating copy into guest (64bit)\n"); - - ret = v3_gva_to_hva(core, get_addr_linear(core, gva, &(core->segments.ds)), &hva); - if (ret == -1) { - PrintDebug("Error translating gva in v3_copy_chunk_2guest64\n"); - return -1; - } - - char * host_cursor = (char*) hva; - uint64_t guest_cursor = (uint64_t) gva; - host_cursor -= strlen(core->var_dump.envp[i]) + 1; - guest_cursor -= strlen(core->var_dump.envp[i]) + 1; - while (i < core->var_dump.envc) { - //PrintDebug("Copying envvar#%d: %s\n", i, core->var_dump.envp[i]); - strcpy(host_cursor, core->var_dump.envp[i]); - tmp_envs[i] = guest_cursor; - i++; - if (i != core->var_dump.envc) { - host_cursor -= strlen(core->var_dump.envp[i]) + 1; - guest_cursor -= strlen(core->var_dump.envp[i]) + 1; - } - } - - i = 0; - host_cursor -= strlen(core->var_dump.argv[i]) + 1; - guest_cursor -= strlen(core->var_dump.argv[i]) + 1; - while (i < core->var_dump.argc) { - //PrintDebug("Copying arg #%d: %s\n", i, core->var_dump.argv[i]); - strcpy(host_cursor, core->var_dump.argv[i]); - tmp_args[i] = guest_cursor; - i++; - if (i != core->var_dump.argc) { - host_cursor -= strlen(core->var_dump.argv[i]) + 1; - guest_cursor -= strlen(core->var_dump.argv[i]) + 1; - } - } - - // padding - host_cursor--; - guest_cursor--; - while ((long)host_cursor % 8) { - *host_cursor = 0; - host_cursor--; - guest_cursor--; - } - - // one null ptr - host_cursor -= 8; - guest_cursor -= 8; - *((uint64_t*)host_cursor) = 0; - - host_cursor -= 8; - guest_cursor -= 8; - for (i = 0; i < core->var_dump.envc; i++) { - *((uint64_t*)host_cursor) = tmp_envs[i]; - host_cursor -= 8; - guest_cursor -= 8; - } - - core->vm_regs.rdx = guest_cursor + 8; - - *((uint64_t*)host_cursor) = 0; - host_cursor -= 8; - guest_cursor -= 8; - for (i = 0; i < core->var_dump.argc; i++) { - *((uint64_t*)host_cursor) = tmp_args[i]; - host_cursor -= 8; - guest_cursor -= 8; - } - - core->vm_regs.rcx = guest_cursor + 8; - - for (i = 0; i < core->var_dump.argc; i++) { - V3_Free(core->var_dump.argv[i]); - } - for (i = 0; i < core->var_dump.envc; i++) { - V3_Free(core->var_dump.envp[i]); - } - - V3_Free(core->var_dump.envp); - V3_Free(core->var_dump.argv); - return 0; -} - - -static int v3_copy_chunk_vmm64(struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt) { - - addr_t envp, argv; - uint_t argc = 0, envc = 0, bytes = 0; - char * cursor; - - PrintDebug("Initiating copy into vmm\n"); - - int ret = v3_gva_to_hva(core, get_addr_linear(core, core->vm_regs.rdx, &(core->segments.ds)), &envp); - if (ret == -1) { - PrintDebug("Error translating address in rdx\n"); - return 0; - } - - ret = v3_gva_to_hva(core, get_addr_linear(core, core->vm_regs.rcx, &(core->segments.ds)), &argv); - if (ret == -1) { - PrintDebug("Error translating address in rcx\n"); - return 0; - } - - cursor = (char*)argv; - while (*((uint64_t*)cursor) != 0) { - addr_t argvn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint64_t*)cursor), &(core->segments.ds)), &argvn); - if (ret == -1) { - PrintDebug("Error translating address for argvn\n"); - } - argc++; - cursor += 8; - } - - /* account for new strings */ - argc += argcnt; - core->var_dump.argv = (char**)V3_Malloc(sizeof(char*)*argc); - core->var_dump.argc = argc; - bytes += sizeof(char*)*argc; - - cursor = (char*)argv; - int i = 0; - while (*((uint64_t*)cursor) != 0) { - addr_t argvn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint64_t*)cursor), &(core->segments.ds)), &argvn); - if (ret == -1) { - PrintDebug("Error translating argvn address\n"); - } - - /* malloc room for the string */ - char * tmpstr = (char*)V3_Malloc(strlen((char*)argvn) + 1); - - /* copy the pointer */ - core->var_dump.argv[i] = tmpstr; - - /* copy the string */ - strncpy(tmpstr, (char*)argvn, strlen((char*)argvn) + 1); - i++; - cursor += 8; - bytes += strlen((char*)argvn) + 1; - } - - /* stick in new arg strings */ - int j = 0; - while (j < argcnt) { - char * tmpstr = (char*)V3_Malloc(strlen(argstrs[j]) + 1); - strncpy(tmpstr, argstrs[j], strlen(argstrs[j]) + 1); - core->var_dump.argv[i] = tmpstr; - bytes += strlen(argstrs[j]) + 1; - i++; j++; - } - - - cursor = (char*)envp; - while (*((uint64_t*)cursor) != 0) { - addr_t envpn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint64_t*)cursor), &(core->segments.ds)), &envpn); - if (ret == -1) { - PrintDebug("Error translating address for envpn\n"); - } - envc++; - cursor += 8; - } - - envc += envcnt; - core->var_dump.envp = (char**)V3_Malloc(sizeof(char*)*envc); - core->var_dump.envc = envc; - bytes += sizeof(uint64_t)*(envc); - - - cursor = (char*)envp; - i = 0; - while (*((uint64_t*)cursor) != 0) { - addr_t envpn; - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)*((uint64_t*)cursor), &(core->segments.ds)), &envpn); - if (ret == -1) { - PrintDebug("Error translating address for envpn\n"); - } - - /* malloc room for the string */ - char * tmpstr = (char*)V3_Malloc(strlen((char*)envpn) + 1); - - /* copy the pointer */ - core->var_dump.envp[i] = tmpstr; - - /* deepcopy the string */ - strncpy(tmpstr, (char*)envpn, strlen((char*)envpn) + 1); - i++; - cursor += 8; - bytes += strlen((char*)envpn) + 1; - } - - /* stick in new env strings */ - j = 0; - while (j < envcnt) { - char * tmpstr = (char*)V3_Malloc(strlen(envstrs[j]) + 1); - strncpy(tmpstr, envstrs[i], strlen(envstrs[j]) + 1); - core->var_dump.envp[i] = tmpstr; - bytes += strlen(envstrs[j]) + 1; - i++; j++; - } - - - /* account for padding for strings - and 2 null pointers */ - bytes += (bytes % 8) + 16; - core->var_dump.bytes = bytes; - return bytes; -} - - -static int v3_inject_strings64 (struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt) { - - addr_t inject_gva; - uint_t bytes_needed = 0; - - /* copy out all of the arguments and the environment to the VMM */ - if ((bytes_needed = v3_copy_chunk_vmm64(core, argstrs, envstrs, argcnt, envcnt)) == -1) { - PrintDebug("Error copying out environment and arguments\n"); - return -1; - } - - PrintDebug("environment successfully copied into VMM\n"); - - inject_gva = v3_prepare_guest_stack(core, bytes_needed); - if (!inject_gva) { - PrintDebug("Not enough space on user stack\n"); - return -1; - } - - v3_copy_chunk_guest64(core, inject_gva, argcnt, envcnt); - return 0; -} - - -addr_t v3_prepare_guest_stack (struct guest_info * core, uint_t bytes_needed) { - - /* TODO: check if we've injected a page fault to get more stack space */ - - // do we have enough room between esp and the next page boundary? - uint_t rem_bytes = 4096 - (core->vm_regs.rsp % 4096); - - if (rem_bytes >= bytes_needed) { - return (addr_t)core->vm_regs.rsp; - } else { - // not enough room, find out how many pages we need (ceiling) - uint_t num_pages = (bytes_needed + 4095) / 4096; - - // check if num_pages are user & writable - int i = 0; - int pages_ok = 1; - addr_t gva = core->vm_regs.rsp + rem_bytes; - for (; i < num_pages; i++, gva -= 4096) { - if (!v3_gva_can_access(core, gva)) { - pages_ok = 0; - } - } - - if (pages_ok) { - return (addr_t)core->vm_regs.rsp; - } else { - - /* - // inject a page fault - pf_error_t fault_type = { - .write = 1, - .user = 1 - }; - - // hoping Linux will allocate all pages in between gva and esp - v3_inject_guest_pf(core, gva - (num_pages*4096), fault_type); - */ - return -1; - } - } -} - - -/* TODO: give these next to functions the ability to copy into guest stack */ -int v3_replace_arg (struct guest_info * core, uint_t argnum, const char * newval) { - - return 0; -} - - -int v3_replace_env (struct guest_info * core, const char * envname, const char * newval) { - - return 0; -} - - -int v3_inject_strings (struct guest_info * core, const char ** argstrs, const char ** envstrs, uint_t argcnt, uint_t envcnt) { - - if (core->cpu_mode == LONG || core->cpu_mode == LONG_32_COMPAT) { - if (v3_inject_strings64(core, argstrs, envstrs, argcnt, envcnt) == -1) { - PrintDebug("Error injecting strings into environment (64)\n"); - return -1; - } - } else { - if (v3_inject_strings32(core, argstrs, envstrs, argcnt, envcnt) == -1) { - PrintDebug("Error injecting strings into environment (32)\n"); - return -1; - } - } - - return 0; -} diff --git a/palacios/src/extensions/vmm_syscall_hijack.c b/palacios/src/extensions/vmm_syscall_hijack.c deleted file mode 100644 index 31445df..0000000 --- a/palacios/src/extensions/vmm_syscall_hijack.c +++ /dev/null @@ -1,191 +0,0 @@ -/* - * This file is part of the Palacios Virtual Machine Monitor developed - * by the V3VEE Project with funding from the United States National - * Science Foundation and the Department of Energy. - * - * The V3VEE Project is a joint project between Northwestern University - * and the University of New Mexico. You can find out more at - * http://www.v3vee.org - * - * Copyright (c) 2011, Kyle C. Hale - * Copyright (c) 2011, The V3VEE Project - * All rights reserved. - * - * Author: Kyle C. Hale - * - * This is free software. You are permitted to use, - * redistribute, and modify it as specified in the file "V3VEE_LICENSE". - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#ifndef CONFIG_DEBUG_SYSCALL_HIJACK -#undef PrintDebug -#define PrintDebug(fmt, args...) -#endif - -#define MAX_CHARS 256 -#ifndef max - #define max(a, b) ( ((a) > (b)) ? (a) : (b) ) -#endif - - - -static void print_arg (struct guest_info * core, v3_reg_t reg, uint8_t argnum) { - - addr_t hva; - int ret = 0; - - PrintDebug("\t ARG%d: INT - %ld\n", argnum, (long) reg); - - if (core->mem_mode == PHYSICAL_MEM) { - ret = v3_gpa_to_hva(core, get_addr_linear(core, reg, &(core->segments.ds)), &hva); - } - else { - ret = v3_gva_to_hva(core, get_addr_linear(core, reg, &(core->segments.ds)), &hva); - } - - PrintDebug("\t STR - "); - if (ret == -1) { - PrintDebug("\n"); - return; - } - - uint32_t c = max(MAX_CHARS, 4096 - (hva % 4096)); - int i = 0; - for (; i < c && *((char*)(hva + i)) != 0; i++) { - PrintDebug("%c", *((char*)(hva + i))); - } - PrintDebug("\n"); -} - - -static void print_syscall (uint8_t is64, struct guest_info * core) { - - if (is64) { - PrintDebug("Syscall #%ld: \"%s\"\n", (long)core->vm_regs.rax, get_linux_syscall_name64(core->vm_regs.rax)); - } else { - PrintDebug("Syscall #%ld: \"%s\"\n", (long)core->vm_regs.rax, get_linux_syscall_name32(core->vm_regs.rax)); - } - - print_arg(core, core->vm_regs.rbx, 1); - print_arg(core, core->vm_regs.rcx, 2); - print_arg(core, core->vm_regs.rdx, 3); -} - - -int v3_syscall_handler (struct guest_info * core, uint8_t vector, void * priv_data) { - - uint_t syscall_nr = (uint_t) core->vm_regs.rax; - int err = 0; - - struct v3_syscall_hook * hook = core->sc_hook_map.syscall_hooks[syscall_nr]; - if (hook == NULL) { -#ifdef CONFIG_SYSCALL_PASSTHROUGH - if (v3_hook_passthrough_syscall(core, syscall_nr) == -1) { - PrintDebug("Error hooking passthrough syscall\n"); - return -1; - } - hook = core->sc_hook_map.syscall_hooks[syscall_nr]; -#else - return v3_signal_swintr(core, vector); -#endif - } - - err = hook->handler(core, syscall_nr, hook->priv_data); - if (err == -1) { - PrintDebug("V3 Syscall Handler: Error in syscall hook\n"); - return -1; - } - - return 0; -} - - -static inline struct v3_syscall_hook * get_syscall_hook (struct guest_info * core, uint_t syscall_nr) { - return core->sc_hook_map.syscall_hooks[syscall_nr]; -} - - -int v3_hook_syscall (struct guest_info * core, - uint_t syscall_nr, - int (*handler)(struct guest_info * core, uint_t syscall_nr, void * priv_data), - void * priv_data) -{ - struct v3_syscall_hook * hook = (struct v3_syscall_hook *)V3_Malloc(sizeof(struct v3_syscall_hook)); - - - if (hook == NULL) { - return -1; - } - - if (get_syscall_hook(core, syscall_nr) != NULL) { - PrintError("System Call #%d already hooked\n", syscall_nr); - return -1; - } - - hook->handler = handler; - hook->priv_data = priv_data; - - core->sc_hook_map.syscall_hooks[syscall_nr] = hook; - - return 0; -} - - -static int passthrough_syscall_handler (struct guest_info * core, uint_t syscall_nr, void * priv_data) { - print_syscall(0, core); - return 0; -} - - -int v3_hook_passthrough_syscall (struct guest_info * core, uint_t syscall_nr) { - - int rc = v3_hook_syscall(core, syscall_nr, passthrough_syscall_handler, NULL); - - if (rc) { - PrintError("failed to hook syscall 0x%x for passthrough (guest=0x%p)\n", syscall_nr, (void *)core); - return -1; - } else { - PrintDebug("hooked syscall 0x%x for passthrough (guest=0x%p)\n", syscall_nr, (void *)core); - return 0; - } - - /* shouldn't get here */ - return 0; -} - - -int v3_sysexecve_handler (struct guest_info * core, uint_t syscall_nr, void * priv_data) { - addr_t hva, key; - struct exec_hook * hook; - int ret; - - ret = v3_gva_to_hva(core, get_addr_linear(core, (addr_t)core->vm_regs.rbx, &(core->segments.ds)), &hva); - if (ret == -1) { - PrintDebug("Error translating file path in sysexecve handler\n"); - return -1; - } - - key = v3_hash_buffer((uchar_t*)hva, strlen((uchar_t*)hva)); - if ((hook = (struct exec_hook*)v3_htable_search(core->exec_hooks.bin_table, key)) != NULL) { - if (hook->handler(core, NULL) == -1) { - PrintDebug("Error handling execve hook\n"); - return -1; - } - } - - return 0; -} - diff --git a/palacios/src/palacios/Makefile b/palacios/src/palacios/Makefile index 4985623..4c55738 100644 --- a/palacios/src/palacios/Makefile +++ b/palacios/src/palacios/Makefile @@ -71,4 +71,5 @@ obj-$(V3_CONFIG_SYMBIOTIC) += vmm_symbiotic.o vmm_symspy.o obj-$(V3_CONFIG_SYMCALL) += vmm_symcall.o obj-$(V3_CONFIG_SYMMOD) += vmm_symmod.o + obj-y += mmu/ diff --git a/palacios/src/palacios/svm.c b/palacios/src/palacios/svm.c index 8134d01..d23c56d 100644 --- a/palacios/src/palacios/svm.c +++ b/palacios/src/palacios/svm.c @@ -136,11 +136,6 @@ static void Init_VMCB_BIOS(vmcb_t * vmcb, struct guest_info * core) { ctrl_area->instrs.PAUSE = 1; ctrl_area->instrs.shutdown_evts = 1; - /* KCH: intercept SW Interrupts (INT instr) */ -#ifdef V3_CONFIG_SW_INTERRUPTS - ctrl_area->instrs.INTn = 1; -#endif - /* DEBUG FOR RETURN CODE */ ctrl_area->exit_code = 1; @@ -229,37 +224,6 @@ static void Init_VMCB_BIOS(vmcb_t * vmcb, struct guest_info * core) { &v3_handle_efer_write, core); -#ifdef V3_CONFIG_HIJACK_SYSCALL_MSR - /* KCH: we're not hooking these to TRAP them, - instead, we're going to catch the target EIP. - Hopefully this EIP is the entry point in the ELF located in the - vsyscall page. We can inject checks into the code segment such that - we don't have to exit on uninteresting system calls. This should - give us much better performance than INT 80, and should even obviate - the need to deal with software interrupts at all */ - v3_hook_msr(core->vm_info, STAR_MSR, - &v3_handle_star_read, - &v3_handle_star_write, - core); - v3_hook_msr(core->vm_info, LSTAR_MSR, - &v3_handle_lstar_read, - &v3_handle_lstar_write, - core); - v3_hook_msr(core->vm_info, CSTAR_MSR, - &v3_handle_cstar_read, - &v3_handle_cstar_write, - core); - - /* KCH: this probably isn't necessary, as - SYSENTER is only used in legacy mode. In fact, - in long mode it results in an illegal instruction - exception */ - v3_hook_msr(core->vm_info, IA32_SYSENTER_EIP_MSR, - &v3_handle_seeip_read, - &v3_handle_seeip_write, - core); -#endif - if (core->shdw_pg_mode == SHADOW_PAGING) { PrintDebug("Creating initial shadow page table\n"); @@ -459,23 +423,9 @@ static int update_irq_entry_state(struct guest_info * info) { case V3_NMI: guest_ctrl->EVENTINJ.type = SVM_INJECTION_NMI; break; - case V3_SOFTWARE_INTR: { -#ifdef CONFIG_DEBUG_INTERRUPTS - PrintDebug("Caught an injected software interrupt\n"); - PrintDebug("\ttype: %d, vector: %d\n", SVM_INJECTION_SOFT_INTR, info->intr_core_state.swintr_vector); -#endif - guest_ctrl->EVENTINJ.type = SVM_INJECTION_SOFT_INTR; - guest_ctrl->EVENTINJ.vector = info->intr_core_state.swintr_vector; - guest_ctrl->EVENTINJ.valid = 1; - - /* reset the software interrupt state. - we can do this because we know only one - sw int can be posted at a time on a given - core, unlike irqs */ - info->intr_core_state.swintr_posted = 0; - info->intr_core_state.swintr_vector = 0; - break; - } + case V3_SOFTWARE_INTR: + guest_ctrl->EVENTINJ.type = SVM_INJECTION_SOFT_INTR; + break; case V3_VIRTUAL_IRQ: guest_ctrl->EVENTINJ.type = SVM_INJECTION_IRQ; break; diff --git a/palacios/src/palacios/svm_handler.c b/palacios/src/palacios/svm_handler.c index da85eb2..a84d2e1 100644 --- a/palacios/src/palacios/svm_handler.c +++ b/palacios/src/palacios/svm_handler.c @@ -33,7 +33,6 @@ #include #include #include -#include #ifndef V3_CONFIG_DEBUG_SVM #undef PrintDebug @@ -194,15 +193,6 @@ int v3_handle_svm_exit(struct guest_info * info, addr_t exit_code, addr_t exit_i } break; } - case VMEXIT_SWINT: -#ifdef CONFIG_DEBUG_INTERRUPTS - PrintDebug("Intercepted SW Interrupt\n"); -#endif - if (v3_handle_swintr(info) == -1) { - PrintError("Error handling software interrupt\n"); - return -1; - } - break; case VMEXIT_INVLPG: if (info->shdw_pg_mode == SHADOW_PAGING) { #ifdef V3_CONFIG_DEBUG_SHADOW_PAGING diff --git a/palacios/src/palacios/vm_guest.c b/palacios/src/palacios/vm_guest.c index af6b6d4..62d2a94 100644 --- a/palacios/src/palacios/vm_guest.c +++ b/palacios/src/palacios/vm_guest.c @@ -31,11 +31,6 @@ #include #include -#ifdef V3_CONFIG_SYSCALL_HIJACK -#include -#include -#endif - v3_cpu_mode_t v3_get_vm_cpu_mode(struct guest_info * info) { @@ -685,14 +680,6 @@ int v3_init_core(struct guest_info * core) { v3_init_symbiotic_core(core); #endif - /* This is test code for exec hook insertion -// KCH -#ifdef V3_CONFIG_SYSCALL_HIJACK - v3_init_exec_hooks(core); - v3_init_mpi_accel(core); -#endif - */ - // init SVM/VMX diff --git a/palacios/src/palacios/vm_guest_mem.c b/palacios/src/palacios/vm_guest_mem.c index caf8a89..8cc497a 100644 --- a/palacios/src/palacios/vm_guest_mem.c +++ b/palacios/src/palacios/vm_guest_mem.c @@ -168,15 +168,15 @@ int v3_gva_to_gpa(struct guest_info * guest_info, addr_t gva, addr_t * gpa) { switch (guest_info->cpu_mode) { case PROTECTED: if (v3_translate_guest_pt_32(guest_info, guest_cr3, gva, gpa) == -1) { - /*PrintDebug("Could not translate addr (%p) through 32 bit guest PT at %p\n", - (void *)gva, (void *)(addr_t)guest_cr3);*/ + PrintDebug("Could not translate addr (%p) through 32 bit guest PT at %p\n", + (void *)gva, (void *)(addr_t)guest_cr3); return -1; } break; case PROTECTED_PAE: if (v3_translate_guest_pt_32pae(guest_info, guest_cr3, gva, gpa) == -1) { - /*PrintDebug("Could not translate addr (%p) through 32 bitpae guest PT at %p\n", - (void *)gva, (void *)(addr_t)guest_cr3);*/ + PrintDebug("Could not translate addr (%p) through 32 bitpae guest PT at %p\n", + (void *)gva, (void *)(addr_t)guest_cr3); return -1; } break; @@ -184,8 +184,8 @@ int v3_gva_to_gpa(struct guest_info * guest_info, addr_t gva, addr_t * gpa) { case LONG_32_COMPAT: case LONG_16_COMPAT: if (v3_translate_guest_pt_64(guest_info, guest_cr3, gva, gpa) == -1) { - /*PrintDebug("Could not translate addr (%p) through 64 bit guest PT at %p\n", - (void *)gva, (void *)(addr_t)guest_cr3);*/ + PrintDebug("Could not translate addr (%p) through 64 bit guest PT at %p\n", + (void *)gva, (void *)(addr_t)guest_cr3); return -1; } break; @@ -266,8 +266,8 @@ int v3_gva_to_hva(struct guest_info * guest_info, addr_t gva, addr_t * hva) { *hva = 0; if (v3_gva_to_gpa(guest_info, gva, &gpa) != 0) { - /*PrintError("In GVA->HVA: Invalid GVA(%p)->GPA lookup\n", - (void *)gva);*/ + PrintError("In GVA->HVA: Invalid GVA(%p)->GPA lookup\n", + (void *)gva); return -1; } @@ -317,56 +317,6 @@ int v3_hva_to_gva(struct guest_info * guest_info, addr_t hva, addr_t * gva) { -/* KCH: currently only checks if we can perform a user-mode write - return 1 on success */ -int v3_gva_can_access(struct guest_info * core, addr_t gva) { - - v3_reg_t guest_cr3 = 0; - pf_error_t access_type; - pt_access_status_t access_status; - - access_type.write = 1; - access_type.user = 1; - - if (core->mem_mode == PHYSICAL_MEM) { - return -1; - } - - if (core->shdw_pg_mode == SHADOW_PAGING) { - guest_cr3 = core->shdw_pg_state.guest_cr3; - } else { - guest_cr3 = core->ctrl_regs.cr3; - } - - // guest is in paged mode - switch (core->cpu_mode) { - case PROTECTED: - if (v3_check_guest_pt_32(core, guest_cr3, gva, access_type, &access_status) == -1) { - return -1; - } - break; - case PROTECTED_PAE: - if (v3_check_guest_pt_32pae(core, guest_cr3, gva, access_type, &access_status) == -1) { - return -1; - } - break; - case LONG: - case LONG_32_COMPAT: - case LONG_16_COMPAT: - if (v3_check_guest_pt_64(core, guest_cr3, gva, access_type, &access_status) == -1) { - return -1; - } - break; - default: - return -1; - } - - if (access_status != PT_ACCESS_OK) { - return 0; - } else { - return 1; - } -} diff --git a/palacios/src/palacios/vmm_ctrl_regs.c b/palacios/src/palacios/vmm_ctrl_regs.c index 4c84e2e..d5a8650 100644 --- a/palacios/src/palacios/vmm_ctrl_regs.c +++ b/palacios/src/palacios/vmm_ctrl_regs.c @@ -582,78 +582,6 @@ int v3_handle_efer_write(struct guest_info * core, uint_t msr, struct v3_msr src return 0; } - -/* KCH: all of the star handlers are for syscall interposition */ -int v3_handle_star_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data) { - -#ifdef CONFIG_DEBUG_SYSCALL_HIJACK - PrintDebug("STAR Read\n"); -#endif - - return 0; -} - - -int v3_handle_star_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data) { - -#ifdef V3_CONFIG_DEBUG_SYSCALL_HIJACK - PrintDebug("STAR Write\n"); -#endif - return 0; -} - - -int v3_handle_lstar_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data) { - -#ifdef V3_CONFIG_DEBUG_SYSCALL_HIJACK - PrintDebug("LSTAR Read\n"); -#endif - return 0; -} - - -int v3_handle_lstar_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data) { - -#ifdef V3_CONFIG_DEBUG_SYSCALL_HIJACK - ulong_t entry = ((ulong_t)src.hi << 32) | (ulong_t)src.lo; - PrintDebug("LSTAR Write\n"); - PrintDebug("\tKernel syscall entry point: 0x%lx\n", entry); -#endif - - return 0; -} - - -int v3_handle_cstar_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data) { - -#ifdef V3_CONFIG_DEBUG_SYSCALL_HIJACK - PrintDebug("CSTAR Read\n"); -#endif - return 0; -} - - -int v3_handle_cstar_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data) { - -#ifdef V3_CONFIG_DEBUG_SYSCALL_HIJACK - PrintDebug("CSTAR Write\n"); -#endif - return 0; -} - -int v3_handle_seeip_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data) { - /* we don't care about reads */ - return 0; -} - -int v3_handle_seeip_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data) { -#ifdef V3_CONFIG_DEBUG_SYSALL_HIJACK - PrintDebug("SYSENTER_EIP Write\n"); -#endif - return 0; -} - - int v3_handle_vm_cr_read(struct guest_info * core, uint_t msr, struct v3_msr * dst, void * priv_data) { /* tell the guest that the BIOS disabled SVM, that way it doesn't get * confused by the fact that CPUID reports SVM as available but it still diff --git a/palacios/src/palacios/vmm_decoder.c b/palacios/src/palacios/vmm_decoder.c index 1783ca1..a2f260c 100644 --- a/palacios/src/palacios/vmm_decoder.c +++ b/palacios/src/palacios/vmm_decoder.c @@ -146,7 +146,6 @@ static char * op_type_to_str(v3_op_type_t type) { case V3_OP_STOS: return "V3_OP_STOS"; case V3_OP_MOVZX: return "V3_OP_MOVZX"; case V3_OP_MOVSX: return "V3_OP_MOVSX"; - case V3_OP_INT: return "V3_OP_INT"; // KCH case V3_INVALID_OP: default: return "V3_INVALID_OP"; diff --git a/palacios/src/palacios/vmm_intr.c b/palacios/src/palacios/vmm_intr.c index f8dbd68..8c4e1c2 100644 --- a/palacios/src/palacios/vmm_intr.c +++ b/palacios/src/palacios/vmm_intr.c @@ -25,8 +25,6 @@ #include #include -#include -#include #ifndef V3_CONFIG_DEBUG_INTERRUPTS #undef PrintDebug @@ -35,6 +33,7 @@ + struct intr_controller { struct intr_ctrl_ops * ctrl_ops; @@ -51,8 +50,6 @@ struct intr_router { }; - - void v3_init_intr_controllers(struct guest_info * info) { struct v3_intr_core_state * intr_state = &(info->intr_core_state); @@ -98,7 +95,6 @@ void v3_deinit_intr_routers(struct v3_vm_info * vm) { } } - void * v3_register_intr_controller(struct guest_info * info, struct intr_ctrl_ops * ops, void * priv_data) { struct intr_controller * ctrlr = (struct intr_controller *)V3_Malloc(sizeof(struct intr_controller)); @@ -110,7 +106,6 @@ void * v3_register_intr_controller(struct guest_info * info, struct intr_ctrl_op return (void *)ctrlr; } - void v3_remove_intr_controller(struct guest_info * core, void * handle) { struct v3_intr_core_state * intr_state = &(core->intr_core_state); struct intr_controller * ctrlr = handle; @@ -133,7 +128,6 @@ void v3_remove_intr_controller(struct guest_info * core, void * handle) { V3_Free(ctrlr); } - void * v3_register_intr_router(struct v3_vm_info * vm, struct intr_router_ops * ops, void * priv_data) { struct intr_router * router = (struct intr_router *)V3_Malloc(sizeof(struct intr_router)); @@ -145,7 +139,6 @@ void * v3_register_intr_router(struct v3_vm_info * vm, struct intr_router_ops * return (void *)router; } - void v3_remove_intr_router(struct v3_vm_info * vm, void * handle) { struct intr_router * router = handle; struct intr_router * tmp = NULL; @@ -168,7 +161,9 @@ void v3_remove_intr_router(struct v3_vm_info * vm, void * handle) { } -static inline struct v3_irq_hook * get_irq_hook(struct v3_vm_info * vm, uint8_t irq) { + +static inline struct v3_irq_hook * get_irq_hook(struct v3_vm_info * vm, uint_t irq) { + V3_ASSERT(irq <= 256); return vm->intr_routers.hooks[irq]; } @@ -204,6 +199,7 @@ int v3_hook_irq(struct v3_vm_info * vm, } + static int passthrough_irq_handler(struct v3_vm_info * vm, struct v3_interrupt * intr, void * priv_data) { PrintDebug("[passthrough_irq_handler] raise_irq=%d (guest=0x%p)\n", intr->irq, (void *)vm); @@ -211,7 +207,6 @@ static int passthrough_irq_handler(struct v3_vm_info * vm, struct v3_interrupt * return v3_raise_irq(vm, intr->irq); } - int v3_hook_passthrough_irq(struct v3_vm_info * vm, uint_t irq) { int rc = v3_hook_irq(vm, irq, passthrough_irq_handler, NULL); @@ -225,6 +220,9 @@ int v3_hook_passthrough_irq(struct v3_vm_info * vm, uint_t irq) { } + + + int v3_deliver_irq(struct v3_vm_info * vm, struct v3_interrupt * intr) { PrintDebug("v3_deliver_irq: irq=%d state=0x%p, \n", intr->irq, (void *)intr); @@ -239,6 +237,9 @@ int v3_deliver_irq(struct v3_vm_info * vm, struct v3_interrupt * intr) { } + + + int v3_raise_virq(struct guest_info * info, int irq) { struct v3_intr_core_state * intr_state = &(info->intr_core_state); int major = irq / 8; @@ -249,7 +250,6 @@ int v3_raise_virq(struct guest_info * info, int irq) { return 0; } - int v3_lower_virq(struct guest_info * info, int irq) { struct v3_intr_core_state * intr_state = &(info->intr_core_state); int major = irq / 8; @@ -277,7 +277,6 @@ int v3_lower_irq(struct v3_vm_info * vm, int irq) { return 0; } - int v3_raise_irq(struct v3_vm_info * vm, int irq) { struct intr_router * router = NULL; struct v3_intr_routers * routers = &(vm->intr_routers); @@ -295,131 +294,11 @@ int v3_raise_irq(struct v3_vm_info * vm, int irq) { } -int v3_signal_swintr(struct guest_info * core, int vector) { - struct v3_intr_core_state * intr_state = &(core->intr_core_state); - - PrintDebug("Signaling software interrupt in vmm_intr.c\n"); - PrintDebug("\tINT vector: %d\n", vector); - - intr_state->swintr_posted = 1; - intr_state->swintr_vector = vector; - return 0; -} - - -int v3_handle_swintr(struct guest_info * core) { - - int ret = 0; - void * instr_ptr = NULL; - struct x86_instr instr; - - if (core->mem_mode == PHYSICAL_MEM) { - ret = v3_gpa_to_hva(core, get_addr_linear(core, core->rip, &(core->segments.cs)), (addr_t *)&instr_ptr); - } else { - ret = v3_gva_to_hva(core, get_addr_linear(core, core->rip, &(core->segments.cs)), (addr_t *)&instr_ptr); - } - - if (ret == -1) { - PrintError("V3 SWintr Handler: Could not translate Instruction Address (%p)\n", (void *)core->rip); - return -1; - } - - if (v3_decode(core, (addr_t)instr_ptr, &instr) == -1) { - PrintError("V3 SWintr Handler: Decoding Error\n"); - return -1; - } - - uint8_t vector = instr.dst_operand.operand; - - struct v3_swintr_hook * hook = core->intr_core_state.swintr_hooks[vector]; - if (hook == NULL) { -#ifdef V3_CONFIG_SWINTR_PASSTHROUGH - if (v3_hook_passthrough_swintr(core, vector) == -1) { - PrintDebug("V3 SWintr Handler: Error hooking passthrough swintr\n"); - return -1; - } - hook = core->intr_core_state.swintr_hooks[vector]; -#else - core->rip += instr.instr_length; - return v3_signal_swintr(core, vector); -#endif - } - - ret = hook->handler(core, vector, NULL); - if (ret == -1) { - PrintDebug("V3 SWintr Handler: Error in swintr hook\n"); - return -1; - } - - /* KCH: at some point we may need to prioritize swints - so that they finish in time for the next - instruction... */ - core->rip += instr.instr_length; - return v3_signal_swintr(core, vector); -} - - -static inline struct v3_swintr_hook * get_swintr_hook(struct guest_info * core, uint8_t vector) { - return core->intr_core_state.swintr_hooks[vector]; -} - - -int v3_hook_swintr(struct guest_info * core, - uint8_t vector, - int (*handler)(struct guest_info * core, uint8_t vector, void * priv_data), - void * priv_data) -{ - - struct v3_swintr_hook * hook = (struct v3_swintr_hook *)V3_Malloc(sizeof(struct v3_swintr_hook)); - - if (hook == NULL) { - return -1; - } - - if (get_swintr_hook(core, vector) != NULL) { - PrintError("SWINT %d already hooked\n", vector); - return -1; - } - - hook->handler = handler; - hook->priv_data = priv_data; - - core->intr_core_state.swintr_hooks[vector] = hook; - - return 0; -} - - -static int passthrough_swintr_handler(struct guest_info * core, uint8_t vector, void * priv_data) { - - PrintDebug("[passthrough_swint_handler] INT vector=%d (guest=0x%p)\n", - vector, (void *)core); - - return 0; -} - - -int v3_hook_passthrough_swintr(struct guest_info * core, uint8_t vector) { - - int rc = v3_hook_swintr(core, vector, passthrough_swintr_handler, NULL); - - if (rc) { - PrintError("guest_swintr_injection: failed to hook swint 0x%x (guest=0x%p)\n", vector, (void *)core); - return -1; - } else { - PrintDebug("guest_swintr_injection: hooked swint 0x%x (guest=0x%p)\n", vector, (void *)core); - return 0; - } - - /* shouldn't get here */ - return 0; -} - - void v3_clear_pending_intr(struct guest_info * core) { struct v3_intr_core_state * intr_state = &(core->intr_core_state); intr_state->irq_pending = 0; + } @@ -449,11 +328,6 @@ v3_intr_type_t v3_intr_pending(struct guest_info * info) { } } - // KCH: added for SWintr injection - if (intr_state->swintr_posted == 1) { - ret = V3_SOFTWARE_INTR; - } - v3_unlock_irqrestore(intr_state->irq_lock, irq_state); return ret; @@ -528,6 +402,9 @@ intr_type_t v3_get_intr_type(struct guest_info * info) { */ + + + int v3_injecting_intr(struct guest_info * info, uint_t intr_num, v3_intr_type_t type) { struct v3_intr_core_state * intr_state = &(info->intr_core_state); diff --git a/palacios/src/palacios/vmm_v3dec.c b/palacios/src/palacios/vmm_v3dec.c index f10bed9..2de8b00 100644 --- a/palacios/src/palacios/vmm_v3dec.c +++ b/palacios/src/palacios/vmm_v3dec.c @@ -506,10 +506,6 @@ static v3_op_type_t op_form_to_type(op_form_t form) { case MOV_2CR: return V3_OP_MOV2CR; - // KCH: for syscall interposition - case INT: - return V3_OP_INT; - case MOV_MEM2_8: case MOV_MEM2: diff --git a/palacios/src/palacios/vmm_xed.c b/palacios/src/palacios/vmm_xed.c index 9c0fc33..1a80d18 100644 --- a/palacios/src/palacios/vmm_xed.c +++ b/palacios/src/palacios/vmm_xed.c @@ -443,19 +443,6 @@ int v3_decode(struct guest_info * info, addr_t instr_ptr, struct x86_instr * ins case XED_OPERAND_IMM0: - { - v3_op->size = xed_decoded_inst_get_immediate_width(&xed_instr); - - if (v3_op->size > 4) { - PrintError("Unhandled 64 bit immediates\n"); - return -1; - } - v3_op->operand = xed_decoded_inst_get_unsigned_immediate(&xed_instr); - - v3_op->type = IMM_OPERAND; - - } - break; case XED_OPERAND_AGEN: case XED_OPERAND_PTR: case XED_OPERAND_RELBR: @@ -594,7 +581,7 @@ int v3_decode(struct guest_info * info, addr_t instr_ptr, struct x86_instr * ins instr->third_operand.type = REG_OPERAND; - PrintDebug("Operand 2 mode: %s\n", xed_operand_action_enum_t2str(xed_operand_rw(op))); + PrintDebug("Operand 3 mode: %s\n", xed_operand_action_enum_t2str(xed_operand_rw(op))); if (xed_operand_read(op)) { @@ -1283,10 +1270,6 @@ static v3_op_type_t get_opcode(xed_iform_enum_t iform) { case XED_IFORM_INVLPG_MEMb: return V3_OP_INVLPG; - // KCH - case XED_IFORM_INT_IMM: - return V3_OP_INT; - /* Data Instructions */