自学教程：C++ virDomainLookupByName函数代码示例

static inline intwait_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;}

boolVirshType::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;}

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;}

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;}

void SnapshotActionDialog::setDomainSnapshots(){    if ( nullptr==ptr_ConnPtr || nullptr==*ptr_ConnPtr ) {        emit ptrIsNull();        return;    };    domain = virDomainLookupByName(                *ptr_ConnPtr, domName.toUtf8().data());    int namesLen = virDomainSnapshotNum(                domain, VIR_DOMAIN_SNAPSHOT_LIST_ROOTS);    if ( namesLen>0 ) {        char *names;        int ret = virDomainSnapshotListNames(                    domain,                    &names,                    namesLen,                    VIR_DOMAIN_SNAPSHOT_LIST_ROOTS);        if ( ret>0 ) {            for (int i = 0; i<ret; i++) {                addSnapshotChild(                            i,                            snapshotTree->rootIndex(),                            (&names)[i]);            };        };    };}

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;}

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 intlibvirt_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;}

int libvirt_domain_save(char * name, int idonweb){    virDomainPtr domain;    domain = virDomainLookupByName(g_conn, name);    if (domain == NULL) {        logerror(_("%s: connect domain by name(%s) error./n"),                   __func__, name);        return -1;    }    virDomainInfo info;    if (virDomainGetInfo(dom, &info) < 0) {        logprintfl(SCERROR, "Cannot check guest state/n");        return -3;    }    if (info.state == VIR_DOMAIN_SHUTOFF) {        logprintfl(SCERROR, "Not saving guest that isn't running/n");        return -4;    }    const char *filename = "";    if (virDomainSave(dom, filename) < 0) {        fprintf(stderr, "Unable to save guest to %s/n", filename);    }    fprintf(stdout, "Guest state saved to %s/n", filename);    virConnectClose(conn);    return 0;}

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 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;}

// read /var/lib/libvirt/dnsmasq/default.leases to get ip// domain must use DHCPstd::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 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 intmymain(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;}

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;}

int main(int argc, char *argv[]){	virConnectPtr conn;	int i;	int numDomains;	int *activeDomains;	char **inactiveDomains;		conn = virConnectOpen("qemu:///system");	if (conn == NULL) 	{		fprintf(stderr, "Failed to open connection to qemu:///system/n");		return -1;	}	numDomains = virConnectNumOfDomains(conn);	if (numDomains == -1) 	{		fprintf(stderr, "Failed to get domian num of qemu/n");		return -1;	}		activeDomains = malloc(sizeof(int) * numDomains);	numDomains = virConnectListDomains(conn, activeDomains, numDomains);		printf("%d Active domain list:/n", numDomains);	for (i = 0 ; i < numDomains ; i++) 	{		printf("ID = %d, Name = %s/n", activeDomains[i], virDomainGetName(virDomainLookupByID(conn, activeDomains[i])));	}	free(activeDomains);		printf("----------------------------/n");	numDomains = virConnectNumOfDefinedDomains(conn);		if (numDomains == -1) 	{		fprintf(stderr, "Failed to get defined domian num of qemu/n");		return -1;	}		inactiveDomains = malloc(sizeof(char *) * numDomains);	numDomains = virConnectListDefinedDomains(conn, inactiveDomains, numDomains);	printf("%d Inactive domain list:/n", numDomains);	for (i = 0 ; i < numDomains ; i++) 	{		/*All inactive domains's id should be 0*/		printf("ID = %d, Name = %s/n", virDomainGetID(virDomainLookupByName(conn, inactiveDomains[i])), inactiveDomains[i]);		free(inactiveDomains[i]);	}	free(inactiveDomains);		virConnectClose(conn);	return 0;}

static intsuspend_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 intdoTerminateInstance(	struct nc_state_t *nc,			ncMetadata *meta,			char *instanceId,			int *shutdownState,			int *previousState){	ncInstance *instance, *vninstance;	virConnectPtr *conn;	int err;	sem_p (inst_sem); 	instance = find_instance(&global_instances, instanceId);	sem_v (inst_sem);	if (instance == NULL) 		return NOT_FOUND;	/* try stopping the KVM domain */	conn = check_hypervisor_conn();	if (conn) {	        sem_p(hyp_sem);	        virDomainPtr dom = virDomainLookupByName(*conn, instanceId);		sem_v(hyp_sem);		if (dom) {			/* also protect 'destroy' commands, just in case */			sem_p (hyp_sem);			err = virDomainDestroy (dom);			sem_v (hyp_sem);			if (err==0) {				logprintfl (EUCAINFO, "destroyed domain for instance %s/n", instanceId);			}			sem_p(hyp_sem);			virDomainFree(dom); /* necessary? */			sem_v(hyp_sem);		} else {			if (instance->state != BOOTING)				logprintfl (EUCAWARN, "warning: domain %s to be terminated not running on hypervisor/n", instanceId);		}	} 	/* change the state and let the monitoring_thread clean up state */    sem_p (inst_sem);    if (instance->state==BOOTING) {        change_state (instance, CANCELED);    } else {        change_state (instance, SHUTOFF);    }    sem_v (inst_sem);	*previousState = instance->stateCode;	*shutdownState = instance->stateCode;	return OK;}

int libvirt_domain_active(char * name){    if (g_conn == NULL)        return 0;    virDomainPtr domain = virDomainLookupByName(g_conn, name);    int active = domain ? 1 : 0;    if (domain)        virDomainFree(domain);    return active;}

