FD.io VPP  v17.07.01-10-g3be13f0
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/mheap.h>
39 #include <vppinfra/heap.h>
40 #include <vppinfra/pool.h>
41 #include <vppinfra/format.h>
42 
43 #include "svm.h"
44 
45 
46 
47 /*
48  * format_all_svm_regions
49  * Maps / unmaps regions. Do NOT call from client code!
50  */
51 u8 *
52 format_all_svm_regions (u8 * s, va_list * args)
53 {
54  int verbose = va_arg (*args, int);
57  svm_subregion_t *subp;
58  svm_region_t *rp;
60  u8 **svm_names = 0;
61  u8 *name = 0;
62  int i;
63 
64  ASSERT (root_rp);
65 
66  pthread_mutex_lock (&root_rp->mutex);
67 
68  s = format (s, "%U", format_svm_region, root_rp, verbose);
69 
70  mp = root_rp->data_base;
71 
72  /*
73  * Snapshoot names, can't hold root rp mutex across
74  * find_or_create.
75  */
76  /* *INDENT-OFF* */
77  pool_foreach (subp, mp->subregions, ({
78  name = vec_dup (subp->subregion_name);
79  vec_add1(svm_names, name);
80  }));
81  /* *INDENT-ON* */
82 
83  pthread_mutex_unlock (&root_rp->mutex);
84 
85  for (i = 0; i < vec_len (svm_names); i++)
86  {
87  vec_validate (a, 0);
88  a->name = (char *) svm_names[i];
90  if (rp)
91  {
92  pthread_mutex_lock (&rp->mutex);
93  s = format (s, "%U", format_svm_region, rp, verbose);
94  pthread_mutex_unlock (&rp->mutex);
95  svm_region_unmap (rp);
96  vec_free (svm_names[i]);
97  }
98  vec_free (a);
99  }
100  vec_free (svm_names);
101  return (s);
102 }
103 
104 void
105 show (char *chroot_path, int verbose)
106 {
108 
109  vec_validate (a, 0);
110 
111  svm_region_init_chroot (chroot_path);
112 
113  fformat (stdout, "My pid is %d\n", getpid ());
114 
115  fformat (stdout, "%U", format_all_svm_regions, verbose);
116 
117  svm_region_exit ();
118 
119  vec_free (a);
120 }
121 
122 
123 static void *
125 {
126  int svm_fd;
127  svm_region_t *rp;
128  int deadman = 0;
129  u8 *shm_name;
130 
131  ASSERT ((a->size & ~(MMAP_PAGESIZE - 1)) == a->size);
132 
133  shm_name = shm_name_from_svm_map_region_args (a);
134 
135  svm_fd = shm_open ((char *) shm_name, O_RDWR, 0777);
136 
137  if (svm_fd < 0)
138  {
139  perror ("svm_region_map(mmap open)");
140  return (0);
141  }
142  vec_free (shm_name);
143 
144  rp = mmap (0, MMAP_PAGESIZE, PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
145 
146  if (rp == (svm_region_t *) MAP_FAILED)
147  {
148  close (svm_fd);
149  clib_warning ("mmap");
150  return (0);
151  }
152  /*
153  * We lost the footrace to create this region; make sure
154  * the winner has crossed the finish line.
155  */
156  while (rp->version == 0 && deadman++ < 5)
157  {
158  sleep (1);
159  }
160 
161  /*
162  * <bleep>-ed?
163  */
164  if (rp->version == 0)
165  {
166  clib_warning ("rp->version %d not %d", rp->version, SVM_VERSION);
167  munmap (rp, MMAP_PAGESIZE);
168  return (0);
169  }
170  /* Remap now that the region has been placed */
171  a->baseva = rp->virtual_base;
172  a->size = rp->virtual_size;
173  munmap (rp, MMAP_PAGESIZE);
174 
175  rp = (void *) mmap (uword_to_pointer (a->baseva, void *), a->size,
176  PROT_READ | PROT_WRITE,
177  MAP_SHARED | MAP_FIXED, svm_fd, 0);
178  if ((uword) rp == (uword) MAP_FAILED)
179  {
180  clib_unix_warning ("mmap");
181  return (0);
182  }
183 
184  if ((uword) rp != rp->virtual_base)
185  {
186  clib_warning ("mmap botch");
187  }
188 
189  if (pthread_mutex_trylock (&rp->mutex))
190  {
191  clib_warning ("rp->mutex LOCKED by pid %d, tag %d, cleared...",
193  memset (&rp->mutex, 0, sizeof (rp->mutex));
194 
195  }
196  else
197  {
198  clib_warning ("mutex OK...\n");
199  pthread_mutex_unlock (&rp->mutex);
200  }
201 
202  return ((void *) rp);
203 }
204 
205 /*
206  * rnd_pagesize
207  * Round to a pagesize multiple, presumably 4k works
208  */
209 static u64
211 {
212  u64 rv;
213 
214  rv = (size + (MMAP_PAGESIZE - 1)) & ~(MMAP_PAGESIZE - 1);
215  return (rv);
216 }
217 
218 #define MUTEX_DEBUG
219 
220 always_inline void
221 region_lock (svm_region_t * rp, int tag)
222 {
223  pthread_mutex_lock (&rp->mutex);
224 #ifdef MUTEX_DEBUG
225  rp->mutex_owner_pid = getpid ();
226  rp->mutex_owner_tag = tag;
227 #endif
228 }
229 
230 always_inline void
232 {
233 #ifdef MUTEX_DEBUG
234  rp->mutex_owner_pid = 0;
235  rp->mutex_owner_tag = 0;
236 #endif
237  pthread_mutex_unlock (&rp->mutex);
238 }
239 
240 
241 static void *
243 {
244  svm_region_t *root_rp = root_arg;
245  svm_main_region_t *mp;
246  svm_region_t *rp;
247  void *oldheap;
248  uword *p;
249 
250  a->size += MMAP_PAGESIZE +
252  a->size = rnd_pagesize (a->size);
253 
254  region_lock (root_rp, 4);
255  oldheap = svm_push_pvt_heap (root_rp);
256  mp = root_rp->data_base;
257 
258  ASSERT (mp);
259 
260  p = hash_get_mem (mp->name_hash, a->name);
261 
262  if (p)
263  {
264  rp = svm_map_region_nolock (a);
265  region_unlock (root_rp);
266  svm_pop_heap (oldheap);
267  return rp;
268  }
269  return 0;
270 
271 }
272 
273 static void
274 trace (char *chroot_path, char *name, int enable_disable)
275 {
277  svm_region_t *db_rp;
278  void *oldheap;
279 
280  vec_validate (a, 0);
281 
282  svm_region_init_chroot (chroot_path);
283 
284  a->name = name;
285  a->size = 1 << 20;
286  a->flags = SVM_FLAGS_MHEAP;
287 
288  db_rp = svm_region_find_or_create (a);
289 
290  ASSERT (db_rp);
291 
292  region_lock (db_rp, 20);
293 
294  oldheap = svm_push_data_heap (db_rp);
295 
296  mheap_trace (db_rp->data_heap, enable_disable);
297 
298  svm_pop_heap (oldheap);
299  region_unlock (db_rp);
300 
301  svm_region_unmap ((void *) db_rp);
302  svm_region_exit ();
303  vec_free (a);
304 }
305 
306 
307 
308 static void
309 subregion_repair (char *chroot_path)
310 {
311  int i;
312  svm_main_region_t *mp;
315  svm_region_t *rp;
316  svm_subregion_t *subp;
317  u8 *name = 0;
318  u8 **svm_names = 0;
319 
320  svm_region_init_chroot (chroot_path);
321  root_rp = svm_get_root_rp ();
322 
323  pthread_mutex_lock (&root_rp->mutex);
324 
325  mp = root_rp->data_base;
326 
327  /*
328  * Snapshoot names, can't hold root rp mutex across
329  * find_or_create.
330  */
331  /* *INDENT-OFF* */
332  pool_foreach (subp, mp->subregions, ({
333  name = vec_dup (subp->subregion_name);
334  vec_add1(svm_names, name);
335  }));
336  /* *INDENT-ON* */
337 
338  pthread_mutex_unlock (&root_rp->mutex);
339 
340  for (i = 0; i < vec_len (svm_names); i++)
341  {
342  memset (&a, 0, sizeof (a));
343  a.root_path = chroot_path;
344  a.name = (char *) svm_names[i];
345  fformat (stdout, "Checking %s region...\n", a.name);
346  rp = svm_existing_region_map_nolock (root_rp, &a);
347  if (rp)
348  {
349  svm_region_unmap (rp);
350  vec_free (svm_names[i]);
351  }
352  }
353  vec_free (svm_names);
354 }
355 
356 void
357 repair (char *chroot_path, int crash_root_region)
358 {
359  svm_region_t *root_rp = 0;
362  int svm_fd;
363  u8 *shm_name;
364 
365  fformat (stdout, "our pid: %d\n", getpid ());
366 
367  vec_validate (a, 0);
368 
369  a->root_path = chroot_path;
373  a->flags = SVM_FLAGS_NODATA;
374 
375  shm_name = shm_name_from_svm_map_region_args (a);
376 
377  svm_fd = shm_open ((char *) shm_name, O_RDWR, 0777);
378 
379  if (svm_fd < 0)
380  {
381  perror ("svm_region_map(mmap open)");
382  goto out;
383  }
384 
385  vec_free (shm_name);
386 
387  root_rp = mmap (0, MMAP_PAGESIZE,
388  PROT_READ | PROT_WRITE, MAP_SHARED, svm_fd, 0);
389 
390  if (root_rp == (svm_region_t *) MAP_FAILED)
391  {
392  close (svm_fd);
393  clib_warning ("mmap");
394  goto out;
395  }
396 
397  /* Remap now that the region has been placed */
398  clib_warning ("remap to 0x%x", root_rp->virtual_base);
399 
400  a->baseva = root_rp->virtual_base;
401  a->size = root_rp->virtual_size;
402  munmap (root_rp, MMAP_PAGESIZE);
403 
404  root_rp = (void *) mmap (uword_to_pointer (a->baseva, void *), a->size,
405  PROT_READ | PROT_WRITE,
406  MAP_SHARED | MAP_FIXED, svm_fd, 0);
407  if ((uword) root_rp == (uword) MAP_FAILED)
408  {
409  clib_unix_warning ("mmap");
410  goto out;
411  }
412 
413  close (svm_fd);
414 
415  if ((uword) root_rp != root_rp->virtual_base)
416  {
417  clib_warning ("mmap botch");
418  goto out;
419  }
420 
421  if (pthread_mutex_trylock (&root_rp->mutex))
422  {
423  clib_warning ("root_rp->mutex LOCKED by pid %d, tag %d, cleared...",
424  root_rp->mutex_owner_pid, root_rp->mutex_owner_tag);
425  memset (&root_rp->mutex, 0, sizeof (root_rp->mutex));
426  goto out;
427  }
428  else
429  {
430  clib_warning ("root_rp->mutex OK...\n");
431  pthread_mutex_unlock (&root_rp->mutex);
432  }
433 
434 out:
435  vec_free (a);
436  /*
437  * Now that the root region is known to be OK,
438  * fix broken subregions
439  */
440  subregion_repair (chroot_path);
441 
442  if (crash_root_region)
443  {
444  clib_warning ("Leaving root region locked on purpose...");
445  pthread_mutex_lock (&root_rp->mutex);
446  root_rp->mutex_owner_pid = getpid ();
447  root_rp->mutex_owner_tag = 99;
448  }
449  svm_region_exit ();
450 }
451 
452 int
453 main (int argc, char **argv)
454 {
455  unformat_input_t input;
456  int parsed = 0;
457  char *name;
458  char *chroot_path = 0;
459  u8 *chroot_u8;
460 
461  unformat_init_command_line (&input, argv);
462 
463  while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
464  {
465  if (unformat (&input, "show-verbose"))
466  {
467  show (chroot_path, 1);
468  parsed++;
469  }
470  else if (unformat (&input, "show"))
471  {
472  show (chroot_path, 0);
473  parsed++;
474  }
475  else if (unformat (&input, "client-scan"))
476  {
477  svm_client_scan (chroot_path);
478  parsed++;
479  }
480  else if (unformat (&input, "repair"))
481  {
482  repair (chroot_path, 0 /* fix it */ );
483  parsed++;
484  }
485  else if (unformat (&input, "crash"))
486  {
487  repair (chroot_path, 1 /* crash it */ );
488  parsed++;
489  }
490  else if (unformat (&input, "trace-on %s", &name))
491  {
492  trace (chroot_path, name, 1);
493  parsed++;
494  }
495  else if (unformat (&input, "trace-off %s", &name))
496  {
497  trace (chroot_path, name, 0);
498  parsed++;
499  }
500  else if (unformat (&input, "chroot %s", &chroot_u8))
501  {
502  chroot_path = (char *) chroot_u8;
503  }
504  else
505  {
506  break;
507  }
508  }
509 
510  unformat_free (&input);
511 
512  if (!parsed)
513  {
514  fformat (stdout,
515  "%s: show | show-verbose | client-scan | trace-on <region-name>\n",
516  argv[0]);
517  fformat (stdout, " trace-off <region-name>\n");
518  }
519  exit (0);
520 }
521 
522 /*
523  * fd.io coding-style-patch-verification: ON
524  *
525  * Local Variables:
526  * eval: (c-set-style "gnu")
527  * End:
528  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
svm_region_t * svm_get_root_rp(void)
Definition: svm.c:54
#define SVM_GLOBAL_REGION_NAME
Definition: svm_common.h:88
const char * root_path
Definition: svm_common.h:67
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
static void svm_pop_heap(void *oldheap)
Definition: svm.h:94
a
Definition: bitmap.h:516
#define SVM_FLAGS_NODATA
Definition: svm_common.h:29
void * svm_map_region(svm_map_region_args_t *a)
Definition: svm.c:441
Fixed length block allocator.
void svm_client_scan(const char *root_path)
Definition: svm.c:1155
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:210
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static void region_unlock(svm_region_t *rp)
Definition: svmtool.c:231
#define SVM_VERSION
Definition: svm_common.h:25
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:376
static void * svm_push_data_heap(svm_region_t *rp)
Definition: svm.h:86
#define always_inline
Definition: clib.h:84
void * svm_region_find_or_create(svm_map_region_args_t *a)
Definition: svm.c:840
#define SVM_GLOBAL_REGION_BASEVA
Definition: svm_common.h:86
unsigned long u64
Definition: types.h:89
u8 * format_svm_region(u8 *s, va_list *args)
Definition: svm.c:143
static void * svm_existing_region_map_nolock(void *root_arg, svm_map_region_args_t *a)
Definition: svmtool.c:242
#define SVM_FLAGS_MHEAP
Definition: svm_common.h:27
void * data_base
Definition: svm_common.h:45
struct _unformat_input_t unformat_input_t
void unformat_init_command_line(unformat_input_t *input, char *argv[])
Definition: unformat.c:1007
svm_subregion_t * subregions
Definition: svm_common.h:105
uword virtual_size
Definition: svm_common.h:43
void svm_region_exit()
Definition: svm.c:1079
#define SVM_GLOBAL_REGION_SIZE
Definition: svm_common.h:87
void repair(char *chroot_path, int crash_root_region)
Definition: svmtool.c:357
word fformat(FILE *f, char *fmt,...)
Definition: format.c:453
static void * svm_map_region_nolock(svm_map_region_args_t *a)
Definition: svmtool.c:124
#define uword_to_pointer(u, type)
Definition: types.h:136
static void * svm_push_pvt_heap(svm_region_t *rp)
Definition: svm.h:78
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
#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:388
int main(int argc, char **argv)
Definition: svmtool.c:453
void svm_region_init_chroot(const char *root_path)
Definition: svm.c:800
void mheap_trace(void *v, int enable)
Definition: mheap.c:1620
#define ASSERT(truth)
u64 size
Definition: vhost-user.h:75
volatile uword version
Definition: svm_common.h:36
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:309
#define MMAP_PAGESIZE
Definition: ssvm.h:42
u64 uword
Definition: types.h:112
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
const char * name
Definition: svm_common.h:68
u8 * format_all_svm_regions(u8 *s, va_list *args)
Definition: svmtool.c:52
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
#define clib_unix_warning(format, args...)
Definition: error.h:68
void svm_region_unmap(void *rp_arg)
Definition: svm.c:959
void show(char *chroot_path, int verbose)
Definition: svmtool.c:105
#define hash_get_mem(h, key)
Definition: hash.h:268
static void region_lock(svm_region_t *rp, int tag)
Definition: svmtool.c:221
void * data_heap
Definition: svm_common.h:46
static void trace(char *chroot_path, char *name, int enable_disable)
Definition: svmtool.c:274
int mutex_owner_pid
Definition: svm_common.h:39
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
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:169
static svm_region_t * root_rp
Definition: svm.c:46