diff options
Diffstat (limited to 'src/vcl/vcl_private.c')
| -rw-r--r-- | src/vcl/vcl_private.c | 164 |
1 files changed, 151 insertions, 13 deletions
diff --git a/src/vcl/vcl_private.c b/src/vcl/vcl_private.c index d159a49a89c..86dccfe1cc9 100644 --- a/src/vcl/vcl_private.c +++ b/src/vcl/vcl_private.c @@ -220,12 +220,12 @@ vcl_worker_free (vcl_worker_t * wrk) pool_put (vcm->workers, wrk); } -static void -vcl_worker_cleanup (void *arg) +void +vcl_worker_cleanup (void) { vcl_worker_t *wrk = vcl_worker_get_current (); - VDBG (0, "cleaning up worker %u", wrk->wrk_index); + clib_spinlock_lock (&vcm->workers_lock); vcl_send_app_worker_add_del (0 /* is_add */ ); close (wrk->mqs_epfd); hash_free (wrk->session_index_by_vpp_handles); @@ -235,6 +235,14 @@ vcl_worker_cleanup (void *arg) vec_free (wrk->mq_msg_vector); vcl_set_worker_index (~0); vcl_worker_free (wrk); + clib_spinlock_unlock (&vcm->workers_lock); + VDBG (0, "cleaned up worker %u", wrk->wrk_index); +} + +static void +vcl_worker_cleanup_cb (void *arg) +{ + vcl_worker_cleanup (); } vcl_worker_t * @@ -255,6 +263,8 @@ vcl_worker_alloc_and_init () clib_spinlock_lock (&vcm->workers_lock); wrk = vcl_worker_alloc (); vcl_set_worker_index (wrk->wrk_index); + wrk->thread_id = pthread_self (); + wrk->current_pid = getpid (); wrk->mqs_epfd = -1; if (vcm->cfg.use_mq_eventfd) @@ -263,7 +273,7 @@ vcl_worker_alloc_and_init () if (wrk->mqs_epfd < 0) { clib_unix_warning ("epoll_create() returned"); - return 0; + goto done; } } @@ -276,32 +286,160 @@ vcl_worker_alloc_and_init () vec_reset_length (wrk->mq_msg_vector); vec_validate (wrk->unhandled_evts_vector, 128); vec_reset_length (wrk->unhandled_evts_vector); + clib_spinlock_unlock (&vcm->workers_lock); - if (wrk->wrk_index == 0) - { - clib_spinlock_unlock (&vcm->workers_lock); - return wrk; - } +done: + return wrk; +} + +int +vcl_worker_register_with_vpp (void) +{ + vcl_worker_t *wrk = vcl_worker_get_current (); + + clib_spinlock_lock (&vcm->workers_lock); vcm->app_state = STATE_APP_ADDING_WORKER; vcl_send_app_worker_add_del (1 /* is_add */ ); if (vcl_wait_for_app_state_change (STATE_APP_READY)) { clib_warning ("failed to add worker to vpp"); - return 0; + return -1; } - if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup)) + if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup_cb)) clib_warning ("failed to add pthread cleanup function"); if (pthread_setspecific (vcl_worker_stop_key, &wrk->thread_id)) clib_warning ("failed to setup key value"); - wrk->thread_id = pthread_self (); clib_spinlock_unlock (&vcm->workers_lock); VDBG (0, "added worker %u", wrk->wrk_index); + return 0; +} - return wrk; +int +vcl_worker_set_bapi (void) +{ + vcl_worker_t *wrk = vcl_worker_get_current (); + int i; + + /* Find the first worker with the same pid */ + for (i = 0; i < vec_len (vcm->workers); i++) + { + if (i == wrk->wrk_index) + continue; + if (vcm->workers[i].current_pid == wrk->current_pid) + { + wrk->vl_input_queue = vcm->workers[i].vl_input_queue; + wrk->my_client_index = vcm->workers[i].my_client_index; + return 0; + } + } + return -1; +} + +vcl_shared_session_t * +vcl_shared_session_alloc (void) +{ + vcl_shared_session_t *ss; + pool_get (vcm->shared_sessions, ss); + memset (ss, 0, sizeof (*ss)); + ss->ss_index = ss - vcm->shared_sessions; + return ss; +} + +vcl_shared_session_t * +vcl_shared_session_get (u32 ss_index) +{ + if (pool_is_free_index (vcm->shared_sessions, ss_index)) + return 0; + return pool_elt_at_index (vcm->shared_sessions, ss_index); +} + +void +vcl_shared_session_free (vcl_shared_session_t * ss) +{ + pool_put (vcm->shared_sessions, ss); +} + +void +vcl_worker_share_session (vcl_worker_t * parent, vcl_worker_t * wrk, + vcl_session_t * new_s) +{ + vcl_shared_session_t *ss; + vcl_session_t *s; + + s = vcl_session_get (parent, new_s->session_index); + if (s->shared_index == ~0) + { + ss = vcl_shared_session_alloc (); + vec_add1 (ss->workers, parent->wrk_index); + s->shared_index = ss->ss_index; + } + else + { + ss = vcl_shared_session_get (s->shared_index); + } + new_s->shared_index = ss->ss_index; + vec_add1 (ss->workers, wrk->wrk_index); +} + +int +vcl_worker_unshare_session (vcl_worker_t * wrk, vcl_session_t * s) +{ + vcl_shared_session_t *ss; + int i; + + ss = vcl_shared_session_get (s->shared_index); + for (i = 0; i < vec_len (ss->workers); i++) + { + if (ss->workers[i] == wrk->wrk_index) + { + vec_del1 (ss->workers, i); + break; + } + } + + if (vec_len (ss->workers) == 0) + { + vcl_shared_session_free (ss); + return 1; + } + + return 0; +} + +void +vcl_worker_share_sessions (u32 parent_wrk_index) +{ + vcl_worker_t *parent_wrk, *wrk; + vcl_session_t *new_s; + + parent_wrk = vcl_worker_get (parent_wrk_index); + if (!parent_wrk->sessions) + return; + + wrk = vcl_worker_get_current (); + wrk->sessions = pool_dup (parent_wrk->sessions); + wrk->session_index_by_vpp_handles = + hash_dup (parent_wrk->session_index_by_vpp_handles); + + /* *INDENT-OFF* */ + pool_foreach (new_s, wrk->sessions, ({ + vcl_worker_share_session (parent_wrk, wrk, new_s); + })); + /* *INDENT-ON* */ +} + +int +vcl_session_get_refcnt (vcl_session_t * s) +{ + vcl_shared_session_t *ss; + ss = vcl_shared_session_get (s->shared_index); + if (ss) + return vec_len (ss->workers); + return 0; } /* |