FD.io VPP  v19.04.1-1-ge4a0f9f
Vector Packet Processing
stat_client.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * stat_client.c - Library for access to VPP statistics segment
4  *
5  * Copyright (c) 2018 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 <errno.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <sys/un.h>
25 #include <stdbool.h>
26 #include <sys/stat.h>
27 #include <regex.h>
28 #include <assert.h>
29 #include <vppinfra/vec.h>
30 #include <vppinfra/lock.h>
31 #include "stat_client.h"
32 #include <stdatomic.h>
33 #include <vpp/stats/stat_segment.h>
34 
36 {
37  uint64_t current_epoch;
40  ssize_t memory_size;
41 };
42 
44 
47 {
49  sm = (stat_client_main_t *) malloc (sizeof (stat_client_main_t));
50  clib_memset (sm, 0, sizeof (stat_client_main_t));
51  return sm;
52 }
53 
54 void
56 {
57  free (sm);
58 }
59 
60 static int
61 recv_fd (int sock)
62 {
63  struct msghdr msg = { 0 };
64  struct cmsghdr *cmsg;
65  int fd = -1;
66  char iobuf[1];
67  struct iovec io = {.iov_base = iobuf,.iov_len = sizeof (iobuf) };
68  union
69  {
70  char buf[CMSG_SPACE (sizeof (fd))];
71  struct cmsghdr align;
72  } u;
73  msg.msg_iov = &io;
74  msg.msg_iovlen = 1;
75  msg.msg_control = u.buf;
76  msg.msg_controllen = sizeof (u.buf);
77 
78  ssize_t size;
79  if ((size = recvmsg (sock, &msg, 0)) < 0)
80  {
81  perror ("recvmsg failed");
82  return -1;
83  }
84  cmsg = CMSG_FIRSTHDR (&msg);
85  if (cmsg && cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
86  {
87  memmove (&fd, CMSG_DATA (cmsg), sizeof (fd));
88  }
89  return fd;
90 }
91 
94 {
95  ASSERT (sm->shared_header);
98 }
99 
102 {
104  return get_stat_vector_r (sm);
105 }
106 
107 int
108 stat_segment_connect_r (const char *socket_name, stat_client_main_t * sm)
109 {
110  int mfd = -1;
111  int sock;
112 
113  clib_memset (sm, 0, sizeof (*sm));
114  if ((sock = socket (AF_UNIX, SOCK_SEQPACKET, 0)) < 0)
115  {
116  perror ("Stat client couldn't open socket");
117  return -1;
118  }
119 
120  struct sockaddr_un un = { 0 };
121  un.sun_family = AF_UNIX;
122  strncpy ((char *) un.sun_path, socket_name, sizeof (un.sun_path) - 1);
123  if (connect (sock, (struct sockaddr *) &un, sizeof (struct sockaddr_un)) <
124  0)
125  {
126  close (sock);
127  return -2;
128  }
129 
130  if ((mfd = recv_fd (sock)) < 0)
131  {
132  close (sock);
133  fprintf (stderr, "Receiving file descriptor failed\n");
134  return -3;
135  }
136  close (sock);
137 
138  /* mmap shared memory segment. */
139  void *memaddr;
140  struct stat st = { 0 };
141 
142  if (fstat (mfd, &st) == -1)
143  {
144  close (mfd);
145  perror ("mmap fstat failed");
146  return -4;
147  }
148  if ((memaddr =
149  mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, mfd, 0)) == MAP_FAILED)
150  {
151  close (mfd);
152  perror ("mmap map failed");
153  return -5;
154  }
155 
156  close (mfd);
157  sm->memory_size = st.st_size;
158  sm->shared_header = memaddr;
159  sm->directory_vector =
161 
162  return 0;
163 }
164 
165 int
166 stat_segment_connect (const char *socket_name)
167 {
169  return stat_segment_connect_r (socket_name, sm);
170 }
171 
172 void
174 {
175  munmap (sm->shared_header, sm->memory_size);
176  return;
177 }
178 
179 void
181 {
183  return stat_segment_disconnect_r (sm);
184 }
185 
186 double
188 {
190  double *hb = stat_segment_pointer (sm->shared_header, vec[4].offset);
191  return *hb;
192 }
193 
194 double
196 {
198  return stat_segment_heartbeat_r (sm);
199 }
200 
201 static stat_segment_data_t
203 {
204  stat_segment_data_t result = { 0 };
205  int i;
206  vlib_counter_t **combined_c; /* Combined counter */
207  counter_t **simple_c; /* Simple counter */
208  counter_t *error_base;
209  uint64_t *offset_vector;
210 
211  assert (sm->shared_header);
212 
213  result.type = ep->type;
214  result.name = strdup (ep->name);
215  switch (ep->type)
216  {
218  result.scalar_value = ep->value;
219  break;
220 
222  if (ep->offset == 0)
223  return result;
224  simple_c = stat_segment_pointer (sm->shared_header, ep->offset);
225  result.simple_counter_vec = vec_dup (simple_c);
226  offset_vector =
228  for (i = 0; i < vec_len (simple_c); i++)
229  {
230  counter_t *cb =
231  stat_segment_pointer (sm->shared_header, offset_vector[i]);
232  result.simple_counter_vec[i] = vec_dup (cb);
233  }
234  break;
235 
237  if (ep->offset == 0)
238  return result;
239  combined_c = stat_segment_pointer (sm->shared_header, ep->offset);
240  result.combined_counter_vec = vec_dup (combined_c);
241  offset_vector =
243  for (i = 0; i < vec_len (combined_c); i++)
244  {
245  vlib_counter_t *cb =
246  stat_segment_pointer (sm->shared_header, offset_vector[i]);
247  result.combined_counter_vec[i] = vec_dup (cb);
248  }
249  break;
250 
252  error_base =
255  result.error_value = error_base[ep->index];
256  break;
257 
259  if (ep->offset == 0)
260  return result;
261  uint8_t **name_vector =
263  result.name_vector = vec_dup (name_vector);
264  offset_vector =
266  for (i = 0; i < vec_len (name_vector); i++)
267  {
268  if (offset_vector[i])
269  {
270  u8 *name =
271  stat_segment_pointer (sm->shared_header, offset_vector[i]);
272  result.name_vector[i] = vec_dup (name);
273  }
274  else
275  result.name_vector[i] = 0;
276  }
277  break;
278 
279  default:
280  fprintf (stderr, "Unknown type: %d\n", ep->type);
281  }
282  return result;
283 }
284 
285 void
287 {
288  int i, j;
289  for (i = 0; i < vec_len (res); i++)
290  {
291  switch (res[i].type)
292  {
294  for (j = 0; j < vec_len (res[i].simple_counter_vec); j++)
295  vec_free (res[i].simple_counter_vec[j]);
296  vec_free (res[i].simple_counter_vec);
297  break;
299  for (j = 0; j < vec_len (res[i].combined_counter_vec); j++)
300  vec_free (res[i].combined_counter_vec[j]);
301  vec_free (res[i].combined_counter_vec);
302  break;
303  default:
304  ;
305  }
306  free (res[i].name);
307  }
308  vec_free (res);
309 }
310 
311 
312 typedef struct
313 {
314  uint64_t epoch;
316 
317 static void
319  stat_client_main_t * sm)
320 {
322  sa->epoch = shared_header->epoch;
323  while (shared_header->in_progress != 0)
324  ;
325 }
326 
327 static bool
329 {
331 
332  if (shared_header->epoch != sa->epoch || shared_header->in_progress)
333  return false;
334  return true;
335 }
336 
337 uint32_t *
338 stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm)
339 {
341 
342  uint32_t *dir = 0;
343  regex_t regex[vec_len (patterns)];
344 
345  int i, j;
346  for (i = 0; i < vec_len (patterns); i++)
347  {
348  int rv = regcomp (&regex[i], (const char *) patterns[i], 0);
349  if (rv)
350  {
351  fprintf (stderr, "Could not compile regex %s\n", patterns[i]);
352  return dir;
353  }
354  }
355 
356  stat_segment_access_start (&sa, sm);
357 
359  for (j = 0; j < vec_len (counter_vec); j++)
360  {
361  for (i = 0; i < vec_len (patterns); i++)
362  {
363  int rv = regexec (&regex[i], counter_vec[j].name, 0, NULL, 0);
364  if (rv == 0)
365  {
366  vec_add1 (dir, j);
367  break;
368  }
369  }
370  if (vec_len (patterns) == 0)
371  vec_add1 (dir, j);
372  }
373 
374  for (i = 0; i < vec_len (patterns); i++)
375  regfree (&regex[i]);
376 
377  if (!stat_segment_access_end (&sa, sm))
378  {
379  /* Failed, clean up */
380  vec_free (dir);
381  return 0;
382 
383  }
384 
385  /* Update last version */
386  sm->current_epoch = sa.epoch;
387  return dir;
388 }
389 
390 uint32_t *
391 stat_segment_ls (uint8_t ** patterns)
392 {
394  return stat_segment_ls_r ((uint8_t **) patterns, sm);
395 }
396 
398 stat_segment_dump_r (uint32_t * stats, stat_client_main_t * sm)
399 {
400  int i;
402  stat_segment_data_t *res = 0;
404 
405  /* Has directory been update? */
406  if (sm->shared_header->epoch != sm->current_epoch)
407  return 0;
408 
409  stat_segment_access_start (&sa, sm);
410  for (i = 0; i < vec_len (stats); i++)
411  {
412  /* Collect counter */
413  ep = vec_elt_at_index (sm->directory_vector, stats[i]);
414  vec_add1 (res, copy_data (ep, sm));
415  }
416 
417  if (stat_segment_access_end (&sa, sm))
418  return res;
419 
420  fprintf (stderr, "Epoch changed while reading, invalid results\n");
421  // TODO increase counter
422  return 0;
423 }
424 
426 stat_segment_dump (uint32_t * stats)
427 {
429  return stat_segment_dump_r (stats, sm);
430 }
431 
432 /* Wrapper for accessing vectors from other languages */
433 int
435 {
436  return vec_len (vec);
437 }
438 
439 void
441 {
442  vec_free (vec);
443 }
444 
445 /* Create a vector from a string (or add to existing) */
446 uint8_t **
447 stat_segment_string_vector (uint8_t ** string_vector, const char *string)
448 {
449  uint8_t *name = 0;
450  size_t len = strlen (string);
451 
452  vec_validate_init_c_string (name, string, len);
453  vec_add1 (string_vector, name);
454  return string_vector;
455 }
456 
459 {
461  stat_segment_data_t *res = 0;
463 
464  stat_segment_access_start (&sa, sm);
465 
466  /* Collect counter */
467  ep = vec_elt_at_index (sm->directory_vector, index);
468  vec_add1 (res, copy_data (ep, sm));
469 
470  if (stat_segment_access_end (&sa, sm))
471  return res;
472  return 0;
473 }
474 
476 stat_segment_dump_entry (uint32_t index)
477 {
479  return stat_segment_dump_entry_r (index, sm);
480 }
481 
482 char *
484 {
485  char *name;
488  ep = vec_elt_at_index (counter_vec, index);
489  name = strdup (ep->name);
490  return name;
491 }
492 
493 /*
494  * fd.io coding-style-patch-verification: ON
495  *
496  * Local Variables:
497  * eval: (c-set-style "gnu")
498  * End:
499  */
static stat_segment_directory_entry_t * get_stat_vector(void)
Definition: stat_client.c:101
int stat_segment_connect_r(const char *socket_name, stat_client_main_t *sm)
Definition: stat_client.c:108
Definition: stat_segment.h:53
int stat_segment_connect(const char *socket_name)
Definition: stat_client.c:166
stat_segment_data_t * stat_segment_dump_entry(uint32_t index)
Definition: stat_client.c:476
uint64_t index
Definition: stat_segment.h:58
stat_segment_directory_entry_t * directory_vector
Definition: stat_client.c:39
void stat_client_free(stat_client_main_t *sm)
Definition: stat_client.c:55
void stat_segment_data_free(stat_segment_data_t *res)
Definition: stat_client.c:286
counter_t ** simple_counter_vec
Definition: stat_client.h:50
#define NULL
Definition: clib.h:58
stat_client_main_t stat_client_main
Definition: stat_client.c:43
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
int i
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
unsigned char u8
Definition: types.h:56
atomic_int_fast64_t in_progress
Definition: stat_segment.h:74
#define assert(x)
Definition: dlmalloc.c:30
stat_segment_shared_header_t * shared_header
Definition: stat_client.c:38
uint32_t * stat_segment_ls_r(uint8_t **patterns, stat_client_main_t *sm)
Definition: stat_client.c:338
uint64_t value
Definition: stat_segment.h:59
uint64_t current_epoch
Definition: stat_client.c:37
uint64_t counter_t
64bit counters
Definition: counter_types.h:22
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
uint8_t ** name_vector
Definition: stat_client.h:52
stat_segment_data_t * stat_segment_dump_entry_r(uint32_t index, stat_client_main_t *sm)
Definition: stat_client.c:458
double stat_segment_heartbeat_r(stat_client_main_t *sm)
Definition: stat_client.c:187
uword size
static void * stat_segment_pointer(void *start, uint64_t offset)
Definition: stat_segment.h:87
uint64_t offset
Definition: stat_segment.h:57
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
stat_directory_type_t type
Definition: stat_client.h:45
stat_segment_data_t * stat_segment_dump_r(uint32_t *stats, stat_client_main_t *sm)
Definition: stat_client.c:398
u8 name[64]
Definition: memclnt.api:152
void stat_segment_disconnect(void)
Definition: stat_client.c:180
u8 len
Definition: ip_types.api:49
uint8_t ** stat_segment_string_vector(uint8_t **string_vector, const char *string)
Definition: stat_client.c:447
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
char * stat_segment_index_to_name(uint32_t index)
Definition: stat_client.c:483
uint64_t offset_vector
Definition: stat_segment.h:61
#define vec_validate_init_c_string(V, S, L)
Make a vector containing a NULL terminated c-string.
Definition: vec.h:991
char name[128]
Definition: stat_segment.h:62
uint32_t * stat_segment_ls(uint8_t **patterns)
Definition: stat_client.c:391
#define ASSERT(truth)
static stat_segment_directory_entry_t * get_stat_vector_r(stat_client_main_t *sm)
Definition: stat_client.c:93
stat_segment_data_t * stat_segment_dump(uint32_t *stats)
Definition: stat_client.c:426
static bool stat_segment_access_end(stat_segment_access_t *sa, stat_client_main_t *sm)
Definition: stat_client.c:328
atomic_int_fast64_t epoch
Definition: stat_segment.h:73
static int recv_fd(int sock)
Definition: stat_client.c:61
vlib_counter_t ** combined_counter_vec
Definition: stat_client.h:51
stat_client_main_t * stat_client_get(void)
Definition: stat_client.c:46
void stat_segment_vec_free(void *vec)
Definition: stat_client.c:440
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
uint64_t error_value
Definition: stat_client.h:49
static void stat_segment_access_start(stat_segment_access_t *sa, stat_client_main_t *sm)
Definition: stat_client.c:318
int stat_segment_vec_len(void *vec)
Definition: stat_client.c:434
static stat_segment_data_t copy_data(stat_segment_directory_entry_t *ep, stat_client_main_t *sm)
Definition: stat_client.c:202
atomic_int_fast64_t error_offset
Definition: stat_segment.h:76
double stat_segment_heartbeat(void)
Definition: stat_client.c:195
void stat_segment_disconnect_r(stat_client_main_t *sm)
Definition: stat_client.c:173
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
atomic_int_fast64_t directory_offset
Definition: stat_segment.h:75
stat_directory_type_t type
Definition: stat_segment.h:55