1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2018-2019 Cisco Systems, Inc. All rights reserved.
9 #include <sys/socket.h>
11 #include <sys/ioctl.h>
14 #include <rte_version.h>
16 #include <rte_ether.h>
17 #include <rte_ethdev_driver.h>
18 #include <rte_ethdev_vdev.h>
19 #include <rte_malloc.h>
20 #include <rte_kvargs.h>
21 #include <rte_bus_vdev.h>
23 #include <rte_jhash.h>
24 #include <rte_string_fns.h>
26 #include "rte_eth_memif.h"
27 #include "memif_socket.h"
29 static void memif_intr_handler(void *arg);
32 memif_msg_send(int fd, memif_msg_t *msg, int afd)
34 struct msghdr mh = { 0 };
37 char ctl[CMSG_SPACE(sizeof(int))];
39 iov[0].iov_base = msg;
40 iov[0].iov_len = sizeof(memif_msg_t);
45 memset(&ctl, 0, sizeof(ctl));
47 mh.msg_controllen = sizeof(ctl);
48 cmsg = CMSG_FIRSTHDR(&mh);
49 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
50 cmsg->cmsg_level = SOL_SOCKET;
51 cmsg->cmsg_type = SCM_RIGHTS;
52 rte_memcpy(CMSG_DATA(cmsg), &afd, sizeof(int));
55 return sendmsg(fd, &mh, 0);
59 memif_msg_send_from_queue(struct memif_control_channel *cc)
63 struct memif_msg_queue_elt *e;
65 e = TAILQ_FIRST(&cc->msg_queue);
69 size = memif_msg_send(cc->intr_handle.fd, &e->msg, e->fd);
70 if (size != sizeof(memif_msg_t)) {
71 MIF_LOG(ERR, "sendmsg fail: %s.", strerror(errno));
74 MIF_LOG(DEBUG, "Sent msg type %u.", e->msg.type);
76 TAILQ_REMOVE(&cc->msg_queue, e, next);
82 static struct memif_msg_queue_elt *
83 memif_msg_enq(struct memif_control_channel *cc)
85 struct memif_msg_queue_elt *e;
87 e = rte_zmalloc("memif_msg", sizeof(struct memif_msg_queue_elt), 0);
89 MIF_LOG(ERR, "Failed to allocate control message.");
94 TAILQ_INSERT_TAIL(&cc->msg_queue, e, next);
100 memif_msg_enq_disconnect(struct memif_control_channel *cc, const char *reason,
103 struct memif_msg_queue_elt *e;
104 struct pmd_internals *pmd;
105 memif_msg_disconnect_t *d;
108 MIF_LOG(DEBUG, "Missing control channel.");
112 e = memif_msg_enq(cc);
114 MIF_LOG(WARNING, "Failed to enqueue disconnect message.");
118 d = &e->msg.disconnect;
120 e->msg.type = MEMIF_MSG_TYPE_DISCONNECT;
123 if (reason != NULL) {
124 strlcpy((char *)d->string, reason, sizeof(d->string));
125 if (cc->dev != NULL) {
126 pmd = cc->dev->data->dev_private;
127 strlcpy(pmd->local_disc_string, reason,
128 sizeof(pmd->local_disc_string));
134 memif_msg_enq_hello(struct memif_control_channel *cc)
136 struct memif_msg_queue_elt *e = memif_msg_enq(cc);
137 memif_msg_hello_t *h;
144 e->msg.type = MEMIF_MSG_TYPE_HELLO;
145 h->min_version = MEMIF_VERSION;
146 h->max_version = MEMIF_VERSION;
147 h->max_s2m_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS;
148 h->max_m2s_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS;
149 h->max_region = ETH_MEMIF_MAX_REGION_NUM - 1;
150 h->max_log2_ring_size = ETH_MEMIF_MAX_LOG2_RING_SIZE;
152 strlcpy((char *)h->name, rte_version(), sizeof(h->name));
158 memif_msg_receive_hello(struct rte_eth_dev *dev, memif_msg_t *msg)
160 struct pmd_internals *pmd = dev->data->dev_private;
161 memif_msg_hello_t *h = &msg->hello;
163 if (h->min_version > MEMIF_VERSION || h->max_version < MEMIF_VERSION) {
164 memif_msg_enq_disconnect(pmd->cc, "Incompatible memif version", 0);
168 /* Set parameters for active connection */
169 pmd->run.num_s2m_rings = RTE_MIN(h->max_s2m_ring + 1,
170 pmd->cfg.num_s2m_rings);
171 pmd->run.num_m2s_rings = RTE_MIN(h->max_m2s_ring + 1,
172 pmd->cfg.num_m2s_rings);
173 pmd->run.log2_ring_size = RTE_MIN(h->max_log2_ring_size,
174 pmd->cfg.log2_ring_size);
175 pmd->run.pkt_buffer_size = pmd->cfg.pkt_buffer_size;
177 strlcpy(pmd->remote_name, (char *)h->name, sizeof(pmd->remote_name));
179 MIF_LOG(DEBUG, "%s: Connecting to %s.",
180 rte_vdev_device_name(pmd->vdev), pmd->remote_name);
186 memif_msg_receive_init(struct memif_control_channel *cc, memif_msg_t *msg)
188 memif_msg_init_t *i = &msg->init;
189 struct memif_socket_dev_list_elt *elt;
190 struct pmd_internals *pmd;
191 struct rte_eth_dev *dev;
193 if (i->version != MEMIF_VERSION) {
194 memif_msg_enq_disconnect(cc, "Incompatible memif version", 0);
198 if (cc->socket == NULL) {
199 memif_msg_enq_disconnect(cc, "Device error", 0);
203 /* Find device with requested ID */
204 TAILQ_FOREACH(elt, &cc->socket->dev_queue, next) {
206 pmd = dev->data->dev_private;
207 if (((pmd->flags & ETH_MEMIF_FLAG_DISABLED) == 0) &&
209 /* assign control channel to device */
213 if (i->mode != MEMIF_INTERFACE_MODE_ETHERNET) {
214 memif_msg_enq_disconnect(pmd->cc,
215 "Only ethernet mode supported",
220 if (pmd->flags & (ETH_MEMIF_FLAG_CONNECTING |
221 ETH_MEMIF_FLAG_CONNECTED)) {
222 memif_msg_enq_disconnect(pmd->cc,
223 "Already connected", 0);
226 strlcpy(pmd->remote_name, (char *)i->name,
227 sizeof(pmd->remote_name));
229 if (*pmd->secret != '\0') {
230 if (*i->secret == '\0') {
231 memif_msg_enq_disconnect(pmd->cc,
232 "Secret required", 0);
235 if (strncmp(pmd->secret, (char *)i->secret,
236 ETH_MEMIF_SECRET_SIZE) != 0) {
237 memif_msg_enq_disconnect(pmd->cc,
238 "Incorrect secret", 0);
243 pmd->flags |= ETH_MEMIF_FLAG_CONNECTING;
248 /* ID not found on this socket */
249 MIF_LOG(DEBUG, "ID %u not found.", i->id);
250 memif_msg_enq_disconnect(cc, "ID not found", 0);
255 memif_msg_receive_add_region(struct rte_eth_dev *dev, memif_msg_t *msg,
258 struct pmd_internals *pmd = dev->data->dev_private;
259 struct pmd_process_private *proc_private = dev->process_private;
260 memif_msg_add_region_t *ar = &msg->add_region;
261 struct memif_region *r;
264 memif_msg_enq_disconnect(pmd->cc, "Missing region fd", 0);
268 if (ar->index >= ETH_MEMIF_MAX_REGION_NUM ||
269 ar->index != proc_private->regions_num ||
270 proc_private->regions[ar->index] != NULL) {
271 memif_msg_enq_disconnect(pmd->cc, "Invalid region index", 0);
275 r = rte_zmalloc("region", sizeof(struct memif_region), 0);
277 memif_msg_enq_disconnect(pmd->cc, "Failed to alloc memif region.", 0);
282 r->region_size = ar->size;
285 proc_private->regions[ar->index] = r;
286 proc_private->regions_num++;
292 memif_msg_receive_add_ring(struct rte_eth_dev *dev, memif_msg_t *msg, int fd)
294 struct pmd_internals *pmd = dev->data->dev_private;
295 memif_msg_add_ring_t *ar = &msg->add_ring;
296 struct memif_queue *mq;
299 memif_msg_enq_disconnect(pmd->cc, "Missing interrupt fd", 0);
303 /* check if we have enough queues */
304 if (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) {
305 if (ar->index >= pmd->cfg.num_s2m_rings) {
306 memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0);
309 pmd->run.num_s2m_rings++;
311 if (ar->index >= pmd->cfg.num_m2s_rings) {
312 memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0);
315 pmd->run.num_m2s_rings++;
318 mq = (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) ?
319 dev->data->rx_queues[ar->index] : dev->data->tx_queues[ar->index];
321 mq->intr_handle.fd = fd;
322 mq->log2_ring_size = ar->log2_ring_size;
323 mq->region = ar->region;
324 mq->ring_offset = ar->offset;
330 memif_msg_receive_connect(struct rte_eth_dev *dev, memif_msg_t *msg)
332 struct pmd_internals *pmd = dev->data->dev_private;
333 memif_msg_connect_t *c = &msg->connect;
336 ret = memif_connect(dev);
340 strlcpy(pmd->remote_if_name, (char *)c->if_name,
341 sizeof(pmd->remote_if_name));
342 MIF_LOG(INFO, "%s: Remote interface %s connected.",
343 rte_vdev_device_name(pmd->vdev), pmd->remote_if_name);
349 memif_msg_receive_connected(struct rte_eth_dev *dev, memif_msg_t *msg)
351 struct pmd_internals *pmd = dev->data->dev_private;
352 memif_msg_connected_t *c = &msg->connected;
355 ret = memif_connect(dev);
359 strlcpy(pmd->remote_if_name, (char *)c->if_name,
360 sizeof(pmd->remote_if_name));
361 MIF_LOG(INFO, "%s: Remote interface %s connected.",
362 rte_vdev_device_name(pmd->vdev), pmd->remote_if_name);
368 memif_msg_receive_disconnect(struct rte_eth_dev *dev, memif_msg_t *msg)
370 struct pmd_internals *pmd = dev->data->dev_private;
371 memif_msg_disconnect_t *d = &msg->disconnect;
373 memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
374 strlcpy(pmd->remote_disc_string, (char *)d->string,
375 sizeof(pmd->remote_disc_string));
377 MIF_LOG(INFO, "%s: Disconnect received: %s",
378 rte_vdev_device_name(pmd->vdev), pmd->remote_disc_string);
380 memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
381 memif_disconnect(dev);
386 memif_msg_enq_ack(struct rte_eth_dev *dev)
388 struct pmd_internals *pmd = dev->data->dev_private;
389 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
393 e->msg.type = MEMIF_MSG_TYPE_ACK;
399 memif_msg_enq_init(struct rte_eth_dev *dev)
401 struct pmd_internals *pmd = dev->data->dev_private;
402 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
403 memif_msg_init_t *i = &e->msg.init;
409 e->msg.type = MEMIF_MSG_TYPE_INIT;
410 i->version = MEMIF_VERSION;
412 i->mode = MEMIF_INTERFACE_MODE_ETHERNET;
414 strlcpy((char *)i->name, rte_version(), sizeof(i->name));
416 if (*pmd->secret != '\0')
417 strlcpy((char *)i->secret, pmd->secret, sizeof(i->secret));
423 memif_msg_enq_add_region(struct rte_eth_dev *dev, uint8_t idx)
425 struct pmd_internals *pmd = dev->data->dev_private;
426 struct pmd_process_private *proc_private = dev->process_private;
427 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
428 memif_msg_add_region_t *ar;
429 struct memif_region *mr = proc_private->regions[idx];
434 ar = &e->msg.add_region;
435 e->msg.type = MEMIF_MSG_TYPE_ADD_REGION;
438 ar->size = mr->region_size;
444 memif_msg_enq_add_ring(struct rte_eth_dev *dev, uint8_t idx,
445 memif_ring_type_t type)
447 struct pmd_internals *pmd = dev->data->dev_private;
448 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
449 struct memif_queue *mq;
450 memif_msg_add_ring_t *ar;
455 ar = &e->msg.add_ring;
456 mq = (type == MEMIF_RING_S2M) ? dev->data->tx_queues[idx] :
457 dev->data->rx_queues[idx];
459 e->msg.type = MEMIF_MSG_TYPE_ADD_RING;
460 e->fd = mq->intr_handle.fd;
462 ar->offset = mq->ring_offset;
463 ar->region = mq->region;
464 ar->log2_ring_size = mq->log2_ring_size;
465 ar->flags = (type == MEMIF_RING_S2M) ? MEMIF_MSG_ADD_RING_FLAG_S2M : 0;
466 ar->private_hdr_size = 0;
472 memif_msg_enq_connect(struct rte_eth_dev *dev)
474 struct pmd_internals *pmd = dev->data->dev_private;
475 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
476 const char *name = rte_vdev_device_name(pmd->vdev);
477 memif_msg_connect_t *c;
483 e->msg.type = MEMIF_MSG_TYPE_CONNECT;
484 strlcpy((char *)c->if_name, name, sizeof(c->if_name));
490 memif_msg_enq_connected(struct rte_eth_dev *dev)
492 struct pmd_internals *pmd = dev->data->dev_private;
493 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
494 const char *name = rte_vdev_device_name(pmd->vdev);
495 memif_msg_connected_t *c;
500 c = &e->msg.connected;
501 e->msg.type = MEMIF_MSG_TYPE_CONNECTED;
502 strlcpy((char *)c->if_name, name, sizeof(c->if_name));
508 memif_intr_unregister_handler(struct rte_intr_handle *intr_handle, void *arg)
510 struct memif_msg_queue_elt *elt;
511 struct memif_control_channel *cc = arg;
513 /* close control channel fd */
514 close(intr_handle->fd);
515 /* clear message queue */
516 while ((elt = TAILQ_FIRST(&cc->msg_queue)) != NULL) {
517 TAILQ_REMOVE(&cc->msg_queue, elt, next);
520 /* free control channel */
525 memif_disconnect(struct rte_eth_dev *dev)
527 struct pmd_internals *pmd = dev->data->dev_private;
528 struct pmd_process_private *proc_private = dev->process_private;
529 struct memif_msg_queue_elt *elt, *next;
530 struct memif_queue *mq;
531 struct rte_intr_handle *ih;
535 dev->data->dev_link.link_status = ETH_LINK_DOWN;
536 pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTING;
537 pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTED;
539 if (pmd->cc != NULL) {
540 /* Clear control message queue (except disconnect message if any). */
541 for (elt = TAILQ_FIRST(&pmd->cc->msg_queue); elt != NULL; elt = next) {
542 next = TAILQ_NEXT(elt, next);
543 if (elt->msg.type != MEMIF_MSG_TYPE_DISCONNECT) {
544 TAILQ_REMOVE(&pmd->cc->msg_queue, elt, next);
548 /* send disconnect message (if there is any in queue) */
549 memif_msg_send_from_queue(pmd->cc);
551 /* at this point, there should be no more messages in queue */
552 if (TAILQ_FIRST(&pmd->cc->msg_queue) != NULL) {
554 "Unexpected message(s) in message queue.");
557 ih = &pmd->cc->intr_handle;
559 ret = rte_intr_callback_unregister(ih,
563 * If callback is active (disconnecting based on
564 * received control message).
566 if (ret == -EAGAIN) {
567 ret = rte_intr_callback_unregister_pending(ih,
570 memif_intr_unregister_handler);
571 } else if (ret > 0) {
578 "Failed to unregister control channel callback.");
582 /* unconfig interrupts */
583 for (i = 0; i < pmd->cfg.num_s2m_rings; i++) {
584 if (pmd->role == MEMIF_ROLE_SLAVE) {
585 if (dev->data->tx_queues != NULL)
586 mq = dev->data->tx_queues[i];
590 if (dev->data->rx_queues != NULL)
591 mq = dev->data->rx_queues[i];
595 if (mq->intr_handle.fd > 0) {
596 close(mq->intr_handle.fd);
597 mq->intr_handle.fd = -1;
600 for (i = 0; i < pmd->cfg.num_m2s_rings; i++) {
601 if (pmd->role == MEMIF_ROLE_MASTER) {
602 if (dev->data->tx_queues != NULL)
603 mq = dev->data->tx_queues[i];
607 if (dev->data->rx_queues != NULL)
608 mq = dev->data->rx_queues[i];
612 if (mq->intr_handle.fd > 0) {
613 close(mq->intr_handle.fd);
614 mq->intr_handle.fd = -1;
618 memif_free_regions(proc_private);
620 /* reset connection configuration */
621 memset(&pmd->run, 0, sizeof(pmd->run));
623 MIF_LOG(DEBUG, "Disconnected.");
627 memif_msg_receive(struct memif_control_channel *cc)
629 char ctl[CMSG_SPACE(sizeof(int)) +
630 CMSG_SPACE(sizeof(struct ucred))] = { 0 };
631 struct msghdr mh = { 0 };
633 memif_msg_t msg = { 0 };
636 struct ucred *cr __rte_unused;
638 struct cmsghdr *cmsg;
641 struct pmd_internals *pmd;
642 struct pmd_process_private *proc_private;
644 iov[0].iov_base = (void *)&msg;
645 iov[0].iov_len = sizeof(memif_msg_t);
648 mh.msg_control = ctl;
649 mh.msg_controllen = sizeof(ctl);
651 size = recvmsg(cc->intr_handle.fd, &mh, 0);
652 if (size != sizeof(memif_msg_t)) {
653 MIF_LOG(DEBUG, "Invalid message size.");
654 memif_msg_enq_disconnect(cc, "Invalid message size", 0);
657 MIF_LOG(DEBUG, "Received msg type: %u.", msg.type);
659 cmsg = CMSG_FIRSTHDR(&mh);
661 if (cmsg->cmsg_level == SOL_SOCKET) {
662 if (cmsg->cmsg_type == SCM_CREDENTIALS)
663 cr = (struct ucred *)CMSG_DATA(cmsg);
664 else if (cmsg->cmsg_type == SCM_RIGHTS)
665 memcpy(&afd, CMSG_DATA(cmsg), sizeof(int));
667 cmsg = CMSG_NXTHDR(&mh, cmsg);
670 if (cc->dev == NULL && msg.type != MEMIF_MSG_TYPE_INIT) {
671 MIF_LOG(DEBUG, "Unexpected message.");
672 memif_msg_enq_disconnect(cc, "Unexpected message", 0);
676 /* get device from hash data */
678 case MEMIF_MSG_TYPE_ACK:
680 case MEMIF_MSG_TYPE_HELLO:
681 ret = memif_msg_receive_hello(cc->dev, &msg);
684 ret = memif_init_regions_and_queues(cc->dev);
687 ret = memif_msg_enq_init(cc->dev);
690 pmd = cc->dev->data->dev_private;
691 proc_private = cc->dev->process_private;
692 for (i = 0; i < proc_private->regions_num; i++) {
693 ret = memif_msg_enq_add_region(cc->dev, i);
697 for (i = 0; i < pmd->run.num_s2m_rings; i++) {
698 ret = memif_msg_enq_add_ring(cc->dev, i,
703 for (i = 0; i < pmd->run.num_m2s_rings; i++) {
704 ret = memif_msg_enq_add_ring(cc->dev, i,
709 ret = memif_msg_enq_connect(cc->dev);
713 case MEMIF_MSG_TYPE_INIT:
715 * This cc does not have an interface asociated with it.
716 * If suitable interface is found it will be assigned here.
718 ret = memif_msg_receive_init(cc, &msg);
721 ret = memif_msg_enq_ack(cc->dev);
725 case MEMIF_MSG_TYPE_ADD_REGION:
726 ret = memif_msg_receive_add_region(cc->dev, &msg, afd);
729 ret = memif_msg_enq_ack(cc->dev);
733 case MEMIF_MSG_TYPE_ADD_RING:
734 ret = memif_msg_receive_add_ring(cc->dev, &msg, afd);
737 ret = memif_msg_enq_ack(cc->dev);
741 case MEMIF_MSG_TYPE_CONNECT:
742 ret = memif_msg_receive_connect(cc->dev, &msg);
745 ret = memif_msg_enq_connected(cc->dev);
749 case MEMIF_MSG_TYPE_CONNECTED:
750 ret = memif_msg_receive_connected(cc->dev, &msg);
752 case MEMIF_MSG_TYPE_DISCONNECT:
753 ret = memif_msg_receive_disconnect(cc->dev, &msg);
758 memif_msg_enq_disconnect(cc, "Unknown message type", 0);
768 memif_intr_handler(void *arg)
770 struct memif_control_channel *cc = arg;
773 ret = memif_msg_receive(cc);
774 /* if driver failed to assign device */
775 if (cc->dev == NULL) {
776 ret = rte_intr_callback_unregister_pending(&cc->intr_handle,
779 memif_intr_unregister_handler);
782 "Failed to unregister control channel callback.");
785 /* if memif_msg_receive failed */
789 ret = memif_msg_send_from_queue(cc);
796 if (cc->dev == NULL) {
797 MIF_LOG(WARNING, "eth dev not allocated");
800 memif_disconnect(cc->dev);
804 memif_listener_handler(void *arg)
806 struct memif_socket *socket = arg;
809 struct sockaddr_un client;
810 struct memif_control_channel *cc;
813 addr_len = sizeof(client);
814 sockfd = accept(socket->intr_handle.fd, (struct sockaddr *)&client,
815 (socklen_t *)&addr_len);
818 "Failed to accept connection request on socket fd %d",
819 socket->intr_handle.fd);
823 MIF_LOG(DEBUG, "%s: Connection request accepted.", socket->filename);
825 cc = rte_zmalloc("memif-cc", sizeof(struct memif_control_channel), 0);
827 MIF_LOG(ERR, "Failed to allocate control channel.");
831 cc->intr_handle.fd = sockfd;
832 cc->intr_handle.type = RTE_INTR_HANDLE_EXT;
835 TAILQ_INIT(&cc->msg_queue);
837 ret = rte_intr_callback_register(&cc->intr_handle, memif_intr_handler, cc);
839 MIF_LOG(ERR, "Failed to register control channel callback.");
843 ret = memif_msg_enq_hello(cc);
845 MIF_LOG(ERR, "Failed to enqueue hello message.");
848 ret = memif_msg_send_from_queue(cc);
863 static struct memif_socket *
864 memif_socket_create(struct pmd_internals *pmd, char *key, uint8_t listener)
866 struct memif_socket *sock;
867 struct sockaddr_un un;
872 sock = rte_zmalloc("memif-socket", sizeof(struct memif_socket), 0);
874 MIF_LOG(ERR, "Failed to allocate memory for memif socket");
878 sock->listener = listener;
879 rte_memcpy(sock->filename, key, 256);
880 TAILQ_INIT(&sock->dev_queue);
883 sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
887 un.sun_family = AF_UNIX;
888 memcpy(un.sun_path, sock->filename,
889 sizeof(un.sun_path) - 1);
891 ret = setsockopt(sockfd, SOL_SOCKET, SO_PASSCRED, &on,
895 ret = bind(sockfd, (struct sockaddr *)&un, sizeof(un));
898 ret = listen(sockfd, 1);
902 MIF_LOG(DEBUG, "%s: Memif listener socket %s created.",
903 rte_vdev_device_name(pmd->vdev), sock->filename);
905 sock->intr_handle.fd = sockfd;
906 sock->intr_handle.type = RTE_INTR_HANDLE_EXT;
907 ret = rte_intr_callback_register(&sock->intr_handle,
908 memif_listener_handler, sock);
910 MIF_LOG(ERR, "%s: Failed to register interrupt "
911 "callback for listener socket",
912 rte_vdev_device_name(pmd->vdev));
920 MIF_LOG(ERR, "%s: Failed to setup socket %s: %s",
921 rte_vdev_device_name(pmd->vdev), key, strerror(errno));
927 static struct rte_hash *
928 memif_create_socket_hash(void)
930 struct rte_hash_parameters params = { 0 };
931 params.name = MEMIF_SOCKET_HASH_NAME;
932 params.entries = 256;
933 params.key_len = 256;
934 params.hash_func = rte_jhash;
935 params.hash_func_init_val = 0;
936 return rte_hash_create(¶ms);
940 memif_socket_init(struct rte_eth_dev *dev, const char *socket_filename)
942 struct pmd_internals *pmd = dev->data->dev_private;
943 struct memif_socket *socket = NULL;
944 struct memif_socket_dev_list_elt *elt;
945 struct pmd_internals *tmp_pmd;
946 struct rte_hash *hash;
950 hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
952 hash = memif_create_socket_hash();
954 MIF_LOG(ERR, "Failed to create memif socket hash.");
960 rte_memcpy(key, socket_filename, strlen(socket_filename));
961 ret = rte_hash_lookup_data(hash, key, (void **)&socket);
963 socket = memif_socket_create(pmd, key,
965 MEMIF_ROLE_SLAVE) ? 0 : 1);
968 ret = rte_hash_add_key_data(hash, key, socket);
970 MIF_LOG(ERR, "Failed to add socket to socket hash.");
974 pmd->socket_filename = socket->filename;
976 if (socket->listener != 0 && pmd->role == MEMIF_ROLE_SLAVE) {
977 MIF_LOG(ERR, "Socket is a listener.");
979 } else if ((socket->listener == 0) && (pmd->role == MEMIF_ROLE_MASTER)) {
980 MIF_LOG(ERR, "Socket is not a listener.");
984 TAILQ_FOREACH(elt, &socket->dev_queue, next) {
985 tmp_pmd = elt->dev->data->dev_private;
986 if (tmp_pmd->id == pmd->id) {
987 MIF_LOG(ERR, "Memif device with id %d already "
988 "exists on socket %s",
989 pmd->id, socket->filename);
994 elt = rte_malloc("pmd-queue", sizeof(struct memif_socket_dev_list_elt), 0);
996 MIF_LOG(ERR, "%s: Failed to add device to socket device list.",
997 rte_vdev_device_name(pmd->vdev));
1001 TAILQ_INSERT_TAIL(&socket->dev_queue, elt, next);
1007 memif_socket_remove_device(struct rte_eth_dev *dev)
1009 struct pmd_internals *pmd = dev->data->dev_private;
1010 struct memif_socket *socket = NULL;
1011 struct memif_socket_dev_list_elt *elt, *next;
1012 struct rte_hash *hash;
1014 hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
1018 if (pmd->socket_filename == NULL)
1021 if (rte_hash_lookup_data(hash, pmd->socket_filename, (void **)&socket) < 0)
1024 for (elt = TAILQ_FIRST(&socket->dev_queue); elt != NULL; elt = next) {
1025 next = TAILQ_NEXT(elt, next);
1026 if (elt->dev == dev) {
1027 TAILQ_REMOVE(&socket->dev_queue, elt, next);
1029 pmd->socket_filename = NULL;
1033 /* remove socket, if this was the last device using it */
1034 if (TAILQ_EMPTY(&socket->dev_queue)) {
1035 rte_hash_del_key(hash, socket->filename);
1036 if (socket->listener) {
1037 /* remove listener socket file,
1038 * so we can create new one later.
1040 remove(socket->filename);
1047 memif_connect_master(struct rte_eth_dev *dev)
1049 struct pmd_internals *pmd = dev->data->dev_private;
1051 memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1052 memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1053 pmd->flags &= ~ETH_MEMIF_FLAG_DISABLED;
1058 memif_connect_slave(struct rte_eth_dev *dev)
1062 struct sockaddr_un sun;
1063 struct pmd_internals *pmd = dev->data->dev_private;
1065 memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1066 memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1067 pmd->flags &= ~ETH_MEMIF_FLAG_DISABLED;
1069 sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
1071 MIF_LOG(ERR, "%s: Failed to open socket.",
1072 rte_vdev_device_name(pmd->vdev));
1076 sun.sun_family = AF_UNIX;
1078 memcpy(sun.sun_path, pmd->socket_filename, sizeof(sun.sun_path) - 1);
1080 ret = connect(sockfd, (struct sockaddr *)&sun,
1081 sizeof(struct sockaddr_un));
1083 MIF_LOG(ERR, "%s: Failed to connect socket: %s.",
1084 rte_vdev_device_name(pmd->vdev), pmd->socket_filename);
1088 MIF_LOG(DEBUG, "%s: Memif socket: %s connected.",
1089 rte_vdev_device_name(pmd->vdev), pmd->socket_filename);
1091 pmd->cc = rte_zmalloc("memif-cc",
1092 sizeof(struct memif_control_channel), 0);
1093 if (pmd->cc == NULL) {
1094 MIF_LOG(ERR, "%s: Failed to allocate control channel.",
1095 rte_vdev_device_name(pmd->vdev));
1099 pmd->cc->intr_handle.fd = sockfd;
1100 pmd->cc->intr_handle.type = RTE_INTR_HANDLE_EXT;
1101 pmd->cc->socket = NULL;
1103 TAILQ_INIT(&pmd->cc->msg_queue);
1105 ret = rte_intr_callback_register(&pmd->cc->intr_handle,
1106 memif_intr_handler, pmd->cc);
1108 MIF_LOG(ERR, "%s: Failed to register interrupt callback "
1109 "for control fd", rte_vdev_device_name(pmd->vdev));
1120 if (pmd->cc != NULL) {