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; }
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; }
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 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; }
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 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(); }
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 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 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; }
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; }
long long VM_Controller::get_image_size_by_name_in_ll(std::string vm_name){ virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str()); if(dom == NULL){ return -1ll; } else return _get_vm_image_size(dom); }
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 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; }
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; }
static int doTerminateInstance( 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; }
std::string VM_Controller::get_vm_detail_by_name(std::string 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 res = get_vm_detail(dom); virDomainFree(dom); return res; }
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 void add_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 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; 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 int libvirt_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 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; 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; }