Пример #1
0
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;
}
Пример #2
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;
}
Пример #3
0
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;
}
Пример #4
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;
}
Пример #5
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;*/
}
Пример #6
0
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;
}
Пример #7
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;
}
Пример #8
0
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;
}
Пример #9
0
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;
}
Пример #10
0
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);
}
Пример #11
0
/**
 * @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();
}
Пример #13
0
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;
}
Пример #14
0
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;
}
Пример #15
0
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;
}
Пример #16
0
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;
}
Пример #17
0
Файл: virt.cpp Проект: kohn/rsi
// 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();
}
Пример #18
0
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;
}
Пример #19
0
 //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);
 };
Пример #20
0
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;
}
Пример #21
0
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;
}
Пример #22
0
Файл: virt.cpp Проект: kohn/rsi
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;
}
Пример #23
0
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;
}
Пример #24
0
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;
}
Пример #25
0
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;
}
Пример #26
0
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();
}
Пример #28
0
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;
}
Пример #29
0
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;
}
Пример #30
0
Файл: virt.cpp Проект: kohn/rsi
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;
}