#include "vppapiclient.h"
+bool timeout_cancelled;
+bool timeout_in_progress;
+bool rx_thread_done;
+
/*
* Asynchronous mode:
* Client registers a callback. All messages are sent to the callback.
pthread_cond_t suspend_cv;
pthread_cond_t resume_cv;
pthread_mutex_t timeout_lock;
+ u8 timeout_loop;
pthread_cond_t timeout_cv;
pthread_cond_t timeout_cancel_cv;
pthread_cond_t terminate_cv;
vac_callback_t vac_callback;
u16 read_timeout = 0;
bool rx_is_running = false;
+bool timeout_thread_cancelled = false;
+
+/* Set to true to enable memory tracing */
+bool mem_trace = false;
+
+__attribute__((constructor))
+static void
+vac_client_constructor (void)
+{
+ clib_mem_init (0, 1 << 30);
+#if USE_DLMALLOC == 0
+ {
+ u8 *heap;
+ mheap_t *h;
+
+ heap = clib_mem_get_per_cpu_heap ();
+ h = mheap_header (heap);
+ /* make the main heap thread-safe */
+ h->flags |= MHEAP_FLAG_THREAD_SAFE;
+ }
+#endif
+ 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)
{
vac_main_t *pm = &vac_main;
- memset(pm, 0, sizeof(*pm));
+ clib_memset(pm, 0, sizeof(*pm));
pthread_mutex_init(&pm->queue_lock, NULL);
pthread_cond_init(&pm->suspend_cv, NULL);
pthread_cond_init(&pm->resume_cv, NULL);
pthread_mutex_init(&pm->timeout_lock, NULL);
+ pm->timeout_loop = 1;
pthread_cond_init(&pm->timeout_cv, NULL);
pthread_cond_init(&pm->timeout_cancel_cv, NULL);
pthread_cond_init(&pm->terminate_cv, NULL);
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));
+ clib_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;
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);
/* signal waiting threads that this thread is about to terminate */
pthread_mutex_lock(&pm->queue_lock);
+ rx_thread_done = true;
pthread_cond_signal(&pm->terminate_cv);
pthread_mutex_unlock(&pm->queue_lock);
pthread_exit(0);
case VL_API_MEMCLNT_KEEPALIVE:
mp = (void *)msg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
shmem_hdr = am->shmem_hdr;
api_main_t *am = &api_main;
struct timespec ts;
struct timeval tv;
- u16 timeout;
int rv;
- while (1)
+ while (pm->timeout_loop)
{
/* Wait for poke */
pthread_mutex_lock(&pm->timeout_lock);
- pthread_cond_wait (&pm->timeout_cv, &pm->timeout_lock);
- timeout = read_timeout;
+ while (!timeout_in_progress)
+ pthread_cond_wait (&pm->timeout_cv, &pm->timeout_lock);
+
+ /* Starting timer */
gettimeofday(&tv, NULL);
- ts.tv_sec = tv.tv_sec + timeout;
+ ts.tv_sec = tv.tv_sec + read_timeout;
ts.tv_nsec = 0;
- rv = pthread_cond_timedwait (&pm->timeout_cancel_cv,
- &pm->timeout_lock, &ts);
- pthread_mutex_unlock(&pm->timeout_lock);
- if (rv == ETIMEDOUT)
- {
+
+ if (!timeout_cancelled) {
+ rv = pthread_cond_timedwait (&pm->timeout_cancel_cv,
+ &pm->timeout_lock, &ts);
+ if (rv == ETIMEDOUT && !timeout_thread_cancelled) {
ep = vl_msg_api_alloc (sizeof (*ep));
ep->_vl_msg_id = ntohs(VL_API_MEMCLNT_READ_TIMEOUT);
vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep);
}
+ }
+
+ pthread_mutex_unlock(&pm->timeout_lock);
}
pthread_exit(0);
}
ep = vl_msg_api_alloc (sizeof (*ep));
ep->_vl_msg_id = ntohs(VL_API_MEMCLNT_RX_THREAD_SUSPEND);
vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep);
- /* Wait for RX thread to tell us it has suspendend */
+ /* Wait for RX thread to tell us it has suspended */
pthread_cond_wait(&pm->suspend_cv, &pm->queue_lock);
rx_is_running = false;
}
vac_connect (char * name, char * chroot_prefix, vac_callback_t cb,
int rx_qlen)
{
+ rx_thread_done = false;
int rv = 0;
vac_main_t *pm = &vac_main;
vl_set_memory_root_path (chroot_prefix);
if ((rv = vl_client_api_map("/vpe-api"))) {
- clib_warning ("vl_client_api map rv %d", rv);
+ clib_warning ("vl_client_api_map returned %d", rv);
return rv;
}
return (0);
}
+static void
+set_timeout (unsigned short timeout)
+{
+ vac_main_t *pm = &vac_main;
+ pthread_mutex_lock(&pm->timeout_lock);
+ read_timeout = timeout;
+ timeout_in_progress = true;
+ timeout_cancelled = false;
+ 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);
+ timeout_in_progress = false;
+ timeout_cancelled = true;
+ 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;
+ int rv = 0;
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);
gettimeofday(&tv, NULL);
ts.tv_sec = tv.tv_sec + 5;
ts.tv_nsec = 0;
+
pthread_mutex_lock(&pm->queue_lock);
- int rv = pthread_cond_timedwait(&pm->terminate_cv, &pm->queue_lock, &ts);
+ if (rx_thread_done == false)
+ rv = pthread_cond_timedwait(&pm->terminate_cv, &pm->queue_lock, &ts);
pthread_mutex_unlock(&pm->queue_lock);
+
/* now join so we wait until thread has -really- finished */
if (rv == ETIMEDOUT)
pthread_cancel(pm->rx_thread_handle);
else
pthread_join(pm->rx_thread_handle, (void **) &junk);
}
- if (pm->timeout_thread_handle)
- pthread_cancel(pm->timeout_thread_handle);
+ if (pm->timeout_thread_handle) {
+ /* cancel, wake then join the timeout thread */
+ pm->timeout_loop = 0;
+ timeout_thread_cancelled = true;
+ 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;
int rv;
vl_shmem_hdr_t *shmem_hdr;
- if (!pm->connected_to_vlib) return -1;
+ /* svm_queue_sub(below) returns {-1, -2} */
+ if (!pm->connected_to_vlib) return -3;
*l = 0;
- if (am->our_pid == 0) return (-1);
+ /* svm_queue_sub(below) returns {-1, -2} */
+ if (am->our_pid == 0) return (-4);
/* Poke timeout thread */
if (timeout)
q = am->vl_input_queue;
again:
- rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0);
+ 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");
- return -1;
+ vl_msg_api_free((void *) msg);
+ goto error;
case VL_API_MEMCLNT_RX_THREAD_SUSPEND:
- printf("Received thread suspend\n");
goto error;
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));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
shmem_hdr = am->shmem_hdr;
msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
*l = ntohl(msgbuf->data_len);
if (*l == 0) {
- printf("Unregistered API message: %d\n", msg_id);
+ fprintf(stderr, "Unregistered API message: %d\n", msg_id);
goto error;
}
}
*p = (char *)msg;
- /* Let timeout notification thread know we're done */
- unset_timeout();
} else {
- printf("Read failed with %d\n", rv);
+ fprintf(stderr, "Read failed with %d\n", rv);
}
+ /* Let timeout notification thread know we're done */
+ if (timeout)
+ unset_timeout();
+
return (rv);
error:
+ if (timeout)
+ unset_timeout();
vl_msg_api_free((void *) msg);
/* Client might forget to resume RX thread on failure */
vac_rx_resume ();
u32 client_index;
}) vl_api_header_t;
-static unsigned int
+static u32
vac_client_index (void)
{
return (api_main.my_client_index);
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);
+ fprintf(stderr, "vpe_api_write fails: %d\n", rv);
/* Clear message */
vac_free(mp);
}
int
vac_get_msg_index (unsigned char * name)
{
- return vl_api_get_msg_index (name);
+ return vl_msg_api_get_msg_index (name);
}
int