static int showDomains(virConnectPtr conn) { int ret = 0, i, numNames, numInactiveDomains, numActiveDomains; char **nameList = NULL; numActiveDomains = virConnectNumOfDomains(conn); if (numActiveDomains == -1) { ret = 1; printf("Failed to get number of active domains\n"); showError(conn); goto out; } numInactiveDomains = virConnectNumOfDefinedDomains(conn); if (numInactiveDomains == -1) { ret = 1; printf("Failed to get number of inactive domains\n"); showError(conn); goto out; } printf("There are %d active and %d inactive domains\n", numActiveDomains, numInactiveDomains); nameList = malloc(sizeof(*nameList) * numInactiveDomains); if (nameList == NULL) { ret = 1; printf("Could not allocate memory for list of inactive domains\n"); goto out; } numNames = virConnectListDefinedDomains(conn, nameList, numInactiveDomains); if (numNames == -1) { ret = 1; printf("Could not get list of defined domains from hypervisor\n"); showError(conn); goto out; } if (numNames > 0) { printf("Inactive domains:\n"); } for (i = 0 ; i < numNames ; i++) { printf(" %s\n", *(nameList + i)); /* The API documentation doesn't say so, but the names * returned by virConnectListDefinedDomains are strdup'd and * must be freed here. */ free(*(nameList + i)); } out: free(nameList); 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; }
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; }
void NodeWrap::doLoop() { fd_set fds; struct timeval tv; int retval; /* Go through all domains and call update() for each, letting them update * information and statistics. */ while (1) { int read_fd = agent->getSignalFd(); // We're using this to check to see if our connection is still good. // I don't see any reason this call should fail unless there is some // connection problem.. int maxname = virConnectNumOfDefinedDomains(conn); if (maxname < 0) { return; } syncDomains(); syncPools(); for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end(); iter++) { (*iter)->update(); } for (std::vector<PoolWrap*>::iterator iter = pools.begin(); iter != pools.end(); iter++) { (*iter)->update(); } /* Poll agent fd. If any methods are being made this FD will be ready for reading. */ FD_ZERO(&fds); FD_SET(read_fd, &fds); /* Wait up to three seconds. */ tv.tv_sec = 3; tv.tv_usec = 0; retval = select(read_fd + 1, &fds, NULL, NULL, &tv); if (retval < 0) { fprintf(stderr, "Error in select loop: %s\n", strerror(errno)); continue; } if (retval > 0) { /* This implements any pending methods. */ agent->pollCallbacks(); } } }
int main(int argc, char** argv) { if(argc<2) { printf("usage: %s uri\n", argv[0]); return 1; } virConnectPtr conn=virConnectOpen(argv[1]); int l=virConnectNumOfDefinedDomains(conn); char* arr[l]; l=virConnectListDefinedDomains(conn, arr, l); for(int i=0;i<l;i++) { printf("%s\n", arr[i]); } virConnectClose(conn); }
std::string VM_Controller::get_vm_info(){ Json::Value j(Json::arrayValue); int numActiveDomains = virConnectNumOfDomains(_conn); int *activeDomainsIDs = (int *)malloc(sizeof(int) * numActiveDomains); numActiveDomains = virConnectListDomains(_conn, activeDomainsIDs, numActiveDomains); for (int i = 0 ; i < numActiveDomains ; i++) { virDomainPtr dom = virDomainLookupByID(_conn, activeDomainsIDs[i]); virDomainInfo info; if(virDomainGetInfo(dom, &info) < 0){ LOG_ERROR("could not get domain info"); continue; } Json::Value j_dom(Json::objectValue); j_dom["id"] = activeDomainsIDs[i]; j_dom["mem_total"] = (unsigned long long)info.maxMem; j_dom["vcpu"] = info.nrVirtCpu; j_dom["name"] = virDomainGetName(dom); j_dom["status"] = "running"; j.append(j_dom); } free(activeDomainsIDs); int numInactiveDomains = virConnectNumOfDefinedDomains(_conn); char **inactiveDomainsNames = (char **)malloc(sizeof(char *) * numInactiveDomains); numInactiveDomains = virConnectListDefinedDomains(_conn, inactiveDomainsNames, numInactiveDomains); if(numInactiveDomains < 0){ LOG_ERROR("could not get defined domains"); exit(-1); } for(int i=0; i< numInactiveDomains; i++){ Json::Value j_dom(Json::objectValue); j_dom["status"] = "shutoff"; j_dom["name"] = inactiveDomainsNames[i]; free(inactiveDomainsNames[i]); j.append(j_dom); } free(inactiveDomainsNames); return j.toStyledString(); }
int libvirt_num_inactive_domains(void) { int num_domains = virConnectNumOfDefinedDomains(conn); return num_domains; }
void get_all_libvirt_domains (const char *libvirt_uri) { virErrorPtr err; int n; size_t i; /* Get the list of all domains. */ conn = virConnectOpenAuth (libvirt_uri, virConnectAuthPtrDefault, VIR_CONNECT_RO); if (!conn) { err = virGetLastError (); fprintf (stderr, _("%s: could not connect to libvirt (code %d, domain %d): %s\n"), guestfs_int_program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } n = virConnectNumOfDomains (conn); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not get number of running domains (code %d, domain %d): %s\n"), guestfs_int_program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } int ids[n]; n = virConnectListDomains (conn, ids, n); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not list running domains (code %d, domain %d): %s\n"), guestfs_int_program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } add_domains_by_id (conn, ids, n); n = virConnectNumOfDefinedDomains (conn); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not get number of inactive domains (code %d, domain %d): %s\n"), guestfs_int_program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } char *names[n]; n = virConnectListDefinedDomains (conn, names, n); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not list inactive domains (code %d, domain %d): %s\n"), guestfs_int_program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } add_domains_by_name (conn, names, n); /* You must free these even though the libvirt documentation doesn't * mention it. */ for (i = 0; i < (size_t) n; ++i) free (names[i]); /* No domains? */ if (nr_domains == 0) return; /* Sort the domains alphabetically by name for display. */ qsort (domains, nr_domains, sizeof (struct domain), compare_domain_names); }
void NodeWrap::syncDomains() { /* Sync up with domains that are defined but not active. */ int maxname = virConnectNumOfDefinedDomains(conn); if (maxname < 0) { REPORT_ERR(conn, "virConnectNumOfDefinedDomains"); return; } else { char **dnames; dnames = (char **) malloc(sizeof(char *) * maxname); if ((maxname = virConnectListDefinedDomains(conn, dnames, maxname)) < 0) { REPORT_ERR(conn, "virConnectListDefinedDomains"); free(dnames); return; } for (int i = 0; i < maxname; i++) { virDomainPtr domain_ptr; bool found = false; for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end(); iter++) { if ((*iter)->domain_name == dnames[i]) { found = true; break; } } if (found) { continue; } domain_ptr = virDomainLookupByName(conn, dnames[i]); if (!domain_ptr) { REPORT_ERR(conn, "virDomainLookupByName"); } else { DomainWrap *domain; try { domain = new DomainWrap(agent, this, domain_ptr, conn); printf("Created new domain: %s, ptr is %p\n", dnames[i], domain_ptr); domains.push_back(domain); } catch (int i) { printf ("Error constructing domain\n"); REPORT_ERR(conn, "constructing domain."); delete domain; } } } for (int i = 0; i < maxname; i++) { free(dnames[i]); } free(dnames); } /* Go through all the active domains */ int maxids = virConnectNumOfDomains(conn); if (maxids < 0) { REPORT_ERR(conn, "virConnectNumOfDomains"); return; } else { int *ids; ids = (int *) malloc(sizeof(int *) * maxids); if ((maxids = virConnectListDomains(conn, ids, maxids)) < 0) { printf("Error getting list of defined domains\n"); return; } for (int i = 0; i < maxids; i++) { virDomainPtr domain_ptr; char dom_uuid[VIR_UUID_STRING_BUFLEN]; domain_ptr = virDomainLookupByID(conn, ids[i]); if (!domain_ptr) { REPORT_ERR(conn, "virDomainLookupByID"); continue; } if (virDomainGetUUIDString(domain_ptr, dom_uuid) < 0) { REPORT_ERR(conn, "virDomainGetUUIDString"); continue; } bool found = false; for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end(); iter++) { if (strcmp((*iter)->domain_uuid.c_str(), dom_uuid) == 0) { found = true; break; } } if (found) { virDomainFree(domain_ptr); continue; } DomainWrap *domain; try { domain = new DomainWrap(agent, this, domain_ptr, conn); printf("Created new domain: %d, ptr is %p\n", ids[i], domain_ptr); domains.push_back(domain); } catch (int i) { printf ("Error constructing domain\n"); REPORT_ERR(conn, "constructing domain."); delete domain; } } free(ids); } /* Go through our list of domains and ensure that they still exist. */ for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end();) { printf("verifying domain %s\n", (*iter)->domain_name.c_str()); virDomainPtr ptr = virDomainLookupByUUIDString(conn, (*iter)->domain_uuid.c_str()); if (ptr == NULL) { REPORT_ERR(conn, "virDomainLookupByUUIDString"); delete (*iter); iter = domains.erase(iter); } else { virDomainFree(ptr); iter++; } } }
void get_domains_from_libvirt (void) { virErrorPtr err; virConnectPtr conn; int n; size_t i, j, nr_disks_added; nr_domains = 0; domains = NULL; /* Get the list of all domains. */ conn = virConnectOpenReadOnly (libvirt_uri); if (!conn) { err = virGetLastError (); fprintf (stderr, _("%s: could not connect to libvirt (code %d, domain %d): %s"), program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } n = virConnectNumOfDomains (conn); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not get number of running domains (code %d, domain %d): %s"), program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } int ids[n]; n = virConnectListDomains (conn, ids, n); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not list running domains (code %d, domain %d): %s"), program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } add_domains_by_id (conn, ids, n); n = virConnectNumOfDefinedDomains (conn); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not get number of inactive domains (code %d, domain %d): %s"), program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } char *names[n]; n = virConnectListDefinedDomains (conn, names, n); if (n == -1) { err = virGetLastError (); fprintf (stderr, _("%s: could not list inactive domains (code %d, domain %d): %s"), program_name, err->code, err->domain, err->message); exit (EXIT_FAILURE); } add_domains_by_name (conn, names, n); /* You must free these even though the libvirt documentation doesn't * mention it. */ for (i = 0; i < (size_t) n; ++i) free (names[i]); virConnectClose (conn); /* No domains? */ if (nr_domains == 0) return; /* Sort the domains alphabetically by name for display. */ qsort (domains, nr_domains, sizeof (struct domain), compare_domain_names); print_title (); /* To minimize the number of times we have to launch the appliance, * shuffle as many domains together as we can, but not exceeding * MAX_DISKS per request. If --one-per-guest was requested then only * request disks from a single guest each time. * Interesting application for NP-complete knapsack problem here. */ if (one_per_guest) { for (i = 0; i < nr_domains; ++i) multi_df (&domains[i], 1); } else { for (i = 0; i < nr_domains; /**/) { nr_disks_added = 0; /* Make a request with domains [i..j-1]. */ for (j = i; j < nr_domains; ++j) { if (nr_disks_added + domains[j].nr_disks > MAX_DISKS) break; nr_disks_added += domains[j].nr_disks; } multi_df (&domains[i], j-i); i = j; } } /* Free up domains structure. */ for (i = 0; i < nr_domains; ++i) free_domain (&domains[i]); free (domains); }
int get_domain_list(virConnectPtr conn, virDomainPtr **_list) { char **names = NULL; int n_names; int *ids = NULL; int n_ids; virDomainPtr *list = NULL; int i; int idx = 0; n_names = virConnectNumOfDefinedDomains(conn); n_ids = virConnectNumOfDomains(conn); if ((n_names < 0) || (n_ids < 0)) goto out; list = calloc(n_names + n_ids, sizeof(virDomainPtr)); if (!list) return 0; if (n_names > 0) { names = calloc(n_names, sizeof(char *)); if (!names) goto out; #if LIBVIR_VERSION_NUMBER<=2000 n_names = virConnectListDefinedDomains(conn, (const char **)names, n_names); #else n_names = virConnectListDefinedDomains(conn, (char ** const)names, n_names); #endif if (n_names < 0) goto out; } for (i = 0; i < n_names; i++) { virDomainPtr dom; dom = virDomainLookupByName(conn, names[i]); if (dom) list[idx++] = dom; free(names[i]); } if (n_ids > 0) { ids = calloc(n_ids, sizeof(int)); if (!ids) goto out; n_ids = virConnectListDomains(conn, ids, n_ids); if (n_ids < 0) goto out; } for (i = 0; i < n_ids; i++) { virDomainPtr dom; dom = virDomainLookupByID(conn, ids[i]); if (dom) list[idx++] = dom; } out: free(names); free(ids); if (idx == 0) { free(list); list = NULL; } *_list = list; return idx; }