pool_get (vcm->workers, wrk);
memset (wrk, 0, sizeof (*wrk));
wrk->wrk_index = wrk - vcm->workers;
+ wrk->forked_child = ~0;
return wrk;
}
}
void
-vcl_worker_cleanup (void)
+vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp)
{
- vcl_worker_t *wrk = vcl_worker_get_current ();
-
clib_spinlock_lock (&vcm->workers_lock);
- vcl_send_app_worker_add_del (0 /* is_add */ );
- close (wrk->mqs_epfd);
+ if (notify_vpp)
+ {
+ if (wrk->wrk_index == vcl_get_worker_index ())
+ vcl_send_app_worker_add_del (0 /* is_add */ );
+ else
+ vcl_send_child_worker_del (wrk);
+ }
+ if (wrk->mqs_epfd > 0)
+ close (wrk->mqs_epfd);
hash_free (wrk->session_index_by_vpp_handles);
hash_free (wrk->ct_registration_by_mq);
clib_spinlock_free (&wrk->ct_registration_lock);
vec_free (wrk->mq_events);
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 *wrk = vcl_worker_get_current ();
+ u32 wrk_index = wrk->wrk_index;
+ vcl_worker_cleanup (wrk, 1 /* notify vpp */ );
+ vcl_set_worker_index (~0);
+ VDBG (0, "cleaned up worker %u", wrk_index);
}
vcl_worker_t *
clib_warning ("failed to add worker to vpp");
return -1;
}
-
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))
return -1;
}
-vcl_shared_session_t *
-vcl_shared_session_alloc (void)
+void
+vcl_segment_table_add (u64 segment_handle, u32 svm_segment_index)
{
- 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;
+ clib_rwlock_writer_lock (&vcm->segment_table_lock);
+ hash_set (vcm->segment_table, segment_handle, svm_segment_index);
+ clib_rwlock_writer_unlock (&vcm->segment_table_lock);
}
-vcl_shared_session_t *
-vcl_shared_session_get (u32 ss_index)
+u32
+vcl_segment_table_lookup (u64 segment_handle)
{
- if (pool_is_free_index (vcm->shared_sessions, ss_index))
- return 0;
- return pool_elt_at_index (vcm->shared_sessions, ss_index);
+ uword *seg_indexp;
+
+ clib_rwlock_reader_lock (&vcm->segment_table_lock);
+ seg_indexp = hash_get (vcm->segment_table, segment_handle);
+ clib_rwlock_reader_unlock (&vcm->segment_table_lock);
+
+ if (!seg_indexp)
+ return VCL_INVALID_SEGMENT_INDEX;
+ return ((u32) * seg_indexp);
}
void
-vcl_shared_session_free (vcl_shared_session_t * ss)
+vcl_segment_table_del (u64 segment_handle)
{
- pool_put (vcm->shared_sessions, ss);
+ clib_rwlock_writer_lock (&vcm->segment_table_lock);
+ hash_unset (vcm->segment_table, segment_handle);
+ clib_rwlock_writer_unlock (&vcm->segment_table_lock);
}
void
-vcl_worker_share_session (vcl_worker_t * parent, vcl_worker_t * wrk,
- vcl_session_t * new_s)
+vcl_cleanup_bapi (void)
{
- vcl_shared_session_t *ss;
- vcl_session_t *s;
+ socket_client_main_t *scm = &socket_client_main;
+ api_main_t *am = &api_main;
- 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);
+ am->my_client_index = ~0;
+ am->my_registration = 0;
+ am->vl_input_queue = 0;
+ am->msg_index_by_name_and_crc = 0;
+ scm->socket_fd = 0;
+
+ vl_client_api_unmap ();
}
int
-vcl_worker_unshare_session (vcl_worker_t * wrk, vcl_session_t * s)
+vcl_session_read_ready (vcl_session_t * session)
{
- vcl_shared_session_t *ss;
- int i;
-
- ss = vcl_shared_session_get (s->shared_index);
- for (i = 0; i < vec_len (ss->workers); i++)
+ /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
+ if (PREDICT_FALSE (session->is_vep))
{
- if (ss->workers[i] == wrk->wrk_index)
- {
- vec_del1 (ss->workers, i);
- break;
- }
+ VDBG (0, "ERROR: session %u: cannot read from an epoll session!",
+ session->session_index);
+ return VPPCOM_EBADFD;
}
- if (vec_len (ss->workers) == 0)
+ if (PREDICT_FALSE (!(session->session_state & (STATE_OPEN | STATE_LISTEN))))
{
- vcl_shared_session_free (ss);
- return 1;
- }
+ session_state_t state = session->session_state;
+ int rv;
- return 0;
-}
+ rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
-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* */
-}
+ VDBG (1, "session %u [0x%llx]: not open! state 0x%x (%s), ret %d (%s)",
+ session->session_index, session->vpp_handle, state,
+ vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
+ return rv;
+ }
-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;
-}
+ if (session->session_state & STATE_LISTEN)
+ return clib_fifo_elts (session->accept_evts_fifo);
-void
-vcl_segment_table_add (u64 segment_handle, u32 svm_segment_index)
-{
- clib_rwlock_writer_lock (&vcm->segment_table_lock);
- hash_set (vcm->segment_table, segment_handle, svm_segment_index);
- clib_rwlock_writer_unlock (&vcm->segment_table_lock);
+ return svm_fifo_max_dequeue (session->rx_fifo);
}
-u32
-vcl_segment_table_lookup (u64 segment_handle)
+int
+vcl_session_write_ready (vcl_session_t * session)
{
- uword *seg_indexp;
+ /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
+ if (PREDICT_FALSE (session->is_vep))
+ {
+ VDBG (0, "session %u [0x%llx]: cannot write to an epoll session!",
+ session->session_index, session->vpp_handle);
+ return VPPCOM_EBADFD;
+ }
- clib_rwlock_reader_lock (&vcm->segment_table_lock);
- seg_indexp = hash_get (vcm->segment_table, segment_handle);
- clib_rwlock_reader_unlock (&vcm->segment_table_lock);
+ if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
+ {
+ if (session->tx_fifo)
+ return svm_fifo_max_enqueue (session->tx_fifo);
+ else
+ return VPPCOM_EBADFD;
+ }
- if (!seg_indexp)
- return VCL_INVALID_SEGMENT_INDEX;
- return ((u32) * seg_indexp);
-}
+ if (PREDICT_FALSE (!(session->session_state & STATE_OPEN)))
+ {
+ session_state_t state = session->session_state;
+ int rv;
+
+ rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
+ VDBG (0, "session %u [0x%llx]: not open! state 0x%x (%s), ret %d (%s)",
+ session->session_index, session->vpp_handle, state,
+ vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
+ return rv;
+ }
-void
-vcl_segment_table_del (u64 segment_handle)
-{
- clib_rwlock_writer_lock (&vcm->segment_table_lock);
- hash_unset (vcm->segment_table, segment_handle);
- clib_rwlock_writer_unlock (&vcm->segment_table_lock);
+ return svm_fifo_max_enqueue (session->tx_fifo);
}
/*
Code Review / vpp.git / blobdiff