FD.io VPP  v21.01.1
Vector Packet Processing
svmtool.c
Go to the documentation of this file.
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);
56  svm_subregion_t *subp;
57  svm_region_t *rp;
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];
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 {
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 *
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...",
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
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
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 *
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 +
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 {
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;
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;
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;
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  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
void mheap_trace(clib_mem_heap_t *v, int enable)
Definition: mem_dlmalloc.c:491
svm_region_t * svm_get_root_rp(void)
Definition: svm.c:53
#define SVM_GLOBAL_REGION_NAME
Definition: svm_common.h:101
const char * root_path
Definition: svm_common.h:67
static void svm_pop_heap(void *oldheap)
Definition: svm.h:94
a
Definition: bitmap.h:544
#define SVM_FLAGS_NODATA
Definition: svm_common.h:29
void * svm_map_region(svm_map_region_args_t *a)
Definition: svm.c:550
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:527
Optimized string handling code, including c11-compliant "safe C library" variants.
unsigned long u64
Definition: types.h:89
Fixed length block allocator.
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
void svm_client_scan(const char *root_path)
Definition: svm.c:1247
uword virtual_base
Definition: svm_common.h:42
#define SVM_PVT_MHEAP_SIZE
Definition: svm_common.h:32
static u64 rnd_pagesize(u64 size)
Definition: svmtool.c:209
unsigned char u8
Definition: types.h:56
static void region_unlock(svm_region_t *rp)
Definition: svmtool.c:230
__clib_export word fformat(FILE *f, char *fmt,...)
Definition: format.c:462
#define SVM_VERSION
Definition: svm_common.h:25
void svm_region_exit(void)
Definition: svm.c:1207
static void * svm_push_data_heap(svm_region_t *rp)
Definition: svm.h:86
void * svm_region_find_or_create(svm_map_region_args_t *a)
Definition: svm.c:877
description fragment has unexpected format
Definition: map.api:433
u8 * format_svm_region(u8 *s, va_list *args)
Definition: svm.c:183
static void * svm_existing_region_map_nolock(void *root_arg, svm_map_region_args_t *a)
Definition: svmtool.c:241
#define SVM_FLAGS_MHEAP
Definition: svm_common.h:27
void * data_base
Definition: svm_common.h:45
struct _unformat_input_t unformat_input_t
u32 size
Definition: vhost_user.h:106
void unformat_init_command_line(unformat_input_t *input, char *argv[])
Definition: unformat.c:1013
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:429
svm_subregion_t * subregions
Definition: svm_common.h:119
#define always_inline
Definition: ipsec.h:28
uword virtual_size
Definition: svm_common.h:43
#define SVM_GLOBAL_REGION_SIZE
Definition: svm_common.h:100
void repair(char *chroot_path, int crash_root_region)
Definition: svmtool.c:356
static void * svm_map_region_nolock(svm_map_region_args_t *a)
Definition: svmtool.c:123
static void * svm_push_pvt_heap(svm_region_t *rp)
Definition: svm.h:78
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
#define clib_warning(format, args...)
Definition: error.h:59
u8 * shm_name_from_svm_map_region_args(svm_map_region_args_t *a)
Definition: svm.c:422
string name[64]
Definition: ip.api:44
int main(int argc, char **argv)
Definition: svmtool.c:452
#define uword_to_pointer(u, type)
Definition: types.h:136
#define ASSERT(truth)
volatile uword version
Definition: svm_common.h:36
u64 svm_get_global_region_base_va()
Definition: svm.c:61
Bitmaps built as vectors of machine words.
int mutex_owner_tag
Definition: svm_common.h:40
static void subregion_repair(char *chroot_path)
Definition: svmtool.c:308
#define MMAP_PAGESIZE
Definition: ssvm.h:42
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
const char * name
Definition: svm_common.h:68
u8 * format_all_svm_regions(u8 *s, va_list *args)
Definition: svmtool.c:51
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
#define clib_unix_warning(format, args...)
Definition: error.h:68
void svm_region_unmap(void *rp_arg)
Definition: svm.c:1140
void show(char *chroot_path, int verbose)
Definition: svmtool.c:104
#define hash_get_mem(h, key)
Definition: hash.h:269
static void region_lock(svm_region_t *rp, int tag)
Definition: svmtool.c:220
void * data_heap
Definition: svm_common.h:46
void * clib_mem_init_thread_safe(void *memory, uword memory_size)
Definition: mem_dlmalloc.c:280
static void trace(char *chroot_path, char *name, int enable_disable)
Definition: svmtool.c:273
int mutex_owner_pid
Definition: svm_common.h:39
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
pthread_mutex_t mutex
Definition: svm_common.h:37
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
static svm_region_t * root_rp
Definition: svm.c:45
int svm_region_init_chroot(const char *root_path)
Definition: svm.c:837