X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlibmemory%2Fsocket_api.c;h=24a460979f4ebd542c6f42506b301167be9d936e;hb=d7413835e1478b0c1356bae7d45e00061d7eb8d4;hp=5587611d65afc7c5a21b61ad3eae942126008559;hpb=466f289c27f290a2764a82f57f5c20d080227ead;p=vpp.git diff --git a/src/vlibmemory/socket_api.c b/src/vlibmemory/socket_api.c index 5587611d65a..24a460979f4 100644 --- a/src/vlibmemory/socket_api.c +++ b/src/vlibmemory/socket_api.c @@ -1,6 +1,6 @@ /* *------------------------------------------------------------------ - * socksvr_vlib.c + * socket_api.c * * Copyright (c) 2009 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -35,7 +35,6 @@ #undef vl_typedefs /* instantiate all the print functions we know about */ -#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) #define vl_printfun #include #undef vl_printfun @@ -45,8 +44,33 @@ #include #undef vl_endianfun +#define vl_calcsizefun +#include +#undef vl_calcsizefun + socket_main_t socket_main; +#define SOCK_API_REG_HANDLE_BIT (1<<31) + +static u32 +sock_api_registration_handle (vl_api_registration_t * regp) +{ + ASSERT (regp->vl_api_registration_pool_index < SOCK_API_REG_HANDLE_BIT); + return regp->vl_api_registration_pool_index | SOCK_API_REG_HANDLE_BIT; +} + +static u32 +socket_api_registration_handle_to_index (u32 reg_index) +{ + return (reg_index & ~SOCK_API_REG_HANDLE_BIT); +} + +u8 +vl_socket_api_registration_handle_is_valid (u32 reg_handle) +{ + return ((reg_handle & SOCK_API_REG_HANDLE_BIT) != 0); +} + void vl_sock_api_dump_clients (vlib_main_t * vm, api_main_t * am) { @@ -64,16 +88,31 @@ vl_sock_api_dump_clients (vlib_main_t * vm, api_main_t * am) vlib_cli_output (vm, "Socket clients"); vlib_cli_output (vm, "%20s %8s", "Name", "Fildesc"); /* *INDENT-OFF* */ - pool_foreach (reg, sm->registration_pool, - ({ + pool_foreach (reg, sm->registration_pool) + { if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) { f = vl_api_registration_file (reg); vlib_cli_output (vm, "%20s %8d", reg->name, f->file_descriptor); } - })); + } /* *INDENT-ON* */ } +vl_api_registration_t * +vl_socket_api_client_handle_to_registration (u32 handle) +{ + socket_main_t *sm = &socket_main; + u32 index = socket_api_registration_handle_to_index (handle); + if (pool_is_free_index (sm->registration_pool, index)) + { +#if DEBUG > 2 + clib_warning ("Invalid index %d\n", index); +#endif + return 0; + } + return pool_elt_at_index (sm->registration_pool, index); +} + void vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) { @@ -82,15 +121,17 @@ vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) #endif socket_main_t *sm = &socket_main; u16 msg_id = ntohs (*(u16 *) elem); - api_main_t *am = &api_main; + api_main_t *am = vlibapi_get_main (); msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data)); vl_api_registration_t *sock_rp; + clib_file_main_t *fm = &file_main; + clib_error_t *error; clib_file_t *cf; cf = vl_api_registration_file (rp); ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); - if (msg_id >= vec_len (am->api_trace_cfg)) + if (msg_id >= vec_len (am->msg_data)) { clib_warning ("id out of range: %d", msg_id); vl_msg_api_free ((void *) elem); @@ -102,10 +143,21 @@ vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) ASSERT (sock_rp); /* Add the msgbuf_t to the output vector */ - vl_socket_add_pending_output_no_flush (cf, sock_rp, (u8 *) mb, - sizeof (*mb)); - /* Send the message */ - vl_socket_add_pending_output (cf, sock_rp, elem, ntohl (mb->data_len)); + vec_add (sock_rp->output_vector, (u8 *) mb, sizeof (*mb)); + + /* Try to send the message and save any error like + * we do in the input epoll loop */ + vec_add (sock_rp->output_vector, elem, ntohl (mb->data_len)); + error = clib_file_write (cf); + unix_save_error (&unix_main, error); + + /* If we didn't finish sending everything, wait for tx space */ + if (vec_len (sock_rp->output_vector) > 0 + && !(cf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) + { + cf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE; + fm->file_update (cf, UNIX_FILE_UPDATE_MODIFY); + } #if CLIB_DEBUG > 1 output_length = sizeof (*mb) + ntohl (mb->data_len); @@ -121,6 +173,8 @@ vl_socket_free_registration_index (u32 pool_index) { int i; vl_api_registration_t *rp; + void vl_api_call_reaper_functions (u32 client_index); + if (pool_is_free_index (socket_main.registration_pool, pool_index)) { clib_warning ("main pool index %d already free", pool_index); @@ -128,6 +182,9 @@ vl_socket_free_registration_index (u32 pool_index) } rp = pool_elt_at_index (socket_main.registration_pool, pool_index); + vl_api_call_reaper_functions ( + clib_host_to_net_u32 (sock_api_registration_handle (rp))); + ASSERT (rp->registration_type != REGISTRATION_TYPE_FREE); for (i = 0; i < vec_len (rp->additional_fds_to_close); i++) if (close (rp->additional_fds_to_close[i]) < 0) @@ -141,57 +198,114 @@ vl_socket_free_registration_index (u32 pool_index) } void -vl_socket_process_api_msg (clib_file_t * uf, vl_api_registration_t * rp, - i8 * input_v) +vl_socket_process_api_msg (vl_api_registration_t * rp, i8 * input_v) { msgbuf_t *mbp = (msgbuf_t *) input_v; u8 *the_msg = (u8 *) (mbp->data); - socket_main.current_uf = uf; socket_main.current_rp = rp; - vl_msg_api_socket_handler (the_msg); - socket_main.current_uf = 0; + vl_msg_api_socket_handler (the_msg, ntohl (mbp->data_len)); socket_main.current_rp = 0; } +int +is_being_removed_reg_index (u32 reg_index) +{ + vl_api_registration_t *rp = vl_socket_get_registration (reg_index); + ALWAYS_ASSERT (rp != 0); + return (rp->is_being_removed); +} + +static void +socket_cleanup_pending_remove_registration_cb (u32 *preg_index) +{ + vl_api_registration_t *rp = vl_socket_get_registration (*preg_index); + if (!rp) + { + /* Might already have gone */ + return; + } + + clib_file_main_t *fm = &file_main; + u32 pending_remove_file_index = vl_api_registration_file_index (rp); + + clib_file_t *zf = fm->file_pool + pending_remove_file_index; + + clib_file_del (fm, zf); + vl_socket_free_registration_index (rp - socket_main.registration_pool); +} + +static void +vl_socket_request_remove_reg_index (u32 reg_index) +{ + vl_api_registration_t *rp = vl_socket_get_registration (reg_index); + ALWAYS_ASSERT (rp != 0); + if (rp->is_being_removed) + { + return; + } + rp->is_being_removed = 1; + vl_api_force_rpc_call_main_thread ( + socket_cleanup_pending_remove_registration_cb, (void *) ®_index, + sizeof (u32)); +} + +/* + * Read function for API socket. + * + * Read data from socket, invoke SOCKET_READ_EVENT + * for each fully read API message, return 0. + * Store incomplete data for next invocation to continue. + * + * On severe read error, the file is closed. + * + * As reading is single threaded, + * socket_main.input_buffer is used temporarily. + * Even its length is modified, but always restored before return. + * + * Incomplete data is copied into a vector, + * pointer saved in registration's unprocessed_input. + */ clib_error_t * vl_socket_read_ready (clib_file_t * uf) { - clib_file_main_t *fm = &file_main; vlib_main_t *vm = vlib_get_main (); vl_api_registration_t *rp; + /* n is the size of data read to input_buffer */ int n; + /* msg_buffer vector can point to input_buffer or unprocessed_input */ i8 *msg_buffer = 0; + /* data_for_process is a vector containing one full message, incl msgbuf_t */ u8 *data_for_process; - u32 msg_len; + /* msgbuf_len is the size of one message, including sizeof (msgbuf_t) */ + u32 msgbuf_len; u32 save_input_buffer_length = vec_len (socket_main.input_buffer); vl_socket_args_for_process_t *a; - msgbuf_t *mbp; - int mbp_set = 0; + u32 reg_index = uf->private_data; + if (is_being_removed_reg_index (reg_index)) + { + return 0; + } - rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); + rp = vl_socket_get_registration (reg_index); + /* Ignore unprocessed_input for now, n describes input_buffer for now. */ n = read (uf->file_descriptor, socket_main.input_buffer, vec_len (socket_main.input_buffer)); - if (n <= 0 && errno != EAGAIN) + if (n <= 0) { - clib_file_del (fm, uf); - - if (!pool_is_free (socket_main.registration_pool, rp)) - { - u32 index = rp - socket_main.registration_pool; - vl_socket_free_registration_index (index); - } - else + if (errno != EAGAIN) { - clib_warning ("client index %d already free?", - rp->vl_api_registration_pool_index); + /* Severe error, close the file. */ + vl_socket_request_remove_reg_index (reg_index); } + /* EAGAIN means we do not close the file, but no data to process anyway. */ return 0; } - _vec_len (socket_main.input_buffer) = n; + /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */ + vec_set_len (socket_main.input_buffer, n); /* * Look for bugs here. This code is tricky because @@ -199,114 +313,79 @@ vl_socket_read_ready (clib_file_t * uf) * boundaries. In the case of a long message (>4K bytes) * we have to do (at least) 2 reads, etc. */ + /* Determine msg_buffer. */ + if (vec_len (rp->unprocessed_input)) + { + vec_append (rp->unprocessed_input, socket_main.input_buffer); + msg_buffer = rp->unprocessed_input; + } + else + { + msg_buffer = socket_main.input_buffer; + } + /* Loop to process any full messages. */ + ASSERT (vec_len (msg_buffer) > 0); do { - if (vec_len (rp->unprocessed_input)) - { - vec_append (rp->unprocessed_input, socket_main.input_buffer); - msg_buffer = rp->unprocessed_input; - } - else - { - msg_buffer = socket_main.input_buffer; - mbp_set = 0; - } - - if (mbp_set == 0) - { - /* Any chance that we have a complete message? */ - if (vec_len (msg_buffer) <= sizeof (msgbuf_t)) - goto save_and_split; - - mbp = (msgbuf_t *) msg_buffer; - msg_len = ntohl (mbp->data_len); - mbp_set = 1; - } - - /* We don't have the entire message yet. */ - if (mbp_set == 0 - || (msg_len + sizeof (msgbuf_t)) > vec_len (msg_buffer)) + /* Here, we are not sure how big a chunk of message we have left. */ + /* Do we at least know how big the full message will be? */ + if (vec_len (msg_buffer) <= sizeof (msgbuf_t)) + /* No, so fragment is not a full message. */ + goto save_and_split; + + /* Now we know how big the full message will be. */ + msgbuf_len = + ntohl (((msgbuf_t *) msg_buffer)->data_len) + sizeof (msgbuf_t); + + /* But do we have a full message? */ + if (msgbuf_len > vec_len (msg_buffer)) { save_and_split: - /* if we were using the input buffer save the fragment */ + /* We don't have the entire message yet. */ + /* If msg_buffer is unprocessed_input, nothing needs to be done. */ if (msg_buffer == socket_main.input_buffer) + /* But if we were using the input buffer, save the fragment. */ { ASSERT (vec_len (rp->unprocessed_input) == 0); vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1); - clib_memcpy (rp->unprocessed_input, msg_buffer, - vec_len (msg_buffer)); - _vec_len (rp->unprocessed_input) = vec_len (msg_buffer); + clib_memcpy_fast (rp->unprocessed_input, msg_buffer, + vec_len (msg_buffer)); + vec_set_len (rp->unprocessed_input, vec_len (msg_buffer)); } - _vec_len (socket_main.input_buffer) = save_input_buffer_length; + /* No more full messages, restore original input_buffer length. */ + vec_set_len (socket_main.input_buffer, save_input_buffer_length); return 0; } + /* + * We have at least one full message. + * But msg_buffer can contain more data, so copy one message data + * so we can overwrite its length to what single message has. + */ data_for_process = (u8 *) vec_dup (msg_buffer); - _vec_len (data_for_process) = (msg_len + sizeof (msgbuf_t)); + vec_set_len (data_for_process, msgbuf_len); + /* Everything is ready to signal the SOCKET_READ_EVENT. */ pool_get (socket_main.process_args, a); - a->clib_file = uf; - a->regp = rp; + a->reg_index = reg_index; a->data = data_for_process; vlib_process_signal_event (vm, vl_api_clnt_node.index, SOCKET_READ_EVENT, a - socket_main.process_args); - if (n > (msg_len + sizeof (*mbp))) - vec_delete (msg_buffer, msg_len + sizeof (*mbp), 0); + if (vec_len (msg_buffer) > msgbuf_len) + /* There are some fragments left. Shrink the msg_buffer to simplify logic. */ + vec_delete (msg_buffer, msgbuf_len, 0); else - _vec_len (msg_buffer) = 0; - n -= msg_len + sizeof (msgbuf_t); - msg_len = 0; - mbp_set = 0; + /* We are done with msg_buffer. */ + vec_set_len (msg_buffer, 0); } - while (n > 0); - - _vec_len (socket_main.input_buffer) = save_input_buffer_length; + while (vec_len (msg_buffer) > 0); + /* Restore input_buffer, it could have been msg_buffer. */ + vec_set_len (socket_main.input_buffer, save_input_buffer_length); return 0; } -void -vl_socket_add_pending_output (clib_file_t * uf, - vl_api_registration_t * rp, - u8 * buffer, uword buffer_bytes) -{ - clib_file_main_t *fm = &file_main; - - vec_add (rp->output_vector, buffer, buffer_bytes); - if (vec_len (rp->output_vector) > 0) - { - int skip_update = 0 != (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE); - uf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE; - if (!skip_update) - fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY); - } -} - -void -vl_socket_add_pending_output_no_flush (clib_file_t * uf, - vl_api_registration_t * rp, - u8 * buffer, uword buffer_bytes) -{ - vec_add (rp->output_vector, buffer, buffer_bytes); -} - -static void -socket_del_pending_output (clib_file_t * uf, - vl_api_registration_t * rp, uword n_bytes) -{ - clib_file_main_t *fm = &file_main; - - vec_delete (rp->output_vector, n_bytes, 0); - if (vec_len (rp->output_vector) <= 0) - { - int skip_update = 0 == (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE); - uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE; - if (!skip_update) - fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY); - } -} - clib_error_t * vl_socket_write_ready (clib_file_t * uf) { @@ -314,24 +393,45 @@ vl_socket_write_ready (clib_file_t * uf) vl_api_registration_t *rp; int n; - rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); + u32 reg_index = uf->private_data; + if (is_being_removed_reg_index (reg_index)) + { + return 0; + } + + rp = pool_elt_at_index (socket_main.registration_pool, reg_index); /* Flush output vector. */ - n = write (uf->file_descriptor, - rp->output_vector, vec_len (rp->output_vector)); - if (n < 0) + size_t total_bytes = vec_len (rp->output_vector); + size_t bytes_to_send, remaining_bytes = total_bytes; + void *p = rp->output_vector; + while (remaining_bytes > 0) { + bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes; + n = send (uf->file_descriptor, p, bytes_to_send, MSG_NOSIGNAL); + if (n < 0) + { + if (errno == EAGAIN) + { + break; + } #if DEBUG > 2 - clib_warning ("write error, close the file...\n"); + clib_warning ("write error, close the file...\n"); #endif - clib_file_del (fm, uf); - - vl_socket_free_registration_index (rp - socket_main.registration_pool); - return 0; + vl_socket_request_remove_reg_index (reg_index); + return 0; + } + remaining_bytes -= bytes_to_send; + p += bytes_to_send; } - else if (n > 0) - socket_del_pending_output (uf, rp, n); + vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0); + if (vec_len (rp->output_vector) <= 0 + && (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) + { + uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE; + fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY); + } return 0; } @@ -339,13 +439,8 @@ vl_socket_write_ready (clib_file_t * uf) clib_error_t * vl_socket_error_ready (clib_file_t * uf) { - vl_api_registration_t *rp; - clib_file_main_t *fm = &file_main; - - rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); - clib_file_del (fm, uf); - vl_socket_free_registration_index (rp - socket_main.registration_pool); - + u32 reg_index = uf->private_data; + vl_socket_request_remove_reg_index (reg_index); return 0; } @@ -356,12 +451,13 @@ socksvr_file_add (clib_file_main_t * fm, int fd) clib_file_t template = { 0 }; pool_get (socket_main.registration_pool, rp); - memset (rp, 0, sizeof (*rp)); + clib_memset (rp, 0, sizeof (*rp)); template.read_function = vl_socket_read_ready; template.write_function = vl_socket_write_ready; template.error_function = vl_socket_error_ready; template.file_descriptor = fd; + template.description = format (0, "socksrv"); template.private_data = rp - socket_main.registration_pool; rp->registration_type = REGISTRATION_TYPE_SOCKET_SERVER; @@ -401,21 +497,43 @@ vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) { vl_api_registration_t *regp; vl_api_sockclnt_create_reply_t *rp; + api_main_t *am = vlibapi_get_main (); + hash_pair_t *hp; int rv = 0; + u32 nmsg = hash_elts (am->msg_index_by_name_and_crc); + u32 i = 0; regp = socket_main.current_rp; - ASSERT (regp->registration_type == REGISTRATION_TYPE_SOCKET_SERVER); + /* client already connected through shared memory? */ + if (!regp || regp->registration_type != REGISTRATION_TYPE_SOCKET_SERVER) + { + clib_warning ( + "unsupported API call: already connected though shared memory?"); + return; + } regp->name = format (0, "%s%c", mp->name, 0); - rp = vl_msg_api_alloc (sizeof (*rp)); + u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t)); + rp = vl_msg_api_alloc_zero (size); rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY); - rp->handle = (uword) regp; - rp->index = (uword) regp->vl_api_registration_pool_index; + rp->index = htonl (sock_api_registration_handle (regp)); rp->context = mp->context; rp->response = htonl (rv); - + rp->count = htons (nmsg); + + /* *INDENT-OFF* */ + hash_foreach_pair (hp, am->msg_index_by_name_and_crc, + ({ + rp->message_table[i].index = htons(hp->value[0]); + (void) strncpy_s((char *)rp->message_table[i].name, + 64 /* bytes of space at dst */, + (char *)hp->key, + 64-1 /* chars to copy, without zero byte. */); + i++; + })); + /* *INDENT-ON* */ vl_api_send_msg (regp, (u8 *) rp); } @@ -428,23 +546,28 @@ vl_api_sockclnt_delete_t_handler (vl_api_sockclnt_delete_t * mp) vl_api_registration_t *regp; vl_api_sockclnt_delete_reply_t *rp; - if (!pool_is_free_index (socket_main.registration_pool, mp->index)) - { - regp = pool_elt_at_index (socket_main.registration_pool, mp->index); + regp = vl_api_client_index_to_registration (mp->client_index); + if (!regp) + return; - rp = vl_msg_api_alloc (sizeof (*rp)); - rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY); - rp->handle = mp->handle; - rp->response = htonl (1); + u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index)); + rp = vl_msg_api_alloc (sizeof (*rp)); + rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY); + rp->context = mp->context; + if (!pool_is_free_index (socket_main.registration_pool, reg_index)) + { + rp->response = htonl (1); vl_api_send_msg (regp, (u8 *) rp); vl_api_registration_del_file (regp); - vl_socket_free_registration_index (mp->index); + vl_socket_free_registration_index (reg_index); } else { - clib_warning ("unknown client ID %d", mp->index); + clib_warning ("unknown client ID %d", reg_index); + rp->response = htonl (-1); + vl_api_send_msg (regp, (u8 *) rp); } } @@ -453,7 +576,7 @@ vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds) { struct msghdr mh = { 0 }; struct iovec iov[1]; - char ctl[CMSG_SPACE (sizeof (int)) * n_fds]; + char ctl[CMSG_SPACE (sizeof (int) * n_fds)]; struct cmsghdr *cmsg; char *msg = "fdmsg"; int rv; @@ -463,16 +586,17 @@ vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds) mh.msg_iov = iov; mh.msg_iovlen = 1; - memset (&ctl, 0, sizeof (ctl)); + clib_memset (&ctl, 0, sizeof (ctl)); mh.msg_control = ctl; mh.msg_controllen = sizeof (ctl); cmsg = CMSG_FIRSTHDR (&mh); cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; - memcpy (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds); + clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds); - rv = sendmsg (socket_fd, &mh, 0); + while ((rv = sendmsg (socket_fd, &mh, 0)) < 0 && errno == EAGAIN) + ; if (rv < 0) return clib_error_return_unix (0, "sendmsg"); return 0; @@ -543,12 +667,12 @@ vl_api_sock_init_shm_t_handler (vl_api_sock_init_shm_t * mp) ssvm_private_t _memfd_private, *memfd = &_memfd_private; svm_map_region_args_t _args, *a = &_args; vl_api_registration_t *regp; - api_main_t *am = &api_main; + api_main_t *am = vlibapi_get_main (); svm_region_t *vlib_rp; clib_file_t *cf; vl_api_shm_elem_config_t *config = 0; vl_shmem_hdr_t *shmem_hdr; - int rv; + int rv, tries = 1000; regp = vl_api_client_index_to_registration (mp->client_index); if (regp == 0) @@ -558,30 +682,35 @@ vl_api_sock_init_shm_t_handler (vl_api_sock_init_shm_t * mp) } if (regp->registration_type != REGISTRATION_TYPE_SOCKET_SERVER) { - rv = -31; /* VNET_API_ERROR_INVALID_REGISTRATION */ - goto reply; + clib_warning ("Invalid registration"); + return; } /* * Set up a memfd segment of the requested size wherein the * shmem data structures will be initialized */ - memset (memfd, 0, sizeof (*memfd)); + clib_memset (memfd, 0, sizeof (*memfd)); memfd->ssvm_size = mp->requested_size; memfd->requested_va = 0ULL; - memfd->i_am_master = 1; + memfd->is_server = 1; memfd->name = format (0, "%s%c", regp->name, 0); - if ((rv = ssvm_master_init_memfd (memfd))) + if ((rv = ssvm_server_init_memfd (memfd))) goto reply; + /* delete the unused heap created in ssvm_server_init_memfd and mark it + * accessible again for ASAN */ + clib_mem_destroy_heap (memfd->sh->heap); + clib_mem_unpoison ((void *) memfd->sh->ssvm_va, memfd->ssvm_size); + /* Remember to close this fd when the socket connection goes away */ vec_add1 (regp->additional_fds_to_close, memfd->fd); /* * Create a plausible svm_region in the memfd backed segment */ - memset (a, 0, sizeof (*a)); + clib_memset (a, 0, sizeof (*a)); a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE; a->size = memfd->ssvm_size - MMAP_PAGESIZE; /* $$$$ might want a different config parameter */ @@ -616,30 +745,51 @@ reply: rmp->context = mp->context; rmp->retval = htonl (rv); - vl_api_send_msg (regp, (u8 *) rmp); + /* + * Note: The reply message needs to make it out the back door + * before we send the magic fd message. That's taken care of by + * the send function. + */ + vl_socket_api_send (regp, (u8 *) rmp); if (rv != 0) return; - /* - * We need the reply message to make it out the back door - * before we send the magic fd message so force a flush - */ + /* Send the magic "here's your sign (aka fd)" socket message */ cf = vl_api_registration_file (regp); - cf->write_function (cf); + if (!cf) + { + clib_warning ("cf removed"); + return; + } + + /* Wait for reply to be consumed before sending the fd */ + while (tries-- > 0) + { + int bytes; + rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes); + if (rv < 0) + { + clib_unix_warning ("ioctl returned"); + break; + } + if (bytes == 0) + break; + usleep (1e3); + } - /* Send the magic "here's your sign (aka fd)" socket message */ vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1); } -#define foreach_vlib_api_msg \ -_(SOCKCLNT_CREATE, sockclnt_create) \ -_(SOCKCLNT_DELETE, sockclnt_delete) \ -_(SOCK_INIT_SHM, sock_init_shm) +#define foreach_vlib_api_msg \ + _ (SOCKCLNT_CREATE, sockclnt_create, 0) \ + _ (SOCKCLNT_DELETE, sockclnt_delete, 0) \ + _ (SOCK_INIT_SHM, sock_init_shm, 0) clib_error_t * vl_sock_api_init (vlib_main_t * vm) { + api_main_t *am = vlibapi_get_main (); clib_file_main_t *fm = &file_main; clib_file_t template = { 0 }; vl_api_registration_t *rp; @@ -651,49 +801,40 @@ vl_sock_api_init (vlib_main_t * vm) if (sm->socket_name == 0) return 0; -#define _(N,n) \ - vl_msg_api_set_handlers(VL_API_##N, #n, \ - vl_api_##n##_t_handler, \ - vl_noop_handler, \ - vl_api_##n##_t_endian, \ - vl_api_##n##_t_print, \ - sizeof(vl_api_##n##_t), 1); +#define _(N, n, t) \ + vl_msg_api_config (&(vl_msg_api_msg_config_t){ \ + .id = VL_API_##N, \ + .name = #n, \ + .handler = vl_api_##n##_t_handler, \ + .endian = vl_api_##n##_t_endian, \ + .format_fn = vl_api_##n##_t_format, \ + .size = sizeof (vl_api_##n##_t), \ + .traced = t, \ + .tojson = vl_api_##n##_t_tojson, \ + .fromjson = vl_api_##n##_t_fromjson, \ + .calc_size = vl_api_##n##_t_calc_size, \ + }); \ + am->msg_data[VL_API_##N].replay_allowed = 0; foreach_vlib_api_msg; #undef _ vec_resize (sm->input_buffer, 4096); sock->config = (char *) sm->socket_name; - - /* mkdir of file socket, only under /run */ - if (strncmp (sock->config, "/run", 4) == 0) - { - u8 *tmp = format (0, "%s", sock->config); - int i = vec_len (tmp); - while (i && tmp[--i] != '/') - ; - - tmp[i] = 0; - - if (i) - vlib_unix_recursive_mkdir ((char *) tmp); - vec_free (tmp); - } - - sock->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_SEQPACKET | - CLIB_SOCKET_F_ALLOW_GROUP_WRITE; + sock->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_ALLOW_GROUP_WRITE; error = clib_socket_init (sock); if (error) return error; pool_get (sm->registration_pool, rp); - memset (rp, 0, sizeof (*rp)); + clib_memset (rp, 0, sizeof (*rp)); rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN; template.read_function = socksvr_accept_ready; template.write_function = socksvr_bogus_write; template.file_descriptor = sock->fd; + template.description = format (0, "socksvr %s", sock->config); template.private_data = rp - sm->registration_pool; rp->clib_file_index = clib_file_add (fm, &template); @@ -711,11 +852,11 @@ socket_exit (vlib_main_t * vm) { u32 index; /* *INDENT-OFF* */ - pool_foreach (rp, sm->registration_pool, ({ + pool_foreach (rp, sm->registration_pool) { vl_api_registration_del_file (rp); index = rp->vl_api_registration_pool_index; vl_socket_free_registration_index (index); - })); + } /* *INDENT-ON* */ } @@ -733,29 +874,31 @@ socksvr_config (vlib_main_t * vm, unformat_input_t * input) { if (unformat (input, "socket-name %s", &sm->socket_name)) ; + /* DEPRECATE: default keyword is ignored */ else if (unformat (input, "default")) - { - sm->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0); - } + ; else { return clib_error_return (0, "unknown input '%U'", format_unformat_error, input); } } + + if (!vec_len (sm->socket_name)) + sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (), + API_SOCKET_FILENAME); + vec_terminate_c_string (sm->socket_name); + return 0; } VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr"); -clib_error_t * -vlibsocket_init (vlib_main_t * vm) +void +vlibsocket_reference () { - return 0; } -VLIB_INIT_FUNCTION (vlibsocket_init); - /* * fd.io coding-style-patch-verification: ON *