mirror of https://github.com/BOINC/boinc.git
2078 lines
70 KiB
C++
2078 lines
70 KiB
C++
// This file is part of BOINC.
|
|
// http://boinc.berkeley.edu
|
|
// Copyright (C) 2010-2012 University of California
|
|
//
|
|
// BOINC is free software; you can redistribute it and/or modify it
|
|
// under the terms of the GNU Lesser General Public License
|
|
// as published by the Free Software Foundation,
|
|
// either version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// BOINC is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with BOINC. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifdef _WIN32
|
|
#include "boinc_win.h"
|
|
#include "win_util.h"
|
|
#else
|
|
#include <sys/wait.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
using std::string;
|
|
|
|
#include "diagnostics.h"
|
|
#include "filesys.h"
|
|
#include "parse.h"
|
|
#include "str_util.h"
|
|
#include "str_replace.h"
|
|
#include "util.h"
|
|
#include "error_numbers.h"
|
|
#include "procinfo.h"
|
|
#include "network.h"
|
|
#include "boinc_api.h"
|
|
#include "floppyio.h"
|
|
#include "vboxlogging.h"
|
|
#include "vboxwrapper.h"
|
|
#include "vbox_common.h"
|
|
#include "vbox_vboxmanage.h"
|
|
|
|
|
|
namespace vboxmanage {
|
|
|
|
VBOX_VM::VBOX_VM() {
|
|
}
|
|
|
|
VBOX_VM::~VBOX_VM() {
|
|
}
|
|
|
|
|
|
int VBOX_VM::initialize() {
|
|
int rc = 0;
|
|
string old_path;
|
|
string new_path;
|
|
string command;
|
|
string output;
|
|
APP_INIT_DATA aid;
|
|
bool force_sandbox = false;
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
get_install_directory(virtualbox_install_directory);
|
|
get_scratch_directory(virtualbox_scratch_directory);
|
|
|
|
// Prep the environment so we can execute the vboxmanage application
|
|
//
|
|
#ifdef _WIN32
|
|
if (!virtualbox_install_directory.empty())
|
|
{
|
|
old_path = getenv("PATH");
|
|
new_path = virtualbox_install_directory + ";" + old_path;
|
|
|
|
if (!SetEnvironmentVariable("PATH", const_cast<char*>(new_path.c_str()))) {
|
|
vboxlog_msg("Failed to modify the search path.");
|
|
}
|
|
}
|
|
#else
|
|
old_path = getenv("PATH");
|
|
if(boinc_file_exists("/usr/local/bin/VBoxManage")) {
|
|
new_path = "/usr/local/bin/:" + old_path;
|
|
}
|
|
if(boinc_file_exists("/usr/bin/VBoxManage")) {
|
|
new_path = "/usr/bin/:" + old_path;
|
|
}
|
|
// putenv does not copy its input buffer, so we must use setenv
|
|
if (setenv("PATH", const_cast<char*>(new_path.c_str()), 1)) {
|
|
vboxlog_msg("Failed to modify the search path.");
|
|
}
|
|
#endif
|
|
|
|
// Determine the VirtualBox home directory. Overwrite as needed.
|
|
//
|
|
if (getenv("VBOX_USER_HOME")) {
|
|
virtualbox_home_directory = getenv("VBOX_USER_HOME");
|
|
} else {
|
|
// If the override environment variable isn't specified then
|
|
// it is based of the current users HOME directory.
|
|
#ifdef _WIN32
|
|
virtualbox_home_directory = getenv("USERPROFILE");
|
|
#else
|
|
virtualbox_home_directory = getenv("HOME");
|
|
#endif
|
|
virtualbox_home_directory += "/.VirtualBox";
|
|
}
|
|
|
|
// On *nix style systems, VirtualBox expects that there is a home directory specified
|
|
// by environment variable. When it doesn't exist it attempts to store logging information
|
|
// in root's home directory. Bad things happen if the process attempts to use root's home
|
|
// directory.
|
|
//
|
|
// if the HOME environment variable is missing force VirtualBox to use a directory it
|
|
// has a reasonable chance of writing log files too.
|
|
#ifndef _WIN32
|
|
if (NULL == getenv("HOME")) {
|
|
force_sandbox = true;
|
|
}
|
|
#endif
|
|
|
|
// Set the location in which the VirtualBox Configuration files can be
|
|
// stored for this instance.
|
|
if (aid.using_sandbox || force_sandbox) {
|
|
virtualbox_home_directory = aid.project_dir;
|
|
virtualbox_home_directory += "/../virtualbox";
|
|
|
|
if (!boinc_file_exists(virtualbox_home_directory.c_str())) boinc_mkdir(virtualbox_home_directory.c_str());
|
|
|
|
#ifdef _WIN32
|
|
if (!SetEnvironmentVariable("VBOX_USER_HOME", const_cast<char*>(virtualbox_home_directory.c_str()))) {
|
|
vboxlog_msg("Failed to modify the search path.");
|
|
}
|
|
#else
|
|
// putenv does not copy its input buffer, so we must use setenv
|
|
if (setenv("VBOX_USER_HOME", const_cast<char*>(virtualbox_home_directory.c_str()), 1)) {
|
|
vboxlog_msg("Failed to modify the VBOX_USER_HOME path.");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
// Launch vboxsvc manually so that the DCOM subsystem won't be able too. Our version
|
|
// will have permission and direction to write its state information to the BOINC
|
|
// data directory.
|
|
//
|
|
launch_vboxsvc();
|
|
#endif
|
|
|
|
rc = get_version_information(virtualbox_version_raw, virtualbox_version_display);
|
|
if (rc) return rc;
|
|
|
|
get_guest_additions(virtualbox_guest_additions);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::create_vm() {
|
|
string command;
|
|
string output;
|
|
string virtual_machine_slot_directory;
|
|
string default_interface;
|
|
APP_INIT_DATA aid;
|
|
bool disable_acceleration = false;
|
|
char buf[256];
|
|
int retval;
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
get_slot_directory(virtual_machine_slot_directory);
|
|
|
|
|
|
vboxlog_msg("Create VM. (%s, slot#%d)", vm_master_name.c_str(), aid.slot);
|
|
|
|
|
|
// Reset VM name in case it was changed while deregistering a stale VM
|
|
//
|
|
vm_name = vm_master_name;
|
|
|
|
// Fixup chipset and drive controller information for known configurations
|
|
//
|
|
if (enable_isocontextualization) {
|
|
if ("PIIX4" == vm_disk_controller_model) {
|
|
vboxlog_msg("Updating drive controller type and model for desired configuration.");
|
|
vm_disk_controller_type = "sata";
|
|
vm_disk_controller_model = "IntelAHCI";
|
|
}
|
|
}
|
|
|
|
|
|
// Create and register the VM
|
|
//
|
|
command = "createvm ";
|
|
command += "--name \"" + vm_name + "\" ";
|
|
command += "--basefolder \"" + virtual_machine_slot_directory + "\" ";
|
|
command += "--ostype \"" + os_name + "\" ";
|
|
command += "--register";
|
|
|
|
retval = vbm_popen(command, output, "create");
|
|
if (retval) return retval;
|
|
|
|
// Tweak the VM's Description
|
|
//
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--description \"" + vm_master_description + "\" ";
|
|
|
|
vbm_popen(command, output, "modifydescription", false, false);
|
|
|
|
|
|
// Tweak the VM's Memory Size
|
|
//
|
|
vboxlog_msg("Setting Memory Size for VM. (%dMB)", (int)memory_size_mb);
|
|
sprintf(buf, "%d", (int)memory_size_mb);
|
|
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--memory " + string(buf) + " ";
|
|
|
|
retval = vbm_popen(command, output, "modifymem");
|
|
if (retval) return retval;
|
|
|
|
// Tweak the VM's CPU Count
|
|
//
|
|
vboxlog_msg("Setting CPU Count for VM. (%s)", vm_cpu_count.c_str());
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--cpus " + vm_cpu_count + " ";
|
|
|
|
retval = vbm_popen(command, output, "modifycpu");
|
|
if (retval) return retval;
|
|
|
|
// Tweak the VM's Chipset Options
|
|
//
|
|
vboxlog_msg("Setting Chipset Options for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--acpi on ";
|
|
command += "--ioapic on ";
|
|
|
|
retval = vbm_popen(command, output, "modifychipset");
|
|
if (retval) return retval;
|
|
|
|
// Tweak the VM's Boot Options
|
|
//
|
|
vboxlog_msg("Setting Boot Options for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
if (boot_iso) {
|
|
command += "--boot1 dvd ";
|
|
command += "--boot2 disk ";
|
|
} else {
|
|
command += "--boot1 disk ";
|
|
command += "--boot2 dvd ";
|
|
}
|
|
command += "--boot3 none ";
|
|
command += "--boot4 none ";
|
|
|
|
retval = vbm_popen(command, output, "modifyboot");
|
|
if (retval) return retval;
|
|
|
|
// Tweak the VM's Network Configuration
|
|
//
|
|
if (network_bridged_mode) {
|
|
vboxlog_msg("Setting Network Configuration for Bridged Mode.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--nic1 bridged ";
|
|
command += "--cableconnected1 off ";
|
|
|
|
retval = vbm_popen(command, output, "set bridged mode");
|
|
if (retval) return retval;
|
|
|
|
get_default_network_interface(default_interface);
|
|
|
|
vboxlog_msg("Setting Bridged Interface. (%s)", default_interface.c_str());
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--bridgeadapter1 \"";
|
|
command += default_interface;
|
|
command += "\" ";
|
|
|
|
retval = vbm_popen(command, output, "set bridged interface");
|
|
if (retval) return retval;
|
|
} else {
|
|
vboxlog_msg("Setting Network Configuration for NAT.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--nic1 nat ";
|
|
command += "--natdnsproxy1 on ";
|
|
command += "--cableconnected1 off ";
|
|
|
|
retval = vbm_popen(command, output, "set nat mode");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
if (enable_network) {
|
|
vboxlog_msg("Enabling VM Network Access.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--cableconnected1 on ";
|
|
retval = vbm_popen(command, output, "enable network");
|
|
if (retval) return retval;
|
|
} else {
|
|
vboxlog_msg("Disabling VM Network Access.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--cableconnected1 off ";
|
|
retval = vbm_popen(command, output, "disable network");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
// Tweak the VM's USB Configuration
|
|
//
|
|
vboxlog_msg("Disabling USB Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--usb off ";
|
|
|
|
vbm_popen(command, output, "modifyusb", false, false);
|
|
|
|
// Tweak the VM's COM Port Support
|
|
//
|
|
vboxlog_msg("Disabling COM Port Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--uart1 off ";
|
|
command += "--uart2 off ";
|
|
|
|
vbm_popen(command, output, "modifycom", false, false);
|
|
|
|
#ifndef __APPLE__
|
|
// Tweak the VM's LPT Port Support
|
|
//
|
|
vboxlog_msg("Disabling LPT Port Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--lpt1 off ";
|
|
command += "--lpt2 off ";
|
|
|
|
vbm_popen(command, output, "modifylpt", false, false);
|
|
#endif
|
|
|
|
// Tweak the VM's Audio Support
|
|
//
|
|
vboxlog_msg("Disabling Audio Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--audio none ";
|
|
|
|
vbm_popen(command, output, "modifyaudio", false, false);
|
|
|
|
// Tweak the VM's Clipboard Support
|
|
//
|
|
vboxlog_msg("Disabling Clipboard Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--clipboard disabled ";
|
|
|
|
vbm_popen(command, output, "modifyclipboard", false, false);
|
|
|
|
// Tweak the VM's Drag & Drop Support
|
|
//
|
|
vboxlog_msg("Disabling Drag and Drop Support for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--draganddrop disabled ";
|
|
|
|
vbm_popen(command, output, "modifydragdrop", false, false);
|
|
|
|
// Check to see if the processor supports hardware acceleration for virtualization
|
|
// If it doesn't, disable the use of it in VirtualBox. Multi-core jobs require hardware
|
|
// acceleration and actually override this setting.
|
|
//
|
|
if (!strstr(aid.host_info.p_features, "vmx") && !strstr(aid.host_info.p_features, "svm")) {
|
|
vboxlog_msg("Hardware acceleration CPU extensions not detected. Disabling VirtualBox hardware acceleration support.");
|
|
disable_acceleration = true;
|
|
}
|
|
if (strstr(aid.host_info.p_features, "hypervisor")) {
|
|
vboxlog_msg("Running under Hypervisor. Disabling VirtualBox hardware acceleration support.");
|
|
disable_acceleration = true;
|
|
}
|
|
|
|
if (is_boinc_client_version_newer(aid, 7, 2, 16)) {
|
|
if (aid.vm_extensions_disabled) {
|
|
vboxlog_msg("Hardware acceleration failed with previous execution. Disabling VirtualBox hardware acceleration support.");
|
|
disable_acceleration = true;
|
|
}
|
|
|
|
} else {
|
|
if (vm_cpu_count == "1") {
|
|
// Keep this around for older clients. Removing this for older clients might
|
|
// lead to a machine that will only return crashed VM reports.
|
|
vboxlog_msg("Legacy fallback configuration detected. Disabling VirtualBox hardware acceleration support.");
|
|
vboxlog_msg("NOTE: Upgrading to BOINC 7.2.16 or better may re-enable hardware acceleration.");
|
|
disable_acceleration = true;
|
|
}
|
|
}
|
|
|
|
// Only allow disabling of hardware acceleration on 32-bit VM types, 64-bit VM types require it.
|
|
//
|
|
if (os_name.find("_64") == std::string::npos) {
|
|
if (disable_acceleration) {
|
|
vboxlog_msg("Disabling hardware acceleration support for virtualization.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--hwvirtex off ";
|
|
|
|
retval = vbm_popen(command, output, "VT-x/AMD-V support");
|
|
if (retval) return retval;
|
|
}
|
|
} else if (os_name.find("_64") != std::string::npos) {
|
|
if (disable_acceleration) {
|
|
vboxlog_msg("ERROR: Invalid configuration. VM type requires acceleration but the current configuration cannot support it.");
|
|
return ERR_INVALID_PARAM;
|
|
}
|
|
}
|
|
|
|
// Add storage controller to VM
|
|
// See: http://www.virtualbox.org/manual/ch08.html#vboxmanage-storagectl
|
|
// See: http://www.virtualbox.org/manual/ch05.html#iocaching
|
|
//
|
|
vboxlog_msg("Adding storage controller(s) to VM.");
|
|
command = "storagectl \"" + vm_name + "\" ";
|
|
command += "--name \"Hard Disk Controller\" ";
|
|
command += "--add \"" + vm_disk_controller_type + "\" ";
|
|
command += "--controller \"" + vm_disk_controller_model + "\" ";
|
|
if (
|
|
(vm_disk_controller_type == "sata") || (vm_disk_controller_type == "SATA") ||
|
|
(vm_disk_controller_type == "scsi") || (vm_disk_controller_type == "SCSI") ||
|
|
(vm_disk_controller_type == "sas") || (vm_disk_controller_type == "SAS")
|
|
) {
|
|
command += "--hostiocache off ";
|
|
}
|
|
if ((vm_disk_controller_type == "sata") || (vm_disk_controller_type == "SATA")) {
|
|
if (is_virtualbox_version_newer(4, 3, 0)) {
|
|
command += "--portcount 3";
|
|
} else {
|
|
command += "--sataportcount 3";
|
|
}
|
|
}
|
|
|
|
retval = vbm_popen(command, output, "add storage controller (fixed disk)");
|
|
if (retval) return retval;
|
|
|
|
// Add storage controller for a floppy device if desired
|
|
//
|
|
if (enable_floppyio) {
|
|
command = "storagectl \"" + vm_name + "\" ";
|
|
command += "--name \"Floppy Controller\" ";
|
|
command += "--add floppy ";
|
|
|
|
retval = vbm_popen(command, output, "add storage controller (floppy)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
if (enable_isocontextualization) {
|
|
|
|
// Add virtual ISO 9660 disk drive to VM
|
|
//
|
|
vboxlog_msg("Adding virtual ISO 9660 disk drive to VM. (%s)", iso_image_filename.c_str());
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Hard Disk Controller\" ";
|
|
command += "--port 0 ";
|
|
command += "--device 0 ";
|
|
command += "--type dvddrive ";
|
|
command += "--medium \"" + virtual_machine_slot_directory + "/" + iso_image_filename + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (ISO 9660 image)");
|
|
if (retval) return retval;
|
|
|
|
// Add guest additions to the VM
|
|
//
|
|
if (virtualbox_guest_additions.size()) {
|
|
vboxlog_msg("Adding VirtualBox Guest Additions to VM.");
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Hard Disk Controller\" ";
|
|
command += "--port 2 ";
|
|
command += "--device 0 ";
|
|
command += "--type dvddrive ";
|
|
command += "--medium \"" + virtualbox_guest_additions + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (guest additions image)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
// Add a virtual cache disk drive to VM
|
|
//
|
|
if (enable_cache_disk){
|
|
vboxlog_msg("Adding virtual cache disk drive to VM. (%s)", cache_disk_filename.c_str());
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Hard Disk Controller\" ";
|
|
command += "--port 1 ";
|
|
command += "--device 0 ";
|
|
command += "--type hdd ";
|
|
command += "--setuuid \"\" ";
|
|
command += "--medium \"" + virtual_machine_slot_directory + "/" + cache_disk_filename + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (cached disk)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
} else {
|
|
|
|
// Adding virtual hard drive to VM
|
|
//
|
|
vboxlog_msg("Adding virtual disk drive to VM. (%s)", image_filename.c_str());
|
|
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Hard Disk Controller\" ";
|
|
command += "--port 0 ";
|
|
command += "--device 0 ";
|
|
command += "--type hdd ";
|
|
command += "--setuuid \"\" ";
|
|
command += "--medium \"" + virtual_machine_slot_directory + "/" + image_filename + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (fixed disk)");
|
|
if (retval) return retval;
|
|
|
|
// Add guest additions to the VM
|
|
//
|
|
if (virtualbox_guest_additions.size()) {
|
|
vboxlog_msg("Adding VirtualBox Guest Additions to VM.");
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Hard Disk Controller\" ";
|
|
command += "--port 1 ";
|
|
command += "--device 0 ";
|
|
command += "--type dvddrive ";
|
|
command += "--medium \"" + virtualbox_guest_additions + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (guest additions image)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
}
|
|
|
|
// Adding virtual floppy disk drive to VM
|
|
//
|
|
if (enable_floppyio) {
|
|
|
|
// Put in place the FloppyIO abstraction
|
|
//
|
|
// NOTE: This creates the floppy.img file at runtime for use by the VM.
|
|
//
|
|
pFloppy = new FloppyIONS::FloppyIO(floppy_image_filename.c_str());
|
|
if (!pFloppy->ready()) {
|
|
vboxlog_msg("Creating virtual floppy image failed.");
|
|
vboxlog_msg("Error Code '%d' Error Message '%s'", pFloppy->error, pFloppy->errorStr.c_str());
|
|
return ERR_FWRITE;
|
|
}
|
|
|
|
vboxlog_msg("Adding virtual floppy disk drive to VM.");
|
|
command = "storageattach \"" + vm_name + "\" ";
|
|
command += "--storagectl \"Floppy Controller\" ";
|
|
command += "--port 0 ";
|
|
command += "--device 0 ";
|
|
command += "--medium \"" + virtual_machine_slot_directory + "/" + floppy_image_filename + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "storage attach (floppy disk)");
|
|
if (retval) return retval;
|
|
|
|
}
|
|
|
|
// Add network bandwidth throttle group
|
|
//
|
|
if (is_virtualbox_version_newer(4, 2, 0)) {
|
|
vboxlog_msg("Adding network bandwidth throttle group to VM. (Defaulting to 1024GB)");
|
|
command = "bandwidthctl \"" + vm_name + "\" ";
|
|
command += "add \"" + vm_name + "_net\" ";
|
|
command += "--type network ";
|
|
command += "--limit 1024G";
|
|
command += " ";
|
|
|
|
retval = vbm_popen(command, output, "network throttle group (add)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
// Enable the network adapter if a network connection is required.
|
|
//
|
|
if (enable_network) {
|
|
// set up port forwarding
|
|
//
|
|
if (pf_guest_port) {
|
|
VBOX_PORT_FORWARD pf;
|
|
pf.guest_port = pf_guest_port;
|
|
pf.host_port = pf_host_port;
|
|
if (!pf_host_port) {
|
|
retval = boinc_get_port(false, pf.host_port);
|
|
if (retval) return retval;
|
|
pf_host_port = pf.host_port;
|
|
}
|
|
port_forwards.push_back(pf);
|
|
}
|
|
for (unsigned int i=0; i<port_forwards.size(); i++) {
|
|
VBOX_PORT_FORWARD& pf = port_forwards[i];
|
|
|
|
vboxlog_msg("forwarding host port %d to guest port %d", pf.host_port, pf.guest_port);
|
|
|
|
// Add new firewall rule
|
|
//
|
|
sprintf(buf, ",tcp,%s,%d,,%d",
|
|
pf.is_remote?"":"127.0.0.1",
|
|
pf.host_port, pf.guest_port
|
|
);
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--natpf1 \"" + string(buf) + "\" ";
|
|
|
|
retval = vbm_popen(command, output, "add updated port forwarding rule");
|
|
if (retval) return retval;
|
|
}
|
|
}
|
|
|
|
// If the VM wants to enable remote desktop for the VM do it here
|
|
//
|
|
if (enable_remotedesktop) {
|
|
vboxlog_msg("Enabling remote desktop for VM.");
|
|
if (!is_extpack_installed()) {
|
|
vboxlog_msg("Required extension pack not installed, remote desktop not enabled.");
|
|
} else {
|
|
retval = boinc_get_port(false, rd_host_port);
|
|
if (retval) return retval;
|
|
|
|
sprintf(buf, "%d", rd_host_port);
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--vrde on ";
|
|
command += "--vrdeextpack default ";
|
|
command += "--vrdeauthlibrary default ";
|
|
command += "--vrdeauthtype null ";
|
|
command += "--vrdeport " + string(buf) + " ";
|
|
|
|
retval = vbm_popen(command, output, "remote desktop");
|
|
if(retval) return retval;
|
|
}
|
|
}
|
|
|
|
// Enable the shared folder if a shared folder is specified.
|
|
//
|
|
if (enable_shared_directory) {
|
|
vboxlog_msg("Enabling shared directory for VM.");
|
|
command = "sharedfolder add \"" + vm_name + "\" ";
|
|
command += "--name \"shared\" ";
|
|
command += "--hostpath \"" + virtual_machine_slot_directory + "/shared\"";
|
|
|
|
retval = vbm_popen(command, output, "enable shared dir");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
// Enable the scratch folder if a scratch folder is specified.
|
|
//
|
|
if (enable_scratch_directory) {
|
|
vboxlog_msg("Enabling scratch shared directory for VM.");
|
|
command = "sharedfolder add \"" + vm_name + "\" ";
|
|
command += "--name \"scratch\" ";
|
|
command += "--hostpath \"" + virtualbox_scratch_directory + "\"";
|
|
|
|
retval = vbm_popen(command, output, "enable scratch shared dir");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::register_vm() {
|
|
string command;
|
|
string output;
|
|
string virtual_machine_slot_directory;
|
|
APP_INIT_DATA aid;
|
|
int retval;
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
get_slot_directory(virtual_machine_slot_directory);
|
|
|
|
|
|
vboxlog_msg("Register VM. (%s, slot#%d)", vm_master_name.c_str(), aid.slot);
|
|
|
|
|
|
// Reset VM name in case it was changed while deregistering a stale VM
|
|
//
|
|
vm_name = vm_master_name;
|
|
|
|
// Register the VM
|
|
//
|
|
command = "registervm ";
|
|
command += "\"" + virtual_machine_slot_directory + "/" + vm_name + "/" + vm_name + ".vbox\" ";
|
|
|
|
|
|
retval = vbm_popen(command, output, "register");
|
|
if (retval) return retval;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::deregister_vm(bool delete_media) {
|
|
string command;
|
|
string output;
|
|
string virtual_machine_slot_directory;
|
|
APP_INIT_DATA aid;
|
|
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
get_slot_directory(virtual_machine_slot_directory);
|
|
|
|
|
|
vboxlog_msg("Deregistering VM. (%s, slot#%d)", vm_name.c_str(), aid.slot);
|
|
|
|
|
|
// Cleanup any left-over snapshots
|
|
//
|
|
cleanup_snapshots(true);
|
|
|
|
// Delete network bandwidth throttle group
|
|
//
|
|
if (is_virtualbox_version_newer(4, 2, 0)) {
|
|
vboxlog_msg("Removing network bandwidth throttle group from VM.");
|
|
command = "bandwidthctl \"" + vm_name + "\" ";
|
|
command += "remove \"" + vm_name + "_net\" ";
|
|
|
|
vbm_popen(command, output, "network throttle group (remove)", false, false);
|
|
}
|
|
|
|
if (enable_floppyio) {
|
|
command = "storagectl \"" + vm_name + "\" ";
|
|
command += "--name \"Floppy Controller\" ";
|
|
command += "--remove ";
|
|
|
|
vbm_popen(command, output, "deregister storage controller (floppy disk)", false, false);
|
|
}
|
|
|
|
|
|
// Next, delete VM
|
|
//
|
|
vboxlog_msg("Removing VM from VirtualBox.");
|
|
command = "unregistervm \"" + vm_name + "\" ";
|
|
command += "--delete ";
|
|
|
|
vbm_popen(command, output, "delete VM", false, false);
|
|
|
|
// Lastly delete medium(s) from Virtual Box Media Registry
|
|
//
|
|
if (enable_isocontextualization) {
|
|
vboxlog_msg("Removing virtual ISO 9660 disk from VirtualBox.");
|
|
command = "closemedium dvd \"" + virtual_machine_slot_directory + "/" + iso_image_filename + "\" ";
|
|
if (delete_media) {
|
|
command += "--delete ";
|
|
}
|
|
vbm_popen(command, output, "remove virtual ISO 9660 disk", false, false);
|
|
|
|
if (enable_cache_disk) {
|
|
vboxlog_msg("Removing virtual cache disk from VirtualBox.");
|
|
command = "closemedium disk \"" + virtual_machine_slot_directory + "/" + cache_disk_filename + "\" ";
|
|
if (delete_media) {
|
|
command += "--delete ";
|
|
}
|
|
|
|
vbm_popen(command, output, "remove virtual cache disk", false, false);
|
|
}
|
|
}
|
|
|
|
if (enable_floppyio) {
|
|
vboxlog_msg("Removing virtual floppy disk from VirtualBox.");
|
|
command = "closemedium floppy \"" + virtual_machine_slot_directory + "/" + floppy_image_filename + "\" ";
|
|
if (delete_media) {
|
|
command += "--delete ";
|
|
}
|
|
|
|
vbm_popen(command, output, "remove virtual floppy disk", false, false);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::deregister_stale_vm() {
|
|
string command;
|
|
string output;
|
|
string virtual_machine_slot_directory;
|
|
size_t uuid_start;
|
|
size_t uuid_end;
|
|
int retval;
|
|
|
|
get_slot_directory(virtual_machine_slot_directory);
|
|
|
|
// Output from showhdinfo should look a little like this:
|
|
// UUID: c119acaf-636c-41f6-86c9-38e639a31339
|
|
// Accessible: yes
|
|
// Logical size: 10240 MBytes
|
|
// Current size on disk: 0 MBytes
|
|
// Type: normal (base)
|
|
// Storage format: VDI
|
|
// Format variant: dynamic default
|
|
// In use by VMs: test2 (UUID: 000ab2be-1254-4c6a-9fdc-1536a478f601)
|
|
// Location: C:\Users\romw\VirtualBox VMs\test2\test2.vdi
|
|
//
|
|
if (enable_isocontextualization) {
|
|
command = "showhdinfo \"" + virtual_machine_slot_directory + "/" + cache_disk_filename + "\" ";
|
|
retval = vbm_popen(command, output, "get HDD info");
|
|
if (retval) return retval;
|
|
|
|
uuid_start = output.find("(UUID: ");
|
|
if (uuid_start != string::npos) {
|
|
// We can parse the virtual machine ID from the output
|
|
uuid_start += 7;
|
|
uuid_end = output.find(")", uuid_start);
|
|
vm_name = output.substr(uuid_start, uuid_end - uuid_start);
|
|
|
|
// Deregister stale VM by UUID
|
|
return deregister_vm(false);
|
|
} else {
|
|
command = "closemedium dvd \"" + virtual_machine_slot_directory + "/" + iso_image_filename + "\" ";
|
|
// coverity[CHECKED_RETURN]
|
|
vbm_popen(command, output, "remove virtual ISO 9660 disk", false);
|
|
if (enable_cache_disk) {
|
|
command = "closemedium disk \"" + virtual_machine_slot_directory + "/" + cache_disk_filename + "\" ";
|
|
// coverity[CHECKED_RETURN]
|
|
vbm_popen(command, output, "remove virtual cache disk", false);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
command = "showhdinfo \"" + virtual_machine_slot_directory + "/" + image_filename + "\" ";
|
|
retval = vbm_popen(command, output, "get HDD info");
|
|
if (retval) return retval;
|
|
|
|
uuid_start = output.find("(UUID: ");
|
|
if (uuid_start != string::npos) {
|
|
// We can parse the virtual machine ID from the output
|
|
uuid_start += 7;
|
|
uuid_end = output.find(")", uuid_start);
|
|
vm_name = output.substr(uuid_start, uuid_end - uuid_start);
|
|
|
|
// Deregister stale VM by UUID
|
|
return deregister_vm(false);
|
|
} else {
|
|
// Did the user delete the VM in VirtualBox and not the medium? If so,
|
|
// just remove the medium.
|
|
command = "closemedium disk \"" + virtual_machine_slot_directory + "/" + image_filename + "\" ";
|
|
vbm_popen(command, output, "remove virtual disk", false, false);
|
|
if (enable_floppyio) {
|
|
command = "closemedium floppy \"" + virtual_machine_slot_directory + "/" + floppy_image_filename + "\" ";
|
|
vbm_popen(command, output, "remove virtual floppy disk", false, false);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::poll(bool log_state) {
|
|
int retval = ERR_EXEC;
|
|
APP_INIT_DATA aid;
|
|
string command;
|
|
string output;
|
|
string::iterator iter;
|
|
string vmstate;
|
|
static string vmstate_old = "poweredoff";
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
|
|
//
|
|
// Is our environment still sane?
|
|
//
|
|
#ifdef _WIN32
|
|
if (aid.using_sandbox && vboxsvc_pid_handle && !process_exists(vboxsvc_pid_handle)) {
|
|
vboxlog_msg("Status Report: vboxsvc.exe is no longer running.");
|
|
}
|
|
if (started_successfully && vm_pid_handle && !process_exists(vm_pid_handle)) {
|
|
vboxlog_msg("Status Report: virtualbox.exe/vboxheadless.exe is no longer running.");
|
|
}
|
|
#else
|
|
if (started_successfully && vm_pid && !process_exists(vm_pid)) {
|
|
vboxlog_msg("Status Report: virtualbox/vboxheadless is no longer running.");
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// What state is the VM in?
|
|
//
|
|
vmstate = read_vm_log();
|
|
if (vmstate != "Error in parsing the log file") {
|
|
|
|
// VirtualBox Documentation suggests that that a VM is running when its
|
|
// machine state is between MachineState_FirstOnline and MachineState_LastOnline
|
|
// which as of this writing is 5 and 17.
|
|
//
|
|
// VboxManage's source shows more than that though:
|
|
// see: http://www.virtualbox.org/browser/trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp
|
|
//
|
|
// So for now, go with what VboxManage is reporting.
|
|
//
|
|
if (vmstate == "running") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "paused") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = true;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "starting") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "stopping") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "saving") {
|
|
online = true;
|
|
saving = true;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "restoring") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = true;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "livesnapshotting") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "deletingsnapshotonline" || vmstate == "deletingsnapshotlive") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "deletingsnapshotpaused" || vmstate == "deletingsnapshotlivepaused") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "aborted") {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = true;
|
|
}
|
|
else if (vmstate == "gurumeditation") {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = true;
|
|
}
|
|
else {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
if (log_state) {
|
|
vboxlog_msg("VM is no longer is a running state. It is in '%s'.", vmstate.c_str());
|
|
}
|
|
}
|
|
if (log_state && (vmstate_old != vmstate)) {
|
|
vboxlog_msg("VM state change detected. (old = '%s', new = '%s')", vmstate_old.c_str(), vmstate.c_str());
|
|
vmstate_old = vmstate;
|
|
}
|
|
|
|
retval = BOINC_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
vboxlog_msg("Error in parsing the log file");
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::poll2(bool log_state) {
|
|
int retval = ERR_EXEC;
|
|
APP_INIT_DATA aid;
|
|
string command;
|
|
string output;
|
|
string::iterator iter;
|
|
string vmstate;
|
|
static string vmstate_old = "poweroff";
|
|
size_t vmstate_start;
|
|
size_t vmstate_end;
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
|
|
//
|
|
// Is our environment still sane?
|
|
//
|
|
#ifdef _WIN32
|
|
if (aid.using_sandbox && vboxsvc_pid_handle && !process_exists(vboxsvc_pid_handle)) {
|
|
vboxlog_msg("Status Report: vboxsvc.exe is no longer running.");
|
|
}
|
|
if (started_successfully && vm_pid_handle && !process_exists(vm_pid_handle)) {
|
|
vboxlog_msg("Status Report: virtualbox.exe/vboxheadless.exe is no longer running.");
|
|
}
|
|
#else
|
|
if (started_successfully && vm_pid && !process_exists(vm_pid)) {
|
|
vboxlog_msg("Status Report: virtualbox/vboxheadless is no longer running.");
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// What state is the VM in?
|
|
//
|
|
|
|
command = "showvminfo \"" + vm_name + "\" ";
|
|
command += "--machinereadable ";
|
|
|
|
if (vbm_popen(command, output, "VM state", false, false, 45, false) == 0) {
|
|
vmstate_start = output.find("VMState=\"");
|
|
if (vmstate_start != string::npos) {
|
|
vmstate_start += 9;
|
|
vmstate_end = output.find("\"", vmstate_start);
|
|
vmstate = output.substr(vmstate_start, vmstate_end - vmstate_start);
|
|
|
|
// VirtualBox Documentation suggests that that a VM is running when its
|
|
// machine state is between MachineState_FirstOnline and MachineState_LastOnline
|
|
// which as of this writing is 5 and 17.
|
|
//
|
|
// VboxManage's source shows more than that though:
|
|
// see: http://www.virtualbox.org/browser/trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp
|
|
//
|
|
// So for now, go with what VboxManage is reporting.
|
|
//
|
|
if (vmstate == "running") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "paused") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = true;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "starting") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "stopping") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "saving") {
|
|
online = true;
|
|
saving = true;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "restoring") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = true;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "livesnapshotting") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "deletingsnapshotlive") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "deletingsnapshotlivepaused") {
|
|
online = true;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
}
|
|
else if (vmstate == "aborted") {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = true;
|
|
}
|
|
else if (vmstate == "gurumeditation") {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = true;
|
|
}
|
|
else {
|
|
online = false;
|
|
saving = false;
|
|
restoring = false;
|
|
suspended = false;
|
|
crashed = false;
|
|
if (log_state) {
|
|
vboxlog_msg("VM is no longer is a running state. It is in '%s'.",
|
|
vmstate.c_str());
|
|
}
|
|
}
|
|
if (log_state && (vmstate_old != vmstate)) {
|
|
vboxlog_msg("VM state change detected. (old = '%s', new = '%s')",
|
|
vmstate_old.c_str(), vmstate.c_str());
|
|
vmstate_old = vmstate;
|
|
}
|
|
|
|
retval = BOINC_SUCCESS;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Grab a snapshot of the latest log file. Avoids multiple queries across several
|
|
// functions.
|
|
//
|
|
get_vm_log(vm_log);
|
|
|
|
//
|
|
// Dump any new VM Guest Log entries
|
|
//
|
|
dump_vmguestlog_entries();
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::start() {
|
|
int retval;
|
|
APP_INIT_DATA aid;
|
|
string command;
|
|
string output;
|
|
int timeout = 0;
|
|
|
|
boinc_get_init_data_p(&aid);
|
|
|
|
|
|
log_pointer = 0;
|
|
vboxlog_msg("Starting VM using VBoxManage interface. (%s, slot#%d)", vm_name.c_str(), aid.slot);
|
|
|
|
command = "startvm \"" + vm_name + "\"";
|
|
if (headless) {
|
|
command += " --type headless";
|
|
}
|
|
retval = vbm_popen(command, output, "start VM", true, false, 0);
|
|
|
|
// Get the VM pid as soon as possible
|
|
while (!retval) {
|
|
boinc_sleep(1.0);
|
|
timeout += 1;
|
|
|
|
get_vm_process_id();
|
|
|
|
if (vm_pid) break;
|
|
|
|
if (timeout > 45) {
|
|
retval = ERR_TIMEOUT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (BOINC_SUCCESS == retval) {
|
|
vboxlog_msg("Successfully started VM. (PID = '%d')", vm_pid);
|
|
started_successfully = true;
|
|
} else {
|
|
vboxlog_msg("VM failed to start.");
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::stop() {
|
|
string command;
|
|
string output;
|
|
double timeout;
|
|
int retval = 0;
|
|
|
|
vboxlog_msg("Stopping VM.");
|
|
if (online) {
|
|
command = "controlvm \"" + vm_name + "\" savestate";
|
|
retval = vbm_popen(command, output, "stop VM", true, false);
|
|
|
|
// Wait for up to 5 minutes for the VM to switch states. A system
|
|
// under load can take a while. Since the poll function can wait for up
|
|
// to 45 seconds to execute a command we need to make this time based instead
|
|
// of iteration based.
|
|
if (!retval) {
|
|
timeout = dtime() + 300;
|
|
do {
|
|
poll(false);
|
|
if (!online && !saving) break;
|
|
boinc_sleep(1.0);
|
|
} while (timeout >= dtime());
|
|
}
|
|
|
|
if (!online) {
|
|
vboxlog_msg("Successfully stopped VM.");
|
|
retval = BOINC_SUCCESS;
|
|
} else {
|
|
vboxlog_msg("VM did not stop when requested.");
|
|
|
|
// Attempt to terminate the VM
|
|
retval = kill_program(vm_pid);
|
|
if (retval) {
|
|
vboxlog_msg("VM was NOT successfully terminated.");
|
|
} else {
|
|
vboxlog_msg("VM was successfully terminated.");
|
|
}
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::poweroff() {
|
|
string command;
|
|
string output;
|
|
double timeout;
|
|
int retval = 0;
|
|
|
|
vboxlog_msg("Powering off VM.");
|
|
if (online) {
|
|
command = "controlvm \"" + vm_name + "\" poweroff";
|
|
retval = vbm_popen(command, output, "poweroff VM", true, false);
|
|
|
|
// Wait for up to 5 minutes for the VM to switch states. A system
|
|
// under load can take a while. Since the poll function can wait for up
|
|
// to 45 seconds to execute a command we need to make this time based instead
|
|
// of iteration based.
|
|
if (!retval) {
|
|
timeout = dtime() + 300;
|
|
do {
|
|
poll(false);
|
|
if (!online && !saving) break;
|
|
boinc_sleep(1.0);
|
|
} while (timeout >= dtime());
|
|
}
|
|
|
|
if (!online) {
|
|
vboxlog_msg("Successfully stopped VM.");
|
|
retval = BOINC_SUCCESS;
|
|
} else {
|
|
vboxlog_msg("VM did not power off when requested.");
|
|
|
|
// Attempt to terminate the VM
|
|
retval = kill_program(vm_pid);
|
|
if (retval) {
|
|
vboxlog_msg("VM was NOT successfully terminated.");
|
|
} else {
|
|
vboxlog_msg("VM was successfully terminated.");
|
|
}
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::pause() {
|
|
string command;
|
|
string output;
|
|
int retval;
|
|
|
|
// Restore the process priority back to the default process priority
|
|
// to speed up the last minute maintenance tasks before the VirtualBox
|
|
// VM goes to sleep
|
|
//
|
|
reset_vm_process_priority();
|
|
|
|
command = "controlvm \"" + vm_name + "\" pause";
|
|
retval = vbm_popen(command, output, "pause VM");
|
|
if (retval) return retval;
|
|
suspended = true;
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::resume() {
|
|
string command;
|
|
string output;
|
|
int retval;
|
|
|
|
// Set the process priority back to the lowest level before resuming
|
|
// execution
|
|
//
|
|
lower_vm_process_priority();
|
|
|
|
command = "controlvm \"" + vm_name + "\" resume";
|
|
retval = vbm_popen(command, output, "resume VM");
|
|
if (retval) return retval;
|
|
suspended = false;
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::capture_screenshot() {
|
|
if (enable_screenshots_on_error) {
|
|
if (is_virtualbox_version_newer(5, 0, 0)) {
|
|
|
|
string command;
|
|
string output;
|
|
string virtual_machine_slot_directory;
|
|
int retval = BOINC_SUCCESS;
|
|
|
|
get_slot_directory(virtual_machine_slot_directory);
|
|
|
|
vboxlog_msg("Capturing screenshot.");
|
|
|
|
command = "controlvm \"" + vm_name + "\" ";
|
|
command += "keyboardputscancode 39";
|
|
vbm_popen(command, output, "put scancode", true, true, 0);
|
|
boinc_sleep(1);
|
|
|
|
command = "controlvm \"" + vm_name + "\" ";
|
|
command += "screenshotpng \"";
|
|
command += virtual_machine_slot_directory;
|
|
command += "/";
|
|
command += SCREENSHOT_FILENAME;
|
|
command += "\"";
|
|
retval = vbm_popen(command, output, "capture screenshot", true, true, 0);
|
|
if (retval) return retval;
|
|
|
|
vboxlog_msg("Screenshot completed.");
|
|
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::create_snapshot(double elapsed_time) {
|
|
string command;
|
|
string output;
|
|
char buf[256];
|
|
int retval = BOINC_SUCCESS;
|
|
|
|
if (disable_automatic_checkpoints) return BOINC_SUCCESS;
|
|
|
|
vboxlog_msg("Creating new snapshot for VM.");
|
|
|
|
// Pause VM - Try and avoid the live snapshot and trigger an online
|
|
// snapshot instead.
|
|
pause();
|
|
|
|
// Create new snapshot
|
|
sprintf(buf, "%d", (int)elapsed_time);
|
|
command = "snapshot \"" + vm_name + "\" ";
|
|
command += "take boinc_";
|
|
command += buf;
|
|
retval = vbm_popen(command, output, "create new snapshot", true, true, 0);
|
|
if (retval) return retval;
|
|
|
|
// Resume VM
|
|
resume();
|
|
|
|
// Set the suspended flag back to false before deleting the stale
|
|
// snapshot
|
|
poll(false);
|
|
|
|
// Delete stale snapshot(s), if one exists
|
|
cleanup_snapshots(false);
|
|
|
|
vboxlog_msg("Checkpoint completed.");
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::cleanup_snapshots(bool delete_active) {
|
|
string command;
|
|
string output;
|
|
string snapshotlist;
|
|
string line;
|
|
string uuid;
|
|
size_t eol_pos;
|
|
size_t eol_prev_pos;
|
|
size_t uuid_start;
|
|
size_t uuid_end;
|
|
int retval;
|
|
|
|
|
|
// Enumerate snapshot(s)
|
|
command = "snapshot \"" + vm_name + "\" ";
|
|
command += "list ";
|
|
|
|
// Only log the error if we are not attempting to deregister the VM.
|
|
// delete_active is only set to true when we are deregistering the VM.
|
|
retval = vbm_popen(command, snapshotlist, "enumerate snapshot(s)", !delete_active, false, 0);
|
|
if (retval) return retval;
|
|
|
|
// Output should look a little like this:
|
|
// Name: Snapshot 2 (UUID: 1751e9a6-49e7-4dcc-ab23-08428b665ddf)
|
|
// Name: Snapshot 3 (UUID: 92fa8b35-873a-4197-9d54-7b6b746b2c58)
|
|
// Name: Snapshot 4 (UUID: c049023a-5132-45d5-987d-a9cfadb09664) *
|
|
//
|
|
// Traverse the list from newest to oldest. Otherwise we end up with an error:
|
|
// VBoxManage.exe: error: Snapshot operation failed
|
|
// VBoxManage.exe: error: Hard disk 'C:\ProgramData\BOINC\slots\23\vm_image.vdi' has
|
|
// more than one child hard disk (2)
|
|
//
|
|
|
|
// Prepend a space and line feed to the output since we are going to traverse it backwards
|
|
snapshotlist = " \n" + snapshotlist;
|
|
|
|
eol_prev_pos = snapshotlist.rfind("\n");
|
|
eol_pos = snapshotlist.rfind("\n", eol_prev_pos - 1);
|
|
while (eol_pos != string::npos) {
|
|
line = snapshotlist.substr(eol_pos, eol_prev_pos - eol_pos);
|
|
|
|
|
|
// Find the previous line to use in the next iteration
|
|
eol_prev_pos = eol_pos;
|
|
eol_pos = snapshotlist.rfind("\n", eol_prev_pos - 1);
|
|
|
|
// This VM does not yet have any snapshots
|
|
if (line.find("does not have any snapshots") != string::npos) break;
|
|
|
|
// The * signifies that it is the active snapshot and one we do not want to delete
|
|
if (!delete_active && (line.rfind("*") != string::npos)) continue;
|
|
|
|
uuid_start = line.find("(UUID: ");
|
|
if (uuid_start != string::npos) {
|
|
// We can parse the virtual machine ID from the line
|
|
uuid_start += 7;
|
|
uuid_end = line.find(")", uuid_start);
|
|
uuid = line.substr(uuid_start, uuid_end - uuid_start);
|
|
|
|
vboxlog_msg("Deleting stale snapshot.");
|
|
|
|
// Delete stale snapshot, if one exists
|
|
command = "snapshot \"" + vm_name + "\" ";
|
|
command += "delete \"";
|
|
command += uuid;
|
|
command += "\" ";
|
|
|
|
// Only log the error if we are not attempting to deregister the VM.
|
|
// delete_active is only set to true when we are deregistering the VM.
|
|
retval = vbm_popen(command, output, "delete stale snapshot", !delete_active, false, 0);
|
|
if (retval) return retval;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::restore_snapshot() {
|
|
string command;
|
|
string output;
|
|
int retval = BOINC_SUCCESS;
|
|
|
|
if (disable_automatic_checkpoints) return BOINC_SUCCESS;
|
|
|
|
vboxlog_msg("Restore from previously saved snapshot.");
|
|
|
|
command = "snapshot \"" + vm_name + "\" ";
|
|
command += "restorecurrent ";
|
|
retval = vbm_popen(command, output, "restore current snapshot", true, false, 0);
|
|
if (retval) return retval;
|
|
|
|
vboxlog_msg("Restore completed.");
|
|
|
|
return retval;
|
|
}
|
|
|
|
void VBOX_VM::dump_hypervisor_status_reports() {
|
|
}
|
|
|
|
int VBOX_VM::is_registered() {
|
|
string command;
|
|
string output;
|
|
string needle;
|
|
int retval;
|
|
|
|
command = "showvminfo \"" + vm_master_name + "\" ";
|
|
command += "--machinereadable ";
|
|
|
|
// Look for this string in the output
|
|
//
|
|
needle = "name=\"" + vm_master_name + "\"";
|
|
|
|
retval = vbm_popen(command, output, "registration detection", false, false);
|
|
|
|
// Handle explicit cases first
|
|
if (ERR_TIMEOUT == retval) {
|
|
return ERR_TIMEOUT;
|
|
}
|
|
if (output.find("VBOX_E_OBJECT_NOT_FOUND") != string::npos) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
if (!retval && output.find(needle.c_str()) != string::npos) {
|
|
return BOINC_SUCCESS;
|
|
}
|
|
|
|
// Something unexpected has happened. Dump diagnostic output.
|
|
vboxlog_msg(
|
|
"Error in registration for VM: %d\nArguments:\n%s\nOutput:\n%s",
|
|
retval,
|
|
command.c_str(),
|
|
output.c_str()
|
|
);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
// Attempt to detect any condition that would prevent VirtualBox from running a VM properly, like:
|
|
// 1. The DCOM service not being started on Windows
|
|
// 2. Vboxmanage not being able to communicate with vboxsvc for some reason
|
|
// 3. VirtualBox driver not loaded for the current Linux kernel.
|
|
//
|
|
// Luckly both of the above conditions can be detected by attempting to detect the host information
|
|
// via vboxmanage and it is cross platform.
|
|
//
|
|
bool VBOX_VM::is_system_ready(std::string& message) {
|
|
string command;
|
|
string output;
|
|
int retval;
|
|
bool rc = false;
|
|
|
|
command = "list hostinfo ";
|
|
retval = vbm_popen(command, output, "host info");
|
|
if (BOINC_SUCCESS == retval) {
|
|
rc = true;
|
|
}
|
|
|
|
if (output.size() == 0) {
|
|
vboxlog_msg("WARNING: Communication with VM Hypervisor failed. (Possibly Out of Memory).");
|
|
message = "Communication with VM Hypervisor failed. (Possibly Out of Memory).";
|
|
rc = false;
|
|
}
|
|
|
|
if (output.find("Processor count:") == string::npos) {
|
|
vboxlog_msg("WARNING: Communication with VM Hypervisor failed.");
|
|
message = "Communication with VM Hypervisor failed.";
|
|
rc = false;
|
|
}
|
|
|
|
if (
|
|
(output.find("WARNING: The vboxdrv kernel module is not loaded.") != string::npos) ||
|
|
(output.find("WARNING: The VirtualBox kernel modules are not loaded.") != string::npos)
|
|
){
|
|
vboxlog_msg("WARNING: The VirtualBox kernel modules are not loaded.");
|
|
vboxlog_msg("WARNING: Please update/recompile VirtualBox kernel drivers.");
|
|
message = "Please update/recompile VirtualBox kernel drivers.";
|
|
rc = false;
|
|
}
|
|
|
|
if (
|
|
(output.find("Warning: program compiled against ") != string::npos) &&
|
|
(output.find(" using older ") != string::npos)
|
|
){
|
|
vboxlog_msg("WARNING: VirtualBox incompatible dependencies detected.");
|
|
message = "Please update/reinstall VirtualBox";
|
|
rc = false;
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
bool VBOX_VM::is_disk_image_registered() {
|
|
string command;
|
|
string output;
|
|
string virtual_machine_root_dir;
|
|
|
|
get_slot_directory(virtual_machine_root_dir);
|
|
|
|
command = "showhdinfo \"" + virtual_machine_root_dir + "/" + image_filename + "\" ";
|
|
if (vbm_popen(command, output, "hdd registration", false, false) == 0) {
|
|
|
|
if ((output.find("VBOX_E_FILE_ERROR") == string::npos) &&
|
|
|
|
(output.find("VBOX_E_OBJECT_NOT_FOUND") == string::npos) &&
|
|
(output.find("does not match the value") == string::npos)
|
|
) {
|
|
// Error message not found in text
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (enable_isocontextualization && enable_cache_disk) {
|
|
command = "showhdinfo \"" + virtual_machine_root_dir + "/" + cache_disk_filename + "\" ";
|
|
if (vbm_popen(command, output, "hdd registration", false, false) == 0) {
|
|
if ((output.find("VBOX_E_FILE_ERROR") == string::npos) &&
|
|
(output.find("VBOX_E_OBJECT_NOT_FOUND") == string::npos) &&
|
|
(output.find("does not match the value") == string::npos)
|
|
) {
|
|
// Error message not found in text
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool VBOX_VM::is_extpack_installed() {
|
|
string command;
|
|
string output;
|
|
|
|
command = "list extpacks";
|
|
|
|
if (vbm_popen(command, output, "extpack detection", false, false) == 0) {
|
|
if ((output.find("Oracle VM VirtualBox Extension Pack") != string::npos) && (output.find("VBoxVRDP") != string::npos)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int VBOX_VM::get_install_directory(string& install_directory) {
|
|
#ifdef _WIN32
|
|
|
|
LONG lReturnValue;
|
|
HKEY hkSetupHive;
|
|
LPTSTR lpszRegistryValue = NULL;
|
|
DWORD dwSize = 0;
|
|
|
|
// change the current directory to the boinc data directory if it exists
|
|
lReturnValue = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
_T("SOFTWARE\\Oracle\\VirtualBox"),
|
|
0,
|
|
KEY_READ,
|
|
&hkSetupHive
|
|
);
|
|
if (lReturnValue == ERROR_SUCCESS) {
|
|
// How large does our buffer need to be?
|
|
lReturnValue = RegQueryValueEx(
|
|
hkSetupHive,
|
|
_T("InstallDir"),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwSize
|
|
);
|
|
if (lReturnValue != ERROR_FILE_NOT_FOUND) {
|
|
// Allocate the buffer space.
|
|
lpszRegistryValue = (LPTSTR) malloc(dwSize);
|
|
(*lpszRegistryValue) = NULL;
|
|
|
|
// Now get the data
|
|
lReturnValue = RegQueryValueEx(
|
|
hkSetupHive,
|
|
_T("InstallDir"),
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)lpszRegistryValue,
|
|
&dwSize
|
|
);
|
|
|
|
install_directory = lpszRegistryValue;
|
|
}
|
|
|
|
}
|
|
|
|
if (hkSetupHive) RegCloseKey(hkSetupHive);
|
|
if (lpszRegistryValue) free(lpszRegistryValue);
|
|
if (install_directory.empty()) {
|
|
return ERR_FREAD;
|
|
}
|
|
return BOINC_SUCCESS;
|
|
#else
|
|
install_directory = "";
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int VBOX_VM::get_version_information(std::string& version_raw, std::string& version_display) {
|
|
string command;
|
|
string output;
|
|
int vbox_major = 0, vbox_minor = 0, vbox_release = 0;
|
|
int retval;
|
|
char buf[256];
|
|
|
|
// Record the VirtualBox version information for later use.
|
|
command = "--version ";
|
|
retval = vbm_popen(command, output, "version check");
|
|
|
|
if (!retval) {
|
|
// Remove \r or \n from the output spew
|
|
string::iterator iter = output.begin();
|
|
while (iter != output.end()) {
|
|
if (*iter == '\r' || *iter == '\n') {
|
|
iter = output.erase(iter);
|
|
} else {
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
if (3 == sscanf(output.c_str(), "%d.%d.%d", &vbox_major, &vbox_minor, &vbox_release)) {
|
|
snprintf(
|
|
buf, sizeof(buf),
|
|
"%d.%d.%d",
|
|
vbox_major, vbox_minor, vbox_release
|
|
);
|
|
version_raw = buf;
|
|
snprintf(
|
|
buf, sizeof(buf),
|
|
"VirtualBox VboxManage Interface (Version: %d.%d.%d)",
|
|
vbox_major, vbox_minor, vbox_release
|
|
);
|
|
version_display = buf;
|
|
} else {
|
|
version_raw = "Unknown";
|
|
version_display = "VirtualBox VboxManage Interface (Version: Unknown)";
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::get_guest_additions(string& guest_additions) {
|
|
string command;
|
|
string output;
|
|
size_t ga_start;
|
|
size_t ga_end;
|
|
int retval;
|
|
|
|
// Get the location of where the guest additions are
|
|
command = "list systemproperties";
|
|
retval = vbm_popen(command, output, "guest additions");
|
|
|
|
// Output should look like this:
|
|
// API version: 4_3
|
|
// Minimum guest RAM size: 4 Megabytes
|
|
// Maximum guest RAM size: 2097152 Megabytes
|
|
// Minimum video RAM size: 1 Megabytes
|
|
// Maximum video RAM size: 256 Megabytes
|
|
// ...
|
|
// Default Guest Additions ISO: C:\Program Files\Oracle\VirtualBox/VBoxGuestAdditions.iso
|
|
//
|
|
|
|
ga_start = output.find("Default Guest Additions ISO:");
|
|
if (ga_start == string::npos) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
ga_start += strlen("Default Guest Additions ISO:");
|
|
ga_end = output.find("\n", ga_start);
|
|
guest_additions = output.substr(ga_start, ga_end - ga_start);
|
|
strip_whitespace(guest_additions);
|
|
|
|
if (guest_additions.size() <= 0) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
|
|
if (!boinc_file_exists(guest_additions.c_str())) {
|
|
guest_additions.clear();
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::get_default_network_interface(string& iface) {
|
|
string command;
|
|
string output;
|
|
size_t if_start;
|
|
size_t if_end;
|
|
int retval;
|
|
|
|
// Get the location of where the guest additions are
|
|
command = "list bridgedifs";
|
|
retval = vbm_popen(command, output, "default interface");
|
|
|
|
// Output should look like this:
|
|
// Name: Intel(R) Ethernet Connection I217-V
|
|
// GUID: 4b8796d6-a4ed-4752-8e8e-bf23984fd93c
|
|
// DHCP: Enabled
|
|
// IPAddress: 192.168.1.19
|
|
// NetworkMask: 255.255.255.0
|
|
// IPV6Address: fe80:0000:0000:0000:31c2:0053:4f50:4e64
|
|
// IPV6NetworkMaskPrefixLength: 64
|
|
// HardwareAddress: bc:5f:f4:ba:cc:16
|
|
// MediumType: Ethernet
|
|
// Status: Up
|
|
// VBoxNetworkName: HostInterfaceNetworking-Intel(R) Ethernet Connection I217-V
|
|
|
|
if_start = output.find("Name:");
|
|
if (if_start == string::npos) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
if_start += strlen("Name:");
|
|
if_end = output.find("\n", if_start);
|
|
iface = output.substr(if_start, if_end - if_start);
|
|
strip_whitespace(iface);
|
|
if (iface.size() <= 0) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::get_vm_network_bytes_sent(double& sent) {
|
|
string command;
|
|
string output;
|
|
string counter_value;
|
|
size_t counter_start;
|
|
size_t counter_end;
|
|
int retval;
|
|
|
|
command = "debugvm \"" + vm_name + "\" ";
|
|
command += "statistics --pattern \"/Devices/*/TransmitBytes\" ";
|
|
|
|
retval = vbm_popen(command, output, "get bytes sent");
|
|
if (retval) return retval;
|
|
|
|
// Output should look like this:
|
|
// <?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
|
// <Statistics>
|
|
// <Counter c="397229" unit="bytes" name="/Devices/PCNet0/TransmitBytes"/>
|
|
// <Counter c="256" unit="bytes" name="/Devices/PCNet1/TransmitBytes"/>
|
|
// </Statistics>
|
|
|
|
// add up the counter(s)
|
|
//
|
|
sent = 0;
|
|
counter_start = output.find("c=\"");
|
|
while (counter_start != string::npos) {
|
|
counter_start += 3;
|
|
counter_end = output.find("\"", counter_start);
|
|
counter_value = output.substr(counter_start, counter_end - counter_start);
|
|
sent += atof(counter_value.c_str());
|
|
counter_start = output.find("c=\"", counter_start);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::get_vm_network_bytes_received(double& received) {
|
|
string command;
|
|
string output;
|
|
string counter_value;
|
|
size_t counter_start;
|
|
size_t counter_end;
|
|
int retval;
|
|
|
|
command = "debugvm \"" + vm_name + "\" ";
|
|
command += "statistics --pattern \"/Devices/*/ReceiveBytes\" ";
|
|
|
|
retval = vbm_popen(command, output, "get bytes received");
|
|
if (retval) return retval;
|
|
|
|
// Output should look like this:
|
|
// <?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
|
// <Statistics>
|
|
// <Counter c="9423150" unit="bytes" name="/Devices/PCNet0/ReceiveBytes"/>
|
|
// <Counter c="256" unit="bytes" name="/Devices/PCNet1/ReceiveBytes"/>
|
|
// </Statistics>
|
|
|
|
// add up the counter(s)
|
|
//
|
|
received = 0;
|
|
counter_start = output.find("c=\"");
|
|
while (counter_start != string::npos) {
|
|
counter_start += 3;
|
|
counter_end = output.find("\"", counter_start);
|
|
counter_value = output.substr(counter_start, counter_end - counter_start);
|
|
received += atof(counter_value.c_str());
|
|
counter_start = output.find("c=\"", counter_start);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::get_vm_process_id() {
|
|
string virtualbox_vm_log;
|
|
string::iterator iter;
|
|
int retval = BOINC_SUCCESS;
|
|
string line;
|
|
string comp = "Process ID: ";
|
|
string pid;
|
|
std::size_t found;
|
|
|
|
|
|
virtualbox_vm_log = vm_master_name + "/Logs/VBox.log";
|
|
|
|
if (boinc_file_exists(virtualbox_vm_log.c_str())) {
|
|
|
|
std::ifstream src(virtualbox_vm_log.c_str(), std::ios::binary);
|
|
while (std::getline(src, line))
|
|
{
|
|
|
|
found = line.find(comp);
|
|
if (found != string::npos){
|
|
|
|
found += comp.size();
|
|
pid = line.substr(found, string::npos);
|
|
strip_whitespace(pid);
|
|
if (pid.size() <= 0) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
|
|
vm_pid = atol(pid.c_str());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pid.size() <= 0) {
|
|
return ERR_NOT_FOUND;
|
|
}
|
|
}
|
|
else retval = ERR_NOT_FOUND;
|
|
|
|
return retval;
|
|
}
|
|
|
|
int VBOX_VM::get_vm_exit_code(unsigned long& exit_code) {
|
|
#ifdef _WIN32
|
|
if (vm_pid_handle) {
|
|
GetExitCodeProcess(vm_pid_handle, &exit_code);
|
|
}
|
|
#else
|
|
int ec = 0;
|
|
waitpid(vm_pid, &ec, WNOHANG);
|
|
exit_code = ec;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
double VBOX_VM::get_vm_cpu_time() {
|
|
double x = process_tree_cpu_time(vm_pid);
|
|
if (x > current_cpu_time) {
|
|
current_cpu_time = x;
|
|
}
|
|
return current_cpu_time;
|
|
}
|
|
|
|
// Enable the network adapter if a network connection is required.
|
|
// NOTE: Network access should never be allowed if the code running in a
|
|
// shared directory or the VM image itself is NOT signed. Doing so
|
|
// opens up the network behind the company firewall to attack.
|
|
//
|
|
// Imagine a doomsday scenario where a project has been compromised and
|
|
// an unsigned executable/VM image has been tampered with. Volunteer
|
|
// downloads compromised code and executes it on a company machine.
|
|
// Now the compromised VM starts attacking other machines on the company
|
|
// network. The company firewall cannot help because the attacking
|
|
// machine is already behind the company firewall.
|
|
//
|
|
int VBOX_VM::set_network_access(bool enabled) {
|
|
string command;
|
|
string output;
|
|
int retval;
|
|
|
|
network_suspended = !enabled;
|
|
|
|
if (enabled) {
|
|
vboxlog_msg("Enabling network access for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--cableconnected1 on ";
|
|
|
|
retval = vbm_popen(command, output, "enable network");
|
|
if (retval) return retval;
|
|
} else {
|
|
vboxlog_msg("Disabling network access for VM.");
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--cableconnected1 off ";
|
|
|
|
retval = vbm_popen(command, output, "disable network");
|
|
if (retval) return retval;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::set_cpu_usage(int percentage) {
|
|
string command;
|
|
string output;
|
|
char buf[256];
|
|
int retval;
|
|
|
|
// the arg to controlvm is percentage
|
|
//
|
|
vboxlog_msg("Setting CPU throttle for VM. (%d%%)", percentage);
|
|
sprintf(buf, "%d", percentage);
|
|
command = "controlvm \"" + vm_name + "\" ";
|
|
command += "cpuexecutioncap ";
|
|
command += buf;
|
|
command += " ";
|
|
|
|
retval = vbm_popen(command, output, "CPU throttle");
|
|
if (retval) return retval;
|
|
return 0;
|
|
}
|
|
|
|
int VBOX_VM::set_network_usage(int kilobytes) {
|
|
string command;
|
|
string output;
|
|
char buf[256];
|
|
int retval;
|
|
|
|
// the argument to modifyvm is in KB
|
|
//
|
|
if (kilobytes == 0) {
|
|
vboxlog_msg("Setting network throttle for VM. (1024GB)");
|
|
} else {
|
|
vboxlog_msg("Setting network throttle for VM. (%dKB)", kilobytes);
|
|
}
|
|
|
|
if (is_virtualbox_version_newer(4, 2, 0)) {
|
|
|
|
// Update bandwidth group limits
|
|
//
|
|
if (kilobytes == 0) {
|
|
command = "bandwidthctl \"" + vm_name + "\" ";
|
|
command += "set \"" + vm_name + "_net\" ";
|
|
command += "--limit 1024G ";
|
|
|
|
retval = vbm_popen(command, output, "network throttle (set default value)");
|
|
if (retval) return retval;
|
|
} else {
|
|
sprintf(buf, "%d", kilobytes);
|
|
command = "bandwidthctl \"" + vm_name + "\" ";
|
|
command += "set \"" + vm_name + "_net\" ";
|
|
command += "--limit ";
|
|
command += buf;
|
|
command += "K ";
|
|
|
|
retval = vbm_popen(command, output, "network throttle (set)");
|
|
if (retval) return retval;
|
|
}
|
|
|
|
} else {
|
|
|
|
sprintf(buf, "%d", kilobytes);
|
|
command = "modifyvm \"" + vm_name + "\" ";
|
|
command += "--nicspeed1 ";
|
|
command += buf;
|
|
command += " ";
|
|
|
|
retval = vbm_popen(command, output, "network throttle");
|
|
if (retval) return retval;
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void VBOX_VM::lower_vm_process_priority() {
|
|
#ifdef _WIN32
|
|
if (vm_pid_handle) {
|
|
SetPriorityClass(vm_pid_handle, BELOW_NORMAL_PRIORITY_CLASS);
|
|
}
|
|
#else
|
|
if (vm_pid) {
|
|
setpriority(PRIO_PROCESS, vm_pid, PROCESS_MEDIUM_PRIORITY);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void VBOX_VM::reset_vm_process_priority() {
|
|
#ifdef _WIN32
|
|
if (vm_pid_handle) {
|
|
SetPriorityClass(vm_pid_handle, NORMAL_PRIORITY_CLASS);
|
|
}
|
|
#else
|
|
if (vm_pid) {
|
|
setpriority(PRIO_PROCESS, vm_pid, PROCESS_NORMAL_PRIORITY);
|
|
}
|
|
#endif
|
|
}
|
|
}
|