src/svm/svmtool.c

   1 /*
   2  *------------------------------------------------------------------
   3  * svmtool.c
   4  *
   5  * Copyright (c) 2009 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <sys/types.h>
  23 #include <sys/mman.h>
  24 #include <sys/stat.h>
  25 #include <netinet/in.h>
  26 #include <signal.h>
  27 #include <pthread.h>
  28 #include <unistd.h>
  29 #include <time.h>
  30 #include <fcntl.h>
  31 #include <string.h>
  32 #include <vppinfra/clib.h>
  33 #include <vppinfra/vec.h>
  34 #include <vppinfra/hash.h>
  35 #include <vppinfra/bitmap.h>
  36 #include <vppinfra/fifo.h>
  37 #include <vppinfra/time.h>
  38 #include <vppinfra/heap.h>
  39 #include <vppinfra/pool.h>
  40 #include <vppinfra/format.h>
  41
  42 #include "svm.h"
  43
  44
  45
  46 /*
  47  * format_all_svm_regions
  48  * Maps / unmaps regions. Do NOT call from client code!
  49  */
  50 u8 *
  51 format_all_svm_regions (u8 * s, va_list * args)
  52 {
  53   int verbose = va_arg (*args, int);
  54   svm_region_t *root_rp = svm_get_root_rp ();
  55   svm_main_region_t *mp;
  56   svm_subregion_t *subp;
  57   svm_region_t *rp;
  58   svm_map_region_args_t *a = 0;
  59   u8 **svm_names = 0;
  60   u8 *name = 0;
  61   int i;
  62
  63   ASSERT (root_rp);
  64
  65   pthread_mutex_lock (&root_rp->mutex);
  66
  67   s = format (s, "%U", format_svm_region, root_rp, verbose);
  68
  69   mp = root_rp->data_base;
  70
  71   /*
  72    * Snapshoot names, can't hold root rp mutex across
  73    * find_or_create.
  74    */
  75   /* *INDENT-OFF* */
  76   pool_foreach (subp, mp->subregions)  {
  77         name = vec_dup (subp->subregion_name);
  78         vec_add1(svm_names, name);
  79       }
  80   /* *INDENT-ON* */
  81
  82   pthread_mutex_unlock (&root_rp->mutex);
  83
  84   for (i = 0; i < vec_len (svm_names); i++)
  85     {
  86       vec_validate (a, 0);
  87       a->name = (char *) svm_names[i];
  88       rp = svm_region_find_or_create (a);
  89       if (rp)
  90         {
  91           pthread_mutex_lock (&rp->mutex);
  92           s = format (s, "%U", format_svm_region, rp, verbose);
  93           pthread_mutex_unlock (&rp->mutex);
  94           svm_region_unmap (rp);
  95           vec_free (svm_names[i]);
  96         }
  97       vec_free (a);
  98     }
  99   vec_free (svm_names);
 100   return (s);
 101 }
 102
 103 void
 104 show (char *chroot_path, int verbose)
 105 {
 106   svm_map_region_args_t *a = 0;
 107
 108   vec_validate (a, 0);
 109
 110   svm_region_init_chroot (chroot_path);
 111
 112   fformat (stdout, "My pid is %d\n", getpid ());
 113
 114   fformat (stdout, "%U", format_all_svm_regions, verbose);
 115
 116   svm_region_exit ();
 117
 118   vec_free (a);
 119 }
 120
 121
 122 static void *
 123 svm_map_region_nolock (svm_map_region_args_t * a)
 124 {
 125   int svm_fd;
 126   svm_region_t *rp;
 127   int deadman = 0;
 128   u8 *shm_name;
 129
 130   ASSERT ((a->size & ~(MMAP_PAGESIZE - 1)) == a->size);
 131
 132   shm_name = shm_name_from_svm_map_region_args (a);
 133
 134   svm_fd = shm_open ((char *) shm_name, O_RDWR, 0777);
 135
 136   if (svm_fd < 0)
 137     {
 138       perror ("svm_region_map(mmap open)");
 139       return (0);
 140     }
 141   vec_free (shm_name);
 142
 143   rp = mmap (0, MMAP_PAGESIZE, PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
 144
 145   if (rp == (svm_region_t *) MAP_FAILED)
 146     {
 147       close (svm_fd);
 148       clib_warning ("mmap");
 149       return (0);
 150     }
 151   /*
 152    * We lost the footrace to create this region; make sure
 153    * the winner has crossed the finish line.
 154    */
 155   while (rp->version == 0 && deadman++ < 5)
 156     {
 157       sleep (1);
 158     }
 159
 160   /*
 161    * <bleep>-ed?
 162    */
 163   if (rp->version == 0)
 164     {
 165       clib_warning ("rp->version %d not %d", rp->version, SVM_VERSION);
 166       munmap (rp, MMAP_PAGESIZE);
 167       return (0);
 168     }
 169   /* Remap now that the region has been placed */
 170   a->baseva = rp->virtual_base;
 171   a->size = rp->virtual_size;
 172   munmap (rp, MMAP_PAGESIZE);
 173
 174   rp = (void *) mmap (uword_to_pointer (a->baseva, void *), a->size,
 175                       PROT_READ | PROT_WRITE,
 176                       MAP_SHARED | MAP_FIXED, svm_fd, 0);
 177   if ((uword) rp == (uword) MAP_FAILED)
 178     {
 179       clib_unix_warning ("mmap");
 180       return (0);
 181     }
 182
 183   if ((uword) rp != rp->virtual_base)
 184     {
 185       clib_warning ("mmap botch");
 186     }
 187
 188   if (pthread_mutex_trylock (&rp->mutex))
 189     {
 190       clib_warning ("rp->mutex LOCKED by pid %d, tag %d, cleared...",
 191                     rp->mutex_owner_pid, rp->mutex_owner_tag);
 192       clib_memset (&rp->mutex, 0, sizeof (rp->mutex));
 193
 194     }
 195   else
 196     {
 197       clib_warning ("mutex OK...\n");
 198       pthread_mutex_unlock (&rp->mutex);
 199     }
 200
 201   return ((void *) rp);
 202 }
 203
 204 /*
 205  * rnd_pagesize
 206  * Round to a pagesize multiple, presumably 4k works
 207  */
 208 static u64
 209 rnd_pagesize (u64 size)
 210 {
 211   u64 rv;
 212
 213   rv = (size + (MMAP_PAGESIZE - 1)) & ~(MMAP_PAGESIZE - 1);
 214   return (rv);
 215 }
 216
 217 #define MUTEX_DEBUG
 218
 219 always_inline void
 220 region_lock (svm_region_t * rp, int tag)
 221 {
 222   pthread_mutex_lock (&rp->mutex);
 223 #ifdef MUTEX_DEBUG
 224   rp->mutex_owner_pid = getpid ();
 225   rp->mutex_owner_tag = tag;
 226 #endif
 227 }
 228
 229 always_inline void
 230 region_unlock (svm_region_t * rp)
 231 {
 232 #ifdef MUTEX_DEBUG
 233   rp->mutex_owner_pid = 0;
 234   rp->mutex_owner_tag = 0;
 235 #endif
 236   pthread_mutex_unlock (&rp->mutex);
 237 }
 238
 239
 240 static void *
 241 svm_existing_region_map_nolock (void *root_arg, svm_map_region_args_t * a)
 242 {
 243   svm_region_t *root_rp = root_arg;
 244   svm_main_region_t *mp;
 245   svm_region_t *rp;
 246   void *oldheap;
 247   uword *p;
 248
 249   a->size += MMAP_PAGESIZE +
 250     (a->pvt_heap_size ? a->pvt_heap_size : SVM_PVT_MHEAP_SIZE);
 251   a->size = rnd_pagesize (a->size);
 252
 253   region_lock (root_rp, 4);
 254   oldheap = svm_push_pvt_heap (root_rp);
 255   mp = root_rp->data_base;
 256
 257   ASSERT (mp);
 258
 259   p = hash_get_mem (mp->name_hash, a->name);
 260
 261   if (p)
 262     {
 263       rp = svm_map_region_nolock (a);
 264       region_unlock (root_rp);
 265       svm_pop_heap (oldheap);
 266       return rp;
 267     }
 268   return 0;
 269
 270 }
 271
 272 static void
 273 trace (char *chroot_path, char *name, int enable_disable)
 274 {
 275   svm_map_region_args_t *a = 0;
 276   svm_region_t *db_rp;
 277   void *oldheap;
 278
 279   vec_validate (a, 0);
 280
 281   svm_region_init_chroot (chroot_path);
 282
 283   a->name = name;
 284   a->size = 1 << 20;
 285   a->flags = SVM_FLAGS_MHEAP;
 286
 287   db_rp = svm_region_find_or_create (a);
 288
 289   ASSERT (db_rp);
 290
 291   region_lock (db_rp, 20);
 292
 293   oldheap = svm_push_data_heap (db_rp);
 294
 295   mheap_trace (db_rp->data_heap, enable_disable);
 296
 297   svm_pop_heap (oldheap);
 298   region_unlock (db_rp);
 299
 300   svm_region_unmap ((void *) db_rp);
 301   svm_region_exit ();
 302   vec_free (a);
 303 }
 304
 305
 306
 307 static void
 308 subregion_repair (char *chroot_path)
 309 {
 310   int i;
 311   svm_main_region_t *mp;
 312   svm_map_region_args_t a;
 313   svm_region_t *root_rp;
 314   svm_region_t *rp;
 315   svm_subregion_t *subp;
 316   u8 *name = 0;
 317   u8 **svm_names = 0;
 318
 319   svm_region_init_chroot (chroot_path);
 320   root_rp = svm_get_root_rp ();
 321
 322   pthread_mutex_lock (&root_rp->mutex);
 323
 324   mp = root_rp->data_base;
 325
 326   /*
 327    * Snapshoot names, can't hold root rp mutex across
 328    * find_or_create.
 329    */
 330   /* *INDENT-OFF* */
 331   pool_foreach (subp, mp->subregions)  {
 332         name = vec_dup (subp->subregion_name);
 333         vec_add1(svm_names, name);
 334       }
 335   /* *INDENT-ON* */
 336
 337   pthread_mutex_unlock (&root_rp->mutex);
 338
 339   for (i = 0; i < vec_len (svm_names); i++)
 340     {
 341       clib_memset (&a, 0, sizeof (a));
 342       a.root_path = chroot_path;
 343       a.name = (char *) svm_names[i];
 344       fformat (stdout, "Checking %s region...\n", a.name);
 345       rp = svm_existing_region_map_nolock (root_rp, &a);
 346       if (rp)
 347         {
 348           svm_region_unmap (rp);
 349           vec_free (svm_names[i]);
 350         }
 351     }
 352   vec_free (svm_names);
 353 }
 354
 355 void
 356 repair (char *chroot_path, int crash_root_region)
 357 {
 358   svm_region_t *root_rp = 0;
 359   svm_map_region_args_t *a = 0;
 360   void *svm_map_region (svm_map_region_args_t * a);
 361   int svm_fd;
 362   u8 *shm_name;
 363
 364   fformat (stdout, "our pid: %d\n", getpid ());
 365
 366   vec_validate (a, 0);
 367
 368   a->root_path = chroot_path;
 369   a->name = SVM_GLOBAL_REGION_NAME;
 370   a->baseva = svm_get_global_region_base_va ();
 371   a->size = SVM_GLOBAL_REGION_SIZE;
 372   a->flags = SVM_FLAGS_NODATA;
 373
 374   shm_name = shm_name_from_svm_map_region_args (a);
 375
 376   svm_fd = shm_open ((char *) shm_name, O_RDWR, 0777);
 377
 378   if (svm_fd < 0)
 379     {
 380       perror ("svm_region_map(mmap open)");
 381       goto out;
 382     }
 383
 384   vec_free (shm_name);
 385
 386   root_rp = mmap (0, MMAP_PAGESIZE,
 387                   PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
 388
 389   if (root_rp == (svm_region_t *) MAP_FAILED)
 390     {
 391       close (svm_fd);
 392       clib_warning ("mmap");
 393       goto out;
 394     }
 395
 396   /* Remap now that the region has been placed */
 397   clib_warning ("remap to 0x%x", root_rp->virtual_base);
 398
 399   a->baseva = root_rp->virtual_base;
 400   a->size = root_rp->virtual_size;
 401   munmap (root_rp, MMAP_PAGESIZE);
 402
 403   root_rp = (void *) mmap (uword_to_pointer (a->baseva, void *), a->size,
 404                            PROT_READ | PROT_WRITE,
 405                            MAP_SHARED | MAP_FIXED, svm_fd, 0);
 406   if ((uword) root_rp == (uword) MAP_FAILED)
 407     {
 408       clib_unix_warning ("mmap");
 409       goto out;
 410     }
 411
 412   close (svm_fd);
 413
 414   if ((uword) root_rp != root_rp->virtual_base)
 415     {
 416       clib_warning ("mmap botch");
 417       goto out;
 418     }
 419
 420   if (pthread_mutex_trylock (&root_rp->mutex))
 421     {
 422       clib_warning ("root_rp->mutex LOCKED by pid %d, tag %d, cleared...",
 423                     root_rp->mutex_owner_pid, root_rp->mutex_owner_tag);
 424       clib_memset (&root_rp->mutex, 0, sizeof (root_rp->mutex));
 425       goto out;
 426     }
 427   else
 428     {
 429       clib_warning ("root_rp->mutex OK...\n");
 430       pthread_mutex_unlock (&root_rp->mutex);
 431     }
 432
 433 out:
 434   vec_free (a);
 435   /*
 436    * Now that the root region is known to be OK,
 437    * fix broken subregions
 438    */
 439   subregion_repair (chroot_path);
 440
 441   if (crash_root_region)
 442     {
 443       clib_warning ("Leaving root region locked on purpose...");
 444       pthread_mutex_lock (&root_rp->mutex);
 445       root_rp->mutex_owner_pid = getpid ();
 446       root_rp->mutex_owner_tag = 99;
 447     }
 448   svm_region_exit ();
 449 }
 450
 451 int
 452 main (int argc, char **argv)
 453 {
 454   unformat_input_t input;
 455   int parsed = 0;
 456   char *name;
 457   char *chroot_path = 0;
 458   u8 *chroot_u8;
 459
 460   clib_mem_init_thread_safe (0, 128 << 20);
 461
 462   unformat_init_command_line (&input, argv);
 463
 464   while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
 465     {
 466       if (unformat (&input, "show-verbose"))
 467         {
 468           show (chroot_path, 1);
 469           parsed++;
 470         }
 471       else if (unformat (&input, "show"))
 472         {
 473           show (chroot_path, 0);
 474           parsed++;
 475         }
 476       else if (unformat (&input, "client-scan"))
 477         {
 478           svm_client_scan (chroot_path);
 479           parsed++;
 480         }
 481       else if (unformat (&input, "repair"))
 482         {
 483           repair (chroot_path, 0 /* fix it */ );
 484           parsed++;
 485         }
 486       else if (unformat (&input, "crash"))
 487         {
 488           repair (chroot_path, 1 /* crash it */ );
 489           parsed++;
 490         }
 491       else if (unformat (&input, "trace-on %s", &name))
 492         {
 493           trace (chroot_path, name, 1);
 494           parsed++;
 495         }
 496       else if (unformat (&input, "trace-off %s", &name))
 497         {
 498           trace (chroot_path, name, 0);
 499           parsed++;
 500         }
 501       else if (unformat (&input, "chroot %s", &chroot_u8))
 502         {
 503           chroot_path = (char *) chroot_u8;
 504         }
 505       else
 506         {
 507           break;
 508         }
 509     }
 510
 511   unformat_free (&input);
 512
 513   if (!parsed)
 514     {
 515       fformat (stdout,
 516                "%s: show | show-verbose | client-scan | trace-on <region-name>\n",
 517                argv[0]);
 518       fformat (stdout, "      trace-off <region-name>\n");
 519     }
 520   exit (0);
 521 }
 522
 523 /*
 524  * fd.io coding-style-patch-verification: ON
 525  *
 526  * Local Variables:
 527  * eval: (c-set-style "gnu")
 528  * End:
 529  */