#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
-#include <sys/un.h>
#include <sys/ioctl.h>
#include <errno.h>
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;
}
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_MASTER)) {
+ 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;
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));
int fd)
{
struct pmd_internals *pmd = dev->data->dev_private;
+ struct pmd_process_private *proc_private = dev->process_private;
memif_msg_add_region_t *ar = &msg->add_region;
struct memif_region *r;
return -1;
}
- if (ar->index >= ETH_MEMIF_MAX_REGION_NUM || ar->index != pmd->regions_num ||
- pmd->regions[ar->index] != NULL) {
+ if (ar->index >= ETH_MEMIF_MAX_REGION_NUM ||
+ ar->index != proc_private->regions_num ||
+ proc_private->regions[ar->index] != NULL) {
memif_msg_enq_disconnect(pmd->cc, "Invalid region index", 0);
return -1;
}
r = rte_zmalloc("region", sizeof(struct memif_region), 0);
if (r == NULL) {
- MIF_LOG(ERR, "%s: Failed to alloc memif region.",
- rte_vdev_device_name(pmd->vdev));
+ memif_msg_enq_disconnect(pmd->cc, "Failed to alloc memif region.", 0);
return -ENOMEM;
}
r->region_size = ar->size;
r->addr = NULL;
- pmd->regions[ar->index] = r;
- pmd->regions_num++;
+ proc_private->regions[ar->index] = r;
+ proc_private->regions_num++;
return 0;
}
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;
}
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;
}
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);
- memif_disconnect(rte_eth_dev_allocated
- (rte_vdev_device_name(pmd->vdev)));
+ memset(pmd->local_disc_string, 0, 96);
+ memif_disconnect(dev);
return 0;
}
memif_msg_enq_add_region(struct rte_eth_dev *dev, uint8_t idx)
{
struct pmd_internals *pmd = dev->data->dev_private;
+ struct pmd_process_private *proc_private = dev->process_private;
struct memif_msg_queue_elt *e = memif_msg_enq(pmd->cc);
memif_msg_add_region_t *ar;
- struct memif_region *mr = pmd->regions[idx];
+ struct memif_region *mr = proc_private->regions[idx];
if (e == NULL)
return -1;
{
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)
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;
}
{
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)
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;
}
int i;
int ret;
+ dev->data->dev_link.link_status = 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) {
/* at this point, there should be no more messages in queue */
if (TAILQ_FIRST(&pmd->cc->msg_queue) != NULL) {
MIF_LOG(WARNING,
- "%s: Unexpected message(s) in message queue.",
- rte_vdev_device_name(pmd->vdev));
+ "Unexpected message(s) in message queue.");
}
ih = &pmd->cc->intr_handle;
}
pmd->cc = NULL;
if (ret <= 0)
- MIF_LOG(WARNING, "%s: Failed to unregister "
- "control channel callback.",
- rte_vdev_device_name(pmd->vdev));
+ MIF_LOG(WARNING,
+ "Failed to unregister control channel callback.");
}
}
+ rte_spinlock_unlock(&pmd->cc_lock);
/* unconfig interrupts */
for (i = 0; i < pmd->cfg.num_s2m_rings; i++) {
close(mq->intr_handle.fd);
mq->intr_handle.fd = -1;
}
- mq->ring = NULL;
}
for (i = 0; i < pmd->cfg.num_m2s_rings; i++) {
if (pmd->role == MEMIF_ROLE_MASTER) {
close(mq->intr_handle.fd);
mq->intr_handle.fd = -1;
}
- mq->ring = NULL;
}
- memif_free_regions(pmd);
+ memif_free_regions(dev);
/* reset connection configuration */
memset(&pmd->run, 0, sizeof(pmd->run));
- dev->data->dev_link.link_status = ETH_LINK_DOWN;
- pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTING;
- pmd->flags &= ~ETH_MEMIF_FLAG_CONNECTED;
- MIF_LOG(DEBUG, "%s: Disconnected.", rte_vdev_device_name(pmd->vdev));
+ MIF_LOG(DEBUG, "Disconnected, id: %d, role: %s.", pmd->id,
+ (pmd->role == MEMIF_ROLE_MASTER) ? "master" : "slave");
}
static int
int afd = -1;
int i;
struct pmd_internals *pmd;
+ struct pmd_process_private *proc_private;
iov[0].iov_base = (void *)&msg;
iov[0].iov_len = sizeof(memif_msg_t);
size = recvmsg(cc->intr_handle.fd, &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);
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);
}
if (ret < 0)
goto exit;
pmd = cc->dev->data->dev_private;
- for (i = 0; i < pmd->regions_num; i++) {
+ proc_private = cc->dev->process_private;
+ for (i = 0; i < proc_private->regions_num; i++) {
ret = memif_msg_enq_add_region(cc->dev, i);
if (ret < 0)
goto exit;
ret = memif_msg_receive(cc);
/* if driver failed to assign device */
if (cc->dev == NULL) {
+ memif_msg_send_from_queue(cc);
ret = rte_intr_callback_unregister_pending(&cc->intr_handle,
memif_intr_handler,
cc,
return;
error:
- if (sockfd > 0) {
+ if (sockfd >= 0) {
close(sockfd);
sockfd = -1;
}
}
static struct memif_socket *
-memif_socket_create(struct pmd_internals *pmd, char *key, uint8_t listener)
+memif_socket_create(char *key, uint8_t listener)
{
struct memif_socket *sock;
struct sockaddr_un un;
}
sock->listener = listener;
- rte_memcpy(sock->filename, key, 256);
+ strlcpy(sock->filename, key, MEMIF_SOCKET_UN_SIZE);
TAILQ_INIT(&sock->dev_queue);
if (listener != 0) {
goto error;
un.sun_family = AF_UNIX;
- memcpy(un.sun_path, sock->filename,
- sizeof(un.sun_path) - 1);
+ 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, sizeof(un));
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);
sock->intr_handle.fd = sockfd;
sock->intr_handle.type = RTE_INTR_HANDLE_EXT;
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;
}
}
return sock;
error:
- MIF_LOG(ERR, "%s: Failed to setup socket %s: %s",
- rte_vdev_device_name(pmd->vdev), key, strerror(errno));
+ MIF_LOG(ERR, "Failed to setup socket %s: %s", key, strerror(errno));
if (sock != NULL)
rte_free(sock);
+ if (sockfd >= 0)
+ close(sockfd);
return NULL;
}
memif_create_socket_hash(void)
{
struct rte_hash_parameters params = { 0 };
+
params.name = MEMIF_SOCKET_HASH_NAME;
params.entries = 256;
- params.key_len = 256;
+ params.key_len = MEMIF_SOCKET_UN_SIZE;
params.hash_func = rte_jhash;
params.hash_func_init_val = 0;
return rte_hash_create(¶ms);
struct pmd_internals *tmp_pmd;
struct rte_hash *hash;
int ret;
- char key[256];
+ char key[MEMIF_SOCKET_UN_SIZE];
hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
if (hash == NULL) {
}
}
- memset(key, 0, 256);
- rte_memcpy(key, socket_filename, strlen(socket_filename));
+ 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_SLAVE) ? 0 : 1);
if (socket == NULL)
return -1;
ret = rte_hash_add_key_data(hash, key, socket);
}
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;
struct memif_socket *socket = NULL;
struct memif_socket_dev_list_elt *elt, *next;
struct rte_hash *hash;
+ int ret;
hash = rte_hash_find_existing(MEMIF_SOCKET_HASH_NAME);
if (hash == NULL)
/* remove listener socket file,
* so we can create new one later.
*/
- remove(socket->filename);
+ ret = remove(socket->filename);
+ if (ret < 0)
+ MIF_LOG(ERR, "Failed to remove socket file: %s",
+ socket->filename);
}
rte_free(socket);
}
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;
}
ret = connect(sockfd, (struct sockaddr *)&sun,
sizeof(struct sockaddr_un));
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;
}
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;
}
return 0;
error:
- if (sockfd > 0) {
+ if (sockfd >= 0) {
close(sockfd);
sockfd = -1;
}