summaryrefslogtreecommitdiffstats
path: root/vlib-api/vlibmemory/memory_shared.c
diff options
context:
space:
mode:
authorEd Warnicke <eaw@cisco.com>2015-12-08 15:45:58 -0700
committerEd Warnicke <eaw@cisco.com>2015-12-08 15:47:27 -0700
commitcb9cadad578297ffd78fa8a33670bdf1ab669e7e (patch)
tree6ac2be912482cc7849a26f0ab845561c3d7f4e26 /vlib-api/vlibmemory/memory_shared.c
parentfb0815d4ae4bb0fe27bd9313f34b45c8593b907e (diff)
Initial commit of vpp code.v1.0.0
Change-Id: Ib246f1fbfce93274020ee93ce461e3d8bd8b9f17 Signed-off-by: Ed Warnicke <eaw@cisco.com>
Diffstat (limited to 'vlib-api/vlibmemory/memory_shared.c')
-rw-r--r--vlib-api/vlibmemory/memory_shared.c681
1 files changed, 681 insertions, 0 deletions
diff --git a/vlib-api/vlibmemory/memory_shared.c b/vlib-api/vlibmemory/memory_shared.c
new file mode 100644
index 00000000000..de1eafdad80
--- /dev/null
+++ b/vlib-api/vlibmemory/memory_shared.c
@@ -0,0 +1,681 @@
+/*
+ *------------------------------------------------------------------
+ * memclnt_shared.c - API message handling, common code for both clients
+ * and the vlib process itself.
+ *
+ *
+ * Copyright (c) 2009 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *------------------------------------------------------------------
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <vppinfra/format.h>
+#include <vppinfra/byte_order.h>
+#include <vppinfra/error.h>
+#include <vlib/vlib.h>
+#include <vlib/unix/unix.h>
+#include <vlibmemory/api.h>
+#include <vlibmemory/unix_shared_memory_queue.h>
+
+#include <vlibmemory/vl_memory_msg_enum.h>
+
+#define vl_typedefs
+#include <vlibmemory/vl_memory_api_h.h>
+#undef vl_typedefs
+
+typedef struct msgbuf_ {
+ unix_shared_memory_queue_t *q;
+ u8 data[0];
+} msgbuf_t;
+
+static inline void *vl_msg_api_alloc_internal(int nbytes, int pool)
+{
+ int i;
+ msgbuf_t *rv;
+ ring_alloc_t *ap;
+ unix_shared_memory_queue_t *q;
+ void *oldheap;
+ vl_shmem_hdr_t *shmem_hdr;
+ api_main_t *am = &api_main;
+
+ shmem_hdr = am->shmem_hdr;
+
+ if (shmem_hdr == 0) {
+ clib_warning ("shared memory header NULL");
+ return 0;
+ }
+
+ /* account for the msgbuf_t header*/
+ nbytes += sizeof(msgbuf_t);
+
+ if (shmem_hdr->vl_rings == 0) {
+ clib_warning ("vl_rings NULL");
+ return 0;
+ }
+
+ if (shmem_hdr->client_rings == 0) {
+ clib_warning ("client_rings NULL");
+ return 0;
+ }
+
+ ap = pool ? shmem_hdr->vl_rings : shmem_hdr->client_rings;
+ for (i = 0; i < vec_len (ap); i++) {
+ /* Too big? */
+ if (nbytes > ap[i].size) {
+ continue;
+ }
+
+ q = ap[i].rp;
+ if (pool == 0) {
+ pthread_mutex_lock(&q->mutex);
+ }
+ rv = (msgbuf_t *) (&q->data[0] + q->head*q->elsize);
+ /*
+ * Is this item still in use?
+ */
+ if (rv->q) {
+ /* yes, loser; try next larger pool */
+ ap[i].misses++;
+ if (pool == 0)
+ pthread_mutex_unlock(&q->mutex);
+ continue;
+ }
+ /* OK, we have a winner */
+ ap[i].hits++;
+ /*
+ * Remember the source queue, although we
+ * don't need to know the queue to free the item.
+ */
+ rv->q = q;
+ q->head++;
+ if (q->head == q->maxsize)
+ q->head = 0;
+
+ if (pool == 0)
+ pthread_mutex_unlock(&q->mutex);
+ goto out;
+ }
+
+ /*
+ * Request too big, or head element of all size-compatible rings
+ * still in use. Fall back to shared-memory malloc.
+ */
+ am->ring_misses++;
+
+ pthread_mutex_lock (&am->vlib_rp->mutex);
+ oldheap = svm_push_data_heap (am->vlib_rp);
+ rv = clib_mem_alloc(nbytes + sizeof(msgbuf_t));
+ rv->q = 0;
+ svm_pop_heap (oldheap);
+ pthread_mutex_unlock (&am->vlib_rp->mutex);
+
+ out:
+ return(rv->data);
+}
+
+void *vl_msg_api_alloc (int nbytes)
+{
+ int pool;
+ api_main_t *am = &api_main;
+ vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
+
+ /*
+ * Clients use pool-0, vlib proc uses pool 1
+ */
+ pool = (am->our_pid == shmem_hdr->vl_pid);
+ return vl_msg_api_alloc_internal (nbytes, pool);
+}
+
+void *vl_msg_api_alloc_as_if_client (int nbytes)
+{
+ return vl_msg_api_alloc_internal (nbytes, 0);
+}
+
+void vl_msg_api_free(void *a)
+{
+ msgbuf_t *rv;
+ void *oldheap;
+ api_main_t *am = &api_main;
+
+ rv = (msgbuf_t *)(((u8 *)a) - sizeof(*rv));
+ /*
+ * Here's the beauty of the scheme. Only one proc/thread has
+ * control of a given message buffer. To free a buffer, we just clear the
+ * queue field, and leave. No locks, no hits, no errors...
+ */
+ if (rv->q) {
+ rv->q = 0;
+ return;
+ }
+
+ pthread_mutex_lock (&am->vlib_rp->mutex);
+ oldheap = svm_push_data_heap (am->vlib_rp);
+ clib_mem_free (rv);
+ svm_pop_heap (oldheap);
+ pthread_mutex_unlock (&am->vlib_rp->mutex);
+}
+
+static void vl_msg_api_free_nolock (void *a)
+{
+ msgbuf_t *rv;
+ void *oldheap;
+ api_main_t *am = &api_main;
+
+ rv = (msgbuf_t *)(((u8 *)a) - sizeof(*rv));
+ /*
+ * Here's the beauty of the scheme. Only one proc/thread has
+ * control of a given message buffer. To free a buffer, we just clear the
+ * queue field, and leave. No locks, no hits, no errors...
+ */
+ if (rv->q) {
+ rv->q = 0;
+ return;
+ }
+
+ oldheap = svm_push_data_heap (am->vlib_rp);
+ clib_mem_free (rv);
+ svm_pop_heap (oldheap);
+}
+
+int vl_map_shmem (char *region_name, int is_vlib)
+{
+ svm_map_region_args_t *a = 0;
+ svm_region_t *vlib_rp, *root_rp;
+ void *oldheap;
+ vl_shmem_hdr_t *shmem_hdr=0;
+ api_main_t *am = &api_main;
+ int i;
+ struct timespec ts, tsrem;
+
+ if (is_vlib == 0)
+ svm_region_init();
+
+ vec_validate (a, 0);
+
+ a->name = region_name;
+ a->size = 16<<20;
+ a->flags = SVM_FLAGS_MHEAP;
+
+ vlib_rp = svm_region_find_or_create (a);
+
+ vec_free (a);
+
+ if (vlib_rp == 0)
+ return (-2);
+
+ pthread_mutex_lock (&vlib_rp->mutex);
+ /* Has someone else set up the shared-memory variable table? */
+ if (vlib_rp->user_ctx) {
+ am->shmem_hdr = (void *) vlib_rp->user_ctx;
+ am->our_pid = getpid();
+ if (is_vlib) {
+ unix_shared_memory_queue_t *q;
+ uword old_msg;
+ /*
+ * application restart. Reset cached pids, API message
+ * rings, list of clients; otherwise, various things
+ * fail. (e.g. queue non-empty notification)
+ */
+
+ /* ghosts keep the region from disappearing properly */
+ svm_client_scan_this_region_nolock(vlib_rp);
+ am->shmem_hdr->application_restarts++;
+ q = am->shmem_hdr->vl_input_queue;
+ am->shmem_hdr->vl_pid = getpid();
+ q->consumer_pid = am->shmem_hdr->vl_pid;
+ /* Drain the input queue, freeing msgs */
+ for (i = 0; i < 10; i++) {
+ if (pthread_mutex_trylock (&q->mutex) == 0) {
+ pthread_mutex_unlock (&q->mutex);
+ goto mutex_ok;
+ }
+ ts.tv_sec = 0;
+ ts.tv_nsec = 10000*1000; /* 10 ms */
+ while (nanosleep(&ts, &tsrem) < 0)
+ ts = tsrem;
+ }
+ /* Mutex buggered, "fix" it */
+ memset (&q->mutex, 0, sizeof (q->mutex));
+ clib_warning ("forcibly release main input queue mutex");
+
+ mutex_ok:
+ am->vlib_rp = vlib_rp;
+ while (unix_shared_memory_queue_sub (q,
+ (u8 *)&old_msg,
+ 1 /* nowait */)
+ != -2 /* queue underflow */) {
+ vl_msg_api_free_nolock ((void *)old_msg);
+ am->shmem_hdr->restart_reclaims++;
+ }
+ pthread_mutex_unlock (&vlib_rp->mutex);
+ root_rp = svm_get_root_rp();
+ ASSERT(root_rp);
+ /* Clean up the root region client list */
+ pthread_mutex_lock (&root_rp->mutex);
+ svm_client_scan_this_region_nolock (root_rp);
+ pthread_mutex_unlock (&root_rp->mutex);
+ } else {
+ pthread_mutex_unlock (&vlib_rp->mutex);
+ /*
+ * Make sure the vlib app is really there...
+ * Wait up to 100 seconds...
+ */
+ for (i = 0; i < 10000; i++) {
+ /* Yup, it's there, off we go... */
+ if (kill (am->shmem_hdr->vl_pid, 0) >= 0)
+ break;
+
+ ts.tv_sec = 0;
+ ts.tv_nsec = 10000*1000; /* 10 ms */
+ while (nanosleep(&ts, &tsrem) < 0)
+ ts = tsrem;
+ }
+ }
+
+ am->vlib_rp = vlib_rp;
+ vec_add1(am->mapped_shmem_regions, vlib_rp);
+ return 0;
+ }
+ /* Clients simply have to wait... */
+ if (!is_vlib) {
+ pthread_mutex_unlock (&vlib_rp->mutex);
+
+ /* Wait up to 100 seconds... */
+ for (i = 0; i < 10000; i++) {
+ ts.tv_sec = 0;
+ ts.tv_nsec = 10000*1000; /* 10 ms */
+ while (nanosleep(&ts, &tsrem) < 0)
+ ts = tsrem;
+ if (vlib_rp->user_ctx)
+ goto ready;
+ }
+ /* Clean up and leave... */
+ svm_region_unmap (vlib_rp);
+ clib_warning ("region init fail");
+ return (-2);
+
+ ready:
+ am->shmem_hdr = (void *)vlib_rp->user_ctx;
+ am->our_pid = getpid();
+ am->vlib_rp = vlib_rp;
+ vec_add1(am->mapped_shmem_regions, vlib_rp);
+ return 0;
+ }
+
+ /* Nope, it's our problem... */
+
+ oldheap = svm_push_data_heap (vlib_rp);
+
+ vec_validate(shmem_hdr, 0);
+ shmem_hdr->version = VL_SHM_VERSION;
+
+ /* vlib main input queue */
+ shmem_hdr->vl_input_queue =
+ unix_shared_memory_queue_init (1024, sizeof (uword), getpid(),
+ am->vlib_signal);
+
+ /* Set up the msg ring allocator */
+#define _(sz,n) \
+ do { \
+ ring_alloc_t _rp; \
+ _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \
+ _rp.size = (sz); \
+ _rp.nitems = n; \
+ _rp.hits = 0; \
+ _rp.misses = 0; \
+ vec_add1(shmem_hdr->vl_rings, _rp); \
+ } while (0);
+
+ foreach_vl_aring_size;
+#undef _
+
+#define _(sz,n) \
+ do { \
+ ring_alloc_t _rp; \
+ _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \
+ _rp.size = (sz); \
+ _rp.nitems = n; \
+ _rp.hits = 0; \
+ _rp.misses = 0; \
+ vec_add1(shmem_hdr->client_rings, _rp); \
+ } while (0);
+
+ foreach_clnt_aring_size;
+#undef _
+
+ am->shmem_hdr = shmem_hdr;
+ am->vlib_rp = vlib_rp;
+ am->our_pid = getpid();
+ if (is_vlib)
+ am->shmem_hdr->vl_pid = am->our_pid;
+
+ svm_pop_heap (oldheap);
+
+ /*
+ * After absolutely everything that a client might see is set up,
+ * declare the shmem region valid
+ */
+ vlib_rp->user_ctx = shmem_hdr;
+
+ pthread_mutex_unlock (&vlib_rp->mutex);
+ vec_add1(am->mapped_shmem_regions, vlib_rp);
+ return 0;
+}
+
+void vl_register_mapped_shmem_region(svm_region_t *rp)
+{
+ api_main_t *am = &api_main;
+
+ vec_add1(am->mapped_shmem_regions, rp);
+}
+
+void vl_unmap_shmem (void)
+{
+ svm_region_t *rp;
+ int i;
+ api_main_t *am = &api_main;
+
+ if (! svm_get_root_rp())
+ return;
+
+ for (i = 0; i < vec_len(am->mapped_shmem_regions); i++) {
+ rp = am->mapped_shmem_regions[i];
+ svm_region_unmap (rp);
+ }
+
+ vec_free(am->mapped_shmem_regions);
+ am->shmem_hdr = 0;
+
+ svm_region_exit ();
+ /* $$$ more careful cleanup, valgrind run... */
+ vec_free (am->msg_handlers);
+ vec_free (am->msg_endian_handlers);
+ vec_free (am->msg_print_handlers);
+}
+
+void vl_msg_api_send_shmem (unix_shared_memory_queue_t *q, u8 *elem)
+{
+ api_main_t *am = &api_main;
+ uword *trace = (uword *)elem;
+
+ if (am->tx_trace && am->tx_trace->enabled)
+ vl_msg_api_trace(am, am->tx_trace, (void *)trace[0]);
+
+ (void)unix_shared_memory_queue_add(q, elem, 0 /* nowait */);
+}
+
+void vl_msg_api_send_shmem_nolock (unix_shared_memory_queue_t *q, u8 *elem)
+{
+ api_main_t *am = &api_main;
+ uword *trace = (uword *)elem;
+
+ if (am->tx_trace && am->tx_trace->enabled)
+ vl_msg_api_trace(am, am->tx_trace, (void *)trace[0]);
+
+ (void)unix_shared_memory_queue_add_nolock (q, elem);
+}
+
+static void vl_api_memclnt_create_reply_t_handler (
+ vl_api_memclnt_create_reply_t *mp)
+{
+ api_main_t *am = &api_main;
+ int rv;
+
+ am->my_client_index = mp->index;
+ am->my_registration = (vl_api_registration_t *)(uword)
+ mp->handle;
+
+ rv = ntohl(mp->response);
+
+ if (rv < 0)
+ clib_warning ("WARNING: API mismatch detected");
+}
+
+void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
+ __attribute__((weak));
+
+void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_LEN(mp->api_versions); i++)
+ mp->api_versions[i] = 0;
+}
+
+int vl_client_connect (char *name, int ctx_quota, int input_queue_size)
+{
+ svm_region_t *svm;
+ vl_api_memclnt_create_t *mp;
+ vl_api_memclnt_create_reply_t *rp;
+ unix_shared_memory_queue_t *vl_input_queue;
+ vl_shmem_hdr_t *shmem_hdr;
+ int rv=0;
+ void *oldheap;
+ api_main_t *am = &api_main;
+
+ if (am->my_registration) {
+ clib_warning ("client %s already connected...", name);
+ return -1;
+ }
+
+ if (am->vlib_rp == 0) {
+ clib_warning ("am->vlib_rp NULL");
+ return -1;
+ }
+
+ svm = am->vlib_rp;
+ shmem_hdr = am->shmem_hdr;
+
+ if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0) {
+ clib_warning ("shmem_hdr / input queue NULL");
+ return -1;
+ }
+
+ pthread_mutex_lock (&svm->mutex);
+ oldheap = svm_push_data_heap(svm);
+ vl_input_queue =
+ unix_shared_memory_queue_init (input_queue_size, sizeof(uword),
+ getpid(), 0);
+ pthread_mutex_unlock(&svm->mutex);
+ svm_pop_heap (oldheap);
+
+ am->my_client_index = ~0;
+ am->my_registration = 0;
+ am->vl_input_queue = vl_input_queue;
+
+ mp = vl_msg_api_alloc(sizeof(vl_api_memclnt_create_t));
+ memset(mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs(VL_API_MEMCLNT_CREATE);
+ mp->ctx_quota = ctx_quota;
+ mp->input_queue = (uword)vl_input_queue;
+ strncpy ((char *) mp->name, name, sizeof(mp->name)-1);
+
+ vl_client_add_api_signatures(mp);
+
+ vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *)&mp);
+
+ while (1) {
+ int qstatus;
+ struct timespec ts, tsrem;
+ int i;
+
+ /* Wait up to 10 seconds */
+ for (i = 0; i < 1000; i++) {
+ qstatus = unix_shared_memory_queue_sub (vl_input_queue, (u8 *)&rp,
+ 1 /* nowait */);
+ if (qstatus == 0)
+ goto read_one_msg;
+ ts.tv_sec = 0;
+ ts.tv_nsec = 10000*1000; /* 10 ms */
+ while (nanosleep(&ts, &tsrem) < 0)
+ ts = tsrem;
+ }
+ /* Timeout... */
+ clib_warning ("memclnt_create_reply timeout");
+ return -1;
+
+ read_one_msg:
+ if (ntohs(rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY) {
+ clib_warning ("unexpected reply: id %d", ntohs(rp->_vl_msg_id));
+ continue;
+ }
+ rv = clib_net_to_host_u32(rp->response);
+
+ vl_msg_api_handler((void *)rp);
+ break;
+ }
+ return (rv);
+}
+
+static void vl_api_memclnt_delete_reply_t_handler (
+ vl_api_memclnt_delete_reply_t *mp)
+{
+ void *oldheap;
+ api_main_t *am = &api_main;
+
+ pthread_mutex_lock (&am->vlib_rp->mutex);
+ oldheap = svm_push_data_heap(am->vlib_rp);
+ unix_shared_memory_queue_free (am->vl_input_queue);
+ pthread_mutex_unlock (&am->vlib_rp->mutex);
+ svm_pop_heap (oldheap);
+
+ am->my_client_index = ~0;
+ am->my_registration = 0;
+ am->vl_input_queue = 0;
+}
+
+void vl_client_disconnect (void)
+{
+ vl_api_memclnt_delete_t *mp;
+ vl_api_memclnt_delete_reply_t *rp;
+ unix_shared_memory_queue_t *vl_input_queue;
+ vl_shmem_hdr_t *shmem_hdr;
+ time_t begin;
+ api_main_t *am = &api_main;
+
+ ASSERT(am->vlib_rp);
+ shmem_hdr = am->shmem_hdr;
+ ASSERT(shmem_hdr && shmem_hdr->vl_input_queue);
+
+ vl_input_queue = am->vl_input_queue;
+
+ mp = vl_msg_api_alloc(sizeof(vl_api_memclnt_delete_t));
+ memset(mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs(VL_API_MEMCLNT_DELETE);
+ mp->index = am->my_client_index;
+ mp->handle = (uword) am->my_registration;
+
+ vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *)&mp);
+
+ /*
+ * Have to be careful here, in case the client is disconnecting
+ * because e.g. the vlib process died, or is unresponsive.
+ */
+
+ begin = time (0);
+ while (1) {
+ time_t now;
+
+ now = time (0);
+
+ if (now >= (begin + 2)) {
+ clib_warning ("peer unresponsive, give up");
+ am->my_client_index = ~0;
+ am->my_registration = 0;
+ am->shmem_hdr = 0;
+ break;
+ }
+ if (unix_shared_memory_queue_sub (vl_input_queue, (u8 *)&rp, 1) < 0)
+ continue;
+
+ /* drain the queue */
+ if (ntohs(rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY) {
+ vl_msg_api_handler ((void *)rp);
+ continue;
+ }
+ vl_msg_api_handler((void *)rp);
+ break;
+ }
+}
+
+static inline vl_api_registration_t
+*vl_api_client_index_to_registration_internal (u32 handle)
+{
+ vl_api_registration_t **regpp;
+ vl_api_registration_t *regp;
+ api_main_t *am = &api_main;
+ u32 index;
+
+ index = vl_msg_api_handle_get_index (handle);
+ if ((am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK)
+ != vl_msg_api_handle_get_epoch (handle)) {
+ vl_msg_api_increment_missing_client_counter();
+ return 0;
+ }
+
+ regpp = am->vl_clients + index;
+
+ if (pool_is_free(am->vl_clients, regpp)) {
+ vl_msg_api_increment_missing_client_counter();
+ return 0;
+ }
+ regp = *regpp;
+ return (regp);
+}
+
+vl_api_registration_t *vl_api_client_index_to_registration (u32 index)
+{
+ return (vl_api_client_index_to_registration_internal (index));
+}
+
+unix_shared_memory_queue_t *vl_api_client_index_to_input_queue (u32 index)
+{
+ vl_api_registration_t *regp;
+
+ regp = vl_api_client_index_to_registration_internal (index);
+ if (!regp)
+ return 0;
+ return (regp->vl_input_queue);
+}
+
+#define foreach_api_client_msg \
+_(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \
+_(MEMCLNT_DELETE_REPLY, memclnt_delete_reply)
+
+int vl_client_api_map (char *region_name)
+{
+ int rv;
+
+ if ((rv = vl_map_shmem (region_name, 0 /* is_vlib */)) < 0) {
+ return rv;
+ }
+
+#define _(N,n) \
+ vl_msg_api_set_handlers(VL_API_##N, 0 /* name */, \
+ vl_api_##n##_t_handler, \
+ 0/* cleanup */, 0/* endian */, 0/* print */, \
+ sizeof(vl_api_##n##_t), 1);
+ foreach_api_client_msg;
+#undef _
+ return 0;
+}
+
+void vl_client_api_unmap (void)
+{
+ vl_unmap_shmem();
+}