svm/svmtool.c - fdio/vpp - Gitiles

 /*
  *------------------------------------------------------------------
  * 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);
 }
	/*
	*------------------------------------------------------------------
	* 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);
	}