X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fvcl_private.c;h=589380d27aa1cb34da761867801354ba675b723b;hb=b52bd3a23a376dfcdc7f1bff5956f1f663c35a42;hp=3cbf02532cdf8201663cc081a12ad4774159b96e;hpb=94fef3e67662c6a92e32164d8db6fcf4bc83e79e;p=vpp.git diff --git a/src/vcl/vcl_private.c b/src/vcl/vcl_private.c index 3cbf02532cd..589380d27aa 100644 --- a/src/vcl/vcl_private.c +++ b/src/vcl/vcl_private.c @@ -38,6 +38,25 @@ vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx) return pool_elt_at_index (wrk->mq_evt_conns, mq_conn_idx); } +/* Add unix socket to epoll. + * Used only to get a notification on socket close + * We can't use eventfd because we don't get notifications on that fds + */ +static int +vcl_mq_epoll_add_api_sock (vcl_worker_t *wrk) +{ + clib_socket_t *cs = &wrk->app_api_sock; + struct epoll_event e = { 0 }; + int rv; + + e.data.u32 = ~0; + rv = epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_ADD, cs->fd, &e); + if (rv != EEXIST && rv < 0) + return -1; + + return 0; +} + int vcl_mq_epoll_add_evfd (vcl_worker_t * wrk, svm_msg_q_t * mq) { @@ -64,6 +83,12 @@ vcl_mq_epoll_add_evfd (vcl_worker_t * wrk, svm_msg_q_t * mq) return -1; } + if (vcl_mq_epoll_add_api_sock (wrk)) + { + VDBG (0, "failed to add mq socket to mq epoll fd"); + return -1; + } + return mqc_index; } @@ -113,6 +138,9 @@ vcl_api_app_worker_add (void) void vcl_api_app_worker_del (vcl_worker_t * wrk) { + if (wrk->api_client_handle == ~0) + return; + if (vcm->cfg.vpp_app_socket_api) return vcl_sapi_app_worker_del (wrk); @@ -158,6 +186,48 @@ vcl_worker_cleanup_cb (void *arg) VDBG (0, "cleaned up worker %u", wrk_index); } +void +vcl_worker_detach_sessions (vcl_worker_t *wrk) +{ + session_event_t *e; + vcl_session_t *s; + uword *seg_indices_map = 0; + u32 seg_index, val, *seg_indices = 0; + + close (wrk->app_api_sock.fd); + pool_foreach (s, wrk->sessions) + { + if (s->session_state == VCL_STATE_LISTEN) + { + s->session_state = VCL_STATE_LISTEN_NO_MQ; + continue; + } + if ((s->flags & VCL_SESSION_F_IS_VEP) || + s->session_state == VCL_STATE_LISTEN_NO_MQ || + s->session_state == VCL_STATE_CLOSED) + continue; + + hash_set (seg_indices_map, s->tx_fifo->segment_index, 1); + + s->session_state = VCL_STATE_DETACHED; + vec_add2 (wrk->unhandled_evts_vector, e, 1); + e->event_type = SESSION_CTRL_EVT_DISCONNECTED; + e->session_index = s->session_index; + e->postponed = 1; + } + + hash_foreach (seg_index, val, seg_indices_map, + ({ vec_add1 (seg_indices, seg_index); })); + + vcl_segment_detach_segments (seg_indices); + + /* Detach worker's mqs segment */ + vcl_segment_detach (vcl_vpp_worker_segment_handle (wrk->wrk_index)); + + vec_free (seg_indices); + hash_free (seg_indices_map); +} + vcl_worker_t * vcl_worker_alloc_and_init () { @@ -182,6 +252,7 @@ vcl_worker_alloc_and_init () wrk = vcl_worker_alloc (); vcl_set_worker_index (wrk->wrk_index); + wrk->api_client_handle = ~0; wrk->thread_id = pthread_self (); wrk->current_pid = getpid (); @@ -410,6 +481,36 @@ vcl_segment_detach (u64 segment_handle) VDBG (0, "detached segment %u handle %u", segment_index, segment_handle); } +void +vcl_segment_detach_segments (u32 *seg_indices) +{ + u64 *seg_handles = 0, *seg_handle, key; + u32 *seg_index; + u32 val; + + clib_rwlock_reader_lock (&vcm->segment_table_lock); + + vec_foreach (seg_index, seg_indices) + { + /* clang-format off */ + hash_foreach (key, val, vcm->segment_table, ({ + if (val == *seg_index) + { + vec_add1 (seg_handles, key); + break; + } + })); + /* clang-format on */ + } + + clib_rwlock_reader_unlock (&vcm->segment_table_lock); + + vec_foreach (seg_handle, seg_handles) + vcl_segment_detach (seg_handle[0]); + + vec_free (seg_handles); +} + int vcl_segment_attach_session (uword segment_handle, uword rxf_offset, uword txf_offset, uword mq_offset, u32 mq_index, @@ -594,6 +695,126 @@ vcl_session_share_fifos (vcl_session_t *s, svm_fifo_t *rxf, svm_fifo_t *txf) return 0; } +const char * +vcl_session_state_str (vcl_session_state_t state) +{ + char *st; + + switch (state) + { + case VCL_STATE_CLOSED: + st = "STATE_CLOSED"; + break; + case VCL_STATE_LISTEN: + st = "STATE_LISTEN"; + break; + case VCL_STATE_READY: + st = "STATE_READY"; + break; + case VCL_STATE_VPP_CLOSING: + st = "STATE_VPP_CLOSING"; + break; + case VCL_STATE_DISCONNECT: + st = "STATE_DISCONNECT"; + break; + case VCL_STATE_DETACHED: + st = "STATE_DETACHED"; + break; + case VCL_STATE_UPDATED: + st = "STATE_UPDATED"; + break; + case VCL_STATE_LISTEN_NO_MQ: + st = "STATE_LISTEN_NO_MQ"; + break; + default: + st = "UNKNOWN_STATE"; + break; + } + + return st; +} + +u8 * +vcl_format_ip4_address (u8 *s, va_list *args) +{ + u8 *a = va_arg (*args, u8 *); + return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]); +} + +u8 * +vcl_format_ip6_address (u8 *s, va_list *args) +{ + ip6_address_t *a = va_arg (*args, ip6_address_t *); + u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon; + + i_max_n_zero = ARRAY_LEN (a->as_u16); + max_n_zeros = 0; + i_first_zero = i_max_n_zero; + n_zeros = 0; + for (i = 0; i < ARRAY_LEN (a->as_u16); i++) + { + u32 is_zero = a->as_u16[i] == 0; + if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16)) + { + i_first_zero = i; + n_zeros = 0; + } + n_zeros += is_zero; + if ((!is_zero && n_zeros > max_n_zeros) || + (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros)) + { + i_max_n_zero = i_first_zero; + max_n_zeros = n_zeros; + i_first_zero = ARRAY_LEN (a->as_u16); + n_zeros = 0; + } + } + + last_double_colon = 0; + for (i = 0; i < ARRAY_LEN (a->as_u16); i++) + { + if (i == i_max_n_zero && max_n_zeros > 1) + { + s = format (s, "::"); + i += max_n_zeros - 1; + last_double_colon = 1; + } + else + { + s = format (s, "%s%x", (last_double_colon || i == 0) ? "" : ":", + clib_net_to_host_u16 (a->as_u16[i])); + last_double_colon = 0; + } + } + + return s; +} + +/* Format an IP46 address. */ +u8 * +vcl_format_ip46_address (u8 *s, va_list *args) +{ + ip46_address_t *ip46 = va_arg (*args, ip46_address_t *); + ip46_type_t type = va_arg (*args, ip46_type_t); + int is_ip4 = 1; + + switch (type) + { + case IP46_TYPE_ANY: + is_ip4 = ip46_address_is_ip4 (ip46); + break; + case IP46_TYPE_IP4: + is_ip4 = 1; + break; + case IP46_TYPE_IP6: + is_ip4 = 0; + break; + } + + return is_ip4 ? format (s, "%U", vcl_format_ip4_address, &ip46->ip4) : + format (s, "%U", vcl_format_ip6_address, &ip46->ip6); +} + /* * fd.io coding-style-patch-verification: ON *