2 * This file is part of the Palacios Virtual Machine Monitor developed
3 * by the V3VEE Project with funding from the United States National
4 * Science Foundation and the Department of Energy.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
10 * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
11 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
12 * All rights reserved.
14 * Author: Jack Lange <jarusl@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
21 //#include <palacios/vmm_inspector.h>
22 #include <palacios/vmm.h>
23 #include <palacios/vm_guest.h>
24 #include <palacios/vmm_sprintf.h>
25 #include <palacios/vmm_extensions.h>
27 #include <palacios/vmm_multitree.h>
28 #include <interfaces/inspector.h>
30 // Note that v3_inspect_node_t is actuall a struct v3_mtree
31 // Its set as void for opaque portability
33 struct v3_inspector_state {
34 struct v3_mtree state_tree;
39 static int init_inspector(struct v3_vm_info * vm, v3_cfg_tree_t * cfg, void ** priv_data) {
40 struct v3_inspector_state * state = V3_Malloc(sizeof(struct v3_inspector_state));
43 PrintError(vm, VCORE_NONE, "Cannot allocate state in inspector\n");
47 memset(state, 0, sizeof(struct v3_inspector_state));
49 strncpy(state->state_tree.name, "vm->name", 50);
50 state->state_tree.name[49] = 0;
51 state->state_tree.subtree = 1;
59 static int init_inspector_core(struct guest_info * core, void * priv_data, void ** core_data) {
60 struct v3_inspector_state * vm_state = priv_data;
63 snprintf(core_name, 50, "core.%d", core->vcpu_id);
66 struct v3_mtree * core_node = v3_mtree_create_subtree(&(vm_state->state_tree), core_name);
67 v3_inspect_64(core_node, "RIP", (uint64_t *)&(core->rip));
68 v3_inspect_64(core_node, "NUM_EXITS", (uint64_t *)&(core->num_exits));
69 // v3_inspect_buf(core_node, "EXEC_NAME", core->exec_name, sizeof(core->exec_name));
72 struct v3_mtree * gpr_node = v3_mtree_create_subtree(core_node, "GPRS");
73 v3_inspect_64(gpr_node, "RAX", (uint64_t *)&(core->vm_regs.rax));
74 v3_inspect_64(gpr_node, "RBX", (uint64_t *)&(core->vm_regs.rbx));
75 v3_inspect_64(gpr_node, "RCX", (uint64_t *)&(core->vm_regs.rcx));
76 v3_inspect_64(gpr_node, "RDX", (uint64_t *)&(core->vm_regs.rdx));
77 v3_inspect_64(gpr_node, "RSP", (uint64_t *)&(core->vm_regs.rsp));
78 v3_inspect_64(gpr_node, "RBP", (uint64_t *)&(core->vm_regs.rbp));
79 v3_inspect_64(gpr_node, "RSI", (uint64_t *)&(core->vm_regs.rsi));
80 v3_inspect_64(gpr_node, "RDI", (uint64_t *)&(core->vm_regs.rdi));
83 struct v3_mtree * cr_node = v3_mtree_create_subtree(core_node, "CTRL_REGS");
84 v3_inspect_64(cr_node, "CR0", (uint64_t *)&(core->ctrl_regs.cr0));
85 v3_inspect_64(cr_node, "CR2", (uint64_t *)&(core->ctrl_regs.cr2));
86 v3_inspect_64(cr_node, "CR3", (uint64_t *)&(core->ctrl_regs.cr3));
87 v3_inspect_64(cr_node, "CR4", (uint64_t *)&(core->ctrl_regs.cr4));
88 v3_inspect_64(cr_node, "RFLAGS", (uint64_t *)&(core->ctrl_regs.rflags));
89 v3_inspect_64(cr_node, "EFER", (uint64_t *)&(core->ctrl_regs.efer));
92 //struct v3_mtree * seg_node = v3_mtree_create_subtree(core_node, "SEGMENTS");
105 static struct v3_extension_impl inspector_impl = {
108 .vm_init = init_inspector,
110 .core_init = init_inspector_core,
117 register_extension(&inspector_impl);
120 v3_inspect_node_t * v3_inspect_add_subtree(v3_inspect_node_t * root, char * name) {
121 return v3_mtree_create_subtree(root, name);
124 int v3_inspect_8(v3_inspect_node_t * node, char * name, uint8_t * val) {
125 v3_mtree_create_value(node, name, 1, val);
130 int v3_inspect_16(v3_inspect_node_t * node, char * name, uint16_t * val) {
131 v3_mtree_create_value(node, name, 2, val);
136 int v3_inspect_32(v3_inspect_node_t * node, char * name, uint32_t * val) {
137 v3_mtree_create_value(node, name, 4, val);
141 int v3_inspect_64(v3_inspect_node_t * node, char * name, uint64_t * val) {
142 v3_mtree_create_value(node, name, 8, val);
146 int v3_inspect_addr(v3_inspect_node_t * node, char * name, addr_t * val) {
147 v3_mtree_create_value(node, name, sizeof(addr_t), val);
151 int v3_inspect_buf(v3_inspect_node_t * node, char * name,
152 uint8_t * buf, uint64_t size) {
153 v3_mtree_create_value(node, name, size, buf);
160 int v3_find_inspection_value(v3_inspect_node_t * node, char * name,
161 struct v3_inspection_value * value) {
162 struct v3_mtree * mt_node = v3_mtree_find_node(node, name);
168 *value = v3_inspection_value(mt_node);
173 struct v3_inspection_value v3_inspection_value(v3_inspect_node_t * node) {
174 struct v3_mtree * mt_node = node;
175 struct v3_inspection_value value;
177 value.value = mt_node->value;
178 value.size = mt_node->size;
179 value.flags = mt_node->user_flags;
180 value.name = mt_node->name;
187 v3_inspect_node_t * v3_get_inspection_root(struct v3_vm_info * vm) {
188 struct v3_inspector_state * inspector = v3_get_extension_state(vm, inspector_impl.name);
190 if (inspector == NULL) {
194 return &(inspector->state_tree);
197 v3_inspect_node_t * v3_get_inspection_subtree(v3_inspect_node_t * root, char * name) {
198 return v3_mtree_find_subtree(root, name);
202 v3_inspect_node_t * v3_inspection_node_next(v3_inspect_node_t * node) {
203 return v3_mtree_next_node(node);
206 v3_inspect_node_t * v3_inspection_first_child(v3_inspect_node_t * root) {
207 return v3_mtree_first_child(root);