static int libvirt_off(const char *vm_name, const char *src, uint32_t seqno, void *priv) { struct libvirt_info *info = (struct libvirt_info *)priv; virDomainPtr vdp = NULL; virDomainInfo vdi; virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *); int ret = -1; int i; dbg_printf(5, "ENTER %s %s %u\n", __FUNCTION__, vm_name, seqno); VALIDATE(info); if (is_uuid(vm_name)) virt_lookup_fn = virDomainLookupByUUIDString; else virt_lookup_fn = virDomainLookupByName; for (i = 0 ; i < info->vp_count ; i++) { vdp = virt_lookup_fn(info->vp[i], vm_name); if (vdp) break; } if (!vdp) { dbg_printf(2, "[libvirt:OFF] Domain %s does not exist\n", vm_name); return 1; } if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state == VIR_DOMAIN_SHUTOFF) { dbg_printf(2, "[libvirt:OFF] Nothing to do - " "domain %s is already off\n", vm_name); virDomainFree(vdp); return 0; } syslog(LOG_NOTICE, "Destroying domain %s\n", vm_name); dbg_printf(2, "[libvirt:OFF] Calling virDomainDestroy for %s\n", vm_name); ret = virDomainDestroy(vdp); virDomainFree(vdp); if (ret < 0) { syslog(LOG_NOTICE, "Failed to destroy domain %s: %d\n", vm_name, ret); dbg_printf(2, "[libvirt:OFF] Failed to destroy domain: %s %d\n", vm_name, ret); return 1; } if (ret) { syslog(LOG_NOTICE, "Domain %s still exists; fencing failed\n", vm_name); dbg_printf(2, "[libvirt:OFF] Domain %s still exists; fencing failed\n", vm_name); return 1; } dbg_printf(2, "[libvirt:OFF] Success for %s\n", vm_name); return 0; }
static int mymain(void) { int id = 0; int ro = 0; virConnectPtr conn; virDomainPtr dom; int status; virCommandPtr cmd; struct utsname ut; /* Skip test if xend is not running. Calling xend on a non-xen kernel causes some versions of xend to issue a crash report, so we first probe uname results. */ uname(&ut); if (strstr(ut.release, "xen") == NULL) return EXIT_AM_SKIP; cmd = virCommandNewArgList("/usr/sbin/xend", "status", NULL); if (virCommandRun(cmd, &status) != 0 || status != 0) { virCommandFree(cmd); return EXIT_AM_SKIP; } virCommandFree(cmd); virSetErrorFunc(NULL, errorHandler); conn = virConnectOpen(NULL); if (conn == NULL) { ro = 1; conn = virConnectOpenReadOnly(NULL); } if (conn == NULL) { fprintf(stderr, "First virConnectOpen() failed\n"); return EXIT_FAILURE; } dom = virDomainLookupByID(conn, id); if (dom == NULL) { fprintf(stderr, "First lookup for domain %d failed\n", id); return EXIT_FAILURE; } virDomainFree(dom); virConnectClose(conn); if (ro == 1) conn = virConnectOpenReadOnly(NULL); else conn = virConnectOpen(NULL); if (conn == NULL) { fprintf(stderr, "Second virConnectOpen() failed\n"); return EXIT_FAILURE; } dom = virDomainLookupByID(conn, id); if (dom == NULL) { fprintf(stderr, "Second lookup for domain %d failed\n", id); return EXIT_FAILURE; } virDomainFree(dom); virConnectClose(conn); return EXIT_SUCCESS; }
static int xenInotifyXendDomainsDirLookup(virConnectPtr conn, const char *filename, char **name, unsigned char *uuid) { int i; virDomainPtr dom; const char *uuid_str; unsigned char rawuuid[VIR_UUID_BUFLEN]; xenUnifiedPrivatePtr priv = conn->privateData; /* xend is managing domains. we will get * a filename in the manner: * /var/lib/xend/domains/<uuid>/ */ uuid_str = filename + strlen(XEND_DOMAINS_DIR) + 1; if (virUUIDParse(uuid_str, rawuuid) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("parsing uuid %s"), uuid_str); return -1; } /* call directly into xend here, as driver may not yet be set during open while we are building our initial list of domains */ VIR_DEBUG("Looking for dom with uuid: %s", uuid_str); /* XXX Should not have to go via a virDomainPtr obj instance */ if(!(dom = xenDaemonLookupByUUID(conn, rawuuid))) { /* If we are here, the domain has gone away. search for, and create a domain from the stored list info */ for (i = 0 ; i < priv->configInfoList->count ; i++) { if (!memcmp(rawuuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN)) { *name = strdup(priv->configInfoList->doms[i]->name); if (!*name) { virReportOOMError(); return -1; } memcpy(uuid, priv->configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN); VIR_DEBUG("Found dom on list"); return 0; } } virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("finding dom on config list")); return -1; } if (!(*name = strdup(dom->name))) { virReportOOMError(); virDomainFree(dom); return -1; } memcpy(uuid, dom->uuid, VIR_UUID_BUFLEN); virDomainFree(dom); /* succeeded too find domain by uuid */ return 0; }
static int registerExisting(virConnectPtr vp, const char *path, int mode) { int *d_ids = NULL; int d_count, x; virDomainPtr dom; virDomainInfo d_info; errno = EINVAL; if (!vp) return -1; d_count = virConnectNumOfDomains(vp); if (d_count <= 0) { if (d_count == 0) { /* Successful, but no domains running */ errno = 0; return 0; } goto out_fail; } d_ids = malloc(sizeof (int) * d_count); if (!d_ids) goto out_fail; if (virConnectListDomains(vp, d_ids, d_count) < 0) goto out_fail; /* Ok, we have the domain IDs - let's get their names and states */ for (x = 0; x < d_count; x++) { dom = virDomainLookupByID(vp, d_ids[x]); if (!dom) { /* XXX doom */ goto out_fail; } if (virDomainGetInfo(dom, &d_info) < 0) { /* XXX no info for the domain?!! */ virDomainFree(dom); goto out_fail; } if (d_info.state != VIR_DOMAIN_SHUTOFF && d_info.state != VIR_DOMAIN_CRASHED) domainStarted(dom, path, mode); virDomainFree(dom); } out_fail: free(d_ids); return 0; }
timearg GetVirtInfo::GetCpuTime(QString VM_name) { virDomainPtr vm_ptr = virDomainLookupByName(conn, qPrintable(VM_name)); if(vm_ptr == NULL) { printf("error finding domain\n"); virConnectClose(conn); exit(1); } virDomainInfo info_s; struct timeval real_time_s; timearg return_arg; if(virDomainGetInfo(vm_ptr, &info_s) != 0) { printf("error get domain info\n"); virDomainFree(vm_ptr); virConnectClose(conn); exit(1); } if(gettimeofday(&real_time_s, NULL) == -1) { printf("error get time of day\n"); virDomainFree(vm_ptr); virConnectClose(conn); exit(1); } return_arg.info = info_s; return_arg.real_time = real_time_s; virDomainFree(vm_ptr); return return_arg; /* sleep(1); if(virDomainGetInfo(vm_ptr, &info_e) !=0) { printf("error get domain info\n"); virDomainFree(vm_ptr); virConnectClose(conn); exit(1); } if(gettimeofday(&real_time_e, NULL) == -1) { printf("error get time of day\n"); virDomainFree(vm_ptr); virConnectClose(conn); exit(1); } cpu_diff = (info_e.cpuTime - info_s.cpuTime) / 1000; real_diff = 1000000 * (real_time_e.tv_sec - real_time_s.tv_sec) +(real_time_e.tv_usec - real_time_s.tv_usec); virDomainFree(vm_ptr); usage = cpu_diff / (float) (real_diff); return usage*100;*/ }
int main(int argc, char *argv[]) { virConnectPtr conn; int i; int numDomains; int *activeDomains; virDomainPtr dom; conn = virConnectOpen("qemu:///system"); if (conn == NULL) { fprintf(stderr, "Failed to open connection to qemu:///system\n"); } numDomains = virConnectNumOfDomains(conn); activeDomains = malloc(sizeof(int) * numDomains); numDomains = virConnectListDomains(conn, activeDomains, numDomains); printf("Active domain IDs:\n"); for (i = 0 ; i < numDomains ; i++) { printf(" %d\n", activeDomains[i]); } printf("Terminating Domain\n"); free(activeDomains); int domainName = "sudip"; dom = virDomainLookupByName(conn,domainName); virDomainDestroy(dom); virDomainFree(dom); printf("Domain sudip terminated successfully\n"); if (conn != NULL) virConnectClose(conn); return 0; }
static int DeleteVirt(virConnectPtr vc, char *uri, Attributes a, Promise *pp) { virDomainPtr dom; int ret = true; dom = virDomainLookupByName(vc, pp->promiser); if (dom) { if (virDomainDestroy(dom) == -1) { cfPS(cf_verbose, CF_FAIL, "", pp, a, " !! Failed to delete virtual domain \"%s\"\n", pp->promiser); ret = false; } else { cfPS(cf_verbose, CF_CHG, "", pp, a, " -> Deleted virtual domain \"%s\"\n", pp->promiser); } virDomainFree(dom); } else { cfPS(cf_verbose, CF_NOP, "", pp, a, " -> No such virtual domain called \"%s\" - promise kept\n", pp->promiser); } return ret; }
static int DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, Promise *pp) { virDomainPtr dom; int ret = true; dom = virDomainLookupByName(vc, pp->promiser); if (dom) { if (virDomainDestroy(dom) == -1) { cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_FAIL, "", pp, a, " !! Failed to delete virtual domain \"%s\"\n", pp->promiser); ret = false; } else { cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, "", pp, a, " -> Deleted virtual domain \"%s\"\n", pp->promiser); } virDomainFree(dom); } else { cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, "", pp, a, " -> No such virtual domain called \"%s\" - promise kept\n", pp->promiser); } return ret; }
static int __domain_op_simple(char * name, int op) { if (g_conn == NULL) return -1; virDomainPtr domain; domain = virDomainLookupByName(g_conn, name); if (domain == NULL) { logerror(_("%s: connect domain by name(%s) error. " "domain may not exist\n"), __func__, name); return -1; } int ret; if (op == __DOMAIN_OP_STOP) ret = virDomainShutdown(domain); else if (op == __DOMAIN_OP_STOP_FORCE) ret = virDomainDestroy(domain); else if (op == __DOMAIN_OP_REBOOT) ret = virDomainReboot(domain, 0); else ret = -1; virDomainFree(domain); return ret; }
static void getDomainInfo(int id) { virConnectPtr conn = NULL; /* the hypervisor connection */ virDomainPtr dom = NULL; /* the domain being checked */ virDomainInfo info; /* the information being fetched */ int ret; /* NULL means connect to local Xen hypervisor */ conn = virConnectOpenReadOnly(NULL); if (conn == NULL) { fprintf(stderr, "Failed to connect to hypervisor\n"); goto error; } /* Find the domain of the given id */ dom = virDomainLookupByID(conn, id); if (dom == NULL) { fprintf(stderr, "Failed to find Domain %d\n", id); goto error; } /* Get the information */ ret = virDomainGetInfo(dom, &info); if (ret < 0) { fprintf(stderr, "Failed to get information for Domain %d\n", id); goto error; } printf("Domains %d: %d CPUs\n", id, info.nrVirtCpu); error: if (dom != NULL) virDomainFree(dom); if (conn != NULL) virConnectClose(conn); }
/** * @fn Domain::~Domain * @brief destroys the domain object * * If domain object references a valid domain in libvirt, * the corresponding memory will be freed. */ Domain::~Domain() { if (m_domain) { virDomainFree(m_domain); } }
void SetDisksDataThread::run() { if ( nullptr==ptr_ConnPtr || nullptr==*ptr_ConnPtr ) { emit ptrIsNull(); return; }; // NOTE: currConnName == domainName virDomainPtr domain = virDomainLookupByName( *ptr_ConnPtr, currConnName.toUtf8().data()); if ( nullptr!=domain ) { char *xmlDesc = virDomainGetXMLDesc(domain, 0); virDomainFree(domain); if ( nullptr!=xmlDesc ) { QDomDocument doc; doc.setContent(QString(xmlDesc)); free(xmlDesc); QDomElement _devices = doc .firstChildElement("domain") .firstChildElement("devices"); QDomElement _disk = _devices .firstChildElement("disk"); while ( !_disk.isNull() ) { emit diskData(_disk); _disk = _disk.nextSiblingElement("disk"); }; }; } else sendConnErrors(); }
static int libvirt_status(const char *vm_name, void *priv) { struct libvirt_info *info = (struct libvirt_info *)priv; virDomainPtr vdp; virDomainInfo vdi; int ret = 0; dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name); VALIDATE(info); if (is_uuid(vm_name)) { vdp = virDomainLookupByUUIDString(info->vp, (const char *)vm_name); } else { vdp = virDomainLookupByName(info->vp, vm_name); } if (!vdp || ((virDomainGetInfo(vdp, &vdi) == 0) && (vdi.state == VIR_DOMAIN_SHUTOFF))) { ret = RESP_OFF; } if (vdp) virDomainFree(vdp); return ret; }
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; }
static int fetch_domains(virConnectPtr conn) { int num_domains, ret = -1; virDomainPtr *domains = NULL; ssize_t i; const int list_flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE; DEBUG("Fetching list of running domains"); num_domains = virConnectListAllDomains(conn, &domains, list_flags); DEBUG("num_domains=%d", num_domains); if (num_domains < 0) { ERROR("Unable to fetch list of running domains"); goto cleanup; } printf("Running domains:\n"); printf("----------------\n"); for (i = 0; i < num_domains; i++) { virDomainPtr dom = domains[i]; const char *dom_name = virDomainGetName(dom); printf("%s\n", dom_name); virDomainFree(dom); } ret = 0; cleanup: free(domains); return ret; }
// read /var/lib/libvirt/dnsmasq/default.leases to get ip // domain must use DHCP std::string VM_Controller::get_vm_ip_by_name(std::string domain_name){ LOG_INFO(domain_name); Json::Value j; virDomainPtr dom = virDomainLookupByName(_conn, domain_name.c_str()); if(dom == NULL){ Json::Value j; j["status"] = "no such domain"; return j.toStyledString(); } std::string mac = _get_vm_mac(dom); LOG_INFO(mac); virDomainFree(dom); std::ifstream leases("/var/lib/libvirt/dnsmasq/default.leases"); while(!leases.eof()){ std::string line; std::getline(leases, line); DEBUG(line); if(line == "") break; std::vector<std::string> v; Tools::split(line, v, ' '); if(v[1] == mac){ j["ip"] = v[2]; j["status"] = "ok"; return j.toStyledString(); } } leases.close(); j["status"] = "Could not find ip for the mac address"; return j.toStyledString(); }
static PromiseResult DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, const Promise *pp) { virDomainPtr dom; dom = virDomainLookupByName(vc, pp->promiser); PromiseResult result = PROMISE_RESULT_NOOP; if (dom) { if (virDomainDestroy(dom) == -1) { cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Failed to delete virtual domain '%s'", pp->promiser); result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL); } else { cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Deleted virtual domain '%s'", pp->promiser); result = PromiseResultUpdate(result, PROMISE_RESULT_CHANGE); } virDomainFree(dom); } else { cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "No such virtual domain called '%s' - promise kept", pp->promiser); } return result; }
//qDebug()<<URIs; foreach (QString uri, URIs) { virConnect *connPtr = virConnectOpenReadOnly(uri.toUtf8().data()); if ( Q_NULLPTR!=connPtr ) { // don't work for VBox // int num = virConnectNumOfDefinedDomains(connPtr); virDomainPtr *domains; int ret = virConnectListAllDomains( connPtr, &domains, 0); if ( ret+1 ) { for (int i = 0; i < ret; i++) { if ( virDomainFree(domains[i]) <0 ) sendConnErrors(); }; if (domains) free(domains); } else { sendConnErrors(); }; virConnectClose(connPtr); if ( ret ) { emit localConnFound(uri); }; } else { sendConnErrors(); }; //msleep(333); };
static int dominfo_from_dom(const char *uri, const char *domain, struct domain **d) { virConnectPtr conn = NULL; virDomainPtr dom = NULL; int ret = 0; conn = virConnectOpen(uri); if (conn == NULL) { printf("Unable to connect to libvirt\n"); goto out; } dom = virDomainLookupByName(conn, domain); if (dom == NULL) { printf("Unable to find domain `%s'\n", domain); goto out; } ret = get_dominfo(dom, d); out: virDomainFree(dom); virConnectClose(conn); return ret; }
static int mymain(void) { struct metadataTest test; int ret = EXIT_SUCCESS; if (!(test.conn = virConnectOpen("test:///default"))) return EXIT_FAILURE; if (!(test.dom = virDomainLookupByName(test.conn, "test"))) { virConnectClose(test.conn); return EXIT_FAILURE; } virtTestQuiesceLibvirtErrors(false); if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0) ret = EXIT_FAILURE; if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0) ret = EXIT_FAILURE; if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0) ret = EXIT_FAILURE; virDomainFree(test.dom); virConnectClose(test.conn); return ret; }
int VM_Controller::get_image_config_fd_by_name(std::string vm_name){ virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str()); if(dom == NULL){ return -1; } char *domain_xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_SECURE); virDomainFree(dom); std::string config_file = _make_tmp_config_file_name(vm_name); int fd = open(config_file.c_str(), O_WRONLY|O_CREAT); int filesize = strlen(domain_xml); int write_count = 0; while(write_count < filesize){ int once_write_count = write(fd, domain_xml, filesize); if(once_write_count < 0){ LOG_ERROR("write error"); close(fd); return -1; } write_count += once_write_count; } close(fd); fd = open(config_file.c_str(), O_RDONLY); return fd; }
static inline int wait_domain(const char *vm_name, virConnectPtr vp, int timeout) { int tries = 0; int response = 1; int ret; virDomainPtr vdp; virDomainInfo vdi; int uuid_check; uuid_check = is_uuid(vm_name); if (uuid_check) { vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name); } else { vdp = virDomainLookupByName(vp, vm_name); } if (!vdp) return 0; /* Check domain liveliness. If the domain is still here, we return failure, and the client must then retry */ /* XXX On the xen 3.0.4 API, we will be able to guarantee synchronous virDomainDestroy, so this check will not be necessary */ do { if (++tries > timeout) break; sleep(1); if (uuid_check) { vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name); } else { vdp = virDomainLookupByName(vp, vm_name); } if (!vdp) { dbg_printf(2, "Domain no longer exists\n"); response = 0; break; } memset(&vdi, 0, sizeof(vdi)); ret = virDomainGetInfo(vdp, &vdi); virDomainFree(vdp); if (ret < 0) continue; if (vdi.state == VIR_DOMAIN_SHUTOFF) { dbg_printf(2, "Domain has been shut off\n"); response = 0; break; } dbg_printf(4, "Domain still exists (state %d) after %d seconds\n", vdi.state, tries); } while (1); return response; }
int libvirt_node_info_update(NodeInfo * ni) { if (g_conn == NULL || ni == NULL) return -1; int ret = -1; int cpu_commit = 0; unsigned int mem_commit = 0; int *activeDomains = NULL; __this_lock(); int numDomains = virConnectNumOfDomains(g_conn); if (numDomains <= 0) { ret = numDomains; goto out; } activeDomains = malloc(sizeof(int) * numDomains); if (activeDomains == NULL) { logerror(_("error in %s(%d)\n"), __func__, __LINE__); goto out; } numDomains = virConnectListDomains(g_conn, activeDomains, numDomains); if (numDomains <= 0) { ret = numDomains; goto out; } for (int i = 0; i< numDomains; i++) { /* skip id dom 0 */ if (activeDomains[i] == 0) continue; virDomainPtr d = virDomainLookupByID(g_conn, activeDomains[i]); if (d == NULL) { logerror(_("error in %s(%d)\n"), __func__, __LINE__); goto out; } virDomainInfo di; if (virDomainGetInfo(d, &di)) { logerror(_("error in %s(%d)\n"), __func__, __LINE__); goto out; } cpu_commit += di.nrVirtCpu; mem_commit += di.maxMem; virDomainFree(d); } ni->cpu_commit = cpu_commit; ni->mem_commit = mem_commit; ret = numDomains; out: __this_unlock(); if (activeDomains) free(activeDomains); return ret; }
static int showDomains(virConnectPtr conn) { int ret = 0, numNames, numInactiveDomains, numActiveDomains; ssize_t i; int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE | VIR_CONNECT_LIST_DOMAINS_INACTIVE; virDomainPtr *nameList = NULL; /* NB: The return from the virConnectNum*() APIs is only useful for * the current call. A domain could be started or stopped and any * assumptions made purely on these return values could result in * unexpected results */ numActiveDomains = virConnectNumOfDomains(conn); if (numActiveDomains == -1) { ret = 1; printf("Failed to get number of active domains: %s\n", virGetLastErrorMessage()); goto out; } numInactiveDomains = virConnectNumOfDefinedDomains(conn); if (numInactiveDomains == -1) { ret = 1; printf("Failed to get number of inactive domains: %s\n", virGetLastErrorMessage()); goto out; } printf("There are %d active and %d inactive domains\n", numActiveDomains, numInactiveDomains); /* Return a list of all active and inactive domains. Using this API * instead of virConnectListDomains() and virConnectListDefinedDomains() * is preferred since it "solves" an inherit race between separated API * calls if domains are started or stopped between calls */ numNames = virConnectListAllDomains(conn, &nameList, flags); if (numNames == -1) { ret = 1; printf("Failed to get a list of all domains: %s\n", virGetLastErrorMessage()); goto out; } for (i = 0; i < numNames; i++) { int active = virDomainIsActive(nameList[i]); printf(" %8s (%s)\n", virDomainGetName(nameList[i]), (active == 1 ? "active" : "non-active")); /* must free the returned named per the API documentation */ virDomainFree(nameList[i]); } free(nameList); out: return ret; }
static void rebootVM(virDomainPtr dom) { int ret = virDomainReset(dom,0); if (ret < 0) { virDomainFree(dom); } }
SnapshotActionDialog::~SnapshotActionDialog() { if ( nullptr!=domain ) virDomainFree(domain); settings.beginGroup("SnapshotActionDialog"); settings.setValue("Geometry", saveGeometry()); settings.setValue("column0", snapshotTree->columnWidth(0)); settings.setValue("column1", snapshotTree->columnWidth(1)); settings.endGroup(); settings.sync(); }
static int suspend_and_resume(virConnectPtr conn, const char *dom_name, unsigned int seconds) { int ret = -1; virDomainPtr dom; virDomainInfo dom_info; if (!(dom = virDomainLookupByName(conn, dom_name))) { ERROR("Unable to find domain '%s'", dom_name); goto cleanup; } if (virDomainGetInfo(dom, &dom_info) < 0) { ERROR("Unable to get domain info"); goto cleanup; } DEBUG("Domain state %d", dom_info.state); switch (dom_info.state) { case VIR_DOMAIN_NOSTATE: case VIR_DOMAIN_RUNNING: case VIR_DOMAIN_BLOCKED: /* In these states the domain can be suspended */ DEBUG("Suspending domain"); if (virDomainSuspend(dom) < 0) { ERROR("Unable to suspend domain"); goto cleanup; } DEBUG("Domain suspended. Entering sleep for %u seconds.", seconds); sleep(seconds); DEBUG("Sleeping done. Resuming the domain."); if (virDomainResume(dom) < 0) { ERROR("Unable to resume domain"); goto cleanup; } break; default: /* In all other states domain can't be suspended */ ERROR("Domain is not in a state where it can be suspended: %d", dom_info.state); goto cleanup; } ret = 0; cleanup: if (dom) virDomainFree(dom); return ret; }
static void free_domains (void) { if (domains) { for (int i = 0; i < nr_domains; ++i) virDomainFree (domains[i]); sfree (domains); } domains = NULL; nr_domains = 0; }
int VM_Controller::get_image_fd_by_name(std::string vm_name){ virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str()); if(dom == NULL){ return -1; } std::string img_path = _get_vm_image_path(dom); virDomainFree(dom); int fd = open(img_path.c_str(), O_RDONLY); return fd; }