bool
VirshType::ResumeFromSoftSuspend(void)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::ResumeFromSoftSuspend\n");
if( (m_configfile.Length() == 0)) {
return false;
}
if( m_is_soft_suspended ) {
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
priv = set_root_priv();
int result = virDomainResume(dom);
virDomainFree(dom);
set_priv(priv);
if( result != 0 ) {
// unpause failed.
vmprintf(D_ALWAYS, "Unpausing VM failed in "
"VirshType::ResumeFromSoftSuspend\n");
return false;
}
m_is_soft_suspended = false;
}
return true;
}
bool
VirshType::killVMFast(const char* vmname, virConnectPtr libvirt_con)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::killVMFast\n");
if( !vmname || (vmname[0] == '\0') ) {
return false;
}
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(libvirt_con, vmname);
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(libvirt_con);
if (err && err->code != VIR_ERR_NO_DOMAIN)
{
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", vmname, (err ? err->message : "No reason found"));
return false;
}
else
{
return true;
}
}
priv = set_root_priv();
bool ret = (virDomainDestroy(dom) == 0);
virDomainFree(dom);
set_priv(priv);
return ret;
}
void ruby_libvirt_raise_error_if(const int condition, VALUE error,
const char *method, virConnectPtr conn)
{
VALUE ruby_errinfo;
virErrorPtr err;
char *msg;
int rc;
struct rb_exc_new2_arg arg;
int exception = 0;
if (!condition) {
return;
}
if (conn == NULL) {
err = virGetLastError();
}
else {
err = virConnGetLastError(conn);
}
if (err != NULL && err->message != NULL) {
rc = asprintf(&msg, "Call to %s failed: %s", method, err->message);
}
else {
rc = asprintf(&msg, "Call to %s failed", method);
}
if (rc < 0) {
/* there's not a whole lot we can do here; try to raise an
* out-of-memory message */
rb_memerror();
}
arg.error = error;
arg.msg = msg;
ruby_errinfo = rb_protect(ruby_libvirt_exc_new2_wrap, (VALUE)&arg,
&exception);
free(msg);
if (exception) {
rb_jump_tag(exception);
}
rb_iv_set(ruby_errinfo, "@libvirt_function_name", rb_str_new2(method));
if (err != NULL) {
rb_iv_set(ruby_errinfo, "@libvirt_code", INT2NUM(err->code));
rb_iv_set(ruby_errinfo, "@libvirt_component", INT2NUM(err->domain));
rb_iv_set(ruby_errinfo, "@libvirt_level", INT2NUM(err->level));
if (err->message != NULL) {
rb_iv_set(ruby_errinfo, "@libvirt_message",
rb_str_new2(err->message));
}
}
rb_exc_raise(ruby_errinfo);
};
void StoragePoolControlThread::sendConnErrors()
{
virtErrors = virConnGetLastError(currWorkConnect);
if ( virtErrors!=NULL && virtErrors->code>0 ) {
emit errorMsg( QString("VirtError(%1) : %2").arg(virtErrors->code)
.arg(QString().fromUtf8(virtErrors->message)) );
virResetError(virtErrors);
} else sendGlobalErrors();
}
void VM_Viewer::sendConnErrors()
{
virtErrors = (NULL!=ptr_ConnPtr && *ptr_ConnPtr)?
virConnGetLastError(*ptr_ConnPtr):NULL;
if ( virtErrors!=NULL && virtErrors->code>0 ) {
QString msg = QString("VirtError(%1) : %2").arg(virtErrors->code)
.arg(QString().fromUtf8(virtErrors->message));
emit errorMsg( msg );
virResetError(virtErrors);
} else sendGlobalErrors();
}
QString _VirtThread::sendConnErrors()
{
QString msg;
virtErrors = (nullptr!=ptr_ConnPtr && *ptr_ConnPtr)?
virConnGetLastError(*ptr_ConnPtr):nullptr;
if ( virtErrors!=nullptr && virtErrors->code>0 ) {
msg = QString("VirtError(%1) : %2").arg(virtErrors->code)
.arg(QString().fromUtf8(virtErrors->message));
emit errorMsg( msg, number );
virResetError(virtErrors);
} else
msg = sendGlobalErrors();
return msg;
}
bool
VirshType::SoftSuspend()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::SoftSuspend\n");
if( (m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
if( m_is_soft_suspended ) {
return true;
}
if( getVMStatus() != VM_RUNNING ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
int result = virDomainSuspend(dom);
virDomainFree(dom);
if( result == 0 ) {
// pause succeeds.
m_is_soft_suspended = true;
return true;
}
// Failed to suspend a VM softly.
// Instead of soft suspend, we use hard suspend.
vmprintf(D_ALWAYS, "SoftSuspend failed, so try hard Suspend instead!.\n");
return Suspend();
}
bool
VirshType::Status()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Status\n");
if((m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
m_result_msg = "";
if( m_vm_networking ) {
if( m_vm_mac.IsEmpty() == false ) {
if( m_result_msg.IsEmpty() == false ) {
m_result_msg += " ";
}
m_result_msg += VMGAHP_STATUS_COMMAND_MAC;
m_result_msg += "=";
m_result_msg += m_vm_mac;
}
if( m_vm_ip.IsEmpty() == false ) {
if( m_result_msg.IsEmpty() == false ) {
m_result_msg += " ";
}
m_result_msg += VMGAHP_STATUS_COMMAND_IP;
m_result_msg += "=";
m_result_msg += m_vm_ip;
}
}
if( m_result_msg.IsEmpty() == false ) {
m_result_msg += " ";
}
m_result_msg += VMGAHP_STATUS_COMMAND_STATUS;
m_result_msg += "=";
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
if ( err )
{
switch (err->code)
{
case (VIR_ERR_NO_DOMAIN):
// The VM isn't there anymore, so signal shutdown
vmprintf(D_FULLDEBUG, "Couldn't find domain %s, assuming it was shutdown\n", m_vm_name.Value());
if(getVMStatus() == VM_RUNNING) {
m_self_shutdown = true;
}
if(getVMStatus() != VM_STOPPED) {
setVMStatus(VM_STOPPED);
m_stop_time.getTime();
}
m_result_msg += "Stopped";
return true;
break;
case (VIR_ERR_SYSTEM_ERROR): //
vmprintf(D_ALWAYS, "libvirt communication error detected, attempting to reconnect...\n");
this->Connect();
if ( NULL == ( dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value() ) ) )
{
vmprintf(D_ALWAYS, "could not reconnect to libvirt... marking vm as stopped (should exit)\n");
if(getVMStatus() == VM_RUNNING) {
m_self_shutdown = true;
}
if(getVMStatus() != VM_STOPPED) {
setVMStatus(VM_STOPPED);
m_stop_time.getTime();
}
m_result_msg += "Stopped";
return true;
}
else
{
vmprintf(D_ALWAYS, "libvirt has successfully reconnected!\n");
}
break;
default:
vmprintf(D_ALWAYS, "Error finding domain %s(%d): %s\n", m_vm_name.Value(), err->code, err->message );
return false;
}
}
else
{
vmprintf(D_ALWAYS, "Error finding domain, no error returned from libvirt\n" );
return false;
}
}
virDomainInfo _info;
virDomainInfoPtr info = &_info;
if(virDomainGetInfo(dom, info) < 0)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain info %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
if(info->state == VIR_DOMAIN_RUNNING || info->state == VIR_DOMAIN_BLOCKED)
{
static unsigned long long LastCpuTime = 0;
static time_t LastStamp = time(0);
time_t CurrentStamp = time(0);
unsigned long long CurrentCpuTime= info->cpuTime;
double percentUtilization=1.0;
setVMStatus(VM_RUNNING);
// libvirt reports cputime in nanoseconds
m_cpu_time = info->cpuTime / 1000000000.0;
m_result_msg += "Running";
// Here is where we tack on utilization we only cate about the
m_result_msg += " ";
m_result_msg += VMGAHP_STATUS_COMMAND_CPUUTILIZATION;
m_result_msg += "=";
if ( (CurrentStamp - LastStamp) > 0 )
{
// Old calc method because of libvirt version mismatches.
// courtesy of http://people.redhat.com/~rjones/virt-top/faq.html#calccpu
percentUtilization = (1.0 * (CurrentCpuTime-LastCpuTime) ) / ((CurrentStamp - LastStamp)*info->nrVirtCpu*1000000000.0);
vmprintf(D_FULLDEBUG, "Computing utilization %f = (%llu) / (%d * %d * 1000000000.0)\n",percentUtilization, (CurrentCpuTime-LastCpuTime), (int) (CurrentStamp - LastStamp), info->nrVirtCpu );
}
m_result_msg += percentUtilization;
LastCpuTime = CurrentCpuTime;
LastStamp = CurrentStamp;
virDomainFree(dom);
return true;
}
else if(info->state == VIR_DOMAIN_PAUSED)
{
m_result_msg += "Suspended";
virDomainFree(dom);
return true;
}
else
{
if(getVMStatus() == VM_RUNNING)
{
m_self_shutdown = true;
}
if(getVMStatus() != VM_STOPPED)
{
setVMStatus(VM_STOPPED);
m_stop_time.getTime();
}
m_result_msg += "Stopped";
virDomainFree(dom);
return true;
}
virDomainFree(dom);
return false;
}
bool
VirshType::Suspend()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Suspend\n");
if( (m_configfile.Length() == 0) ) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
if( getVMStatus() == VM_SUSPENDED ) {
return true;
}
if( getVMStatus() != VM_RUNNING ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
if( m_xen_hw_vt && !m_allow_hw_vt_suspend ) {
// This VM uses hardware virtualization.
// However, Virsh cannot suspend this type of VM yet.
m_result_msg = VMGAHP_ERR_VM_NO_SUPPORT_SUSPEND;
return false;
}
// If a VM is soft suspended, resume it first.
ResumeFromSoftSuspend();
MyString tmpfilename;
makeNameofSuspendfile(tmpfilename);
unlink(tmpfilename.Value());
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
priv = set_root_priv();
int result = virDomainSave(dom, tmpfilename.Value());
virDomainFree(dom);
set_priv(priv);
if( result != 0 ) {
// Read error output
// char *temp = cmd_out.print_to_delimed_string("/");
// m_result_msg = temp;
// free( temp );
unlink(tmpfilename.Value());
return false;
}
m_suspendfile = tmpfilename;
setVMStatus(VM_SUSPENDED);
m_cputime_before_suspend += m_cpu_time;
m_cpu_time = 0;
return true;
}
bool
VirshType::Shutdown()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Shutdown\n");
if( (m_configfile.Length() == 0) ) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
if( getVMStatus() == VM_STOPPED ) {
if( m_self_shutdown ) {
if( m_vm_no_output_vm ) {
// A job user doesn't want to get back VM files.
// So we will delete all files in working directory.
m_delete_working_files = true;
m_is_checkpointed = false;
}else {
if( !m_suspendfile.IsEmpty() ) {
unlink(m_suspendfile.Value());
}
m_suspendfile = "";
// delete the created xen vm configuration file
if( !m_configfile.IsEmpty() ) {
unlink(m_configfile.Value());
}
// delete the checkpoint timestamp file
MyString tmpfilename;
tmpfilename.formatstr("%s%c%s", m_workingpath.Value(),
DIR_DELIM_CHAR, XEN_CKPT_TIMESTAMP_FILE);
unlink(tmpfilename.Value());
// We need to update timestamp of transferred writable disk files
updateLocalWriteDiskTimestamp(time(NULL));
}
}
// We here set m_self_shutdown to false
// So, above functions will not be called twice
m_self_shutdown = false;
return true;
}
// if( getVMStatus() == VM_SUSPENDED )
// do nothing
// If a VM is soft suspended, resume it first
ResumeFromSoftSuspend();
if( getVMStatus() == VM_RUNNING ) {
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
if (err && err->code != VIR_ERR_NO_DOMAIN)
{
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
}
else
{
priv = set_root_priv();
int result = virDomainShutdown(dom);
virDomainFree(dom);
set_priv(priv);
if( result != 0 ) {
// system error happens
// killing VM by force
killVM();
}
}
// Now we don't need working files any more
m_delete_working_files = true;
m_is_checkpointed = false;
}
setVMStatus(VM_STOPPED);
m_stop_time.getTime();
return true;
}
bool
VirshType::Start()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Start\n");
if( (m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
vmprintf(D_FULLDEBUG, "Config file was not set configfile: %s\n", m_configfile.Value());
return false;
}
if( getVMStatus() != VM_STOPPED ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
if( m_restart_with_ckpt ) {
bool res = Resume();
if( res ) {
// Success!!
vmprintf(D_ALWAYS, "Succeeded to restart with checkpointed files\n");
// Here we manually update timestamp of all writable disk files
m_start_time.getTime();
return true;
}else {
// Failed to restart with checkpointed files
vmprintf(D_ALWAYS, "Failed to restart with checkpointed files\n");
vmprintf(D_ALWAYS, "So, we will try to create a new configuration file\n");
deleteNonTransferredFiles();
m_configfile = "";
m_suspendfile = "";
m_restart_with_ckpt = false;
if( this->CreateConfigFile() == false ) {
vmprintf(D_ALWAYS, "Failed to create a new configuration files\n");
return false;
}
// Succeeded to create a configuration file
// Keep going..
}
}
vmprintf(D_FULLDEBUG, "Trying XML: %s\n", m_xml.Value());
priv_state priv = set_root_priv();
virDomainPtr vm = virDomainCreateXML(m_libvirt_connection, m_xml.Value(), 0);
set_priv(priv);
if(vm == NULL)
{
// Error in creating the vm; let's find out what the error
// was
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Failed to create libvirt domain: %s\n", (err ? err->message : "No reason found"));
//virFreeError(err);
return false;
}
priv = set_root_priv();
virDomainFree(vm);
set_priv(priv);
setVMStatus(VM_RUNNING);
m_start_time.getTime();
m_cpu_time = 0;
// Here we manually update timestamp of all writable disk files
return true;
}