1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
14 #include <sys/queue.h>
15 #include <sys/types.h>
17 #include <sys/socket.h>
18 #include <sys/select.h>
20 #include <rte_string_fns.h>
21 #include <rte_malloc.h>
22 #include <rte_memory.h>
23 #include <rte_mempool.h>
25 #include <rte_atomic.h>
26 #include <rte_spinlock.h>
28 #include <libvirt/libvirt.h>
30 #include "channel_manager.h"
31 #include "channel_commands.h"
32 #include "channel_monitor.h"
33 #include "power_manager.h"
36 #define RTE_LOGTYPE_CHANNEL_MANAGER RTE_LOGTYPE_USER1
38 /* Global pointer to libvirt connection */
39 static virConnectPtr global_vir_conn_ptr;
41 static unsigned char *global_cpumaps;
42 static virVcpuInfo *global_vircpuinfo;
43 static size_t global_maplen;
45 static unsigned int global_n_host_cpus;
46 static bool global_hypervisor_available;
49 * Represents a single Virtual Machine
51 struct virtual_machine_info {
52 char name[CHANNEL_MGR_MAX_NAME_LEN];
53 uint16_t pcpu_map[RTE_MAX_LCORE];
54 struct channel_info *channels[RTE_MAX_LCORE];
55 char channel_mask[RTE_MAX_LCORE];
57 enum vm_status status;
58 virDomainPtr domainPtr;
60 rte_spinlock_t config_spinlock;
62 LIST_ENTRY(virtual_machine_info) vms_info;
65 LIST_HEAD(, virtual_machine_info) vm_list_head;
67 static struct virtual_machine_info *
68 find_domain_by_name(const char *name)
70 struct virtual_machine_info *info;
71 LIST_FOREACH(info, &vm_list_head, vms_info) {
72 if (!strncmp(info->name, name, CHANNEL_MGR_MAX_NAME_LEN-1))
79 update_pcpus_mask(struct virtual_machine_info *vm_info)
81 virVcpuInfoPtr cpuinfo;
85 memset(global_cpumaps, 0, RTE_MAX_LCORE*global_maplen);
87 if (!virDomainIsActive(vm_info->domainPtr)) {
88 n_vcpus = virDomainGetVcpuPinInfo(vm_info->domainPtr,
89 vm_info->info.nrVirtCpu, global_cpumaps, global_maplen,
90 VIR_DOMAIN_AFFECT_CONFIG);
92 RTE_LOG(ERR, CHANNEL_MANAGER, "Error getting vCPU info for "
93 "in-active VM '%s'\n", vm_info->name);
99 memset(global_vircpuinfo, 0, sizeof(*global_vircpuinfo)*
102 cpuinfo = global_vircpuinfo;
104 n_vcpus = virDomainGetVcpus(vm_info->domainPtr, cpuinfo,
105 RTE_MAX_LCORE, global_cpumaps, global_maplen);
107 RTE_LOG(ERR, CHANNEL_MANAGER, "Error getting vCPU info for "
108 "active VM '%s'\n", vm_info->name);
112 if (n_vcpus >= RTE_MAX_LCORE) {
113 RTE_LOG(ERR, CHANNEL_MANAGER, "Number of vCPUS(%u) is out of range "
114 "0...%d\n", n_vcpus, RTE_MAX_LCORE-1);
117 if (n_vcpus != vm_info->info.nrVirtCpu) {
118 RTE_LOG(INFO, CHANNEL_MANAGER, "Updating the number of vCPUs for VM '%s"
119 " from %d -> %d\n", vm_info->name, vm_info->info.nrVirtCpu,
121 vm_info->info.nrVirtCpu = n_vcpus;
123 rte_spinlock_lock(&(vm_info->config_spinlock));
124 for (i = 0; i < vm_info->info.nrVirtCpu; i++) {
125 for (j = 0; j < global_n_host_cpus; j++) {
126 if (VIR_CPU_USABLE(global_cpumaps,
127 global_maplen, i, j) <= 0)
129 vm_info->pcpu_map[i] = j;
132 rte_spinlock_unlock(&(vm_info->config_spinlock));
137 set_pcpu(char *vm_name, unsigned int vcpu, unsigned int pcpu)
139 int flags = VIR_DOMAIN_AFFECT_LIVE|VIR_DOMAIN_AFFECT_CONFIG;
140 struct virtual_machine_info *vm_info;
142 if (vcpu >= RTE_MAX_LCORE) {
143 RTE_LOG(ERR, CHANNEL_MANAGER, "vCPU(%u) exceeds max allowable(%d)\n",
144 vcpu, RTE_MAX_LCORE-1);
148 vm_info = find_domain_by_name(vm_name);
149 if (vm_info == NULL) {
150 RTE_LOG(ERR, CHANNEL_MANAGER, "VM '%s' not found\n", vm_name);
154 if (!virDomainIsActive(vm_info->domainPtr)) {
155 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to set vCPU(%u) to pCPU "
156 " for VM '%s', VM is not active\n",
157 vcpu, vm_info->name);
161 if (vcpu >= vm_info->info.nrVirtCpu) {
162 RTE_LOG(ERR, CHANNEL_MANAGER, "vCPU(%u) exceeds the assigned number of "
163 "vCPUs(%u)\n", vcpu, vm_info->info.nrVirtCpu);
166 memset(global_cpumaps, 0, RTE_MAX_LCORE * global_maplen);
168 VIR_USE_CPU(global_cpumaps, pcpu);
170 if (pcpu >= global_n_host_cpus) {
171 RTE_LOG(ERR, CHANNEL_MANAGER, "CPU(%u) exceeds the available "
172 "number of CPUs(%u)\n",
173 pcpu, global_n_host_cpus);
177 if (virDomainPinVcpuFlags(vm_info->domainPtr, vcpu, global_cpumaps,
178 global_maplen, flags) < 0) {
179 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to set vCPU(%u) to pCPU "
180 " for VM '%s'\n", vcpu,
184 rte_spinlock_lock(&(vm_info->config_spinlock));
185 vm_info->pcpu_map[vcpu] = pcpu;
186 rte_spinlock_unlock(&(vm_info->config_spinlock));
191 get_pcpu(struct channel_info *chan_info, unsigned int vcpu)
193 struct virtual_machine_info *vm_info =
194 (struct virtual_machine_info *)chan_info->priv_info;
196 if (global_hypervisor_available && (vm_info != NULL)) {
198 rte_spinlock_lock(&(vm_info->config_spinlock));
199 pcpu = vm_info->pcpu_map[vcpu];
200 rte_spinlock_unlock(&(vm_info->config_spinlock));
207 channel_exists(struct virtual_machine_info *vm_info, unsigned channel_num)
209 rte_spinlock_lock(&(vm_info->config_spinlock));
210 if (vm_info->channel_mask[channel_num] == 1) {
211 rte_spinlock_unlock(&(vm_info->config_spinlock));
214 rte_spinlock_unlock(&(vm_info->config_spinlock));
221 open_non_blocking_channel(struct channel_info *info)
224 struct sockaddr_un sock_addr;
228 info->fd = socket(AF_UNIX, SOCK_STREAM, 0);
230 RTE_LOG(ERR, CHANNEL_MANAGER, "Error(%s) creating socket for '%s'\n",
235 sock_addr.sun_family = AF_UNIX;
236 memcpy(&sock_addr.sun_path, info->channel_path,
237 strlen(info->channel_path)+1);
239 /* Get current flags */
240 flags = fcntl(info->fd, F_GETFL, 0);
242 RTE_LOG(WARNING, CHANNEL_MANAGER, "Error(%s) fcntl get flags socket for"
243 "'%s'\n", strerror(errno), info->channel_path);
246 /* Set to Non Blocking */
248 if (fcntl(info->fd, F_SETFL, flags) < 0) {
249 RTE_LOG(WARNING, CHANNEL_MANAGER, "Error(%s) setting non-blocking "
250 "socket for '%s'\n", strerror(errno), info->channel_path);
253 ret = connect(info->fd, (struct sockaddr *)&sock_addr,
256 /* ECONNREFUSED error is given when VM is not active */
257 if (errno == ECONNREFUSED) {
258 RTE_LOG(WARNING, CHANNEL_MANAGER, "VM is not active or has not "
259 "activated its endpoint to channel %s\n",
263 /* Wait for tv_sec if in progress */
264 else if (errno == EINPROGRESS) {
267 FD_ZERO(&soc_fd_set);
268 FD_SET(info->fd, &soc_fd_set);
269 if (select(info->fd+1, NULL, &soc_fd_set, NULL, &tv) > 0) {
270 RTE_LOG(WARNING, CHANNEL_MANAGER, "Timeout or error on channel "
271 "'%s'\n", info->channel_path);
275 /* Any other error */
276 RTE_LOG(WARNING, CHANNEL_MANAGER, "Error(%s) connecting socket"
277 " for '%s'\n", strerror(errno), info->channel_path);
285 open_host_channel(struct channel_info *info)
289 info->fd = open(info->channel_path, O_RDWR | O_RSYNC);
291 RTE_LOG(ERR, CHANNEL_MANAGER, "Error(%s) opening fifo for '%s'\n",
297 /* Get current flags */
298 flags = fcntl(info->fd, F_GETFL, 0);
300 RTE_LOG(WARNING, CHANNEL_MANAGER, "Error(%s) fcntl get flags socket for"
301 "'%s'\n", strerror(errno), info->channel_path);
304 /* Set to Non Blocking */
306 if (fcntl(info->fd, F_SETFL, flags) < 0) {
307 RTE_LOG(WARNING, CHANNEL_MANAGER,
308 "Error(%s) setting non-blocking "
310 strerror(errno), info->channel_path);
317 setup_channel_info(struct virtual_machine_info **vm_info_dptr,
318 struct channel_info **chan_info_dptr, unsigned channel_num)
320 struct channel_info *chan_info = *chan_info_dptr;
321 struct virtual_machine_info *vm_info = *vm_info_dptr;
323 chan_info->channel_num = channel_num;
324 chan_info->priv_info = (void *)vm_info;
325 chan_info->status = CHANNEL_MGR_CHANNEL_DISCONNECTED;
326 chan_info->type = CHANNEL_TYPE_BINARY;
327 if (open_non_blocking_channel(chan_info) < 0) {
328 RTE_LOG(ERR, CHANNEL_MANAGER, "Could not open channel: "
329 "'%s' for VM '%s'\n",
330 chan_info->channel_path, vm_info->name);
333 if (add_channel_to_monitor(&chan_info) < 0) {
334 RTE_LOG(ERR, CHANNEL_MANAGER, "Could add channel: "
335 "'%s' to epoll ctl for VM '%s'\n",
336 chan_info->channel_path, vm_info->name);
340 rte_spinlock_lock(&(vm_info->config_spinlock));
341 vm_info->num_channels++;
342 vm_info->channel_mask[channel_num] = 1;
343 vm_info->channels[channel_num] = chan_info;
344 chan_info->status = CHANNEL_MGR_CHANNEL_CONNECTED;
345 rte_spinlock_unlock(&(vm_info->config_spinlock));
350 fifo_path(char *dst, unsigned int len, unsigned int id)
354 cnt = snprintf(dst, len, "%s%s%d", CHANNEL_MGR_SOCKET_PATH,
355 CHANNEL_MGR_FIFO_PATTERN_NAME, id);
357 if ((cnt < 0) || (cnt > (int)len - 1)) {
358 RTE_LOG(ERR, CHANNEL_MANAGER, "Could not create proper "
359 "string for fifo path\n");
368 setup_host_channel_info(struct channel_info **chan_info_dptr,
369 unsigned int channel_num)
371 struct channel_info *chan_info = *chan_info_dptr;
373 chan_info->channel_num = channel_num;
374 chan_info->priv_info = (void *)NULL;
375 chan_info->status = CHANNEL_MGR_CHANNEL_DISCONNECTED;
376 chan_info->type = CHANNEL_TYPE_JSON;
378 if (open_host_channel(chan_info) < 0) {
379 RTE_LOG(ERR, CHANNEL_MANAGER, "Could not open host channel: "
381 chan_info->channel_path);
384 if (add_channel_to_monitor(&chan_info) < 0) {
385 RTE_LOG(ERR, CHANNEL_MANAGER, "Could add channel: "
386 "'%s' to epoll ctl\n",
387 chan_info->channel_path);
391 chan_info->status = CHANNEL_MGR_CHANNEL_CONNECTED;
396 add_all_channels(const char *vm_name)
400 struct virtual_machine_info *vm_info;
401 struct channel_info *chan_info;
402 char *token, *remaining, *tail_ptr;
403 char socket_name[PATH_MAX];
404 unsigned channel_num;
405 int num_channels_enabled = 0;
407 /* verify VM exists */
408 vm_info = find_domain_by_name(vm_name);
409 if (vm_info == NULL) {
410 RTE_LOG(ERR, CHANNEL_MANAGER, "VM: '%s' not found"
411 " during channel discovery\n", vm_name);
414 if (!virDomainIsActive(vm_info->domainPtr)) {
415 RTE_LOG(ERR, CHANNEL_MANAGER, "VM: '%s' is not active\n", vm_name);
416 vm_info->status = CHANNEL_MGR_VM_INACTIVE;
419 d = opendir(CHANNEL_MGR_SOCKET_PATH);
421 RTE_LOG(ERR, CHANNEL_MANAGER, "Error opening directory '%s': %s\n",
422 CHANNEL_MGR_SOCKET_PATH, strerror(errno));
425 while ((dir = readdir(d)) != NULL) {
426 if (!strncmp(dir->d_name, ".", 1) ||
427 !strncmp(dir->d_name, "..", 2))
430 strlcpy(socket_name, dir->d_name, sizeof(socket_name));
431 remaining = socket_name;
432 /* Extract vm_name from "<vm_name>.<channel_num>" */
433 token = strsep(&remaining, ".");
434 if (remaining == NULL)
436 if (strncmp(vm_name, token, CHANNEL_MGR_MAX_NAME_LEN))
439 /* remaining should contain only <channel_num> */
441 channel_num = (unsigned)strtol(remaining, &tail_ptr, 0);
442 if ((errno != 0) || (remaining[0] == '\0') ||
443 tail_ptr == NULL || (*tail_ptr != '\0')) {
444 RTE_LOG(WARNING, CHANNEL_MANAGER, "Malformed channel name"
445 "'%s' found it should be in the form of "
446 "'<guest_name>.<channel_num>(decimal)'\n",
450 if (channel_num >= RTE_MAX_LCORE) {
451 RTE_LOG(WARNING, CHANNEL_MANAGER, "Channel number(%u) is "
452 "greater than max allowable: %d, skipping '%s%s'\n",
453 channel_num, RTE_MAX_LCORE-1,
454 CHANNEL_MGR_SOCKET_PATH, dir->d_name);
457 /* if channel has not been added previously */
458 if (channel_exists(vm_info, channel_num))
461 chan_info = rte_malloc(NULL, sizeof(*chan_info),
462 RTE_CACHE_LINE_SIZE);
463 if (chan_info == NULL) {
464 RTE_LOG(ERR, CHANNEL_MANAGER, "Error allocating memory for "
465 "channel '%s%s'\n", CHANNEL_MGR_SOCKET_PATH, dir->d_name);
469 snprintf(chan_info->channel_path,
470 sizeof(chan_info->channel_path), "%s%s",
471 CHANNEL_MGR_SOCKET_PATH, dir->d_name);
473 if (setup_channel_info(&vm_info, &chan_info, channel_num) < 0) {
478 num_channels_enabled++;
481 return num_channels_enabled;
485 add_channels(const char *vm_name, unsigned *channel_list,
486 unsigned len_channel_list)
488 struct virtual_machine_info *vm_info;
489 struct channel_info *chan_info;
490 char socket_path[PATH_MAX];
492 int num_channels_enabled = 0;
494 vm_info = find_domain_by_name(vm_name);
495 if (vm_info == NULL) {
496 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to add channels: VM '%s' "
497 "not found\n", vm_name);
501 if (!virDomainIsActive(vm_info->domainPtr)) {
502 RTE_LOG(ERR, CHANNEL_MANAGER, "VM: '%s' is not active\n", vm_name);
503 vm_info->status = CHANNEL_MGR_VM_INACTIVE;
507 for (i = 0; i < len_channel_list; i++) {
509 if (channel_list[i] >= RTE_MAX_LCORE) {
510 RTE_LOG(INFO, CHANNEL_MANAGER, "Channel(%u) is out of range "
511 "0...%d\n", channel_list[i],
515 if (channel_exists(vm_info, channel_list[i])) {
516 RTE_LOG(INFO, CHANNEL_MANAGER, "Channel already exists, skipping "
517 "'%s.%u'\n", vm_name, i);
521 snprintf(socket_path, sizeof(socket_path), "%s%s.%u",
522 CHANNEL_MGR_SOCKET_PATH, vm_name, channel_list[i]);
524 if (access(socket_path, F_OK) < 0) {
525 RTE_LOG(ERR, CHANNEL_MANAGER, "Channel path '%s' error: "
526 "%s\n", socket_path, strerror(errno));
529 chan_info = rte_malloc(NULL, sizeof(*chan_info),
530 RTE_CACHE_LINE_SIZE);
531 if (chan_info == NULL) {
532 RTE_LOG(ERR, CHANNEL_MANAGER, "Error allocating memory for "
533 "channel '%s'\n", socket_path);
536 snprintf(chan_info->channel_path,
537 sizeof(chan_info->channel_path), "%s%s.%u",
538 CHANNEL_MGR_SOCKET_PATH, vm_name, channel_list[i]);
539 if (setup_channel_info(&vm_info, &chan_info, channel_list[i]) < 0) {
543 num_channels_enabled++;
546 return num_channels_enabled;
550 add_host_channels(void)
552 struct channel_info *chan_info;
553 char socket_path[PATH_MAX];
554 int num_channels_enabled = 0;
556 struct core_info *ci;
557 struct channel_info *chan_infos[RTE_MAX_LCORE];
560 for (i = 0; i < RTE_MAX_LCORE; i++)
561 chan_infos[i] = NULL;
563 ci = get_core_info();
565 RTE_LOG(ERR, CHANNEL_MANAGER, "Cannot allocate memory for core_info\n");
569 for (i = 0; i < ci->core_count; i++) {
570 if (ci->cd[i].global_enabled_cpus == 0)
573 ret = fifo_path(socket_path, sizeof(socket_path), i);
577 ret = mkfifo(socket_path, 0660);
578 RTE_LOG(DEBUG, CHANNEL_MANAGER, "TRY CREATE fifo '%s'\n",
580 if ((errno != EEXIST) && (ret < 0)) {
581 RTE_LOG(ERR, CHANNEL_MANAGER, "Cannot create fifo '%s' error: "
582 "%s\n", socket_path, strerror(errno));
585 chan_info = rte_malloc(NULL, sizeof(*chan_info), 0);
586 if (chan_info == NULL) {
587 RTE_LOG(ERR, CHANNEL_MANAGER, "Error allocating memory for "
588 "channel '%s'\n", socket_path);
591 chan_infos[i] = chan_info;
592 strlcpy(chan_info->channel_path, socket_path,
593 sizeof(chan_info->channel_path));
595 if (setup_host_channel_info(&chan_info, i) < 0) {
597 chan_infos[i] = NULL;
600 num_channels_enabled++;
603 return num_channels_enabled;
605 /* Clean up the channels opened before we hit an error. */
606 for (i = 0; i < ci->core_count; i++) {
607 if (chan_infos[i] != NULL) {
608 remove_channel_from_monitor(chan_infos[i]);
609 close(chan_infos[i]->fd);
610 rte_free(chan_infos[i]);
617 remove_channel(struct channel_info **chan_info_dptr)
619 struct virtual_machine_info *vm_info;
620 struct channel_info *chan_info = *chan_info_dptr;
622 close(chan_info->fd);
624 vm_info = (struct virtual_machine_info *)chan_info->priv_info;
626 rte_spinlock_lock(&(vm_info->config_spinlock));
627 vm_info->channel_mask[chan_info->channel_num] = 0;
628 vm_info->num_channels--;
629 rte_spinlock_unlock(&(vm_info->config_spinlock));
636 set_channel_status_all(const char *vm_name, enum channel_status status)
638 struct virtual_machine_info *vm_info;
640 char mask[RTE_MAX_LCORE];
641 int num_channels_changed = 0;
643 if (!(status == CHANNEL_MGR_CHANNEL_CONNECTED ||
644 status == CHANNEL_MGR_CHANNEL_DISABLED)) {
645 RTE_LOG(ERR, CHANNEL_MANAGER, "Channels can only be enabled or "
646 "disabled: Unable to change status for VM '%s'\n", vm_name);
648 vm_info = find_domain_by_name(vm_name);
649 if (vm_info == NULL) {
650 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to disable channels: VM '%s' "
651 "not found\n", vm_name);
655 rte_spinlock_lock(&(vm_info->config_spinlock));
656 memcpy(mask, (char *)vm_info->channel_mask, RTE_MAX_LCORE);
657 for (i = 0; i < RTE_MAX_LCORE; i++) {
660 vm_info->channels[i]->status = status;
661 num_channels_changed++;
663 rte_spinlock_unlock(&(vm_info->config_spinlock));
664 return num_channels_changed;
669 set_channel_status(const char *vm_name, unsigned *channel_list,
670 unsigned len_channel_list, enum channel_status status)
672 struct virtual_machine_info *vm_info;
674 int num_channels_changed = 0;
676 if (!(status == CHANNEL_MGR_CHANNEL_CONNECTED ||
677 status == CHANNEL_MGR_CHANNEL_DISABLED)) {
678 RTE_LOG(ERR, CHANNEL_MANAGER, "Channels can only be enabled or "
679 "disabled: Unable to change status for VM '%s'\n", vm_name);
681 vm_info = find_domain_by_name(vm_name);
682 if (vm_info == NULL) {
683 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to add channels: VM '%s' "
684 "not found\n", vm_name);
687 for (i = 0; i < len_channel_list; i++) {
688 if (channel_exists(vm_info, channel_list[i])) {
689 rte_spinlock_lock(&(vm_info->config_spinlock));
690 vm_info->channels[channel_list[i]]->status = status;
691 rte_spinlock_unlock(&(vm_info->config_spinlock));
692 num_channels_changed++;
695 return num_channels_changed;
699 get_all_vm(int *num_vm, int *num_vcpu)
702 virNodeInfo node_info;
703 virDomainPtr *domptr;
704 int i, ii, numVcpus[MAX_VCPUS], n_vcpus;
707 unsigned int domain_flags = VIR_CONNECT_LIST_DOMAINS_RUNNING |
708 VIR_CONNECT_LIST_DOMAINS_PERSISTENT;
709 unsigned int domain_flag = VIR_DOMAIN_VCPU_CONFIG;
711 if (!global_hypervisor_available)
714 memset(global_cpumaps, 0, RTE_MAX_LCORE*global_maplen);
715 if (virNodeGetInfo(global_vir_conn_ptr, &node_info)) {
716 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to retrieve node Info\n");
720 /* Returns number of pcpus */
721 global_n_host_cpus = (unsigned int)node_info.cpus;
723 /* Returns number of active domains */
724 *num_vm = virConnectListAllDomains(global_vir_conn_ptr, &domptr,
727 RTE_LOG(ERR, CHANNEL_MANAGER, "No Active Domains Running\n");
731 for (i = 0; i < *num_vm; i++) {
733 /* Get Domain Names */
734 vm_name = virDomainGetName(domptr[i]);
735 lvm_info[i].vm_name = vm_name;
737 /* Get Number of Vcpus */
738 numVcpus[i] = virDomainGetVcpusFlags(domptr[i], domain_flag);
740 /* Get Number of VCpus & VcpuPinInfo */
741 n_vcpus = virDomainGetVcpuPinInfo(domptr[i],
742 numVcpus[i], global_cpumaps,
743 global_maplen, domain_flag);
745 if ((int)n_vcpus > 0) {
747 lvm_info[i].num_cpus = n_vcpus;
750 /* Save pcpu in use by libvirt VMs */
751 for (ii = 0; ii < n_vcpus; ii++) {
752 for (jj = 0; jj < global_n_host_cpus; jj++) {
753 if (VIR_CPU_USABLE(global_cpumaps,
754 global_maplen, ii, jj) > 0) {
755 lvm_info[i].pcpus[ii] = jj;
763 get_info_vm(const char *vm_name, struct vm_info *info)
765 struct virtual_machine_info *vm_info;
766 unsigned i, channel_num = 0;
767 char mask[RTE_MAX_LCORE];
769 vm_info = find_domain_by_name(vm_name);
770 if (vm_info == NULL) {
771 RTE_LOG(ERR, CHANNEL_MANAGER, "VM '%s' not found\n", vm_name);
774 info->status = CHANNEL_MGR_VM_ACTIVE;
775 if (!virDomainIsActive(vm_info->domainPtr))
776 info->status = CHANNEL_MGR_VM_INACTIVE;
778 rte_spinlock_lock(&(vm_info->config_spinlock));
780 memcpy(mask, (char *)vm_info->channel_mask, RTE_MAX_LCORE);
781 for (i = 0; i < RTE_MAX_LCORE; i++) {
784 info->channels[channel_num].channel_num = i;
785 memcpy(info->channels[channel_num].channel_path,
786 vm_info->channels[i]->channel_path,
788 info->channels[channel_num].status =
789 vm_info->channels[i]->status;
790 info->channels[channel_num].fd =
791 vm_info->channels[i]->fd;
795 info->allow_query = vm_info->allow_query;
796 info->num_channels = channel_num;
797 info->num_vcpus = vm_info->info.nrVirtCpu;
798 rte_spinlock_unlock(&(vm_info->config_spinlock));
800 memcpy(info->name, vm_info->name, sizeof(vm_info->name));
801 rte_spinlock_lock(&(vm_info->config_spinlock));
802 for (i = 0; i < info->num_vcpus; i++) {
803 info->pcpu_map[i] = vm_info->pcpu_map[i];
805 rte_spinlock_unlock(&(vm_info->config_spinlock));
810 add_vm(const char *vm_name)
812 struct virtual_machine_info *new_domain;
813 virDomainPtr dom_ptr;
816 if (find_domain_by_name(vm_name) != NULL) {
817 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to add VM: VM '%s' "
818 "already exists\n", vm_name);
822 if (global_vir_conn_ptr == NULL) {
823 RTE_LOG(ERR, CHANNEL_MANAGER, "No connection to hypervisor exists\n");
826 dom_ptr = virDomainLookupByName(global_vir_conn_ptr, vm_name);
827 if (dom_ptr == NULL) {
828 RTE_LOG(ERR, CHANNEL_MANAGER, "Error on VM lookup with libvirt: "
829 "VM '%s' not found\n", vm_name);
833 new_domain = rte_malloc("virtual_machine_info", sizeof(*new_domain),
834 RTE_CACHE_LINE_SIZE);
835 if (new_domain == NULL) {
836 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to allocate memory for VM "
840 new_domain->domainPtr = dom_ptr;
841 if (virDomainGetInfo(new_domain->domainPtr, &new_domain->info) != 0) {
842 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to get libvirt VM info\n");
843 rte_free(new_domain);
846 if (new_domain->info.nrVirtCpu > RTE_MAX_LCORE) {
847 RTE_LOG(ERR, CHANNEL_MANAGER, "Error the number of virtual CPUs(%u) is "
848 "greater than allowable(%d)\n", new_domain->info.nrVirtCpu,
850 rte_free(new_domain);
854 for (i = 0; i < RTE_MAX_LCORE; i++)
855 new_domain->pcpu_map[i] = 0;
857 if (update_pcpus_mask(new_domain) < 0) {
858 RTE_LOG(ERR, CHANNEL_MANAGER, "Error getting physical CPU pinning\n");
859 rte_free(new_domain);
862 strncpy(new_domain->name, vm_name, sizeof(new_domain->name));
863 new_domain->name[sizeof(new_domain->name) - 1] = '\0';
864 memset(new_domain->channel_mask, 0, RTE_MAX_LCORE);
865 new_domain->num_channels = 0;
867 if (!virDomainIsActive(dom_ptr))
868 new_domain->status = CHANNEL_MGR_VM_INACTIVE;
870 new_domain->status = CHANNEL_MGR_VM_ACTIVE;
872 new_domain->allow_query = 0;
873 rte_spinlock_init(&(new_domain->config_spinlock));
874 LIST_INSERT_HEAD(&vm_list_head, new_domain, vms_info);
879 remove_vm(const char *vm_name)
881 struct virtual_machine_info *vm_info = find_domain_by_name(vm_name);
883 if (vm_info == NULL) {
884 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to remove VM: VM '%s' "
885 "not found\n", vm_name);
888 rte_spinlock_lock(&vm_info->config_spinlock);
889 if (vm_info->num_channels != 0) {
890 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to remove VM '%s', there are "
891 "%"PRId8" channels still active\n",
892 vm_name, vm_info->num_channels);
893 rte_spinlock_unlock(&vm_info->config_spinlock);
896 LIST_REMOVE(vm_info, vms_info);
897 rte_spinlock_unlock(&vm_info->config_spinlock);
903 set_query_status(char *vm_name,
906 struct virtual_machine_info *vm_info;
908 vm_info = find_domain_by_name(vm_name);
909 if (vm_info == NULL) {
910 RTE_LOG(ERR, CHANNEL_MANAGER, "VM '%s' not found\n", vm_name);
913 rte_spinlock_lock(&(vm_info->config_spinlock));
914 vm_info->allow_query = allow_query ? 1 : 0;
915 rte_spinlock_unlock(&(vm_info->config_spinlock));
920 disconnect_hypervisor(void)
922 if (global_vir_conn_ptr != NULL) {
923 virConnectClose(global_vir_conn_ptr);
924 global_vir_conn_ptr = NULL;
929 connect_hypervisor(const char *path)
931 if (global_vir_conn_ptr != NULL) {
932 RTE_LOG(ERR, CHANNEL_MANAGER, "Error connecting to %s, connection "
933 "already established\n", path);
936 global_vir_conn_ptr = virConnectOpen(path);
937 if (global_vir_conn_ptr == NULL) {
938 RTE_LOG(ERR, CHANNEL_MANAGER, "Error failed to open connection to "
939 "Hypervisor '%s'\n", path);
945 channel_manager_init(const char *path __rte_unused)
949 LIST_INIT(&vm_list_head);
950 if (connect_hypervisor(path) < 0) {
951 global_n_host_cpus = 64;
952 global_hypervisor_available = 0;
953 RTE_LOG(INFO, CHANNEL_MANAGER, "Unable to initialize channel manager\n");
955 global_hypervisor_available = 1;
957 global_maplen = VIR_CPU_MAPLEN(RTE_MAX_LCORE);
959 global_vircpuinfo = rte_zmalloc(NULL,
960 sizeof(*global_vircpuinfo) *
961 RTE_MAX_LCORE, RTE_CACHE_LINE_SIZE);
962 if (global_vircpuinfo == NULL) {
963 RTE_LOG(ERR, CHANNEL_MANAGER, "Error allocating memory for CPU Info\n");
966 global_cpumaps = rte_zmalloc(NULL,
967 RTE_MAX_LCORE * global_maplen,
968 RTE_CACHE_LINE_SIZE);
969 if (global_cpumaps == NULL)
972 if (virNodeGetInfo(global_vir_conn_ptr, &info)) {
973 RTE_LOG(ERR, CHANNEL_MANAGER, "Unable to retrieve node Info\n");
976 global_n_host_cpus = (unsigned int)info.cpus;
981 if (global_n_host_cpus > RTE_MAX_LCORE) {
982 RTE_LOG(WARNING, CHANNEL_MANAGER, "The number of host CPUs(%u) exceeds the "
983 "maximum of %u. No cores over %u should be used.\n",
984 global_n_host_cpus, RTE_MAX_LCORE,
986 global_n_host_cpus = RTE_MAX_LCORE;
991 if (global_hypervisor_available)
992 disconnect_hypervisor();
997 channel_manager_exit(void)
1000 char mask[RTE_MAX_LCORE];
1001 struct virtual_machine_info *vm_info;
1003 LIST_FOREACH(vm_info, &vm_list_head, vms_info) {
1005 rte_spinlock_lock(&(vm_info->config_spinlock));
1007 memcpy(mask, (char *)vm_info->channel_mask, RTE_MAX_LCORE);
1008 for (i = 0; i < RTE_MAX_LCORE; i++) {
1011 remove_channel_from_monitor(
1012 vm_info->channels[i]);
1013 close(vm_info->channels[i]->fd);
1014 rte_free(vm_info->channels[i]);
1016 rte_spinlock_unlock(&(vm_info->config_spinlock));
1018 LIST_REMOVE(vm_info, vms_info);
1022 if (global_hypervisor_available) {
1023 /* Only needed if hypervisor available */
1024 rte_free(global_cpumaps);
1025 rte_free(global_vircpuinfo);
1026 disconnect_hypervisor();