1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2018-2019 Cisco Systems, Inc. All rights reserved.
9 #include <sys/socket.h>
10 #include <sys/ioctl.h>
13 #include <rte_version.h>
15 #include <rte_ether.h>
16 #include <rte_ethdev_driver.h>
17 #include <rte_ethdev_vdev.h>
18 #include <rte_malloc.h>
19 #include <rte_kvargs.h>
20 #include <rte_bus_vdev.h>
22 #include <rte_jhash.h>
23 #include <rte_string_fns.h>
25 #include "rte_eth_memif.h"
26 #include "memif_socket.h"
28 static void memif_intr_handler(void *arg);
31 memif_msg_send(int fd, memif_msg_t *msg, int afd)
33 struct msghdr mh = { 0 };
36 char ctl[CMSG_SPACE(sizeof(int))];
38 iov[0].iov_base = msg;
39 iov[0].iov_len = sizeof(memif_msg_t);
44 memset(&ctl, 0, sizeof(ctl));
46 mh.msg_controllen = sizeof(ctl);
47 cmsg = CMSG_FIRSTHDR(&mh);
48 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
49 cmsg->cmsg_level = SOL_SOCKET;
50 cmsg->cmsg_type = SCM_RIGHTS;
51 rte_memcpy(CMSG_DATA(cmsg), &afd, sizeof(int));
54 return sendmsg(fd, &mh, 0);
58 memif_msg_send_from_queue(struct memif_control_channel *cc)
62 struct memif_msg_queue_elt *e;
64 e = TAILQ_FIRST(&cc->msg_queue);
68 size = memif_msg_send(cc->intr_handle.fd, &e->msg, e->fd);
69 if (size != sizeof(memif_msg_t)) {
70 MIF_LOG(ERR, "sendmsg fail: %s.", strerror(errno));
73 MIF_LOG(DEBUG, "Sent msg type %u.", e->msg.type);
75 TAILQ_REMOVE(&cc->msg_queue, e, next);
81 static struct memif_msg_queue_elt *
82 memif_msg_enq(struct memif_control_channel *cc)
84 struct memif_msg_queue_elt *e;
86 e = rte_zmalloc("memif_msg", sizeof(struct memif_msg_queue_elt), 0);
88 MIF_LOG(ERR, "Failed to allocate control message.");
93 TAILQ_INSERT_TAIL(&cc->msg_queue, e, next);
99 memif_msg_enq_disconnect(struct memif_control_channel *cc, const char *reason,
102 struct memif_msg_queue_elt *e;
103 struct pmd_internals *pmd;
104 memif_msg_disconnect_t *d;
107 MIF_LOG(DEBUG, "Missing control channel.");
111 e = memif_msg_enq(cc);
113 MIF_LOG(WARNING, "Failed to enqueue disconnect message.");
117 d = &e->msg.disconnect;
119 e->msg.type = MEMIF_MSG_TYPE_DISCONNECT;
122 if (reason != NULL) {
123 strlcpy((char *)d->string, reason, sizeof(d->string));
124 if (cc->dev != NULL) {
125 pmd = cc->dev->data->dev_private;
126 strlcpy(pmd->local_disc_string, reason,
127 sizeof(pmd->local_disc_string));
133 memif_msg_enq_hello(struct memif_control_channel *cc)
135 struct memif_msg_queue_elt *e = memif_msg_enq(cc);
136 memif_msg_hello_t *h;
143 e->msg.type = MEMIF_MSG_TYPE_HELLO;
144 h->min_version = MEMIF_VERSION;
145 h->max_version = MEMIF_VERSION;
146 h->max_s2m_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS;
147 h->max_m2s_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS;
148 h->max_region = ETH_MEMIF_MAX_REGION_NUM - 1;
149 h->max_log2_ring_size = ETH_MEMIF_MAX_LOG2_RING_SIZE;
151 strlcpy((char *)h->name, rte_version(), sizeof(h->name));
157 memif_msg_receive_hello(struct rte_eth_dev *dev, memif_msg_t *msg)
159 struct pmd_internals *pmd = dev->data->dev_private;
160 memif_msg_hello_t *h = &msg->hello;
162 if (h->min_version > MEMIF_VERSION || h->max_version < MEMIF_VERSION) {
163 memif_msg_enq_disconnect(pmd->cc, "Incompatible memif version", 0);
167 /* Set parameters for active connection */
168 pmd->run.num_s2m_rings = RTE_MIN(h->max_s2m_ring + 1,
169 pmd->cfg.num_s2m_rings);
170 pmd->run.num_m2s_rings = RTE_MIN(h->max_m2s_ring + 1,
171 pmd->cfg.num_m2s_rings);
172 pmd->run.log2_ring_size = RTE_MIN(h->max_log2_ring_size,
173 pmd->cfg.log2_ring_size);
174 pmd->run.pkt_buffer_size = pmd->cfg.pkt_buffer_size;
176 strlcpy(pmd->remote_name, (char *)h->name, sizeof(pmd->remote_name));
178 MIF_LOG(DEBUG, "Connecting to %s.", pmd->remote_name);
184 memif_msg_receive_init(struct memif_control_channel *cc, memif_msg_t *msg)
186 memif_msg_init_t *i = &msg->init;
187 struct memif_socket_dev_list_elt *elt;
188 struct pmd_internals *pmd;
189 struct rte_eth_dev *dev;
191 if (i->version != MEMIF_VERSION) {
192 memif_msg_enq_disconnect(cc, "Incompatible memif version", 0);
196 if (cc->socket == NULL) {
197 memif_msg_enq_disconnect(cc, "Device error", 0);
201 /* Find device with requested ID */
202 TAILQ_FOREACH(elt, &cc->socket->dev_queue, next) {
204 pmd = dev->data->dev_private;
205 if (((pmd->flags & ETH_MEMIF_FLAG_DISABLED) == 0) &&
207 /* assign control channel to device */
211 if (i->mode != MEMIF_INTERFACE_MODE_ETHERNET) {
212 memif_msg_enq_disconnect(pmd->cc,
213 "Only ethernet mode supported",
218 if (pmd->flags & (ETH_MEMIF_FLAG_CONNECTING |
219 ETH_MEMIF_FLAG_CONNECTED)) {
220 memif_msg_enq_disconnect(pmd->cc,
221 "Already connected", 0);
224 strlcpy(pmd->remote_name, (char *)i->name,
225 sizeof(pmd->remote_name));
227 if (*pmd->secret != '\0') {
228 if (*i->secret == '\0') {
229 memif_msg_enq_disconnect(pmd->cc,
230 "Secret required", 0);
233 if (strncmp(pmd->secret, (char *)i->secret,
234 ETH_MEMIF_SECRET_SIZE) != 0) {
235 memif_msg_enq_disconnect(pmd->cc,
236 "Incorrect secret", 0);
241 pmd->flags |= ETH_MEMIF_FLAG_CONNECTING;
246 /* ID not found on this socket */
247 MIF_LOG(DEBUG, "ID %u not found.", i->id);
248 memif_msg_enq_disconnect(cc, "ID not found", 0);
253 memif_msg_receive_add_region(struct rte_eth_dev *dev, memif_msg_t *msg,
256 struct pmd_internals *pmd = dev->data->dev_private;
257 struct pmd_process_private *proc_private = dev->process_private;
258 memif_msg_add_region_t *ar = &msg->add_region;
259 struct memif_region *r;
262 memif_msg_enq_disconnect(pmd->cc, "Missing region fd", 0);
266 if (ar->index >= ETH_MEMIF_MAX_REGION_NUM ||
267 ar->index != proc_private->regions_num ||
268 proc_private->regions[ar->index] != NULL) {
269 memif_msg_enq_disconnect(pmd->cc, "Invalid region index", 0);
273 r = rte_zmalloc("region", sizeof(struct memif_region), 0);
275 memif_msg_enq_disconnect(pmd->cc, "Failed to alloc memif region.", 0);
280 r->region_size = ar->size;
283 proc_private->regions[ar->index] = r;
284 proc_private->regions_num++;
290 memif_msg_receive_add_ring(struct rte_eth_dev *dev, memif_msg_t *msg, int fd)
292 struct pmd_internals *pmd = dev->data->dev_private;
293 memif_msg_add_ring_t *ar = &msg->add_ring;
294 struct memif_queue *mq;
297 memif_msg_enq_disconnect(pmd->cc, "Missing interrupt fd", 0);
301 /* check if we have enough queues */
302 if (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) {
303 if (ar->index >= pmd->cfg.num_s2m_rings) {
304 memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0);
307 pmd->run.num_s2m_rings++;
309 if (ar->index >= pmd->cfg.num_m2s_rings) {
310 memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0);
313 pmd->run.num_m2s_rings++;
316 mq = (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) ?
317 dev->data->rx_queues[ar->index] : dev->data->tx_queues[ar->index];
319 mq->intr_handle.fd = fd;
320 mq->log2_ring_size = ar->log2_ring_size;
321 mq->region = ar->region;
322 mq->ring_offset = ar->offset;
328 memif_msg_receive_connect(struct rte_eth_dev *dev, memif_msg_t *msg)
330 struct pmd_internals *pmd = dev->data->dev_private;
331 memif_msg_connect_t *c = &msg->connect;
334 ret = memif_connect(dev);
338 strlcpy(pmd->remote_if_name, (char *)c->if_name,
339 sizeof(pmd->remote_if_name));
340 MIF_LOG(INFO, "Remote interface %s connected.", pmd->remote_if_name);
346 memif_msg_receive_connected(struct rte_eth_dev *dev, memif_msg_t *msg)
348 struct pmd_internals *pmd = dev->data->dev_private;
349 memif_msg_connected_t *c = &msg->connected;
352 ret = memif_connect(dev);
356 strlcpy(pmd->remote_if_name, (char *)c->if_name,
357 sizeof(pmd->remote_if_name));
358 MIF_LOG(INFO, "Remote interface %s connected.", pmd->remote_if_name);
364 memif_msg_receive_disconnect(struct rte_eth_dev *dev, memif_msg_t *msg)
366 struct pmd_internals *pmd = dev->data->dev_private;
367 memif_msg_disconnect_t *d = &msg->disconnect;
369 memset(pmd->remote_disc_string, 0, sizeof(pmd->remote_disc_string));
370 strlcpy(pmd->remote_disc_string, (char *)d->string,
371 sizeof(pmd->remote_disc_string));
373 MIF_LOG(INFO, "Disconnect received: %s", pmd->remote_disc_string);
375 memset(pmd->local_disc_string, 0, 96);
376 memif_disconnect(dev);
381 memif_msg_enq_ack(struct rte_eth_dev *dev)
383 struct pmd_internals *pmd = dev->data->dev_private;
384 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
388 e->msg.type = MEMIF_MSG_TYPE_ACK;
394 memif_msg_enq_init(struct rte_eth_dev *dev)
396 struct pmd_internals *pmd = dev->data->dev_private;
397 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
398 memif_msg_init_t *i = &e->msg.init;
404 e->msg.type = MEMIF_MSG_TYPE_INIT;
405 i->version = MEMIF_VERSION;
407 i->mode = MEMIF_INTERFACE_MODE_ETHERNET;
409 strlcpy((char *)i->name, rte_version(), sizeof(i->name));
411 if (*pmd->secret != '\0')
412 strlcpy((char *)i->secret, pmd->secret, sizeof(i->secret));
418 memif_msg_enq_add_region(struct rte_eth_dev *dev, uint8_t idx)
420 struct pmd_internals *pmd = dev->data->dev_private;
421 struct pmd_process_private *proc_private = dev->process_private;
422 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
423 memif_msg_add_region_t *ar;
424 struct memif_region *mr = proc_private->regions[idx];
429 ar = &e->msg.add_region;
430 e->msg.type = MEMIF_MSG_TYPE_ADD_REGION;
433 ar->size = mr->region_size;
439 memif_msg_enq_add_ring(struct rte_eth_dev *dev, uint8_t idx,
440 memif_ring_type_t type)
442 struct pmd_internals *pmd = dev->data->dev_private;
443 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
444 struct memif_queue *mq;
445 memif_msg_add_ring_t *ar;
450 ar = &e->msg.add_ring;
451 mq = (type == MEMIF_RING_S2M) ? dev->data->tx_queues[idx] :
452 dev->data->rx_queues[idx];
454 e->msg.type = MEMIF_MSG_TYPE_ADD_RING;
455 e->fd = mq->intr_handle.fd;
457 ar->offset = mq->ring_offset;
458 ar->region = mq->region;
459 ar->log2_ring_size = mq->log2_ring_size;
460 ar->flags = (type == MEMIF_RING_S2M) ? MEMIF_MSG_ADD_RING_FLAG_S2M : 0;
461 ar->private_hdr_size = 0;
467 memif_msg_enq_connect(struct rte_eth_dev *dev)
469 struct pmd_internals *pmd = dev->data->dev_private;
470 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
471 memif_msg_connect_t *c;
477 e->msg.type = MEMIF_MSG_TYPE_CONNECT;
478 strlcpy((char *)c->if_name, dev->data->name, sizeof(c->if_name));
484 memif_msg_enq_connected(struct rte_eth_dev *dev)
486 struct pmd_internals *pmd = dev->data->dev_private;
487 struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
488 memif_msg_connected_t *c;
493 c = &e->msg.connected;
494 e->msg.type = MEMIF_MSG_TYPE_CONNECTED;
495 strlcpy((char *)c->if_name, dev->data->name, sizeof(c->if_name));
501 memif_intr_unregister_handler(struct rte_intr_handle *intr_handle, void *arg)
503 struct memif_msg_queue_elt *elt;
504 struct memif_control_channel *cc = arg;
506 /* close control channel fd */
507 close(intr_handle->fd);
508 /* clear message queue */
509 while ((elt = TAILQ_FIRST(&cc->msg_queue)) != NULL) {
510 TAILQ_REMOVE(&cc->msg_queue, elt, next);
513 /* free control channel */
518 memif_disconnect(struct rte_eth_dev *dev)
520 struct pmd_internals *pmd = dev->data->dev_private;
521 struct memif_msg_queue_elt *elt, *next;
522 struct memif_queue *mq;
523 struct rte_intr_handle *ih;
527 dev->data->dev_link.link_status = ETH_LINK_DOWN;
528 pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTING;
529 pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTED;
531 if (pmd->cc != NULL) {
532 /* Clear control message queue (except disconnect message if any). */
533 for (elt = TAILQ_FIRST(&pmd->cc->msg_queue); elt != NULL; elt = next) {
534 next = TAILQ_NEXT(elt, next);
535 if (elt->msg.type != MEMIF_MSG_TYPE_DISCONNECT) {
536 TAILQ_REMOVE(&pmd->cc->msg_queue, elt, next);
540 /* send disconnect message (if there is any in queue) */
541 memif_msg_send_from_queue(pmd->cc);
543 /* at this point, there should be no more messages in queue */
544 if (TAILQ_FIRST(&pmd->cc->msg_queue) != NULL) {
546 "Unexpected message(s) in message queue.");
549 ih = &pmd->cc->intr_handle;
551 ret = rte_intr_callback_unregister(ih,
555 * If callback is active (disconnecting based on
556 * received control message).
558 if (ret == -EAGAIN) {
559 ret = rte_intr_callback_unregister_pending(ih,
562 memif_intr_unregister_handler);
563 } else if (ret > 0) {
570 "Failed to unregister control channel callback.");
574 /* unconfig interrupts */
575 for (i = 0; i < pmd->cfg.num_s2m_rings; i++) {
576 if (pmd->role == MEMIF_ROLE_SLAVE) {
577 if (dev->data->tx_queues != NULL)
578 mq = dev->data->tx_queues[i];
582 if (dev->data->rx_queues != NULL)
583 mq = dev->data->rx_queues[i];
587 if (mq->intr_handle.fd > 0) {
588 close(mq->intr_handle.fd);
589 mq->intr_handle.fd = -1;
592 for (i = 0; i < pmd->cfg.num_m2s_rings; i++) {
593 if (pmd->role == MEMIF_ROLE_MASTER) {
594 if (dev->data->tx_queues != NULL)
595 mq = dev->data->tx_queues[i];
599 if (dev->data->rx_queues != NULL)
600 mq = dev->data->rx_queues[i];
604 if (mq->intr_handle.fd > 0) {
605 close(mq->intr_handle.fd);
606 mq->intr_handle.fd = -1;
610 memif_free_regions(dev);
612 /* reset connection configuration */
613 memset(&pmd->run, 0, sizeof(pmd->run));
615 MIF_LOG(DEBUG, "Disconnected.");
619 memif_msg_receive(struct memif_control_channel *cc)
621 char ctl[CMSG_SPACE(sizeof(int)) +
622 CMSG_SPACE(sizeof(struct ucred))] = { 0 };
623 struct msghdr mh = { 0 };
625 memif_msg_t msg = { 0 };
628 struct ucred *cr __rte_unused;
630 struct cmsghdr *cmsg;
633 struct pmd_internals *pmd;
634 struct pmd_process_private *proc_private;
636 iov[0].iov_base = (void *)&msg;
637 iov[0].iov_len = sizeof(memif_msg_t);
640 mh.msg_control = ctl;
641 mh.msg_controllen = sizeof(ctl);
643 size = recvmsg(cc->intr_handle.fd, &mh, 0);
644 if (size != sizeof(memif_msg_t)) {
645 MIF_LOG(DEBUG, "Invalid message size.");
646 memif_msg_enq_disconnect(cc, "Invalid message size", 0);
649 MIF_LOG(DEBUG, "Received msg type: %u.", msg.type);
651 cmsg = CMSG_FIRSTHDR(&mh);
653 if (cmsg->cmsg_level == SOL_SOCKET) {
654 if (cmsg->cmsg_type == SCM_CREDENTIALS)
655 cr = (struct ucred *)CMSG_DATA(cmsg);
656 else if (cmsg->cmsg_type == SCM_RIGHTS)
657 rte_memcpy(&afd, CMSG_DATA(cmsg), sizeof(int));
659 cmsg = CMSG_NXTHDR(&mh, cmsg);
662 if (cc->dev == NULL && msg.type != MEMIF_MSG_TYPE_INIT) {
663 MIF_LOG(DEBUG, "Unexpected message.");
664 memif_msg_enq_disconnect(cc, "Unexpected message", 0);
668 /* get device from hash data */
670 case MEMIF_MSG_TYPE_ACK:
672 case MEMIF_MSG_TYPE_HELLO:
673 ret = memif_msg_receive_hello(cc->dev, &msg);
676 ret = memif_init_regions_and_queues(cc->dev);
679 ret = memif_msg_enq_init(cc->dev);
682 pmd = cc->dev->data->dev_private;
683 proc_private = cc->dev->process_private;
684 for (i = 0; i < proc_private->regions_num; i++) {
685 ret = memif_msg_enq_add_region(cc->dev, i);
689 for (i = 0; i < pmd->run.num_s2m_rings; i++) {
690 ret = memif_msg_enq_add_ring(cc->dev, i,
695 for (i = 0; i < pmd->run.num_m2s_rings; i++) {
696 ret = memif_msg_enq_add_ring(cc->dev, i,
701 ret = memif_msg_enq_connect(cc->dev);
705 case MEMIF_MSG_TYPE_INIT:
707 * This cc does not have an interface asociated with it.
708 * If suitable interface is found it will be assigned here.
710 ret = memif_msg_receive_init(cc, &msg);
713 ret = memif_msg_enq_ack(cc->dev);
717 case MEMIF_MSG_TYPE_ADD_REGION:
718 ret = memif_msg_receive_add_region(cc->dev, &msg, afd);
721 ret = memif_msg_enq_ack(cc->dev);
725 case MEMIF_MSG_TYPE_ADD_RING:
726 ret = memif_msg_receive_add_ring(cc->dev, &msg, afd);
729 ret = memif_msg_enq_ack(cc->dev);
733 case MEMIF_MSG_TYPE_CONNECT:
734 ret = memif_msg_receive_connect(cc->dev, &msg);
737 ret = memif_msg_enq_connected(cc->dev);
741 case MEMIF_MSG_TYPE_CONNECTED:
742 ret = memif_msg_receive_connected(cc->dev, &msg);
744 case MEMIF_MSG_TYPE_DISCONNECT:
745 ret = memif_msg_receive_disconnect(cc->dev, &msg);
750 memif_msg_enq_disconnect(cc, "Unknown message type", 0);
760 memif_intr_handler(void *arg)
762 struct memif_control_channel *cc = arg;
765 ret = memif_msg_receive(cc);
766 /* if driver failed to assign device */
767 if (cc->dev == NULL) {
768 ret = rte_intr_callback_unregister_pending(&cc->intr_handle,
771 memif_intr_unregister_handler);
774 "Failed to unregister control channel callback.");
777 /* if memif_msg_receive failed */
781 ret = memif_msg_send_from_queue(cc);
788 if (cc->dev == NULL) {
789 MIF_LOG(WARNING, "eth dev not allocated");
792 memif_disconnect(cc->dev);
796 memif_listener_handler(void *arg)
798 struct memif_socket *socket = arg;
801 struct sockaddr_un client;
802 struct memif_control_channel *cc;
805 addr_len = sizeof(client);
806 sockfd = accept(socket->intr_handle.fd, (struct sockaddr *)&client,
807 (socklen_t *)&addr_len);
810 "Failed to accept connection request on socket fd %d",
811 socket->intr_handle.fd);
815 MIF_LOG(DEBUG, "%s: Connection request accepted.", socket->filename);
817 cc = rte_zmalloc("memif-cc", sizeof(struct memif_control_channel), 0);
819 MIF_LOG(ERR, "Failed to allocate control channel.");
823 cc->intr_handle.fd = sockfd;
824 cc->intr_handle.type = RTE_INTR_HANDLE_EXT;
827 TAILQ_INIT(&cc->msg_queue);
829 ret = rte_intr_callback_register(&cc->intr_handle, memif_intr_handler, cc);
831 MIF_LOG(ERR, "Failed to register control channel callback.");
835 ret = memif_msg_enq_hello(cc);
837 MIF_LOG(ERR, "Failed to enqueue hello message.");
840 ret = memif_msg_send_from_queue(cc);
855 static struct memif_socket *
856 memif_socket_create(char *key, uint8_t listener)
858 struct memif_socket *sock;
859 struct sockaddr_un un;
864 sock = rte_zmalloc("memif-socket", sizeof(struct memif_socket), 0);
866 MIF_LOG(ERR, "Failed to allocate memory for memif socket");
870 sock->listener = listener;
871 strlcpy(sock->filename, key, MEMIF_SOCKET_UN_SIZE);
872 TAILQ_INIT(&sock->dev_queue);
875 sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
879 un.sun_family = AF_UNIX;
880 strlcpy(un.sun_path, sock->filename, MEMIF_SOCKET_UN_SIZE);
882 ret = setsockopt(sockfd, SOL_SOCKET, SO_PASSCRED, &on,
887 ret = bind(sockfd, (struct sockaddr *)&un, sizeof(un));
891 ret = listen(sockfd, 1);
895 MIF_LOG(DEBUG, "Memif listener socket %s created.", sock->filename);
897 sock->intr_handle.fd = sockfd;
898 sock->intr_handle.type = RTE_INTR_HANDLE_EXT;
899 ret = rte_intr_callback_register(&sock->intr_handle,
900 memif_listener_handler, sock);
902 MIF_LOG(ERR, "Failed to register interrupt "
903 "callback for listener socket");
911 MIF_LOG(ERR, "Failed to setup socket %s: %s", key, strerror(errno));
919 static struct rte_hash *
920 memif_create_socket_hash(void)
922 struct rte_hash_parameters params = { 0 };
924 params.name = MEMIF_SOCKET_HASH_NAME;
925 params.entries = 256;
926 params.key_len = MEMIF_SOCKET_UN_SIZE;
927 params.hash_func = rte_jhash;
928 params.hash_func_init_val = 0;
929 return rte_hash_create(¶ms);
933 memif_socket_init(struct rte_eth_dev *dev, const char *socket_filename)
935 struct pmd_internals *pmd = dev->data->dev_private;
936 struct memif_socket *socket = NULL;
937 struct memif_socket_dev_list_elt *elt;
938 struct pmd_internals *tmp_pmd;
939 struct rte_hash *hash;
941 char key[MEMIF_SOCKET_UN_SIZE];
943 hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
945 hash = memif_create_socket_hash();
947 MIF_LOG(ERR, "Failed to create memif socket hash.");
952 memset(key, 0, MEMIF_SOCKET_UN_SIZE);
953 strlcpy(key, socket_filename, MEMIF_SOCKET_UN_SIZE);
954 ret = rte_hash_lookup_data(hash, key, (void **)&socket);
956 socket = memif_socket_create(key,
957 (pmd->role == MEMIF_ROLE_SLAVE) ? 0 : 1);
960 ret = rte_hash_add_key_data(hash, key, socket);
962 MIF_LOG(ERR, "Failed to add socket to socket hash.");
966 pmd->socket_filename = socket->filename;
968 if (socket->listener != 0 && pmd->role == MEMIF_ROLE_SLAVE) {
969 MIF_LOG(ERR, "Socket is a listener.");
971 } else if ((socket->listener == 0) && (pmd->role == MEMIF_ROLE_MASTER)) {
972 MIF_LOG(ERR, "Socket is not a listener.");
976 TAILQ_FOREACH(elt, &socket->dev_queue, next) {
977 tmp_pmd = elt->dev->data->dev_private;
978 if (tmp_pmd->id == pmd->id) {
979 MIF_LOG(ERR, "Memif device with id %d already "
980 "exists on socket %s",
981 pmd->id, socket->filename);
986 elt = rte_malloc("pmd-queue", sizeof(struct memif_socket_dev_list_elt), 0);
988 MIF_LOG(ERR, "Failed to add device to socket device list.");
992 TAILQ_INSERT_TAIL(&socket->dev_queue, elt, next);
998 memif_socket_remove_device(struct rte_eth_dev *dev)
1000 struct pmd_internals *pmd = dev->data->dev_private;
1001 struct memif_socket *socket = NULL;
1002 struct memif_socket_dev_list_elt *elt, *next;
1003 struct rte_hash *hash;
1006 hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
1010 if (pmd->socket_filename == NULL)
1013 if (rte_hash_lookup_data(hash, pmd->socket_filename, (void **)&socket) < 0)
1016 for (elt = TAILQ_FIRST(&socket->dev_queue); elt != NULL; elt = next) {
1017 next = TAILQ_NEXT(elt, next);
1018 if (elt->dev == dev) {
1019 TAILQ_REMOVE(&socket->dev_queue, elt, next);
1021 pmd->socket_filename = NULL;
1025 /* remove socket, if this was the last device using it */
1026 if (TAILQ_EMPTY(&socket->dev_queue)) {
1027 rte_hash_del_key(hash, socket->filename);
1028 if (socket->listener) {
1029 /* remove listener socket file,
1030 * so we can create new one later.
1032 ret = remove(socket->filename);
1034 MIF_LOG(ERR, "Failed to remove socket file: %s",
1042 memif_connect_master(struct rte_eth_dev *dev)
1044 struct pmd_internals *pmd = dev->data->dev_private;
1046 memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1047 memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1048 pmd->flags &= ~ETH_MEMIF_FLAG_DISABLED;
1053 memif_connect_slave(struct rte_eth_dev *dev)
1057 struct sockaddr_un sun;
1058 struct pmd_internals *pmd = dev->data->dev_private;
1060 memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1061 memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE);
1062 pmd->flags &= ~ETH_MEMIF_FLAG_DISABLED;
1064 sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
1066 MIF_LOG(ERR, "Failed to open socket.");
1070 sun.sun_family = AF_UNIX;
1072 memcpy(sun.sun_path, pmd->socket_filename, sizeof(sun.sun_path) - 1);
1074 ret = connect(sockfd, (struct sockaddr *)&sun,
1075 sizeof(struct sockaddr_un));
1077 MIF_LOG(ERR, "Failed to connect socket: %s.", pmd->socket_filename);
1081 MIF_LOG(DEBUG, "Memif socket: %s connected.", pmd->socket_filename);
1083 pmd->cc = rte_zmalloc("memif-cc",
1084 sizeof(struct memif_control_channel), 0);
1085 if (pmd->cc == NULL) {
1086 MIF_LOG(ERR, "Failed to allocate control channel.");
1090 pmd->cc->intr_handle.fd = sockfd;
1091 pmd->cc->intr_handle.type = RTE_INTR_HANDLE_EXT;
1092 pmd->cc->socket = NULL;
1094 TAILQ_INIT(&pmd->cc->msg_queue);
1096 ret = rte_intr_callback_register(&pmd->cc->intr_handle,
1097 memif_intr_handler, pmd->cc);
1099 MIF_LOG(ERR, "Failed to register interrupt callback for control fd");
1110 if (pmd->cc != NULL) {