u16 read_timeout = 0;
bool rx_is_running = false;
+/* Set to true to enable memory tracing */
+bool mem_trace = false;
+
+__attribute__((constructor))
+static void
+vac_client_constructor (void)
+{
+ u8 *heap;
+ mheap_t *h;
+ clib_mem_init (0, 1 << 30);
+ heap = clib_mem_get_per_cpu_heap ();
+ h = mheap_header (heap);
+ /* make the main heap thread-safe */
+ h->flags |= MHEAP_FLAG_THREAD_SAFE;
+ if (mem_trace)
+ clib_mem_trace (1);
+}
+
+__attribute__((destructor))
+static void
+vac_client_destructor (void)
+{
+ if (mem_trace)
+ fformat(stderr, "TRACE: %s",
+ format (0, "%U\n",
+ format_mheap, clib_mem_get_heap (), 1));
+}
+
+
static void
init (void)
{
cleanup (void)
{
vac_main_t *pm = &vac_main;
+ pthread_mutex_destroy(&pm->queue_lock);
pthread_cond_destroy(&pm->suspend_cv);
pthread_cond_destroy(&pm->resume_cv);
+ pthread_mutex_destroy(&pm->timeout_lock);
pthread_cond_destroy(&pm->timeout_cv);
pthread_cond_destroy(&pm->timeout_cancel_cv);
pthread_cond_destroy(&pm->terminate_cv);
- pthread_mutex_destroy(&pm->queue_lock);
- pthread_mutex_destroy(&pm->timeout_lock);
- memset (pm, 0, sizeof (*pm));
+ memset(pm, 0, sizeof(*pm));
}
/*
static void *
vac_rx_thread_fn (void *arg)
{
- unix_shared_memory_queue_t *q;
+ svm_queue_t *q;
+ vl_api_memclnt_keepalive_t *mp;
+ vl_api_memclnt_keepalive_reply_t *rmp;
vac_main_t *pm = &vac_main;
api_main_t *am = &api_main;
+ vl_shmem_hdr_t *shmem_hdr;
uword msg;
q = am->vl_input_queue;
while (1)
- while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
+ while (!svm_queue_sub(q, (u8 *)&msg, SVM_Q_WAIT, 0))
{
u16 id = ntohs(*((u16 *)msg));
switch (id) {
vl_msg_api_free((void *) msg);
break;
+ case VL_API_MEMCLNT_KEEPALIVE:
+ mp = (void *)msg;
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
+ rmp->context = mp->context;
+ shmem_hdr = am->shmem_hdr;
+ vl_msg_api_send_shmem(shmem_hdr->vl_input_queue, (u8 *)&rmp);
+ vl_msg_api_free((void *) msg);
+ break;
+
default:
vac_api_handler((void *)msg);
}
return (0);
}
+static void
+set_timeout (unsigned short timeout)
+{
+ vac_main_t *pm = &vac_main;
+ pthread_mutex_lock(&pm->timeout_lock);
+ read_timeout = timeout;
+ pthread_cond_signal(&pm->timeout_cv);
+ pthread_mutex_unlock(&pm->timeout_lock);
+}
+
+static void
+unset_timeout (void)
+{
+ vac_main_t *pm = &vac_main;
+ pthread_mutex_lock(&pm->timeout_lock);
+ pthread_cond_signal(&pm->timeout_cancel_cv);
+ pthread_mutex_unlock(&pm->timeout_lock);
+}
+
int
vac_disconnect (void)
{
api_main_t *am = &api_main;
vac_main_t *pm = &vac_main;
+ uword junk;
if (!pm->connected_to_vlib) return 0;
if (pm->rx_thread_handle) {
vl_api_rx_thread_exit_t *ep;
- uword junk;
ep = vl_msg_api_alloc (sizeof (*ep));
ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT);
vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep);
else
pthread_join(pm->rx_thread_handle, (void **) &junk);
}
- if (pm->timeout_thread_handle)
+ if (pm->timeout_thread_handle) {
+ /* cancel, wake then join the timeout thread */
pthread_cancel(pm->timeout_thread_handle);
+ set_timeout(0);
+ pthread_join(pm->timeout_thread_handle, (void **) &junk);
+ }
vl_client_disconnect();
vl_client_api_unmap();
return (0);
}
-static void
-set_timeout (unsigned short timeout)
-{
- vac_main_t *pm = &vac_main;
- pthread_mutex_lock(&pm->timeout_lock);
- read_timeout = timeout;
- pthread_cond_signal(&pm->timeout_cv);
- pthread_mutex_unlock(&pm->timeout_lock);
-}
-
-static void
-unset_timeout (void)
-{
- vac_main_t *pm = &vac_main;
- pthread_mutex_lock(&pm->timeout_lock);
- pthread_cond_signal(&pm->timeout_cancel_cv);
- pthread_mutex_unlock(&pm->timeout_lock);
-}
-
int
vac_read (char **p, int *l, u16 timeout)
{
- unix_shared_memory_queue_t *q;
+ svm_queue_t *q;
api_main_t *am = &api_main;
vac_main_t *pm = &vac_main;
+ vl_api_memclnt_keepalive_t *mp;
+ vl_api_memclnt_keepalive_reply_t *rmp;
uword msg;
msgbuf_t *msgbuf;
+ int rv;
+ vl_shmem_hdr_t *shmem_hdr;
if (!pm->connected_to_vlib) return -1;
set_timeout(timeout);
q = am->vl_input_queue;
- int rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0);
+
+ again:
+ rv = svm_queue_sub(q, (u8 *)&msg, SVM_Q_WAIT, 0);
+
if (rv == 0) {
u16 msg_id = ntohs(*((u16 *)msg));
switch (msg_id) {
case VL_API_RX_THREAD_EXIT:
printf("Received thread exit\n");
+ vl_msg_api_free((void *) msg);
return -1;
case VL_API_MEMCLNT_RX_THREAD_SUSPEND:
printf("Received thread suspend\n");
case VL_API_MEMCLNT_READ_TIMEOUT:
printf("Received read timeout %ds\n", timeout);
goto error;
+ case VL_API_MEMCLNT_KEEPALIVE:
+ /* Handle an alive-check ping from vpp. */
+ mp = (void *)msg;
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
+ rmp->context = mp->context;
+ shmem_hdr = am->shmem_hdr;
+ vl_msg_api_send_shmem(shmem_hdr->vl_input_queue, (u8 *)&rmp);
+ vl_msg_api_free((void *) msg);
+ /*
+ * Python code is blissfully unaware of these pings, so
+ * act as if it never happened...
+ */
+ goto again;
default:
msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
int rv = -1;
api_main_t *am = &api_main;
vl_api_header_t *mp = vl_msg_api_alloc(l);
- unix_shared_memory_queue_t *q;
+ svm_queue_t *q;
vac_main_t *pm = &vac_main;
if (!pm->connected_to_vlib) return -1;
memcpy(mp, p, l);
mp->client_index = vac_client_index();
q = am->shmem_hdr->vl_input_queue;
- rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0);
+ rv = svm_queue_add(q, (u8 *)&mp, 0);
if (rv != 0) {
clib_warning("vpe_api_write fails: %d\n", rv);
/* Clear message */
int
vac_get_msg_index (unsigned char * name)
{
- return vl_api_get_msg_index (name);
+ return vl_msg_api_get_msg_index (name);
}
int
Code Review / vpp.git / blobdiff