X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fvppcom.c;h=dbb0d657b8dd9861e86d7bec908362aea6044d96;hb=refs%2Fchanges%2F40%2F16340%2F2;hp=34b663b98318757a5c8b716043f5a3409c229c9a;hpb=d85de68ec3f72888099172fffd45a90a43018155;p=vpp.git diff --git a/src/vcl/vppcom.c b/src/vcl/vppcom.c index 34b663b9831..dbb0d657b8d 100644 --- a/src/vcl/vppcom.c +++ b/src/vcl/vppcom.c @@ -464,7 +464,7 @@ vcl_session_bound_handler (vcl_worker_t * wrk, session_bound_msg_t * mp) session->tx_fifo = tx_fifo; } - VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!", + VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!", getpid (), mp->handle, sid); return sid; } @@ -559,7 +559,10 @@ vppcom_wait_for_session_state_change (u32 session_index, } if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0)) - continue; + { + usleep (100); + continue; + } e = svm_msg_q_msg_data (wrk->app_event_queue, &msg); vcl_handle_mq_event (wrk, e); svm_msg_q_free_msg (wrk->app_event_queue, &msg); @@ -694,18 +697,100 @@ vcl_cleanup_bapi (void) vl_client_api_unmap (); } -void +static void +vcl_cleanup_forked_child (vcl_worker_t * wrk, vcl_worker_t * child_wrk) +{ + vcl_worker_t *sub_child; + int tries = 0; + + if (child_wrk->forked_child != ~0) + { + sub_child = vcl_worker_get_if_valid (child_wrk->forked_child); + if (sub_child) + { + /* Wait a bit, maybe the process is going away */ + while (kill (sub_child->current_pid, 0) >= 0 && tries++ < 50) + usleep (1e3); + if (kill (sub_child->current_pid, 0) < 0) + vcl_cleanup_forked_child (child_wrk, sub_child); + } + } + vcl_worker_cleanup (child_wrk, 1 /* notify vpp */ ); + VDBG (0, "Cleaned up wrk %u", child_wrk->wrk_index); + wrk->forked_child = ~0; +} + +static struct sigaction old_sa; + +static void +vcl_intercept_sigchld_handler (int signum, siginfo_t * si, void *uc) +{ + vcl_worker_t *wrk, *child_wrk; + + if (vcl_get_worker_index () == ~0) + return; + + sigaction (SIGCHLD, &old_sa, 0); + + wrk = vcl_worker_get_current (); + if (wrk->forked_child == ~0) + return; + + child_wrk = vcl_worker_get_if_valid (wrk->forked_child); + if (si->si_pid != child_wrk->current_pid) + { + VDBG (0, "unexpected child pid %u", si->si_pid); + return; + } + if (child_wrk) + vcl_cleanup_forked_child (wrk, child_wrk); + + if (old_sa.sa_flags & SA_SIGINFO) + { + void (*fn) (int, siginfo_t *, void *) = old_sa.sa_sigaction; + fn (signum, si, uc); + } + else + { + void (*fn) (int) = old_sa.sa_handler; + if (fn) + fn (signum); + } +} + +static void +vcl_incercept_sigchld () +{ + struct sigaction sa; + clib_memset (&sa, 0, sizeof (sa)); + sa.sa_sigaction = vcl_intercept_sigchld_handler; + sa.sa_flags = SA_SIGINFO; + if (sigaction (SIGCHLD, &sa, &old_sa)) + { + VERR ("couldn't intercept sigchld"); + exit (-1); + } +} + +static void +vcl_app_pre_fork (void) +{ + vcl_incercept_sigchld (); +} + +static void vcl_app_fork_child_handler (void) { + int rv, parent_wrk_index; + vcl_worker_t *parent_wrk; u8 *child_name; - int rv, parent_wrk; - VDBG (0, "initializing forked child"); + parent_wrk_index = vcl_get_worker_index (); + VDBG (0, "initializing forked child with parent wrk %u", parent_wrk_index); /* * Allocate worker */ - parent_wrk = vcl_get_worker_index (); vcl_set_worker_index (~0); if (!vcl_worker_alloc_and_init ()) VERR ("couldn't allocate new worker"); @@ -729,21 +814,43 @@ vcl_app_fork_child_handler (void) * Register worker with vpp and share sessions */ vcl_worker_register_with_vpp (); + parent_wrk = vcl_worker_get (parent_wrk_index); vcl_worker_share_sessions (parent_wrk); + parent_wrk->forked_child = vcl_get_worker_index (); VDBG (0, "forked child main worker initialized"); vcm->forking = 0; } -void +static void vcl_app_fork_parent_handler (void) { vcm->forking = 1; - while (vcm->forking) ; } +/** + * Handle app exit + * + * Notify vpp of the disconnect and mark the worker as free. If we're the + * last worker, do a full cleanup otherwise, since we're probably a forked + * child, avoid syscalls as much as possible. We might've lost privileges. + */ +void +vppcom_app_exit (void) +{ + if (!pool_elts (vcm->workers)) + return; + vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ ); + vcl_set_worker_index (~0); + vcl_elog_stop (vcm); + if (vec_len (vcm->workers) == 1) + vl_client_disconnect_from_vlib (); + else + vl_client_send_disconnect (); +} + /* * VPPCOM Public API functions */ @@ -755,8 +862,8 @@ vppcom_app_create (char *app_name) if (vcm->is_init) { - clib_warning ("already initialized"); - return -1; + VDBG (1, "already initialized"); + return VPPCOM_EEXIST; } vcm->is_init = 1; @@ -767,13 +874,14 @@ vppcom_app_create (char *app_name) vcm->main_pid = getpid (); vcm->app_name = format (0, "%s", app_name); vppcom_init_error_string_table (); - svm_fifo_segment_main_init (vcl_cfg->segment_baseva, + svm_fifo_segment_main_init (&vcm->segment_main, vcl_cfg->segment_baseva, 20 /* timeout in secs */ ); pool_alloc (vcm->workers, vcl_cfg->max_workers); clib_spinlock_init (&vcm->workers_lock); clib_rwlock_init (&vcm->segment_table_lock); - pthread_atfork (NULL, vcl_app_fork_parent_handler, + pthread_atfork (vcl_app_pre_fork, vcl_app_fork_parent_handler, vcl_app_fork_child_handler); + atexit (vppcom_app_exit); /* Allocate default worker */ vcl_worker_alloc_and_init (); @@ -816,9 +924,12 @@ vppcom_app_destroy (void) int rv; f64 orig_app_timeout; + if (!pool_elts (vcm->workers)) + return; + vcl_evt (VCL_EVT_DETACH, vcm); - if (vec_len (vcm->workers) == 1) + if (pool_elts (vcm->workers) == 1) { vppcom_app_send_detach (); orig_app_timeout = vcm->cfg.app_timeout; @@ -828,15 +939,17 @@ vppcom_app_destroy (void) if (PREDICT_FALSE (rv)) VDBG (0, "application detach timed out! returning %d (%s)", rv, vppcom_retval_str (rv)); + vec_free (vcm->app_name); + vcl_worker_cleanup (vcl_worker_get_current (), 0 /* notify vpp */ ); } else { - vcl_worker_cleanup (); + vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ ); } + vcl_set_worker_index (~0); vcl_elog_stop (vcm); vl_client_disconnect_from_vlib (); - vec_free (vcm->app_name); } int @@ -1155,9 +1268,9 @@ handle: VCL_SESS_ATTR_SET (client_session->attr, VCL_SESS_ATTR_NONBLOCK); listen_vpp_handle = listen_session->vpp_handle; - VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! " + VDBG (0, "vpp handle 0x%llx, sid %u: Got a client request! " "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u", - getpid (), listen_vpp_handle, listen_session_handle, + listen_vpp_handle, listen_session_handle, client_session->vpp_handle, client_session_index, flags, VCL_SESS_ATTR_TEST (client_session->attr, VCL_SESS_ATTR_NONBLOCK)); @@ -1183,9 +1296,9 @@ handle: vcl_send_session_accepted_reply (vpp_evt_q, client_session->client_context, client_session->vpp_handle, 0); - VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle 0x%llx, " + VDBG (0, "vpp handle 0x%llx, sid %u: accepted vpp handle 0x%llx, " "sid %u connection from peer %s address %U port %u to local %s " - "address %U port %u", getpid (), listen_vpp_handle, + "address %U port %u", listen_vpp_handle, listen_session_handle, client_session->vpp_handle, client_session_index, client_session->transport.is_ip4 ? "IPv4" : "IPv6",