X-Git-Url: https://gerrit.fd.io/r/gitweb?p=vpp.git;a=blobdiff_plain;f=src%2Fvlibmemory%2Fsocket_api.c;h=ce834a70aac260e7bc34f61c77b53bc89b57cce4;hp=a07d717e1d1c81680c3f4c8b79b3fc5156aed07a;hb=36217e3ca;hpb=6a6af6ea1a77b5818e717047b5d01251ef6d024a diff --git a/src/vlibmemory/socket_api.c b/src/vlibmemory/socket_api.c index a07d717e1d1..ce834a70aac 100644 --- a/src/vlibmemory/socket_api.c +++ b/src/vlibmemory/socket_api.c @@ -85,13 +85,13 @@ 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* */ } @@ -118,7 +118,7 @@ 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; @@ -170,6 +170,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); @@ -177,6 +179,8 @@ vl_socket_free_registration_index (u32 pool_index) } rp = pool_elt_at_index (socket_main.registration_pool, pool_index); + vl_api_call_reaper_functions (pool_index); + 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) @@ -190,19 +194,52 @@ 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; 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); + 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. * @@ -222,7 +259,6 @@ vl_socket_process_api_msg (clib_file_t * uf, vl_api_registration_t * rp, 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 */ @@ -235,8 +271,13 @@ vl_socket_read_ready (clib_file_t * uf) u32 msgbuf_len; u32 save_input_buffer_length = vec_len (socket_main.input_buffer); vl_socket_args_for_process_t *a; + 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, @@ -247,25 +288,14 @@ vl_socket_read_ready (clib_file_t * uf) if (errno != EAGAIN) { /* Severe error, close the file. */ - 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 - { - clib_warning ("client index %d already free?", - rp->vl_api_registration_pool_index); - } + vl_socket_request_remove_reg_index (reg_index); } /* EAGAIN means we do not close the file, but no data to process anyway. */ return 0; } /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */ - _vec_len (socket_main.input_buffer) = n; + vec_set_len (socket_main.input_buffer, n); /* * Look for bugs here. This code is tricky because @@ -310,10 +340,10 @@ vl_socket_read_ready (clib_file_t * uf) vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1); clib_memcpy_fast (rp->unprocessed_input, msg_buffer, vec_len (msg_buffer)); - _vec_len (rp->unprocessed_input) = vec_len (msg_buffer); + vec_set_len (rp->unprocessed_input, vec_len (msg_buffer)); } /* No more full messages, restore original input_buffer length. */ - _vec_len (socket_main.input_buffer) = save_input_buffer_length; + vec_set_len (socket_main.input_buffer, save_input_buffer_length); return 0; } @@ -323,11 +353,10 @@ vl_socket_read_ready (clib_file_t * uf) * so we can overwrite its length to what single message has. */ data_for_process = (u8 *) vec_dup (msg_buffer); - _vec_len (data_for_process) = msgbuf_len; + 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, @@ -338,12 +367,12 @@ vl_socket_read_ready (clib_file_t * uf) vec_delete (msg_buffer, msgbuf_len, 0); else /* We are done with msg_buffer. */ - _vec_len (msg_buffer) = 0; + vec_set_len (msg_buffer, 0); } while (vec_len (msg_buffer) > 0); /* Restore input_buffer, it could have been msg_buffer. */ - _vec_len (socket_main.input_buffer) = save_input_buffer_length; + vec_set_len (socket_main.input_buffer, save_input_buffer_length); return 0; } @@ -354,7 +383,13 @@ 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. */ size_t total_bytes = vec_len (rp->output_vector); @@ -373,9 +408,7 @@ vl_socket_write_ready (clib_file_t * uf) #if DEBUG > 2 clib_warning ("write error, close the file...\n"); #endif - clib_file_del (fm, uf); - vl_socket_free_registration_index (rp - - socket_main.registration_pool); + vl_socket_request_remove_reg_index (reg_index); return 0; } remaining_bytes -= bytes_to_send; @@ -396,13 +429,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; } @@ -419,6 +447,7 @@ socksvr_file_add (clib_file_main_t * fm, int fd) 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; @@ -458,7 +487,7 @@ 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 = &api_main; + 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); @@ -466,7 +495,13 @@ vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) 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); @@ -482,8 +517,10 @@ vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) hash_foreach_pair (hp, am->msg_index_by_name_and_crc, ({ rp->message_table[i].index = htons(hp->value[0]); - 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. */); + (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* */ @@ -548,7 +585,8 @@ vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds) cmsg->cmsg_type = SCM_RIGHTS; 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; @@ -619,7 +657,7 @@ 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; @@ -634,8 +672,8 @@ 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; } /* @@ -645,12 +683,17 @@ vl_api_sock_init_shm_t_handler (vl_api_sock_init_shm_t * mp) 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); @@ -704,6 +747,11 @@ reply: /* Send the magic "here's your sign (aka fd)" socket message */ cf = vl_api_registration_file (regp); + if (!cf) + { + clib_warning ("cf removed"); + return; + } /* Wait for reply to be consumed before sending the fd */ while (tries-- > 0) @@ -723,14 +771,15 @@ reply: vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1); } -#define foreach_vlib_api_msg \ - _(SOCKCLNT_CREATE, sockclnt_create, 1) \ - _(SOCKCLNT_DELETE, sockclnt_delete, 1) \ - _(SOCK_INIT_SHM, sock_init_shm, 1) +#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; @@ -742,13 +791,13 @@ vl_sock_api_init (vlib_main_t * vm) if (sm->socket_name == 0) return 0; -#define _(N,n,t) \ - 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), t); +#define _(N, n, t) \ + 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), t, \ + vl_api_##n##_t_print_json, vl_api_##n##_t_tojson, \ + vl_api_##n##_t_fromjson); \ + am->api_trace_cfg[VL_API_##N].replay_enable = 0; foreach_vlib_api_msg; #undef _ @@ -768,6 +817,7 @@ vl_sock_api_init (vlib_main_t * vm) 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); @@ -785,11 +835,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* */ }