/*
- * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Copyright (c) 2018-2019 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this
* You may obtain a copy of the License at:
if (vcm->app_state == STATE_APP_FAILED)
return VPPCOM_ECONNABORTED;
}
- VDBG (0, "VCL<%d>: timeout waiting for state %s (%d)", getpid (),
+ VDBG (0, "timeout waiting for state %s (%d)",
vppcom_app_state_str (app_state), app_state);
vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
e.data.u32 = mqc_index;
if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_ADD, mq_fd, &e) < 0)
{
- clib_warning ("failed to add mq eventfd to mq epoll fd");
+ VDBG (0, "failed to add mq eventfd to mq epoll fd");
return -1;
}
mqc = vcl_mq_evt_conn_get (wrk, mqc_index);
if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_DEL, mqc->mq_fd, 0) < 0)
{
- clib_warning ("failed to del mq eventfd to mq epoll fd");
+ VDBG (0, "failed to del mq eventfd to mq epoll fd");
return -1;
}
return 0;
clib_spinlock_lock (&vcm->workers_lock);
if (notify_vpp)
{
+ /* Notify vpp that the worker is going away */
if (wrk->wrk_index == vcl_get_worker_index ())
vcl_send_app_worker_add_del (0 /* is_add */ );
else
vcl_send_child_worker_del (wrk);
+
+ /* Disconnect the binary api */
+ if (vec_len (vcm->workers) == 1)
+ vppcom_disconnect_from_vpp ();
+ else
+ vl_client_send_disconnect (1 /* vpp should cleanup */ );
}
+
if (wrk->mqs_epfd > 0)
close (wrk->mqs_epfd);
hash_free (wrk->session_index_by_vpp_handles);
if (vcl_get_worker_index () != ~0)
return 0;
+ /* Use separate heap map entry for worker */
+ clib_mem_set_thread_index ();
+
if (pool_elts (vcm->workers) == vcm->cfg.max_workers)
{
VDBG (0, "max-workers %u limit reached", vcm->cfg.max_workers);
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");
+ VDBG (0, "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");
+ VDBG (0, "failed to add pthread cleanup function");
if (pthread_setspecific (vcl_worker_stop_key, &wrk->thread_id))
- clib_warning ("failed to setup key value");
+ VDBG (0, "failed to setup key value");
clib_spinlock_unlock (&vcm->workers_lock);
return -1;
}
-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);
-}
-
-u32
-vcl_segment_table_lookup (u64 segment_handle)
-{
- 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_segment_table_del (u64 segment_handle)
+svm_msg_q_t *
+vcl_worker_ctrl_mq (vcl_worker_t * wrk)
{
- clib_rwlock_writer_lock (&vcm->segment_table_lock);
- hash_unset (vcm->segment_table, segment_handle);
- clib_rwlock_writer_unlock (&vcm->segment_table_lock);
+ return wrk->ctrl_mq;
}
void
vcl_cleanup_bapi (void)
{
socket_client_main_t *scm = &socket_client_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->my_client_index = ~0;
am->my_registration = 0;
return clib_fifo_elts (session->accept_evts_fifo);
if (vcl_session_is_ct (session))
- return svm_fifo_max_dequeue (session->ct_rx_fifo);
+ return svm_fifo_max_dequeue_cons (session->ct_rx_fifo);
- return svm_fifo_max_dequeue (session->rx_fifo);
+ return svm_fifo_max_dequeue_cons (session->rx_fifo);
}
int
if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
{
if (session->tx_fifo)
- return svm_fifo_max_enqueue (session->tx_fifo);
+ return svm_fifo_max_enqueue_prod (session->tx_fifo);
else
return VPPCOM_EBADFD;
}
}
if (vcl_session_is_ct (session))
- return svm_fifo_max_enqueue (session->ct_tx_fifo);
+ return svm_fifo_max_enqueue_prod (session->ct_tx_fifo);
- return svm_fifo_max_enqueue (session->tx_fifo);
+ return svm_fifo_max_enqueue_prod (session->tx_fifo);
}
+int
+vcl_segment_attach (u64 segment_handle, char *name, ssvm_segment_type_t type,
+ int fd)
+{
+ fifo_segment_create_args_t _a, *a = &_a;
+ int rv;
+
+ memset (a, 0, sizeof (*a));
+ a->segment_name = name;
+ a->segment_type = type;
+
+ if (type == SSVM_SEGMENT_MEMFD)
+ a->memfd_fd = fd;
+
+ clib_rwlock_writer_lock (&vcm->segment_table_lock);
+
+ if ((rv = fifo_segment_attach (&vcm->segment_main, a)))
+ {
+ clib_warning ("svm_fifo_segment_attach ('%s') failed", name);
+ return rv;
+ }
+ hash_set (vcm->segment_table, segment_handle, a->new_segment_indices[0]);
+
+ clib_rwlock_writer_unlock (&vcm->segment_table_lock);
+
+ vec_reset_length (a->new_segment_indices);
+ return 0;
+}
+
+u32
+vcl_segment_table_lookup (u64 segment_handle)
+{
+ 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_segment_detach (u64 segment_handle)
+{
+ fifo_segment_main_t *sm = &vcm->segment_main;
+ fifo_segment_t *segment;
+ u32 segment_index;
+
+ segment_index = vcl_segment_table_lookup (segment_handle);
+ if (segment_index == (u32) ~ 0)
+ return;
+
+ clib_rwlock_writer_lock (&vcm->segment_table_lock);
+
+ segment = fifo_segment_get_segment (sm, segment_index);
+ fifo_segment_delete (sm, segment);
+ hash_unset (vcm->segment_table, segment_handle);
+
+ clib_rwlock_writer_unlock (&vcm->segment_table_lock);
+
+ VDBG (0, "detached segment %u handle %u", segment_index, segment_handle);
+}
+
+
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff