X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fmemif%2Fmemif_socket.c;h=d48c3685d930d4838fbd3622c0f6174f84dcbd3f;hb=af397b3c93f82b0803c0890874d7ee3b5127522d;hp=0c71f6c454d43fa73a4eddaa511d8cdf8856e8ca;hpb=b923866c697450ae927c4d167a83ea46eee55aa6;p=dpdk.git diff --git a/drivers/net/memif/memif_socket.c b/drivers/net/memif/memif_socket.c index 0c71f6c454..d48c3685d9 100644 --- a/drivers/net/memif/memif_socket.c +++ b/drivers/net/memif/memif_socket.c @@ -7,15 +7,14 @@ #include #include #include -#include #include #include #include #include #include -#include -#include +#include +#include #include #include #include @@ -66,7 +65,8 @@ memif_msg_send_from_queue(struct memif_control_channel *cc) if (e == NULL) return 0; - size = memif_msg_send(cc->intr_handle.fd, &e->msg, e->fd); + size = memif_msg_send(rte_intr_fd_get(cc->intr_handle), &e->msg, + e->fd); if (size != sizeof(memif_msg_t)) { MIF_LOG(ERR, "sendmsg fail: %s.", strerror(errno)); ret = -1; @@ -144,8 +144,8 @@ memif_msg_enq_hello(struct memif_control_channel *cc) e->msg.type = MEMIF_MSG_TYPE_HELLO; h->min_version = MEMIF_VERSION; h->max_version = MEMIF_VERSION; - h->max_s2m_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS; - h->max_m2s_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS; + h->max_c2s_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS; + h->max_s2c_ring = ETH_MEMIF_MAX_NUM_Q_PAIRS; h->max_region = ETH_MEMIF_MAX_REGION_NUM - 1; h->max_log2_ring_size = ETH_MEMIF_MAX_LOG2_RING_SIZE; @@ -166,18 +166,17 @@ memif_msg_receive_hello(struct rte_eth_dev *dev, memif_msg_t *msg) } /* Set parameters for active connection */ - pmd->run.num_s2m_rings = RTE_MIN(h->max_s2m_ring + 1, - pmd->cfg.num_s2m_rings); - pmd->run.num_m2s_rings = RTE_MIN(h->max_m2s_ring + 1, - pmd->cfg.num_m2s_rings); + pmd->run.num_c2s_rings = RTE_MIN(h->max_c2s_ring + 1, + pmd->cfg.num_c2s_rings); + pmd->run.num_s2c_rings = RTE_MIN(h->max_s2c_ring + 1, + pmd->cfg.num_s2c_rings); pmd->run.log2_ring_size = RTE_MIN(h->max_log2_ring_size, pmd->cfg.log2_ring_size); pmd->run.pkt_buffer_size = pmd->cfg.pkt_buffer_size; strlcpy(pmd->remote_name, (char *)h->name, sizeof(pmd->remote_name)); - MIF_LOG(DEBUG, "%s: Connecting to %s.", - rte_vdev_device_name(pmd->vdev), pmd->remote_name); + MIF_LOG(DEBUG, "Connecting to %s.", pmd->remote_name); return 0; } @@ -205,7 +204,14 @@ memif_msg_receive_init(struct memif_control_channel *cc, memif_msg_t *msg) dev = elt->dev; pmd = dev->data->dev_private; if (((pmd->flags & ETH_MEMIF_FLAG_DISABLED) == 0) && - pmd->id == i->id) { + (pmd->id == i->id) && (pmd->role == MEMIF_ROLE_SERVER)) { + if (pmd->flags & (ETH_MEMIF_FLAG_CONNECTING | + ETH_MEMIF_FLAG_CONNECTED)) { + memif_msg_enq_disconnect(cc, + "Already connected", 0); + return -1; + } + /* assign control channel to device */ cc->dev = dev; pmd->cc = cc; @@ -217,12 +223,6 @@ memif_msg_receive_init(struct memif_control_channel *cc, memif_msg_t *msg) return -1; } - if (pmd->flags & (ETH_MEMIF_FLAG_CONNECTING | - ETH_MEMIF_FLAG_CONNECTED)) { - memif_msg_enq_disconnect(pmd->cc, - "Already connected", 0); - return -1; - } strlcpy(pmd->remote_name, (char *)i->name, sizeof(pmd->remote_name)); @@ -301,24 +301,26 @@ memif_msg_receive_add_ring(struct rte_eth_dev *dev, memif_msg_t *msg, int fd) } /* check if we have enough queues */ - if (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) { - if (ar->index >= pmd->cfg.num_s2m_rings) { + if (ar->flags & MEMIF_MSG_ADD_RING_FLAG_C2S) { + if (ar->index >= pmd->cfg.num_c2s_rings) { memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0); return -1; } - pmd->run.num_s2m_rings++; + pmd->run.num_c2s_rings++; } else { - if (ar->index >= pmd->cfg.num_m2s_rings) { + if (ar->index >= pmd->cfg.num_s2c_rings) { memif_msg_enq_disconnect(pmd->cc, "Invalid ring index", 0); return -1; } - pmd->run.num_m2s_rings++; + pmd->run.num_s2c_rings++; } - mq = (ar->flags & MEMIF_MSG_ADD_RING_FLAG_S2M) ? + mq = (ar->flags & MEMIF_MSG_ADD_RING_FLAG_C2S) ? dev->data->rx_queues[ar->index] : dev->data->tx_queues[ar->index]; - mq->intr_handle.fd = fd; + if (rte_intr_fd_set(mq->intr_handle, fd)) + return -1; + mq->log2_ring_size = ar->log2_ring_size; mq->region = ar->region; mq->ring_offset = ar->offset; @@ -339,8 +341,7 @@ memif_msg_receive_connect(struct rte_eth_dev *dev, memif_msg_t *msg) strlcpy(pmd->remote_if_name, (char *)c->if_name, sizeof(pmd->remote_if_name)); - MIF_LOG(INFO, "%s: Remote interface %s connected.", - rte_vdev_device_name(pmd->vdev), pmd->remote_if_name); + MIF_LOG(INFO, "Remote interface %s connected.", pmd->remote_if_name); return 0; } @@ -358,8 +359,7 @@ memif_msg_receive_connected(struct rte_eth_dev *dev, memif_msg_t *msg) strlcpy(pmd->remote_if_name, (char *)c->if_name, sizeof(pmd->remote_if_name)); - MIF_LOG(INFO, "%s: Remote interface %s connected.", - rte_vdev_device_name(pmd->vdev), pmd->remote_if_name); + MIF_LOG(INFO, "Remote interface %s connected.", pmd->remote_if_name); return 0; } @@ -370,14 +370,13 @@ memif_msg_receive_disconnect(struct rte_eth_dev *dev, memif_msg_t *msg) struct pmd_internals *pmd = dev->data->dev_private; memif_msg_disconnect_t *d = &msg->disconnect; - memset(pmd->remote_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE); + memset(pmd->remote_disc_string, 0, sizeof(pmd->remote_disc_string)); strlcpy(pmd->remote_disc_string, (char *)d->string, sizeof(pmd->remote_disc_string)); - MIF_LOG(INFO, "%s: Disconnect received: %s", - rte_vdev_device_name(pmd->vdev), pmd->remote_disc_string); + MIF_LOG(INFO, "Disconnect received: %s", pmd->remote_disc_string); - memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE); + memset(pmd->local_disc_string, 0, 96); memif_disconnect(dev); return 0; } @@ -453,16 +452,16 @@ memif_msg_enq_add_ring(struct rte_eth_dev *dev, uint8_t idx, return -1; ar = &e->msg.add_ring; - mq = (type == MEMIF_RING_S2M) ? dev->data->tx_queues[idx] : + mq = (type == MEMIF_RING_C2S) ? dev->data->tx_queues[idx] : dev->data->rx_queues[idx]; e->msg.type = MEMIF_MSG_TYPE_ADD_RING; - e->fd = mq->intr_handle.fd; + e->fd = rte_intr_fd_get(mq->intr_handle); ar->index = idx; ar->offset = mq->ring_offset; ar->region = mq->region; ar->log2_ring_size = mq->log2_ring_size; - ar->flags = (type == MEMIF_RING_S2M) ? MEMIF_MSG_ADD_RING_FLAG_S2M : 0; + ar->flags = (type == MEMIF_RING_C2S) ? MEMIF_MSG_ADD_RING_FLAG_C2S : 0; ar->private_hdr_size = 0; return 0; @@ -473,7 +472,6 @@ memif_msg_enq_connect(struct rte_eth_dev *dev) { struct pmd_internals *pmd = dev->data->dev_private; struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc); - const char *name = rte_vdev_device_name(pmd->vdev); memif_msg_connect_t *c; if (e == NULL) @@ -481,7 +479,7 @@ memif_msg_enq_connect(struct rte_eth_dev *dev) c = &e->msg.connect; e->msg.type = MEMIF_MSG_TYPE_CONNECT; - strlcpy((char *)c->if_name, name, sizeof(c->if_name)); + strlcpy((char *)c->if_name, dev->data->name, sizeof(c->if_name)); return 0; } @@ -491,7 +489,6 @@ memif_msg_enq_connected(struct rte_eth_dev *dev) { struct pmd_internals *pmd = dev->data->dev_private; struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc); - const char *name = rte_vdev_device_name(pmd->vdev); memif_msg_connected_t *c; if (e == NULL) @@ -499,7 +496,7 @@ memif_msg_enq_connected(struct rte_eth_dev *dev) c = &e->msg.connected; e->msg.type = MEMIF_MSG_TYPE_CONNECTED; - strlcpy((char *)c->if_name, name, sizeof(c->if_name)); + strlcpy((char *)c->if_name, dev->data->name, sizeof(c->if_name)); return 0; } @@ -511,12 +508,13 @@ memif_intr_unregister_handler(struct rte_intr_handle *intr_handle, void *arg) struct memif_control_channel *cc = arg; /* close control channel fd */ - close(intr_handle->fd); + close(rte_intr_fd_get(intr_handle)); /* clear message queue */ while ((elt = TAILQ_FIRST(&cc->msg_queue)) != NULL) { TAILQ_REMOVE(&cc->msg_queue, elt, next); rte_free(elt); } + rte_intr_instance_free(cc->intr_handle); /* free control channel */ rte_free(cc); } @@ -525,17 +523,17 @@ void memif_disconnect(struct rte_eth_dev *dev) { struct pmd_internals *pmd = dev->data->dev_private; - struct pmd_process_private *proc_private = dev->process_private; struct memif_msg_queue_elt *elt, *next; struct memif_queue *mq; struct rte_intr_handle *ih; int i; int ret; - dev->data->dev_link.link_status = ETH_LINK_DOWN; + dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN; pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTING; pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTED; + rte_spinlock_lock(&pmd->cc_lock); if (pmd->cc != NULL) { /* Clear control message queue (except disconnect message if any). */ for (elt = TAILQ_FIRST(&pmd->cc->msg_queue); elt != NULL; elt = next) { @@ -554,8 +552,8 @@ memif_disconnect(struct rte_eth_dev *dev) "Unexpected message(s) in message queue."); } - ih = &pmd->cc->intr_handle; - if (ih->fd > 0) { + ih = pmd->cc->intr_handle; + if (rte_intr_fd_get(ih) > 0) { ret = rte_intr_callback_unregister(ih, memif_intr_handler, pmd->cc); @@ -569,7 +567,8 @@ memif_disconnect(struct rte_eth_dev *dev) pmd->cc, memif_intr_unregister_handler); } else if (ret > 0) { - close(ih->fd); + close(rte_intr_fd_get(ih)); + rte_intr_instance_free(ih); rte_free(pmd->cc); } pmd->cc = NULL; @@ -578,10 +577,11 @@ memif_disconnect(struct rte_eth_dev *dev) "Failed to unregister control channel callback."); } } + rte_spinlock_unlock(&pmd->cc_lock); /* unconfig interrupts */ - for (i = 0; i < pmd->cfg.num_s2m_rings; i++) { - if (pmd->role == MEMIF_ROLE_SLAVE) { + for (i = 0; i < pmd->cfg.num_c2s_rings; i++) { + if (pmd->role == MEMIF_ROLE_CLIENT) { if (dev->data->tx_queues != NULL) mq = dev->data->tx_queues[i]; else @@ -592,13 +592,14 @@ memif_disconnect(struct rte_eth_dev *dev) else continue; } - if (mq->intr_handle.fd > 0) { - close(mq->intr_handle.fd); - mq->intr_handle.fd = -1; + + if (rte_intr_fd_get(mq->intr_handle) > 0) { + close(rte_intr_fd_get(mq->intr_handle)); + rte_intr_fd_set(mq->intr_handle, -1); } } - for (i = 0; i < pmd->cfg.num_m2s_rings; i++) { - if (pmd->role == MEMIF_ROLE_MASTER) { + for (i = 0; i < pmd->cfg.num_s2c_rings; i++) { + if (pmd->role == MEMIF_ROLE_SERVER) { if (dev->data->tx_queues != NULL) mq = dev->data->tx_queues[i]; else @@ -609,18 +610,20 @@ memif_disconnect(struct rte_eth_dev *dev) else continue; } - if (mq->intr_handle.fd > 0) { - close(mq->intr_handle.fd); - mq->intr_handle.fd = -1; + + if (rte_intr_fd_get(mq->intr_handle) > 0) { + close(rte_intr_fd_get(mq->intr_handle)); + rte_intr_fd_set(mq->intr_handle, -1); } } - memif_free_regions(proc_private); + memif_free_regions(dev); /* reset connection configuration */ memset(&pmd->run, 0, sizeof(pmd->run)); - MIF_LOG(DEBUG, "Disconnected."); + MIF_LOG(DEBUG, "Disconnected, id: %d, role: %s.", pmd->id, + (pmd->role == MEMIF_ROLE_SERVER) ? "server" : "client"); } static int @@ -648,10 +651,14 @@ memif_msg_receive(struct memif_control_channel *cc) mh.msg_control = ctl; mh.msg_controllen = sizeof(ctl); - size = recvmsg(cc->intr_handle.fd, &mh, 0); + size = recvmsg(rte_intr_fd_get(cc->intr_handle), &mh, 0); if (size != sizeof(memif_msg_t)) { - MIF_LOG(DEBUG, "Invalid message size."); - memif_msg_enq_disconnect(cc, "Invalid message size", 0); + MIF_LOG(DEBUG, "Invalid message size = %zd", size); + if (size > 0) + /* 0 means end-of-file, negative size means error, + * don't send further disconnect message in such cases. + */ + memif_msg_enq_disconnect(cc, "Invalid message size", 0); return -1; } MIF_LOG(DEBUG, "Received msg type: %u.", msg.type); @@ -662,7 +669,7 @@ memif_msg_receive(struct memif_control_channel *cc) if (cmsg->cmsg_type == SCM_CREDENTIALS) cr = (struct ucred *)CMSG_DATA(cmsg); else if (cmsg->cmsg_type == SCM_RIGHTS) - memcpy(&afd, CMSG_DATA(cmsg), sizeof(int)); + rte_memcpy(&afd, CMSG_DATA(cmsg), sizeof(int)); } cmsg = CMSG_NXTHDR(&mh, cmsg); } @@ -694,15 +701,15 @@ memif_msg_receive(struct memif_control_channel *cc) if (ret < 0) goto exit; } - for (i = 0; i < pmd->run.num_s2m_rings; i++) { + for (i = 0; i < pmd->run.num_c2s_rings; i++) { ret = memif_msg_enq_add_ring(cc->dev, i, - MEMIF_RING_S2M); + MEMIF_RING_C2S); if (ret < 0) goto exit; } - for (i = 0; i < pmd->run.num_m2s_rings; i++) { + for (i = 0; i < pmd->run.num_s2c_rings; i++) { ret = memif_msg_enq_add_ring(cc->dev, i, - MEMIF_RING_M2S); + MEMIF_RING_S2C); if (ret < 0) goto exit; } @@ -773,7 +780,8 @@ memif_intr_handler(void *arg) ret = memif_msg_receive(cc); /* if driver failed to assign device */ if (cc->dev == NULL) { - ret = rte_intr_callback_unregister_pending(&cc->intr_handle, + memif_msg_send_from_queue(cc); + ret = rte_intr_callback_unregister_pending(cc->intr_handle, memif_intr_handler, cc, memif_intr_unregister_handler); @@ -811,12 +819,12 @@ memif_listener_handler(void *arg) int ret; addr_len = sizeof(client); - sockfd = accept(socket->intr_handle.fd, (struct sockaddr *)&client, - (socklen_t *)&addr_len); + sockfd = accept(rte_intr_fd_get(socket->intr_handle), + (struct sockaddr *)&client, (socklen_t *)&addr_len); if (sockfd < 0) { MIF_LOG(ERR, "Failed to accept connection request on socket fd %d", - socket->intr_handle.fd); + rte_intr_fd_get(socket->intr_handle)); return; } @@ -828,13 +836,25 @@ memif_listener_handler(void *arg) goto error; } - cc->intr_handle.fd = sockfd; - cc->intr_handle.type = RTE_INTR_HANDLE_EXT; + /* Allocate interrupt instance */ + cc->intr_handle = rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_SHARED); + if (cc->intr_handle == NULL) { + MIF_LOG(ERR, "Failed to allocate intr handle"); + goto error; + } + + if (rte_intr_fd_set(cc->intr_handle, sockfd)) + goto error; + + if (rte_intr_type_set(cc->intr_handle, RTE_INTR_HANDLE_EXT)) + goto error; + cc->socket = socket; cc->dev = NULL; TAILQ_INIT(&cc->msg_queue); - ret = rte_intr_callback_register(&cc->intr_handle, memif_intr_handler, cc); + ret = rte_intr_callback_register(cc->intr_handle, memif_intr_handler, + cc); if (ret < 0) { MIF_LOG(ERR, "Failed to register control channel callback."); goto error; @@ -856,20 +876,18 @@ memif_listener_handler(void *arg) close(sockfd); sockfd = -1; } - if (cc != NULL) + if (cc != NULL) { + rte_intr_instance_free(cc->intr_handle); rte_free(cc); + } } -#define MEMIF_SOCKET_UN_SIZE \ - (offsetof(struct sockaddr_un, sun_path) + MEMIF_SOCKET_KEY_LEN) - static struct memif_socket * -memif_socket_create(struct pmd_internals *pmd, - const char *key, uint8_t listener) +memif_socket_create(char *key, uint8_t listener, bool is_abstract) { struct memif_socket *sock; - struct sockaddr_un *un; - char un_buf[MEMIF_SOCKET_UN_SIZE]; + struct sockaddr_un un = { 0 }; + uint32_t sunlen; int sockfd; int ret; int on = 1; @@ -881,7 +899,7 @@ memif_socket_create(struct pmd_internals *pmd, } sock->listener = listener; - strlcpy(sock->filename, key, MEMIF_SOCKET_KEY_LEN); + strlcpy(sock->filename, key, MEMIF_SOCKET_UN_SIZE); TAILQ_INIT(&sock->dev_queue); if (listener != 0) { @@ -889,33 +907,53 @@ memif_socket_create(struct pmd_internals *pmd, if (sockfd < 0) goto error; - memset(un_buf, 0, sizeof(un_buf)); - un = (struct sockaddr_un *)un_buf; - un->sun_family = AF_UNIX; - strlcpy(un->sun_path, sock->filename, MEMIF_SOCKET_KEY_LEN); + un.sun_family = AF_UNIX; + if (is_abstract) { + /* abstract address */ + un.sun_path[0] = '\0'; + strlcpy(un.sun_path + 1, sock->filename, MEMIF_SOCKET_UN_SIZE - 1); + sunlen = RTE_MIN(1 + strlen(sock->filename), + MEMIF_SOCKET_UN_SIZE) + + sizeof(un) - sizeof(un.sun_path); + } else { + sunlen = sizeof(un); + strlcpy(un.sun_path, sock->filename, MEMIF_SOCKET_UN_SIZE); + } ret = setsockopt(sockfd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)); if (ret < 0) goto error; - ret = bind(sockfd, (struct sockaddr *)un, MEMIF_SOCKET_UN_SIZE); + + ret = bind(sockfd, (struct sockaddr *)&un, sunlen); if (ret < 0) goto error; + ret = listen(sockfd, 1); if (ret < 0) goto error; - MIF_LOG(DEBUG, "%s: Memif listener socket %s created.", - rte_vdev_device_name(pmd->vdev), sock->filename); + MIF_LOG(DEBUG, "Memif listener socket %s created.", sock->filename); + + /* Allocate interrupt instance */ + sock->intr_handle = + rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_SHARED); + if (sock->intr_handle == NULL) { + MIF_LOG(ERR, "Failed to allocate intr handle"); + goto error; + } + + if (rte_intr_fd_set(sock->intr_handle, sockfd)) + goto error; - sock->intr_handle.fd = sockfd; - sock->intr_handle.type = RTE_INTR_HANDLE_EXT; - ret = rte_intr_callback_register(&sock->intr_handle, + if (rte_intr_type_set(sock->intr_handle, RTE_INTR_HANDLE_EXT)) + goto error; + + ret = rte_intr_callback_register(sock->intr_handle, memif_listener_handler, sock); if (ret < 0) { - MIF_LOG(ERR, "%s: Failed to register interrupt " - "callback for listener socket", - rte_vdev_device_name(pmd->vdev)); + MIF_LOG(ERR, "Failed to register interrupt " + "callback for listener socket"); return NULL; } } @@ -923,11 +961,11 @@ memif_socket_create(struct pmd_internals *pmd, return sock; error: - MIF_LOG(ERR, "%s: Failed to setup socket %s: %s", - rte_vdev_device_name(pmd->vdev) ? - rte_vdev_device_name(pmd->vdev) : "NULL", key, strerror(errno)); - if (sock != NULL) + MIF_LOG(ERR, "Failed to setup socket %s: %s", key, strerror(errno)); + if (sock != NULL) { + rte_intr_instance_free(sock->intr_handle); rte_free(sock); + } if (sockfd >= 0) close(sockfd); return NULL; @@ -940,9 +978,10 @@ memif_create_socket_hash(void) params.name = MEMIF_SOCKET_HASH_NAME; params.entries = 256; - params.key_len = MEMIF_SOCKET_KEY_LEN; + params.key_len = MEMIF_SOCKET_UN_SIZE; params.hash_func = rte_jhash; params.hash_func_init_val = 0; + params.socket_id = SOCKET_ID_ANY; return rte_hash_create(¶ms); } @@ -955,7 +994,7 @@ memif_socket_init(struct rte_eth_dev *dev, const char *socket_filename) struct pmd_internals *tmp_pmd; struct rte_hash *hash; int ret; - char key[MEMIF_SOCKET_KEY_LEN]; + char key[MEMIF_SOCKET_UN_SIZE]; hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME); if (hash == NULL) { @@ -966,13 +1005,13 @@ memif_socket_init(struct rte_eth_dev *dev, const char *socket_filename) } } - memset(key, 0, MEMIF_SOCKET_KEY_LEN); - strlcpy(key, socket_filename, MEMIF_SOCKET_KEY_LEN); + memset(key, 0, MEMIF_SOCKET_UN_SIZE); + strlcpy(key, socket_filename, MEMIF_SOCKET_UN_SIZE); ret = rte_hash_lookup_data(hash, key, (void **)&socket); if (ret < 0) { - socket = memif_socket_create(pmd, key, - (pmd->role == - MEMIF_ROLE_SLAVE) ? 0 : 1); + socket = memif_socket_create(key, + (pmd->role == MEMIF_ROLE_CLIENT) ? 0 : 1, + pmd->flags & ETH_MEMIF_FLAG_SOCKET_ABSTRACT); if (socket == NULL) return -1; ret = rte_hash_add_key_data(hash, key, socket); @@ -983,28 +1022,18 @@ memif_socket_init(struct rte_eth_dev *dev, const char *socket_filename) } pmd->socket_filename = socket->filename; - if (socket->listener != 0 && pmd->role == MEMIF_ROLE_SLAVE) { - MIF_LOG(ERR, "Socket is a listener."); - return -1; - } else if ((socket->listener == 0) && (pmd->role == MEMIF_ROLE_MASTER)) { - MIF_LOG(ERR, "Socket is not a listener."); - return -1; - } - TAILQ_FOREACH(elt, &socket->dev_queue, next) { tmp_pmd = elt->dev->data->dev_private; - if (tmp_pmd->id == pmd->id) { - MIF_LOG(ERR, "Memif device with id %d already " - "exists on socket %s", - pmd->id, socket->filename); + if (tmp_pmd->id == pmd->id && tmp_pmd->role == pmd->role) { + MIF_LOG(ERR, "Two interfaces with the same id (%d) can " + "not have the same role.", pmd->id); return -1; } } elt = rte_malloc("pmd-queue", sizeof(struct memif_socket_dev_list_elt), 0); if (elt == NULL) { - MIF_LOG(ERR, "%s: Failed to add device to socket device list.", - rte_vdev_device_name(pmd->vdev)); + MIF_LOG(ERR, "Failed to add device to socket device list."); return -1; } elt->dev = dev; @@ -1044,7 +1073,7 @@ memif_socket_remove_device(struct rte_eth_dev *dev) /* remove socket, if this was the last device using it */ if (TAILQ_EMPTY(&socket->dev_queue)) { rte_hash_del_key(hash, socket->filename); - if (socket->listener) { + if (socket->listener && !(pmd->flags & ETH_MEMIF_FLAG_SOCKET_ABSTRACT)) { /* remove listener socket file, * so we can create new one later. */ @@ -1053,12 +1082,14 @@ memif_socket_remove_device(struct rte_eth_dev *dev) MIF_LOG(ERR, "Failed to remove socket file: %s", socket->filename); } + if (pmd->role != MEMIF_ROLE_CLIENT) + rte_intr_instance_free(socket->intr_handle); rte_free(socket); } } int -memif_connect_master(struct rte_eth_dev *dev) +memif_connect_server(struct rte_eth_dev *dev) { struct pmd_internals *pmd = dev->data->dev_private; @@ -1069,11 +1100,12 @@ memif_connect_master(struct rte_eth_dev *dev) } int -memif_connect_slave(struct rte_eth_dev *dev) +memif_connect_client(struct rte_eth_dev *dev) { int sockfd; int ret; - struct sockaddr_un sun; + uint32_t sunlen; + struct sockaddr_un sun = { 0 }; struct pmd_internals *pmd = dev->data->dev_private; memset(pmd->local_disc_string, 0, ETH_MEMIF_DISC_STRING_SIZE); @@ -1082,45 +1114,60 @@ memif_connect_slave(struct rte_eth_dev *dev) sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0); if (sockfd < 0) { - MIF_LOG(ERR, "%s: Failed to open socket.", - rte_vdev_device_name(pmd->vdev)); + MIF_LOG(ERR, "Failed to open socket."); return -1; } sun.sun_family = AF_UNIX; + sunlen = sizeof(struct sockaddr_un); + if (pmd->flags & ETH_MEMIF_FLAG_SOCKET_ABSTRACT) { + /* abstract address */ + sun.sun_path[0] = '\0'; + strlcpy(sun.sun_path + 1, pmd->socket_filename, MEMIF_SOCKET_UN_SIZE - 1); + sunlen = RTE_MIN(strlen(pmd->socket_filename) + 1, + MEMIF_SOCKET_UN_SIZE) + + sizeof(sun) - sizeof(sun.sun_path); + } else { + strlcpy(sun.sun_path, pmd->socket_filename, MEMIF_SOCKET_UN_SIZE); + } - memcpy(sun.sun_path, pmd->socket_filename, sizeof(sun.sun_path) - 1); - - ret = connect(sockfd, (struct sockaddr *)&sun, - sizeof(struct sockaddr_un)); + ret = connect(sockfd, (struct sockaddr *)&sun, sunlen); if (ret < 0) { - MIF_LOG(ERR, "%s: Failed to connect socket: %s.", - rte_vdev_device_name(pmd->vdev), pmd->socket_filename); + MIF_LOG(ERR, "Failed to connect socket: %s.", pmd->socket_filename); goto error; } - MIF_LOG(DEBUG, "%s: Memif socket: %s connected.", - rte_vdev_device_name(pmd->vdev), pmd->socket_filename); + MIF_LOG(DEBUG, "Memif socket: %s connected.", pmd->socket_filename); pmd->cc = rte_zmalloc("memif-cc", sizeof(struct memif_control_channel), 0); if (pmd->cc == NULL) { - MIF_LOG(ERR, "%s: Failed to allocate control channel.", - rte_vdev_device_name(pmd->vdev)); + MIF_LOG(ERR, "Failed to allocate control channel."); goto error; } - pmd->cc->intr_handle.fd = sockfd; - pmd->cc->intr_handle.type = RTE_INTR_HANDLE_EXT; + /* Allocate interrupt instance */ + pmd->cc->intr_handle = + rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_SHARED); + if (pmd->cc->intr_handle == NULL) { + MIF_LOG(ERR, "Failed to allocate intr handle"); + goto error; + } + + if (rte_intr_fd_set(pmd->cc->intr_handle, sockfd)) + goto error; + + if (rte_intr_type_set(pmd->cc->intr_handle, RTE_INTR_HANDLE_EXT)) + goto error; + pmd->cc->socket = NULL; pmd->cc->dev = dev; TAILQ_INIT(&pmd->cc->msg_queue); - ret = rte_intr_callback_register(&pmd->cc->intr_handle, + ret = rte_intr_callback_register(pmd->cc->intr_handle, memif_intr_handler, pmd->cc); if (ret < 0) { - MIF_LOG(ERR, "%s: Failed to register interrupt callback " - "for control fd", rte_vdev_device_name(pmd->vdev)); + MIF_LOG(ERR, "Failed to register interrupt callback for control fd"); goto error; } @@ -1132,6 +1179,7 @@ memif_connect_slave(struct rte_eth_dev *dev) sockfd = -1; } if (pmd->cc != NULL) { + rte_intr_instance_free(pmd->cc->intr_handle); rte_free(pmd->cc); pmd->cc = NULL; }