Initial commit of vpp code.v1.0.0

Change-Id: Ib246f1fbfce93274020ee93ce461e3d8bd8b9f17
Signed-off-by: Ed Warnicke <eaw@cisco.com>

1 files changed, 464 insertions, 0 deletions

diff --git a/svm/svmtool.c b/svm/svmtool.c
new file mode 100644
index 00000000000..e87746110ae
--- /dev/null
+++ b/svm/svmtool.c
@@ -0,0 +1,464 @@
+/* 
+ *------------------------------------------------------------------
+ * svmtool.c 
+ *
+ * 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 <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <netinet/in.h>
+#include <signal.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <time.h>
+#include <fcntl.h>
+#include <string.h>
+#include <vppinfra/clib.h>
+#include <vppinfra/vec.h>
+#include <vppinfra/hash.h>
+#include <vppinfra/bitmap.h>
+#include <vppinfra/fifo.h>
+#include <vppinfra/time.h>
+#include <vppinfra/mheap.h>
+#include <vppinfra/heap.h>
+#include <vppinfra/pool.h>
+#include <vppinfra/format.h>
+
+#include "svm.h"
+
+
+
+/*
+ * format_all_svm_regions
+ * Maps / unmaps regions. Do NOT call from client code!
+ */
+u8 *format_all_svm_regions (u8 *s, va_list * args)
+{
+    int verbose = va_arg (*args, int);
+    svm_region_t *root_rp = svm_get_root_rp();
+    svm_main_region_t *mp;
+    svm_subregion_t *subp;
+    svm_region_t *rp;
+    svm_map_region_args_t *a = 0;
+    u8 ** svm_names=0;
+    u8 *name=0;
+    int i;
+
+    ASSERT(root_rp);
+
+    pthread_mutex_lock (&root_rp->mutex);
+
+    s = format (s, "%U", format_svm_region, root_rp, verbose);
+
+    mp = root_rp->data_base;
+
+    /* 
+     * Snapshoot names, can't hold root rp mutex across
+     * find_or_create.
+     */
+    pool_foreach (subp, mp->subregions, ({
+	  name = vec_dup (subp->subregion_name);
+	  vec_add1(svm_names, name);
+	}));
+
+    pthread_mutex_unlock (&root_rp->mutex);
+
+    for (i = 0; i < vec_len(svm_names); i++) {
+	  vec_validate(a, 0);
+	  a->name = (char *) svm_names[i];
+	  rp = svm_region_find_or_create (a);
+	  if (rp) {
+	    pthread_mutex_lock (&rp->mutex);
+	    s = format (s, "%U", format_svm_region, rp, verbose);
+	    pthread_mutex_unlock (&rp->mutex);
+	    svm_region_unmap (rp);
+            vec_free(svm_names[i]);
+	  }
+	  vec_free (a);
+    }
+    vec_free(svm_names);
+    return (s);
+}
+
+void show (char *chroot_path, int verbose)
+{
+    svm_map_region_args_t *a = 0;
+
+    vec_validate (a, 0);
+
+    svm_region_init_chroot(chroot_path);
+
+    fformat(stdout, "My pid is %d\n", getpid());
+
+    fformat(stdout, "%U", format_all_svm_regions, verbose);
+
+    svm_region_exit ();
+
+    vec_free (a);
+}
+
+
+static void *svm_map_region_nolock (svm_map_region_args_t *a)
+{
+    int svm_fd;
+    svm_region_t *rp;
+    int deadman=0;
+    u8 *shm_name;
+
+    ASSERT((a->size & ~(MMAP_PAGESIZE-1)) == a->size);
+
+    shm_name = shm_name_from_svm_map_region_args (a);
+
+    svm_fd = shm_open((char *)shm_name, O_RDWR, 0777);
+
+    if (svm_fd < 0) {
+        perror("svm_region_map(mmap open)");
+        return (0);
+    }
+    vec_free (shm_name);
+
+    rp = mmap(0, MMAP_PAGESIZE, 
+              PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
+    
+    if (rp == (svm_region_t *) MAP_FAILED) {
+        close(svm_fd);
+        clib_warning("mmap");
+        return (0);
+    }
+    /*
+     * We lost the footrace to create this region; make sure
+     * the winner has crossed the finish line.
+     */
+    while (rp->version == 0 && deadman++ < 5) {
+        sleep(1);
+    }
+
+    /*
+     * <bleep>-ed? 
+     */
+    if (rp->version == 0) {
+        clib_warning("rp->version %d not %d", rp->version,
+                     SVM_VERSION);
+        return (0);
+    } 
+    /* Remap now that the region has been placed */
+    a->baseva = rp->virtual_base;
+    a->size = rp->virtual_size;
+    munmap(rp, MMAP_PAGESIZE);
+    
+    rp = (void *) mmap ((void *)a->baseva, a->size, 
+                        PROT_READ | PROT_WRITE, 
+                        MAP_SHARED | MAP_FIXED, svm_fd, 0);
+    if ((uword)rp == (uword)MAP_FAILED) {
+        clib_unix_warning ("mmap");
+        return (0);
+    }
+    
+    if ((uword) rp != rp->virtual_base) {
+        clib_warning("mmap botch");
+    }
+    
+    if (pthread_mutex_trylock(&rp->mutex)) {
+        clib_warning ("rp->mutex LOCKED by pid %d, tag %d, cleared...",
+                      rp->mutex_owner_pid, rp->mutex_owner_tag);
+        memset(&rp->mutex, 0, sizeof (rp->mutex));
+        
+    } else {
+        clib_warning ("mutex OK...\n");
+        pthread_mutex_unlock(&rp->mutex);
+    }
+
+    return ((void *) rp);
+}
+
+/*
+ * rnd_pagesize
+ * Round to a pagesize multiple, presumably 4k works
+ */
+static unsigned int rnd_pagesize(unsigned int size)
+{
+    unsigned int rv;
+
+    rv = (size + (MMAP_PAGESIZE-1)) & ~(MMAP_PAGESIZE-1);
+    return(rv);
+}
+
+#define MUTEX_DEBUG
+
+always_inline void region_lock(svm_region_t *rp, int tag)
+{
+    pthread_mutex_lock(&rp->mutex);
+#ifdef MUTEX_DEBUG
+    rp->mutex_owner_pid = getpid();
+    rp->mutex_owner_tag = tag;
+#endif    
+}
+
+always_inline void region_unlock(svm_region_t *rp)
+{
+#ifdef MUTEX_DEBUG
+    rp->mutex_owner_pid = 0;
+    rp->mutex_owner_tag = 0;
+#endif    
+    pthread_mutex_unlock(&rp->mutex);
+}
+
+
+static void *svm_existing_region_map_nolock (void *root_arg, 
+                                             svm_map_region_args_t *a)
+{
+    svm_region_t *root_rp = root_arg;
+    svm_main_region_t *mp;
+    svm_region_t *rp;
+    void *oldheap;
+    uword *p;
+    
+    a->size +=  MMAP_PAGESIZE + SVM_PVT_MHEAP_SIZE;
+    a->size = rnd_pagesize(a->size);
+
+    region_lock (root_rp, 4);
+    oldheap = svm_push_pvt_heap(root_rp);
+    mp = root_rp->data_base;
+    
+    ASSERT(mp);
+
+    p = hash_get_mem (mp->name_hash, a->name);
+
+    if (p) {
+        rp = svm_map_region_nolock (a);
+        region_unlock(root_rp);
+        svm_pop_heap (oldheap);
+        return rp;
+    }
+    return 0;
+
+}
+
+static void trace (char *chroot_path, char *name, int enable_disable)
+{
+    svm_map_region_args_t *a = 0;
+    svm_region_t *db_rp;
+    void *oldheap;
+
+    vec_validate (a, 0);
+
+    svm_region_init_chroot(chroot_path);
+
+    a->name = name;
+    a->size = 1<<20;
+    a->flags = SVM_FLAGS_MHEAP;
+
+    db_rp = svm_region_find_or_create (a);
+    
+    ASSERT(db_rp);
+    
+    region_lock (db_rp, 20);
+    
+    oldheap = svm_push_data_heap (db_rp);
+
+    mheap_trace (db_rp->data_heap, enable_disable);
+    
+    svm_pop_heap (oldheap);
+    region_unlock (db_rp);
+
+    svm_region_unmap ((void *)db_rp);
+    svm_region_exit ();
+    vec_free (a);
+}
+
+
+
+static void subregion_repair(char *chroot_path)
+{
+    int i;
+    svm_main_region_t *mp;
+    svm_map_region_args_t a;
+    svm_region_t *root_rp;
+    svm_region_t *rp;
+    svm_subregion_t *subp;
+    u8 *name=0;
+    u8 ** svm_names=0;
+
+    svm_region_init_chroot(chroot_path);
+    root_rp = svm_get_root_rp();
+    
+    pthread_mutex_lock (&root_rp->mutex);
+    
+    mp = root_rp->data_base;
+    
+    /* 
+     * Snapshoot names, can't hold root rp mutex across
+     * find_or_create.
+     */
+    pool_foreach (subp, mp->subregions, ({
+                name = vec_dup (subp->subregion_name);
+                vec_add1(svm_names, name);
+            }));
+    
+    pthread_mutex_unlock (&root_rp->mutex);
+    
+    for (i = 0; i < vec_len(svm_names); i++) {
+        memset (&a, 0, sizeof (a));
+        a.root_path = chroot_path;
+        a.name = (char *) svm_names[i];
+        fformat(stdout, "Checking %s region...\n",
+                a.name);
+        rp = svm_existing_region_map_nolock (root_rp, &a);
+        if (rp) {
+            svm_region_unmap (rp);
+            vec_free(svm_names[i]);
+        }
+    }
+    vec_free(svm_names);
+}
+
+void repair (char *chroot_path, int crash_root_region)
+{
+    svm_region_t *root_rp = 0;
+    svm_map_region_args_t *a = 0;
+    void *svm_map_region (svm_map_region_args_t *a);
+    int svm_fd;
+    u8 *shm_name;
+
+    fformat(stdout, "our pid: %d\n", getpid());
+
+    vec_validate (a, 0);
+
+    a->root_path = chroot_path;
+    a->name = SVM_GLOBAL_REGION_NAME;
+    a->baseva = SVM_GLOBAL_REGION_BASEVA;
+    a->size = SVM_GLOBAL_REGION_SIZE;
+    a->flags = SVM_FLAGS_NODATA;
+
+    shm_name = shm_name_from_svm_map_region_args (a);
+
+    svm_fd = shm_open ((char *)shm_name, O_RDWR, 0777);
+
+    if (svm_fd < 0) {
+        perror("svm_region_map(mmap open)");
+        goto out;
+    }
+
+    vec_free(shm_name);
+
+    root_rp = mmap(0, MMAP_PAGESIZE, 
+              PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
+    
+    if (root_rp == (svm_region_t *) MAP_FAILED) {
+        close(svm_fd);
+        clib_warning("mmap");
+        goto out;
+    }
+    
+    /* Remap now that the region has been placed */
+    clib_warning ("remap to 0x%x", root_rp->virtual_base);
+
+    a->baseva = root_rp->virtual_base;
+    a->size = root_rp->virtual_size;
+    munmap(root_rp, MMAP_PAGESIZE);
+    
+    root_rp = (void *) mmap ((void *)a->baseva, a->size, 
+                        PROT_READ | PROT_WRITE, 
+                        MAP_SHARED | MAP_FIXED, svm_fd, 0);
+    if ((uword)root_rp == (uword)MAP_FAILED) {
+        clib_unix_warning ("mmap");
+        goto out;
+    }
+    
+    close(svm_fd);
+
+    if ((uword) root_rp != root_rp->virtual_base) {
+        clib_warning("mmap botch");
+        goto out;
+    }
+    
+    if (pthread_mutex_trylock(&root_rp->mutex)) {
+        clib_warning ("root_rp->mutex LOCKED by pid %d, tag %d, cleared...",
+                      root_rp->mutex_owner_pid, root_rp->mutex_owner_tag);
+        memset(&root_rp->mutex, 0, sizeof (root_rp->mutex));
+        goto out;
+    } else {
+        clib_warning ("root_rp->mutex OK...\n");
+        pthread_mutex_unlock(&root_rp->mutex);
+    }
+    
+ out:
+    vec_free (a);
+    /*
+     * Now that the root region is known to be OK, 
+     * fix broken subregions
+     */
+    subregion_repair(chroot_path);
+
+    if (crash_root_region) {
+        clib_warning ("Leaving root region locked on purpose...");
+        pthread_mutex_lock(&root_rp->mutex);
+        root_rp->mutex_owner_pid = getpid();
+        root_rp->mutex_owner_tag = 99;
+    }
+    svm_region_exit ();
+}
+
+int main (int argc, char **argv)
+{
+    unformat_input_t input;
+    int parsed =0;
+    char *name;
+    char *chroot_path = 0;
+    u8 *chroot_u8;
+
+    unformat_init_command_line (&input, argv);
+
+    while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT) {
+        if (unformat(&input, "show-verbose")) {
+            show (chroot_path, 1);
+            parsed++;
+        } else if (unformat (&input, "show")) {
+            show (chroot_path, 0);
+            parsed++;
+        } else if (unformat (&input, "client-scan")) {
+            svm_client_scan(chroot_path);
+            parsed++;
+        } else if (unformat (&input, "repair")) {
+            repair(chroot_path, 0 /* fix it */);
+            parsed++;
+        } else if (unformat (&input, "crash")) {
+            repair (chroot_path, 1 /* crash it */);
+            parsed++;
+        } else if (unformat (&input, "trace-on %s", &name)) {
+            trace (chroot_path, name, 1);
+            parsed++;
+        } else if (unformat (&input, "trace-off %s", &name)) {
+            trace (chroot_path, name, 0);
+            parsed++;
+        } else if (unformat (&input, "chroot %s", &chroot_u8)) {
+            chroot_path = (char *) chroot_u8;
+        } else {
+            break;
+        }
+    }
+
+    unformat_free (&input);
+
+    if (!parsed) {
+        fformat(stdout, "%s: show | show-verbose | client-scan | trace-on <region-name>\n", argv[0]);
+        fformat(stdout, "      trace-off <region-name>\n");
+    }
+    exit (0);
+}