X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Fmemif%2Fmemif.c;h=e35a8dcb4a001abc586cd003214cd02455c582b0;hb=7a40133d3355463368085c14f9fc4b4fd22d549a;hp=ba1231495c85a1fedb515edeae2bce371edc65b0;hpb=e2b3493029659bb0fd7eb9c571a757a060726774;p=vpp.git diff --git a/src/plugins/memif/memif.c b/src/plugins/memif/memif.c index ba1231495c8..e35a8dcb4a0 100644 --- a/src/plugins/memif/memif.c +++ b/src/plugins/memif/memif.c @@ -33,6 +33,7 @@ #include #include +#include #include #include #include @@ -51,10 +52,10 @@ memif_eth_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags) static void memif_queue_intfd_close (memif_queue_t * mq) { - if (mq->int_unix_file_index != ~0) + if (mq->int_clib_file_index != ~0) { - memif_file_del_by_index (mq->int_unix_file_index); - mq->int_unix_file_index = ~0; + memif_file_del_by_index (mq->int_clib_file_index); + mq->int_clib_file_index = ~0; mq->int_fd = -1; } else if (mq->int_fd > -1) @@ -76,13 +77,14 @@ memif_disconnect (memif_if_t * mif, clib_error_t * err) if (mif == 0) return; - DBG ("disconnect %u (%v)", mif->dev_instance, err ? err->what : 0); + memif_log_debug (mif, "disconnect %u (%v)", mif->dev_instance, + err ? err->what : 0); if (err) { clib_error_t *e = 0; mif->local_disc_string = vec_dup (err->what); - if (mif->conn_fd > -1) + if (mif->sock && clib_socket_is_connected (mif->sock)) e = memif_msg_send_disconnect (mif, err); clib_error_free (e); } @@ -93,58 +95,70 @@ memif_disconnect (memif_if_t * mif, clib_error_t * err) vnet_hw_interface_set_flags (vnm, mif->hw_if_index, 0); /* close connection socket */ - if (mif->conn_unix_file_index != ~0) + if (mif->sock && mif->sock->fd) { memif_socket_file_t *msf = vec_elt_at_index (mm->socket_files, mif->socket_file_index); - hash_unset (msf->dev_instance_by_fd, mif->conn_fd); - memif_file_del_by_index (mif->conn_unix_file_index); - mif->conn_unix_file_index = ~0; + hash_unset (msf->dev_instance_by_fd, mif->sock->fd); + memif_socket_close (&mif->sock); + } + else if (mif->sock) + { + clib_error_t *err; + err = clib_socket_close (mif->sock); + if (err) + { + memif_log_err (mif, "%U", format_clib_error, err); + clib_error_free (err); + } + clib_mem_free (mif->sock); } - else if (mif->conn_fd > -1) - close (mif->conn_fd); - mif->conn_fd = -1; + /* *INDENT-OFF* */ vec_foreach_index (i, mif->rx_queues) - { - mq = vec_elt_at_index (mif->rx_queues, i); - if (mq->ring) - { - int rv; - rv = vnet_hw_interface_unassign_rx_thread (vnm, mif->hw_if_index, i); - if (rv) - DBG ("Warning: unable to unassign interface %d, " - "queue %d: rc=%d", mif->hw_if_index, i, rv); - mq->ring = 0; - } - } + { + mq = vec_elt_at_index (mif->rx_queues, i); + if (mq->ring) + { + int rv; + rv = vnet_hw_interface_unassign_rx_thread (vnm, mif->hw_if_index, i); + if (rv) + memif_log_warn (mif, + "Unable to unassign interface %d, queue %d: rc=%d", + mif->hw_if_index, i, rv); + mq->ring = 0; + } + } /* free tx and rx queues */ - vec_foreach (mq, mif->rx_queues) memif_queue_intfd_close (mq); + vec_foreach (mq, mif->rx_queues) + memif_queue_intfd_close (mq); vec_free (mif->rx_queues); - vec_foreach (mq, mif->tx_queues) memif_queue_intfd_close (mq); + vec_foreach (mq, mif->tx_queues) + memif_queue_intfd_close (mq); vec_free (mif->tx_queues); /* free memory regions */ vec_foreach (mr, mif->regions) - { - int rv; - if ((rv = munmap (mr->shm, mr->region_size))) - clib_warning ("munmap failed, rv = %d", rv); - if (mr->fd > -1) - close (mr->fd); - } + { + int rv; + if (mr->is_external) + continue; + if ((rv = munmap (mr->shm, mr->region_size))) + memif_log_err (mif, "munmap failed, rv = %d", rv); + if (mr->fd > -1) + close (mr->fd); + } + /* *INDENT-ON* */ vec_free (mif->regions); - - mif->remote_pid = 0; vec_free (mif->remote_name); vec_free (mif->remote_if_name); clib_fifo_free (mif->msg_queue); } static clib_error_t * -memif_int_fd_read_ready (unix_file_t * uf) +memif_int_fd_read_ready (clib_file_t * uf) { memif_main_t *mm = &memif_main; vnet_main_t *vnm = vnet_get_main (); @@ -157,7 +171,7 @@ memif_int_fd_read_ready (unix_file_t * uf) size = read (uf->file_descriptor, &b, sizeof (b)); if (size < 0) { - DBG_UNIX_LOG ("Failed to read from socket"); + memif_log_debug (mif, "Failed to read form socket"); return 0; } @@ -172,70 +186,92 @@ clib_error_t * memif_connect (memif_if_t * mif) { vnet_main_t *vnm = vnet_get_main (); - unix_file_t template = { 0 }; + clib_file_t template = { 0 }; memif_region_t *mr; int i; + clib_error_t *err = NULL; - DBG ("connect %u", mif->dev_instance); + memif_log_debug (mif, "connect %u", mif->dev_instance); vec_free (mif->local_disc_string); vec_free (mif->remote_disc_string); + /* *INDENT-OFF* */ vec_foreach (mr, mif->regions) - { - if (mr->shm) - continue; + { + if (mr->shm) + continue; - if (mr->fd < 0) - clib_error_return (0, "no memory region fd"); + if (mr->fd < 0) + { + err = clib_error_return (0, "no memory region fd"); + goto error; + } - if ((mr->shm = mmap (NULL, mr->region_size, PROT_READ | PROT_WRITE, - MAP_SHARED, mr->fd, 0)) == MAP_FAILED) - return clib_error_return_unix (0, "mmap"); - } + if ((mr->shm = mmap (NULL, mr->region_size, PROT_READ | PROT_WRITE, + MAP_SHARED, mr->fd, 0)) == MAP_FAILED) + { + err = clib_error_return_unix (0, "mmap"); + goto error; + } + } + /* *INDENT-ON* */ template.read_function = memif_int_fd_read_ready; + /* *INDENT-OFF* */ vec_foreach_index (i, mif->tx_queues) - { - memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i); + { + memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i); - mq->ring = mif->regions[mq->region].shm + mq->offset; - if (mq->ring->cookie != MEMIF_COOKIE) - return clib_error_return (0, "wrong cookie on tx ring %u", i); - } + mq->ring = mif->regions[mq->region].shm + mq->offset; + if (mq->ring->cookie != MEMIF_COOKIE) + { + err = clib_error_return (0, "wrong cookie on tx ring %u", i); + goto error; + } + } vec_foreach_index (i, mif->rx_queues) - { - memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i); - int rv; - - mq->ring = mif->regions[mq->region].shm + mq->offset; - if (mq->ring->cookie != MEMIF_COOKIE) - return clib_error_return (0, "wrong cookie on tx ring %u", i); - - if (mq->int_fd > -1) - { - template.file_descriptor = mq->int_fd; - template.private_data = (mif->dev_instance << 16) | (i & 0xFFFF); - memif_file_add (&mq->int_unix_file_index, &template); - } - vnet_hw_interface_assign_rx_thread (vnm, mif->hw_if_index, i, ~0); - rv = vnet_hw_interface_set_rx_mode (vnm, mif->hw_if_index, i, - VNET_HW_INTERFACE_RX_MODE_DEFAULT); - if (rv) - clib_warning - ("Warning: unable to set rx mode for interface %d queue %d: " - "rc=%d", mif->hw_if_index, i, rv); - else - { - vnet_hw_interface_rx_mode rxmode; - vnet_hw_interface_get_rx_mode (vnm, mif->hw_if_index, i, &rxmode); - - if (rxmode == VNET_HW_INTERFACE_RX_MODE_POLLING) - mq->ring->flags |= MEMIF_RING_FLAG_MASK_INT; - } - } + { + memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i); + int rv; + + mq->ring = mif->regions[mq->region].shm + mq->offset; + if (mq->ring->cookie != MEMIF_COOKIE) + { + err = clib_error_return (0, "wrong cookie on tx ring %u", i); + goto error; + } + + if (mq->int_fd > -1) + { + template.file_descriptor = mq->int_fd; + template.private_data = (mif->dev_instance << 16) | (i & 0xFFFF); + template.description = format (0, "%U rx %u int", + format_memif_device_name, + mif->dev_instance, i); + memif_file_add (&mq->int_clib_file_index, &template); + } + vnet_hw_interface_assign_rx_thread (vnm, mif->hw_if_index, i, ~0); + rv = vnet_hw_interface_set_rx_mode (vnm, mif->hw_if_index, i, + VNET_HW_INTERFACE_RX_MODE_DEFAULT); + if (rv) + memif_log_err + (mif, "Warning: unable to set rx mode for interface %d queue %d: " + "rc=%d", mif->hw_if_index, i, rv); + else + { + vnet_hw_interface_rx_mode rxmode; + vnet_hw_interface_get_rx_mode (vnm, mif->hw_if_index, i, &rxmode); + + if (rxmode == VNET_HW_INTERFACE_RX_MODE_POLLING) + mq->ring->flags |= MEMIF_RING_FLAG_MASK_INT; + else + vnet_device_input_set_interrupt_pending (vnm, mif->hw_if_index, i); + } + } + /* *INDENT-ON* */ mif->flags &= ~MEMIF_IF_FLAG_CONNECTING; mif->flags |= MEMIF_IF_FLAG_CONNECTED; @@ -243,6 +279,10 @@ memif_connect (memif_if_t * mif) vnet_hw_interface_set_flags (vnm, mif->hw_if_index, VNET_HW_INTERFACE_FLAG_LINK_UP); return 0; + +error: + memif_log_err (mif, "%U", format_clib_error, err); + return err; } static_always_inline memif_ring_t * @@ -262,47 +302,71 @@ memif_get_ring (memif_if_t * mif, memif_ring_type_t type, u16 ring_num) clib_error_t * memif_init_regions_and_queues (memif_if_t * mif) { + vlib_main_t *vm = vlib_get_main (); memif_ring_t *ring = NULL; int i, j; u64 buffer_offset; memif_region_t *r; + clib_mem_vm_alloc_t alloc = { 0 }; + clib_error_t *err; - vec_validate_aligned (mif->regions, 0, CLIB_CACHE_LINE_BYTES); - r = vec_elt_at_index (mif->regions, 0); + ASSERT (vec_len (mif->regions) == 0); + vec_add2_aligned (mif->regions, r, 1, CLIB_CACHE_LINE_BYTES); buffer_offset = (mif->run.num_s2m_rings + mif->run.num_m2s_rings) * (sizeof (memif_ring_t) + sizeof (memif_desc_t) * (1 << mif->run.log2_ring_size)); - r->region_size = buffer_offset + - mif->run.buffer_size * (1 << mif->run.log2_ring_size) * - (mif->run.num_s2m_rings + mif->run.num_m2s_rings); + r->region_size = buffer_offset; - if ((r->fd = memfd_create ("memif region 0", MFD_ALLOW_SEALING)) == -1) - return clib_error_return_unix (0, "memfd_create"); + if ((mif->flags & MEMIF_IF_FLAG_ZERO_COPY) == 0) + r->region_size += mif->run.buffer_size * (1 << mif->run.log2_ring_size) * + (mif->run.num_s2m_rings + mif->run.num_m2s_rings); - if ((fcntl (r->fd, F_ADD_SEALS, F_SEAL_SHRINK)) == -1) - return clib_error_return_unix (0, "fcntl (F_ADD_SEALS, F_SEAL_SHRINK)"); + alloc.name = "memif region"; + alloc.size = r->region_size; + alloc.flags = CLIB_MEM_VM_F_SHARED; - if ((ftruncate (r->fd, r->region_size)) == -1) - return clib_error_return_unix (0, "ftruncate"); + err = clib_mem_vm_ext_alloc (&alloc); + if (err) + goto error; - if ((r->shm = mmap (NULL, r->region_size, PROT_READ | PROT_WRITE, - MAP_SHARED, r->fd, 0)) == MAP_FAILED) - return clib_error_return_unix (0, "mmap"); + r->fd = alloc.fd; + r->shm = alloc.addr; + + if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY) + { + vlib_buffer_pool_t *bp; + /* *INDENT-OFF* */ + vec_foreach (bp, buffer_main.buffer_pools) + { + vlib_physmem_region_t *pr; + pr = vlib_physmem_get_region (vm, bp->physmem_region); + vec_add2_aligned (mif->regions, r, 1, CLIB_CACHE_LINE_BYTES); + r->fd = pr->fd; + r->region_size = pr->size; + r->shm = pr->mem; + r->is_external = 1; + } + /* *INDENT-ON* */ + } for (i = 0; i < mif->run.num_s2m_rings; i++) { ring = memif_get_ring (mif, MEMIF_RING_S2M, i); ring->head = ring->tail = 0; ring->cookie = MEMIF_COOKIE; + + if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY) + continue; + for (j = 0; j < (1 << mif->run.log2_ring_size); j++) { u16 slot = i * (1 << mif->run.log2_ring_size) + j; ring->desc[j].region = 0; ring->desc[j].offset = buffer_offset + (u32) (slot * mif->run.buffer_size); - ring->desc[j].buffer_length = mif->run.buffer_size; + ring->desc[j].length = mif->run.buffer_size; } } for (i = 0; i < mif->run.num_m2s_rings; i++) @@ -310,6 +374,10 @@ memif_init_regions_and_queues (memif_if_t * mif) ring = memif_get_ring (mif, MEMIF_RING_M2S, i); ring->head = ring->tail = 0; ring->cookie = MEMIF_COOKIE; + + if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY) + continue; + for (j = 0; j < (1 << mif->run.log2_ring_size); j++) { u16 slot = @@ -317,43 +385,67 @@ memif_init_regions_and_queues (memif_if_t * mif) ring->desc[j].region = 0; ring->desc[j].offset = buffer_offset + (u32) (slot * mif->run.buffer_size); - ring->desc[j].buffer_length = mif->run.buffer_size; + ring->desc[j].length = mif->run.buffer_size; } } ASSERT (mif->tx_queues == 0); vec_validate_aligned (mif->tx_queues, mif->run.num_s2m_rings - 1, CLIB_CACHE_LINE_BYTES); + + /* *INDENT-OFF* */ vec_foreach_index (i, mif->tx_queues) - { - memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i); - if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0) - return clib_error_return_unix (0, "eventfd[tx queue %u]", i); - mq->int_unix_file_index = ~0; - mq->ring = memif_get_ring (mif, MEMIF_RING_S2M, i); - mq->log2_ring_size = mif->cfg.log2_ring_size; - mq->region = 0; - mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm; - mq->last_head = 0; - } + { + memif_queue_t *mq = vec_elt_at_index (mif->tx_queues, i); + if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0) + { + err = clib_error_return_unix (0, "eventfd[tx queue %u]", i); + goto error; + } + mq->int_clib_file_index = ~0; + mq->ring = memif_get_ring (mif, MEMIF_RING_S2M, i); + mq->log2_ring_size = mif->cfg.log2_ring_size; + mq->region = 0; + mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm; + mq->last_head = 0; + mq->type = MEMIF_RING_S2M; + if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY) + vec_validate_aligned (mq->buffers, 1 << mq->log2_ring_size, + CLIB_CACHE_LINE_BYTES); + } + /* *INDENT-ON* */ ASSERT (mif->rx_queues == 0); vec_validate_aligned (mif->rx_queues, mif->run.num_m2s_rings - 1, CLIB_CACHE_LINE_BYTES); + + /* *INDENT-OFF* */ vec_foreach_index (i, mif->rx_queues) - { - memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i); - if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0) - return clib_error_return_unix (0, "eventfd[rx queue %u]", i); - mq->int_unix_file_index = ~0; - mq->ring = memif_get_ring (mif, MEMIF_RING_M2S, i); - mq->log2_ring_size = mif->cfg.log2_ring_size; - mq->region = 0; - mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm; - mq->last_head = 0; - } + { + memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, i); + if ((mq->int_fd = eventfd (0, EFD_NONBLOCK)) < 0) + { + err = clib_error_return_unix (0, "eventfd[rx queue %u]", i); + goto error; + } + mq->int_clib_file_index = ~0; + mq->ring = memif_get_ring (mif, MEMIF_RING_M2S, i); + mq->log2_ring_size = mif->cfg.log2_ring_size; + mq->region = 0; + mq->offset = (void *) mq->ring - (void *) mif->regions[mq->region].shm; + mq->last_head = 0; + mq->type = MEMIF_RING_M2S; + if (mif->flags & MEMIF_IF_FLAG_ZERO_COPY) + vec_validate_aligned (mq->buffers, 1 << mq->log2_ring_size, + CLIB_CACHE_LINE_BYTES); + } + /* *INDENT-ON* */ return 0; + +error: + memif_log_err (mif, "%U", format_clib_error, err); + return err; } static uword @@ -361,19 +453,14 @@ memif_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) { memif_main_t *mm = &memif_main; memif_if_t *mif; - struct sockaddr_un sun; - int sockfd; + clib_socket_t *sock; uword *event_data = 0, event_type; u8 enabled = 0; f64 start_time, last_run_duration = 0, now; + clib_error_t *err; - sockfd = socket (AF_UNIX, SOCK_SEQPACKET, 0); - if (sockfd < 0) - { - DBG_UNIX_LOG ("socket AF_UNIX"); - return 0; - } - sun.sun_family = AF_UNIX; + sock = clib_mem_alloc (sizeof (clib_socket_t)); + memset (sock, 0, sizeof (clib_socket_t)); while (1) { @@ -424,33 +511,32 @@ memif_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE) { - strncpy (sun.sun_path, (char *) msf->filename, - sizeof (sun.sun_path) - 1); - - if (connect - (sockfd, (struct sockaddr *) &sun, - sizeof (struct sockaddr_un)) == 0) + memset (sock, 0, sizeof(clib_socket_t)); + sock->config = (char *) msf->filename; + sock->flags = CLIB_SOCKET_F_IS_CLIENT| CLIB_SOCKET_F_SEQPACKET; + + if ((err = clib_socket_init (sock))) + { + clib_error_free (err); + } + else { - unix_file_t t = { 0 }; + clib_file_t t = { 0 }; - mif->conn_fd = sockfd; t.read_function = memif_slave_conn_fd_read_ready; t.write_function = memif_slave_conn_fd_write_ready; t.error_function = memif_slave_conn_fd_error; - t.file_descriptor = mif->conn_fd; + t.file_descriptor = sock->fd; t.private_data = mif->dev_instance; - memif_file_add (&mif->conn_unix_file_index, &t); - hash_set (msf->dev_instance_by_fd, mif->conn_fd, mif->dev_instance); + memif_file_add (&sock->private_data, &t); + t.description = format (0, "%U ctl", + format_memif_device_name, + mif->dev_instance); + hash_set (msf->dev_instance_by_fd, sock->fd, mif->dev_instance); mif->flags |= MEMIF_IF_FLAG_CONNECTING; - - /* grab another fd */ - sockfd = socket (AF_UNIX, SOCK_SEQPACKET, 0); - if (sockfd < 0) - { - DBG_UNIX_LOG ("socket AF_UNIX"); - return 0; - } + mif->sock = sock; + sock = clib_mem_alloc (sizeof(clib_socket_t)); } } })); @@ -468,6 +554,144 @@ VLIB_REGISTER_NODE (memif_process_node,static) = { }; /* *INDENT-ON* */ +static int +memif_add_socket_file (u32 sock_id, u8 * socket_filename) +{ + memif_main_t *mm = &memif_main; + uword *p; + memif_socket_file_t *msf; + + p = hash_get (mm->socket_file_index_by_sock_id, sock_id); + if (p) + { + msf = pool_elt_at_index (mm->socket_files, *p); + if (strcmp ((char *) msf->filename, (char *) socket_filename) == 0) + { + /* Silently accept identical "add". */ + return 0; + } + + /* But don't allow a direct add of a different filename. */ + return VNET_API_ERROR_ENTRY_ALREADY_EXISTS; + } + + pool_get (mm->socket_files, msf); + memset (msf, 0, sizeof (memif_socket_file_t)); + + msf->filename = socket_filename; + msf->socket_id = sock_id; + + hash_set (mm->socket_file_index_by_sock_id, sock_id, + msf - mm->socket_files); + + return 0; +} + +static int +memif_delete_socket_file (u32 sock_id) +{ + memif_main_t *mm = &memif_main; + uword *p; + memif_socket_file_t *msf; + + p = hash_get (mm->socket_file_index_by_sock_id, sock_id); + if (!p) + { + /* Don't delete non-existent entries. */ + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + msf = pool_elt_at_index (mm->socket_files, *p); + if (msf->ref_cnt > 0) + { + return VNET_API_ERROR_UNEXPECTED_INTF_STATE; + } + + vec_free (msf->filename); + pool_put (mm->socket_files, msf); + + hash_unset (mm->socket_file_index_by_sock_id, sock_id); + + return 0; +} + +int +memif_socket_filename_add_del (u8 is_add, u32 sock_id, u8 * sock_filename) +{ + struct stat file_stat; + char *dir = 0, *tmp; + u32 idx = 0; + + /* allow adding socket id 0 */ + if ((sock_id == 0 && is_add == 0) || sock_id == ~0) + { + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + if (is_add == 0) + { + return memif_delete_socket_file (sock_id); + } + + if (sock_filename == 0 || sock_filename[0] == 0) + { + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + if (sock_filename[0] != '/') + { + clib_error_t *error; + + /* copy runtime dir path */ + vec_add (dir, vlib_unix_get_runtime_dir (), + strlen (vlib_unix_get_runtime_dir ())); + vec_add1 (dir, '/'); + + /* if sock_filename contains dirs, add them to path */ + tmp = strrchr ((char *) sock_filename, '/'); + if (tmp) + { + idx = tmp - (char *) sock_filename; + vec_add (dir, sock_filename, idx); + } + + vec_add1 (dir, '\0'); + /* create socket dir */ + error = vlib_unix_recursive_mkdir (dir); + if (error) + { + clib_error_free (error); + return VNET_API_ERROR_SYSCALL_ERROR_1; + } + + sock_filename = format (0, "%s/%s%c", vlib_unix_get_runtime_dir (), + sock_filename, 0); + } + else + { + sock_filename = vec_dup (sock_filename); + + /* check if directory exists */ + tmp = strrchr ((char *) sock_filename, '/'); + if (tmp) + { + idx = tmp - (char *) sock_filename; + vec_add (dir, sock_filename, idx); + vec_add1 (dir, '\0'); + } + + if (((dir == 0) || (stat (dir, &file_stat) == -1) + || (!S_ISDIR (file_stat.st_mode))) && (idx != 0)) + { + vec_free (dir); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + } + vec_free (dir); + + return memif_add_socket_file (sock_id, sock_filename); +} + int memif_delete_if (vlib_main_t * vm, memif_if_t * mif) { @@ -489,12 +713,15 @@ memif_delete_if (vlib_main_t * vm, memif_if_t * mif) memif_disconnect (mif, err); clib_error_free (err); - /* remove the interface */ - if (mif->mode == MEMIF_INTERFACE_MODE_IP) - vnet_delete_hw_interface (vnm, mif->hw_if_index); - else - ethernet_delete_interface (vnm, mif->hw_if_index); - mif->hw_if_index = ~0; + if (mif->hw_if_index != ~0) + { + /* remove the interface */ + if (mif->mode == MEMIF_INTERFACE_MODE_IP) + vnet_delete_hw_interface (vnm, mif->hw_if_index); + else + ethernet_delete_interface (vnm, mif->hw_if_index); + mif->hw_if_index = ~0; + } /* free interface data structures */ clib_spinlock_free (&mif->lockp); @@ -505,19 +732,26 @@ memif_delete_if (vlib_main_t * vm, memif_if_t * mif) { if (msf->is_listener) { - uword *x; - memif_file_del_by_index (msf->unix_file_index); - vec_foreach (x, msf->pending_file_indices) - { - memif_file_del_by_index (*x); - } - vec_free (msf->pending_file_indices); + int i; + /* *INDENT-OFF* */ + vec_foreach_index (i, msf->pending_clients) + memif_socket_close (msf->pending_clients + i); + /* *INDENT-ON* */ + memif_socket_close (&msf->sock); + vec_free (msf->pending_clients); } mhash_free (&msf->dev_instance_by_id); hash_free (msf->dev_instance_by_fd); - mhash_unset (&mm->socket_file_index_by_filename, msf->filename, 0); - vec_free (msf->filename); - pool_put (mm->socket_files, msf); + if (msf->sock) + { + err = clib_socket_close (msf->sock); + if (err) + { + memif_log_err (mif, "%U", format_clib_error, err); + clib_error_free (err); + } + clib_mem_free (msf->sock); + } } memset (mif, 0, sizeof (*mif)); @@ -551,34 +785,21 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) uword *p; vnet_hw_interface_t *hw; memif_socket_file_t *msf = 0; - u8 *socket_filename; int rv = 0; - if (args->socket_filename == 0 || args->socket_filename[0] != '/') + p = hash_get (mm->socket_file_index_by_sock_id, args->socket_id); + if (p == 0) { - rv = mkdir (MEMIF_DEFAULT_SOCKET_DIR, 0755); - if (rv && errno != EEXIST) - return VNET_API_ERROR_SYSCALL_ERROR_1; - - if (args->socket_filename == 0) - socket_filename = format (0, "%s/%s%c", MEMIF_DEFAULT_SOCKET_DIR, - MEMIF_DEFAULT_SOCKET_FILENAME, 0); - else - socket_filename = format (0, "%s/%s%c", MEMIF_DEFAULT_SOCKET_DIR, - args->socket_filename, 0); - + rv = VNET_API_ERROR_INVALID_ARGUMENT; + goto done; } - else - socket_filename = vec_dup (args->socket_filename); - p = mhash_get (&mm->socket_file_index_by_filename, socket_filename); + msf = vec_elt_at_index (mm->socket_files, p[0]); - if (p) + /* existing socket file can be either master or slave but cannot be both */ + if (msf->ref_cnt > 0) { - msf = vec_elt_at_index (mm->socket_files, p[0]); - - /* existing socket file can be either master or slave but cannot be both */ - if (!msf->is_listener != !args->is_master) + if ((!msf->is_listener != !args->is_master)) { rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS; goto done; @@ -593,36 +814,62 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) } /* Create new socket file */ - if (msf == 0) + if (msf->ref_cnt == 0) { struct stat file_stat; + /* If we are creating listener make sure file doesn't exist or if it * exists thn delete it if it is old socket file */ - if (args->is_master && - (stat ((char *) socket_filename, &file_stat) == 0)) + if (args->is_master && (stat ((char *) msf->filename, &file_stat) == 0)) { if (S_ISSOCK (file_stat.st_mode)) { - unlink ((char *) socket_filename); + unlink ((char *) msf->filename); } else { - ret = VNET_API_ERROR_SYSCALL_ERROR_3; - goto error; + error = clib_error_return (0, "File exists for %s", + msf->filename); + rv = VNET_API_ERROR_VALUE_EXIST; + goto done; } } - pool_get (mm->socket_files, msf); - memset (msf, 0, sizeof (memif_socket_file_t)); + mhash_init (&msf->dev_instance_by_id, sizeof (uword), sizeof (memif_interface_id_t)); msf->dev_instance_by_fd = hash_create (0, sizeof (uword)); - msf->filename = socket_filename; - msf->fd = -1; msf->is_listener = (args->is_master != 0); - socket_filename = 0; - mhash_set (&mm->socket_file_index_by_filename, msf->filename, - msf - mm->socket_files, 0); - DBG ("creating socket file %s", msf->filename); + + memif_log_debug (0, "initializing socket file %s", msf->filename); + } + + if (mm->per_thread_data == 0) + { + int i; + vlib_buffer_free_list_t *fl; + + vec_validate_aligned (mm->per_thread_data, tm->n_vlib_mains - 1, + CLIB_CACHE_LINE_BYTES); + + fl = + vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX); + for (i = 0; i < tm->n_vlib_mains; i++) + { + memif_per_thread_data_t *ptd = + vec_elt_at_index (mm->per_thread_data, i); + vlib_buffer_t *bt = &ptd->buffer_template; + vlib_buffer_init_for_free_list (bt, fl); + bt->flags = VLIB_BUFFER_TOTAL_LENGTH_VALID; + bt->total_length_not_including_first_buffer = 0; + vnet_buffer (bt)->sw_if_index[VLIB_TX] = (u32) ~ 0; + + /* initially prealloc copy_ops so we can use + _vec_len instead of vec_elen */ + vec_validate_aligned (ptd->copy_ops, 0, CLIB_CACHE_LINE_BYTES); + vec_reset_length (ptd->copy_ops); + vec_validate_aligned (ptd->buffers, 0, CLIB_CACHE_LINE_BYTES); + vec_reset_length (ptd->buffers); + } } pool_get (mm->interfaces, mif); @@ -631,8 +878,6 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) mif->socket_file_index = msf - mm->socket_files; mif->id = args->id; mif->sw_if_index = mif->hw_if_index = mif->per_interface_next_index = ~0; - mif->conn_unix_file_index = ~0; - mif->conn_fd = -1; mif->mode = args->mode; if (args->secret) mif->secret = vec_dup (args->secret); @@ -640,7 +885,6 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) if (tm->n_vlib_mains > 1) clib_spinlock_init (&mif->lockp); - if (mif->mode == MEMIF_INTERFACE_MODE_ETHERNET) { @@ -673,7 +917,6 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) if (error) { - clib_error_report (error); ret = VNET_API_ERROR_SYSCALL_ERROR_2; goto error; } @@ -693,33 +936,21 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) /* If this is new one, start listening */ if (msf->is_listener && msf->ref_cnt == 0) { - struct sockaddr_un un = { 0 }; struct stat file_stat; - int on = 1; + clib_socket_t *s = clib_mem_alloc (sizeof (clib_socket_t)); - if ((msf->fd = socket (AF_UNIX, SOCK_SEQPACKET, 0)) < 0) - { - ret = VNET_API_ERROR_SYSCALL_ERROR_4; - goto error; - } + ASSERT (msf->sock == 0); + msf->sock = s; - un.sun_family = AF_UNIX; - strncpy ((char *) un.sun_path, (char *) msf->filename, - sizeof (un.sun_path) - 1); + memset (s, 0, sizeof (clib_socket_t)); + s->config = (char *) msf->filename; + s->flags = CLIB_SOCKET_F_IS_SERVER | + CLIB_SOCKET_F_ALLOW_GROUP_WRITE | + CLIB_SOCKET_F_SEQPACKET | CLIB_SOCKET_F_PASSCRED; - if (setsockopt (msf->fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)) < 0) - { - ret = VNET_API_ERROR_SYSCALL_ERROR_5; - goto error; - } - if (bind (msf->fd, (struct sockaddr *) &un, sizeof (un)) == -1) - { - ret = VNET_API_ERROR_SYSCALL_ERROR_6; - goto error; - } - if (listen (msf->fd, 1) == -1) + if ((error = clib_socket_init (s))) { - ret = VNET_API_ERROR_SYSCALL_ERROR_7; + ret = VNET_API_ERROR_SYSCALL_ERROR_4; goto error; } @@ -729,18 +960,22 @@ memif_create_if (vlib_main_t * vm, memif_create_if_args_t * args) goto error; } - msf->unix_file_index = ~0; - unix_file_t template = { 0 }; + clib_file_t template = { 0 }; template.read_function = memif_conn_fd_accept_ready; - template.file_descriptor = msf->fd; + template.file_descriptor = msf->sock->fd; template.private_data = mif->socket_file_index; - memif_file_add (&msf->unix_file_index, &template); + template.description = format (0, "memif listener %s", msf->filename); + memif_file_add (&msf->sock->private_data, &template); } msf->ref_cnt++; if (args->is_master == 0) - mif->flags |= MEMIF_IF_FLAG_IS_SLAVE; + { + mif->flags |= MEMIF_IF_FLAG_IS_SLAVE; + if (args->is_zero_copy) + mif->flags |= MEMIF_IF_FLAG_ZERO_COPY; + } hw = vnet_get_hw_interface (vnm, mif->hw_if_index); hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE; @@ -766,29 +1001,36 @@ error: mif->hw_if_index = ~0; } memif_delete_if (vm, mif); + if (error) + { + memif_log_err (mif, "%U", format_clib_error, error); + clib_error_free (error); + } return ret; done: - vec_free (socket_filename); return rv; } - static clib_error_t * memif_init (vlib_main_t * vm) { memif_main_t *mm = &memif_main; - vlib_thread_main_t *tm = vlib_get_thread_main (); memset (mm, 0, sizeof (memif_main_t)); + mm->log_class = vlib_log_register_class ("memif_plugin", 0); + memif_log_debug (0, "initialized"); + /* initialize binary API */ memif_plugin_api_hookup (vm); - mhash_init_c_string (&mm->socket_file_index_by_filename, sizeof (uword)); - - vec_validate_aligned (mm->rx_buffers, tm->n_vlib_mains - 1, - CLIB_CACHE_LINE_BYTES); + /* + * Pre-stuff socket filename pool with a non-modifieable mapping + * for socket-id 0 to MEMIF_DEFAULT_SOCKET_FILENAME in the + * default run-time directory. + */ + memif_socket_filename_add_del (1, 0, (u8 *) MEMIF_DEFAULT_SOCKET_FILENAME); return 0; } @@ -798,7 +1040,7 @@ VLIB_INIT_FUNCTION (memif_init); /* *INDENT-OFF* */ VLIB_PLUGIN_REGISTER () = { .version = VPP_BUILD_VER, - .description = "Packet Memory Interface (experimetal)", + .description = "Packet Memory Interface (experimental)", }; /* *INDENT-ON* */