+ /* Since child may have exited and thereforce fd of vpp_app_socket_api
+ * may have been closed, so DONOT notify VPP.
+ */
+ vcl_worker_cleanup (wrk, vcm->cfg.vpp_app_socket_api ? 0 : 1);
+
+ vls_worker_free (vls_wrk);
+}
+
+static void
+vls_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)
+ vls_cleanup_forked_child (child_wrk, sub_child);
+ }
+ }
+ vls_cleanup_vcl_worker (child_wrk);
+ VDBG (0, "Cleaned up forked child wrk %u", child_wrk->wrk_index);
+ wrk->forked_child = ~0;
+}
+
+static void
+vls_handle_pending_wrk_cleanup (void)
+{
+ u32 *wip;
+ vcl_worker_t *child_wrk, *wrk;
+ vls_worker_t *vls_wrk = vls_worker_get_current ();
+
+ if (PREDICT_TRUE (vec_len (vls_wrk->pending_vcl_wrk_cleanup) == 0))
+ return;
+
+ wrk = vcl_worker_get_current ();
+ vec_foreach (wip, vls_wrk->pending_vcl_wrk_cleanup)
+ {
+ child_wrk = vcl_worker_get_if_valid (*wip);
+ if (!child_wrk)
+ continue;
+ vls_cleanup_forked_child (wrk, child_wrk);
+ }
+ vec_reset_length (vls_wrk->pending_vcl_wrk_cleanup);
+}
+
+static struct sigaction old_sa;
+
+static void
+vls_intercept_sigchld_handler (int signum, siginfo_t * si, void *uc)
+{
+ vcl_worker_t *wrk, *child_wrk;
+ vls_worker_t *vls_wrk;
+
+ if (vcl_get_worker_index () == ~0)
+ return;
+
+ if (sigaction (SIGCHLD, &old_sa, 0))
+ {
+ VERR ("couldn't restore sigchld");
+ exit (-1);
+ }
+
+ wrk = vcl_worker_get_current ();
+ if (wrk->forked_child == ~0)
+ return;
+
+ child_wrk = vcl_worker_get_if_valid (wrk->forked_child);
+ if (!child_wrk)
+ goto done;
+
+ if (si && si->si_pid != child_wrk->current_pid)
+ {
+ VDBG (0, "unexpected child pid %u", si->si_pid);
+ goto done;
+ }
+
+ /* Parent process may enter sighandler with a lock, such as lock in localtime
+ * or in mspace_free, and child wrk cleanup may try to get such locks and
+ * cause deadlock.
+ * So move child wrk cleanup from sighandler to vls_epoll_wait/vls_select.
+ */
+ vls_wrk = vls_worker_get_current ();
+ vec_add1 (vls_wrk->pending_vcl_wrk_cleanup, child_wrk->wrk_index);
+
+done:
+ 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
+vls_incercept_sigchld ()
+{
+ struct sigaction sa;
+ if (old_sa.sa_sigaction)
+ {
+ VDBG (0, "have intercepted sigchld");
+ return;
+ }
+ clib_memset (&sa, 0, sizeof (sa));
+ sa.sa_sigaction = vls_intercept_sigchld_handler;
+ sa.sa_flags = SA_SIGINFO;
+ if (sigaction (SIGCHLD, &sa, &old_sa))
+ {
+ VERR ("couldn't intercept sigchld");
+ exit (-1);
+ }
+}
+
+static void
+vls_app_pre_fork (void)
+{
+ vls_incercept_sigchld ();
+ vcl_flush_mq_events ();
+}
+
+static void
+vls_app_fork_child_handler (void)
+{
+ vcl_worker_t *parent_wrk;
+ int parent_wrk_index;
+
+ parent_wrk_index = vcl_get_worker_index ();
+ VDBG (0, "initializing forked child %u with parent wrk %u", getpid (),
+ parent_wrk_index);
+
+ /*
+ * Clear old state
+ */
+ vcl_set_worker_index (~0);
+
+ /*
+ * Allocate and register vcl worker with vpp
+ */
+ if (vppcom_worker_register ())
+ {
+ VERR ("couldn't register new worker!");
+ return;
+ }
+
+ /*
+ * Allocate/initialize vls worker and share sessions
+ */
+ vls_worker_alloc ();
+
+ /* Reset number of threads and set wrk index */
+ vlsl->vls_mt_n_threads = 0;
+ vlsl->vls_wrk_index = vcl_get_worker_index ();
+ vlsl->select_mp_check = 0;
+ clib_rwlock_init (&vlsl->vls_pool_lock);
+ vls_mt_locks_init ();
+
+ parent_wrk = vcl_worker_get (parent_wrk_index);
+ vls_worker_copy_on_fork (parent_wrk);
+ parent_wrk->forked_child = vcl_get_worker_index ();
+
+ VDBG (0, "forked child main worker initialized");
+ vcm->forking = 0;
+}
+
+static void
+vls_app_fork_parent_handler (void)
+{
+ vcm->forking = 1;
+ while (vcm->forking)
+ ;
+}
+
+void
+vls_app_exit (void)
+{
+ vls_worker_t *wrk = vls_worker_get_current ();
+
+ /* Handle pending wrk cleanup */
+ vls_handle_pending_wrk_cleanup ();
+
+ /* Unshare the sessions. VCL will clean up the worker */
+ vls_unshare_vcl_worker_sessions (vcl_worker_get_current ());
+ vls_worker_free (wrk);
+}
+
+static void
+vls_clone_and_share_rpc_handler (void *args)
+{
+ vls_clone_and_share_msg_t *msg = (vls_clone_and_share_msg_t *) args;
+ vls_worker_t *wrk = vls_worker_get_current (), *dst_wrk;
+ vcl_locked_session_t *vls, *dst_vls;
+ vcl_worker_t *vcl_wrk = vcl_worker_get_current (), *dst_vcl_wrk;
+ vcl_session_t *s, *dst_s;
+
+ VDBG (1, "process session clone of worker (session): %u (%u) -> %u (%u)",
+ vcl_wrk->wrk_index, msg->session_index, msg->origin_vcl_wrk,
+ msg->origin_session_index);
+
+ /* VCL locked session can't been protected, so DONT touch it.
+ * VCL session may been free, check it.
+ */
+ dst_vcl_wrk = vcl_worker_get (msg->origin_vcl_wrk);
+ s = vcl_session_get (vcl_wrk, msg->session_index);
+ if (PREDICT_FALSE (!s))
+ {
+ dst_vcl_wrk->rpc_done = VLS_RPC_STATE_SESSION_NOT_EXIST;
+ return;
+ }
+
+ if (!vls_mt_wrk_supported ())
+ {
+ vls = vls_session_get (wrk, msg->vls_index);
+ vls_init_share_session (wrk, vls);
+ dst_wrk = vls_worker_get (msg->origin_vls_wrk);
+ dst_vls = vls_session_get (dst_wrk, msg->origin_vls_index);
+ dst_vls->shared_data_index = vls->shared_data_index;
+ }
+ dst_s = vcl_session_get (dst_vcl_wrk, msg->origin_session_index);
+ clib_memcpy (dst_s, s, sizeof (*s));
+
+ dst_vcl_wrk->rpc_done = VLS_RPC_STATE_SUCCESS;
+}
+
+static void
+vls_session_cleanup_rpc_handler (void *args)
+{
+ vls_sess_cleanup_msg_t *msg = (vls_sess_cleanup_msg_t *) args;
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vls_worker_t *vls_wrk = vls_worker_get_current ();
+ vcl_session_handle_t sh = vcl_session_handle_from_index (msg->session_index);
+
+ VDBG (1, "process session cleanup of worker (session): %u (%u) from %u ()",
+ wrk->wrk_index, msg->session_index, msg->origin_vcl_wrk);
+
+ vppcom_session_close (sh);
+ vls_sh_to_vlsh_table_del (vls_wrk, sh);
+}
+
+static void
+vls_rpc_handler (void *args)
+{
+ vls_rpc_msg_t *msg = (vls_rpc_msg_t *) args;
+ switch (msg->type)
+ {
+ case VLS_RPC_CLONE_AND_SHARE:
+ vls_clone_and_share_rpc_handler (msg->data);
+ break;
+ case VLS_RPC_SESS_CLEANUP:
+ vls_session_cleanup_rpc_handler (msg->data);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+vls_send_clone_and_share_rpc (vcl_worker_t *wrk, u32 origin_vls_index,
+ u32 session_index, u32 vls_wrk_index,
+ u32 dst_wrk_index, u32 dst_vls_index,
+ u32 dst_session_index)
+{
+ u8 data[sizeof (u8) + sizeof (vls_clone_and_share_msg_t)];
+ vls_clone_and_share_msg_t *msg;
+ vls_rpc_msg_t *rpc;
+ int ret;
+ f64 timeout = clib_time_now (&wrk->clib_time) + VLS_WORKER_RPC_TIMEOUT;
+
+ rpc = (vls_rpc_msg_t *) & data;
+ rpc->type = VLS_RPC_CLONE_AND_SHARE;
+ msg = (vls_clone_and_share_msg_t *) & rpc->data;
+ msg->origin_vls_wrk = vls_wrk_index;
+ msg->origin_vls_index = origin_vls_index;
+ msg->origin_vcl_wrk = wrk->wrk_index;
+ msg->origin_session_index = session_index;
+ msg->vls_index = dst_vls_index;
+ msg->session_index = dst_session_index;
+
+ /* Try lock and handle rpcs if two threads send each other
+ * clone requests at the same time.
+ */
+ wrk->rpc_done = VLS_RPC_STATE_INIT;
+ while (!clib_spinlock_trylock (&vlsm->worker_rpc_lock))
+ vcl_flush_mq_events ();
+ ret = vcl_send_worker_rpc (dst_wrk_index, rpc, sizeof (data));
+
+ VDBG (1, "send session clone to wrk (session): %u (%u) -> %u (%u), ret=%d",
+ dst_wrk_index, msg->session_index, msg->origin_vcl_wrk,
+ msg->origin_session_index, ret);
+ while (!ret && wrk->rpc_done == VLS_RPC_STATE_INIT &&
+ clib_time_now (&wrk->clib_time) < timeout)
+ ;
+ clib_spinlock_unlock (&vlsm->worker_rpc_lock);
+}
+
+void
+vls_send_session_cleanup_rpc (vcl_worker_t * wrk,
+ u32 dst_wrk_index, u32 dst_session_index)
+{
+ u8 data[sizeof (u8) + sizeof (vls_sess_cleanup_msg_t)];
+ vls_sess_cleanup_msg_t *msg;
+ vls_rpc_msg_t *rpc;
+ int ret;
+
+ rpc = (vls_rpc_msg_t *) & data;
+ rpc->type = VLS_RPC_SESS_CLEANUP;
+ msg = (vls_sess_cleanup_msg_t *) & rpc->data;
+ msg->origin_vcl_wrk = wrk->wrk_index;
+ msg->session_index = dst_session_index;
+
+ ret = vcl_send_worker_rpc (dst_wrk_index, rpc, sizeof (data));
+
+ VDBG (1, "send session cleanup to wrk (session): %u (%u) from %u, ret=%d",
+ dst_wrk_index, msg->session_index, msg->origin_vcl_wrk, ret);