// Parse host-os defined options into an easily-accessed format.
v3_parse_options(options);
+#ifdef V3_CONFIG_MULTIBOOT
+ v3_init_multiboot();
+#endif
+
#ifdef V3_CONFIG_HVM
v3_init_hvm();
#endif
v3_deinit_hvm();
#endif
+#ifdef V3_CONFIG_MULTIBOOT
+ v3_deinit_multiboot();
+#endif
+
v3_deinit_options();
return -1;
}
+#if V3_CONFIG_MULTIBOOT
+ if (v3_setup_multiboot_vm_for_boot(vm)) {
+ PrintError(vm, VCORE_NONE, "Multiboot setup for boot failed\n");
+ return -1;
+ }
+#endif
#if V3_CONFIG_HVM
if (v3_setup_hvm_vm_for_boot(vm)) {
PrintError(vm, VCORE_NONE, "HVM setup for boot failed\n");
}
+// resets the whole VM (non-HVM) or the ROS (HVM)
+int v3_reset_vm(struct v3_vm_info *vm)
+{
+#ifdef V3_CONFIG_HVM
+ if (vm->hvm_state.is_hvm) {
+ return v3_reset_vm_extended(vm,V3_VM_RESET_ROS,0);
+ } else {
+ return v3_reset_vm_extended(vm,V3_VM_RESET_ALL,0);
+ }
+#else
+ return v3_reset_vm_extended(vm,V3_VM_RESET_ALL,0);
+#endif
+}
+
+int v3_reset_vm_extended(struct v3_vm_info *vm, v3_vm_reset_type t, void *data)
+{
+ uint32_t start, end, i;
+ uint32_t newcount;
+
+ if (vm->run_state != VM_RUNNING) {
+ PrintError(vm,VCORE_NONE,"Attempt to reset VM in state %d (must be in running state)\n",vm->run_state);
+ return -1;
+ }
+
+
+ switch (t) {
+ case V3_VM_RESET_ALL:
+#ifdef V3_CONFIG_HVM
+ if (vm->hvm_state.is_hvm) {
+ PrintError(vm,VCORE_NONE,"Attempt to do ALL reset of HVM (not allowed)\n");
+ return -1;
+ }
+#endif
+ start=0; end=vm->num_cores-1;
+ break;
+#ifdef V3_CONFIG_HVM
+ case V3_VM_RESET_HRT:
+ case V3_VM_RESET_ROS:
+ if (vm->hvm_state.is_hvm) {
+ if (t==V3_VM_RESET_HRT) {
+ start = vm->hvm_state.first_hrt_core;
+ end = vm->num_cores-1;
+ } else {
+ start = 0;
+ end = vm->hvm_state.first_hrt_core-1;
+ }
+ } else {
+ PrintError(vm,VCORE_NONE,"This is not an HVM and so HVM-specific resets do not apply\n");
+ return -1;
+ }
+#endif
+ break;
+ case V3_VM_RESET_CORE_RANGE:
+ start = ((uint32_t*)data)[0];
+ end = ((uint32_t*)data)[1];
+ break;
+ default:
+ PrintError(vm,VCORE_NONE,"Unsupported reset type %d for this VM\n",t);
+ return -1;
+ break;
+ }
+
+ PrintDebug(vm,VCORE_NONE,"Resetting cores %d through %d\n",start,end);
+
+ newcount = end-start+1;
+
+ for (i=start;i<=end;i++) {
+ if (!(vm->cores[i].core_run_state == CORE_RUNNING || vm->cores[i].core_run_state == CORE_STOPPED)) {
+ PrintError(vm,VCORE_NONE,"Cannot reset VM as core %u is in state %d (must be running or stopped)\n",i,vm->cores[i].core_run_state);
+ return -1;
+ }
+ }
+
+
+ // This had better be the only thread using the barrier at this point...
+ v3_init_counting_barrier(&vm->reset_barrier,newcount);
+
+ // OK, I am the reseter, tell the relevant cores what to do
+ // each will atomically decrement the reset countdown and then
+ // spin waiting for it to hit zero.
+
+ for (i=start;i<=end;i++) {
+ vm->cores[i].core_run_state = CORE_RESETTING;
+ // force exit of core
+ v3_interrupt_cpu(vm, vm->cores[i].pcpu_id, 0);
+ }
+
+ // we don't wait for reset to finish
+ // because reset could have been initiated by a core
+
+ return 0;
+}
+
/* move a virtual core to different physical core */
int v3_move_vm_core(struct v3_vm_info * vm, int vcore_id, int target_cpu) {
new_hpa = V3_AllocPagesExtended(num_pages,
PAGE_SIZE_4KB,
new_node,
- 0); // no constraints given new shadow pager impl
+ 0, 0); // no constraints given new shadow pager impl
if (!new_hpa) {
PrintError(vm, VCORE_NONE, "Cannot allocate memory for new base region...\n");
uint32_t numcores;
uint32_t numregions;
extern uint64_t v3_mem_block_size;
+ void *cur_gpa;
if (!vm || !base || !core || !mem) {
- PrintError(VM_NONE, VCORE_NONE, "Invalid rquest to v3_get_state_vm\n");
+ PrintError(VM_NONE, VCORE_NONE, "Invalid request to v3_get_state_vm\n");
return -1;
}
case VM_INVALID: base->state = V3_VM_INVALID; break;
case VM_RUNNING: base->state = V3_VM_RUNNING; break;
case VM_STOPPED: base->state = V3_VM_STOPPED; break;
- case VM_RESETTING: base->state = V3_VM_RESETTING; break;
case VM_PAUSED: base->state = V3_VM_PAUSED; break;
case VM_ERROR: base->state = V3_VM_ERROR; break;
case VM_SIMULATING: base->state = V3_VM_SIMULATING; break;
+ case VM_RESETTING: base->state = V3_VM_RESETTING; break;
default: base->state = V3_VM_UNKNOWN; break;
}
+ base->vm_type = V3_VM_GENERAL;
+
+#ifdef V3_CONFIG_HVM
+ if (vm->hvm_state.is_hvm) {
+ base->vm_type = V3_VM_HVM;
+ }
+#endif
+
for (i=0;i<numcores;i++) {
switch (vm->cores[i].core_run_state) {
case CORE_INVALID: core->vcore[i].state = V3_VCORE_INVALID; break;
case CORE_RUNNING: core->vcore[i].state = V3_VCORE_RUNNING; break;
case CORE_STOPPED: core->vcore[i].state = V3_VCORE_STOPPED; break;
+ case CORE_RESETTING: core->vcore[i].state = V3_VCORE_RESETTING; break;
default: core->vcore[i].state = V3_VCORE_UNKNOWN; break;
}
switch (vm->cores[i].cpu_mode) {
case VIRTUAL_MEM: core->vcore[i].mem_mode=V3_VCORE_MEM_MODE_VIRTUAL; break;
default: core->vcore[i].mem_mode=V3_VCORE_MEM_MODE_UNKNOWN; break;
}
+
+ core->vcore[i].vcore_type = V3_VCORE_GENERAL;
+
+#ifdef V3_CONFIG_HVM
+ if (vm->hvm_state.is_hvm) {
+ if (v3_is_hvm_ros_core(&vm->cores[i])) {
+ core->vcore[i].vcore_type = V3_VCORE_ROS;
+ } else {
+ core->vcore[i].vcore_type = V3_VCORE_HRT;
+ }
+ }
+#endif
core->vcore[i].pcore=vm->cores[i].pcpu_id;
core->vcore[i].last_rip=(void*)(vm->cores[i].rip);
core->num_vcores=numcores;
+ cur_gpa=0;
+
for (i=0;i<numregions;i++) {
+ mem->region[i].guest_paddr = cur_gpa;
mem->region[i].host_paddr = (void*)(vm->mem_map.base_regions[i].host_addr);
mem->region[i].size = v3_mem_block_size;
#ifdef V3_CONFIG_SWAPPING
mem->region[i].pinned = 0;
#endif
+ cur_gpa += mem->region[i].size;
}
mem->num_regions=numregions;
+
+
+ mem->mem_size=vm->mem_size;
+ mem->ros_mem_size=vm->mem_size;
+
+#ifdef V3_CONFIG_HVM
+ if (vm->hvm_state.is_hvm) {
+ mem->ros_mem_size=v3_get_hvm_ros_memsize(vm);
+ }
+#endif
+
+ return 0;
+}
+
+int v3_get_state_sizes_vm(struct v3_vm_info *vm,
+ unsigned long long *num_vcores,
+ unsigned long long *num_regions)
+{
+ if (!vm || !num_vcores || !num_regions) {
+ PrintError(VM_NONE, VCORE_NONE, "Invalid request to v3_get_state_sizes\n");
+ return -1;
+ }
+
+ *num_vcores = vm->num_cores;
+ *num_regions = vm->mem_map.num_base_regions;
return 0;
}