int find_a_domain(virConnectPtr conn, char *domain){	virDomainPtr dom;	// Search for a virtual machine (aka domain) on the hypervisor	// connection	dom = virDomainLookupByName(conn, domain);        if (!dom) {                return 0;        } else {		return virDomainGetID(dom);	}}

static voidadd_domains_by_name (virConnectPtr conn, char **names, size_t n){  size_t i;  virDomainPtr dom;  for (i = 0; i < n; ++i) {    dom = virDomainLookupByName (conn, names[i]);    if (dom)     /* transient errors are possible here, ignore them */      add_domain (dom);  }}

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;*/}

static intlibvirt_off(const char *vm_name, const char *src,	    uint32_t seqno, void *priv){	struct libvirt_info *info = (struct libvirt_info *)priv;	virDomainPtr vdp;	virDomainInfo vdi;	int ret = -1;	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) {		dbg_printf(2, "Nothing to do - domain does not exist/n");		return 1;	}	if (((virDomainGetInfo(vdp, &vdi) == 0) &&	     (vdi.state == VIR_DOMAIN_SHUTOFF))) {		dbg_printf(2, "Nothing to do - domain is off/n");		virDomainFree(vdp);		return 0;	}	syslog(LOG_NOTICE, "Destroying domain %s/n", vm_name);	dbg_printf(2, "[OFF] Calling virDomainDestroy/n");	ret = virDomainDestroy(vdp);	if (ret < 0) {		syslog(LOG_NOTICE, "Failed to destroy domain: %d/n", ret);		printf("virDomainDestroy() failed: %d/n", ret);		return 1;	}	if (ret) {		syslog(LOG_NOTICE,		       "Domain %s still exists; fencing failed/n",		       vm_name);		printf("Domain %s still exists; fencing failed/n", vm_name);		return 1;	}	return 0;}

static intlibvirt_on(const char *vm_name, const char *src,	   uint32_t seqno, void *priv){	struct libvirt_info *info = (struct libvirt_info *)priv;	virDomainPtr vdp;	virDomainInfo vdi;	int ret = -1;	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))) {		dbg_printf(2, "Nothing to do - domain is running/n");		if (vdp)			virDomainFree(vdp);		return 0;	}	syslog(LOG_NOTICE, "Starting domain %s/n", vm_name);	dbg_printf(2, "[ON] Calling virDomainCreate/n");	ret = virDomainCreate(vdp);	if (ret < 0) {		syslog(LOG_NOTICE, "Failed to start domain: %d/n", ret);		printf("virDomainCreate() failed: %d/n", ret);		return 1;	}	if (ret) {		syslog(LOG_NOTICE,		       "Domain %s did not start/n",		       vm_name);		printf("Domain %s did not start/n", vm_name);		return 1;	}	syslog(LOG_NOTICE, "Domain %s started/n", vm_name);	return 0;}

static int doAttachSystemDisk (    struct nc_state_t *nc,                           ncMetadata *meta,                           char *instanceId,                           char *isoPath){    ncInstance *instance;    virConnectPtr *conn;    virDomainPtr dom = NULL;    char xml[MAX_PATH]={'/0'};    int err;    snprintf (xml, sizeof(xml), "<disk type='block' device='cdrom'><source dev='%s'/><target dev='hdc' bus='ide'/><readonly/></disk>", isoPath);      //logprintfl(EUCAINFO, "doAttachSystemDisk(): founded %s [%s---%s---%d]/n", instanceId,__FILE__, __FUNCTION__, __LINE__);    sem_p(inst_sem);    instance = find_instance(&global_instances, instanceId);    sem_v(inst_sem);    if (instance == NULL || (instance->state != RUNNING&& instance->state !=  BLOCKED&& instance->state !=PAUSED)) {        logprintfl(EUCAINFO, "doAttachSystemDisk(): found %s failed or instance->state!=RUNNING||BLOCKED||PAUSED [file:%s---line:%d]/n", instanceId, __FILE__, __LINE__);        return NOT_FOUND;    }    conn = check_hypervisor_conn();    if (conn) {/*        snprintf(cmd, sizeof(cmd), "virsh attach-disk %s %s hdc --type cdrom --mode readonly",instanceId, isoPath);        logprintfl(EUCAINFO, "xiongm: cmd=%s [%s---%s---%d]/n",cmd, __FILE__, __FUNCTION__, __LINE__);        system(cmd);*/        dom = NULL;        sem_p(hyp_sem);        dom = virDomainLookupByName(*conn, instanceId);        sem_v(hyp_sem);        if (dom) {            sem_p (hyp_sem);            err = virDomainAttachDevice (dom, xml);            sem_v (hyp_sem);            if(err != 0) {                logprintfl(EUCAINFO,"virDomainAttachDevice failed. err=%d/n",err);                return 1;            }        }        logprintfl(EUCAINFO,"doAttachSystemDisk success./n");        return 0;      }    else {        logprintfl(EUCAINFO, "doAttachSystemDisk(): no connect hypervisior [file:%s---line:%d]/n",__FILE__, __LINE__);        return 1;    }       }

static intmymain(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;    TEST_TITLE("1", "qwert");    TEST_TITLE("2", NULL);    TEST_TITLE("3", "blah");    TEST_TITLE_FAIL("4", "qwe/nrt");    TEST_TITLE("5", "");    TEST_TITLE_FAIL("6", "qwert/n");    TEST_TITLE_FAIL("7", "/n");    TEST_DESCR("1", "qwert/nqwert");    TEST_DESCR("2", NULL);    TEST_DESCR("3", "qwert");    TEST_DESCR("4", "/n");    TEST_DESCR("5", "");    virDomainFree(test.dom);    virConnectClose(test.conn);    return ret;}