FD.io VPP  v19.01.3-6-g70449b9b9
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  perror ("mmap fstat failed");
145  return -4;
146  }
147  if ((memaddr =
148  mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, mfd, 0)) == MAP_FAILED)
149  {
150  perror ("mmap map failed");
151  return -5;
152  }
153 
154  sm->memory_size = st.st_size;
155  sm->shared_header = memaddr;
156  sm->directory_vector =
158 
159  return 0;
160 }
161 
162 int
163 stat_segment_connect (const char *socket_name)
164 {
166  return stat_segment_connect_r (socket_name, sm);
167 }
168 
169 void
171 {
172  munmap (sm->shared_header, sm->memory_size);
173  return;
174 }
175 
176 void
178 {
180  return stat_segment_disconnect_r (sm);
181 }
182 
183 double
185 {
187  double *hb = stat_segment_pointer (sm->shared_header, vec[4].offset);
188  return *hb;
189 }
190 
191 double
193 {
195  return stat_segment_heartbeat_r (sm);
196 }
197 
200 {
201  stat_segment_data_t result = { 0 };
202  int i;
203  vlib_counter_t **combined_c; /* Combined counter */
204  counter_t **simple_c; /* Simple counter */
205  counter_t *error_base;
206  uint64_t *offset_vector;
207 
208  assert (sm->shared_header);
209 
210  result.type = ep->type;
211  result.name = strdup (ep->name);
212  switch (ep->type)
213  {
215  result.scalar_value = ep->value;
216  break;
217 
219  if (ep->offset == 0)
220  return result;
221  simple_c = stat_segment_pointer (sm->shared_header, ep->offset);
222  result.simple_counter_vec = vec_dup (simple_c);
223  offset_vector =
225  for (i = 0; i < vec_len (simple_c); i++)
226  {
227  counter_t *cb =
228  stat_segment_pointer (sm->shared_header, offset_vector[i]);
229  result.simple_counter_vec[i] = vec_dup (cb);
230  }
231  break;
232 
234  if (ep->offset == 0)
235  return result;
236  combined_c = stat_segment_pointer (sm->shared_header, ep->offset);
237  result.combined_counter_vec = vec_dup (combined_c);
238  offset_vector =
240  for (i = 0; i < vec_len (combined_c); i++)
241  {
242  vlib_counter_t *cb =
243  stat_segment_pointer (sm->shared_header, offset_vector[i]);
244  result.combined_counter_vec[i] = vec_dup (cb);
245  }
246  break;
247 
249  error_base =
252  result.error_value = error_base[ep->index];
253  break;
254 
255  default:
256  fprintf (stderr, "Unknown type: %d", ep->type);
257  }
258  return result;
259 }
260 
261 void
263 {
264  int i, j;
265  for (i = 0; i < vec_len (res); i++)
266  {
267  switch (res[i].type)
268  {
270  for (j = 0; j < vec_len (res[i].simple_counter_vec); j++)
271  vec_free (res[i].simple_counter_vec[j]);
272  vec_free (res[i].simple_counter_vec);
273  break;
275  for (j = 0; j < vec_len (res[i].combined_counter_vec); j++)
276  vec_free (res[i].combined_counter_vec[j]);
277  vec_free (res[i].combined_counter_vec);
278  break;
279  default:
280  ;
281  }
282  free (res[i].name);
283  }
284  vec_free (res);
285 }
286 
287 
288 typedef struct
289 {
290  uint64_t epoch;
292 
293 static void
295  stat_client_main_t * sm)
296 {
298  sa->epoch = shared_header->epoch;
299  while (shared_header->in_progress != 0)
300  ;
301 }
302 
303 static bool
305 {
307 
308  if (shared_header->epoch != sa->epoch || shared_header->in_progress)
309  return false;
310  return true;
311 }
312 
313 uint32_t *
314 stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm)
315 {
317 
318  uint32_t *dir = 0;
319  regex_t regex[vec_len (patterns)];
320 
321  int i, j;
322  for (i = 0; i < vec_len (patterns); i++)
323  {
324  int rv = regcomp (&regex[i], (const char *) patterns[i], 0);
325  if (rv)
326  {
327  fprintf (stderr, "Could not compile regex %s\n", patterns[i]);
328  return dir;
329  }
330  }
331 
332  stat_segment_access_start (&sa, sm);
333 
335  for (j = 0; j < vec_len (counter_vec); j++)
336  {
337  for (i = 0; i < vec_len (patterns); i++)
338  {
339  int rv = regexec (&regex[i], counter_vec[j].name, 0, NULL, 0);
340  if (rv == 0)
341  {
342  vec_add1 (dir, j);
343  break;
344  }
345  }
346  if (vec_len (patterns) == 0)
347  vec_add1 (dir, j);
348  }
349 
350  for (i = 0; i < vec_len (patterns); i++)
351  regfree (&regex[i]);
352 
353  if (!stat_segment_access_end (&sa, sm))
354  {
355  /* Failed, clean up */
356  vec_free (dir);
357  return 0;
358 
359  }
360 
361  /* Update last version */
362  sm->current_epoch = sa.epoch;
363  return dir;
364 }
365 
366 uint32_t *
367 stat_segment_ls (uint8_t ** patterns)
368 {
370  return stat_segment_ls_r ((uint8_t **) patterns, sm);
371 }
372 
374 stat_segment_dump_r (uint32_t * stats, stat_client_main_t * sm)
375 {
376  int i;
378  stat_segment_data_t *res = 0;
380 
381  /* Has directory been update? */
382  if (sm->shared_header->epoch != sm->current_epoch)
383  return 0;
384 
385  stat_segment_access_start (&sa, sm);
386  for (i = 0; i < vec_len (stats); i++)
387  {
388  /* Collect counter */
389  ep = vec_elt_at_index (sm->directory_vector, stats[i]);
390  vec_add1 (res, copy_data (ep, sm));
391  }
392 
393  if (stat_segment_access_end (&sa, sm))
394  return res;
395 
396  fprintf (stderr, "Epoch changed while reading, invalid results\n");
397  // TODO increase counter
398  return 0;
399 }
400 
402 stat_segment_dump (uint32_t * stats)
403 {
405  return stat_segment_dump_r (stats, sm);
406 }
407 
408 /* Wrapper for accessing vectors from other languages */
409 int
411 {
412  return vec_len (vec);
413 }
414 
415 void
417 {
418  vec_free (vec);
419 }
420 
421 /* Create a vector from a string (or add to existing) */
422 uint8_t **
423 stat_segment_string_vector (uint8_t ** string_vector, const char *string)
424 {
425  uint8_t *name = 0;
426  size_t len = strlen (string);
427 
428  vec_validate_init_c_string (name, string, len);
429  vec_add1 (string_vector, name);
430  return string_vector;
431 }
432 
435 {
437  stat_segment_data_t *res = 0;
439 
440  stat_segment_access_start (&sa, sm);
441 
442  /* Collect counter */
443  ep = vec_elt_at_index (sm->directory_vector, index);
444  vec_add1 (res, copy_data (ep, sm));
445 
446  if (stat_segment_access_end (&sa, sm))
447  return res;
448  return 0;
449 }
450 
452 stat_segment_dump_entry (uint32_t index)
453 {
455  return stat_segment_dump_entry_r (index, sm);
456 }
457 
458 char *
460 {
461  char *name;
464  ep = vec_elt_at_index (counter_vec, index);
465  name = strdup (ep->name);
466  return name;
467 }
468 
469 /*
470  * fd.io coding-style-patch-verification: ON
471  *
472  * Local Variables:
473  * eval: (c-set-style "gnu")
474  * End:
475  */
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:49
int stat_segment_connect(const char *socket_name)
Definition: stat_client.c:163
stat_segment_data_t * stat_segment_dump_entry(uint32_t index)
Definition: stat_client.c:452
uint64_t index
Definition: stat_segment.h:54
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:262
counter_t ** simple_counter_vec
Definition: stat_client.h:46
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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:525
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
int i
atomic_int_fast64_t in_progress
Definition: stat_segment.h:70
#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:314
uint64_t value
Definition: stat_segment.h:55
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.
stat_segment_data_t * stat_segment_dump_entry_r(uint32_t index, stat_client_main_t *sm)
Definition: stat_client.c:434
double stat_segment_heartbeat_r(stat_client_main_t *sm)
Definition: stat_client.c:184
uword size
static void * stat_segment_pointer(void *start, uint64_t offset)
Definition: stat_segment.h:83
uint64_t offset
Definition: stat_segment.h:53
#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:41
stat_segment_data_t * stat_segment_dump_r(uint32_t *stats, stat_client_main_t *sm)
Definition: stat_client.c:374
u8 name[64]
Definition: memclnt.api:152
void stat_segment_disconnect(void)
Definition: stat_client.c:177
u8 len
Definition: ip_types.api:49
uint8_t ** stat_segment_string_vector(uint8_t **string_vector, const char *string)
Definition: stat_client.c:423
#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:459
uint64_t offset_vector
Definition: stat_segment.h:57
#define vec_validate_init_c_string(V, S, L)
Make a vector containing a NULL terminated c-string.
Definition: vec.h:995
char name[128]
Definition: stat_segment.h:58
uint32_t * stat_segment_ls(uint8_t **patterns)
Definition: stat_client.c:367
stat_segment_data_t copy_data(stat_segment_directory_entry_t *ep, stat_client_main_t *sm)
Definition: stat_client.c:199
#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:402
static bool stat_segment_access_end(stat_segment_access_t *sa, stat_client_main_t *sm)
Definition: stat_client.c:304
atomic_int_fast64_t epoch
Definition: stat_segment.h:69
static int recv_fd(int sock)
Definition: stat_client.c:61
vlib_counter_t ** combined_counter_vec
Definition: stat_client.h:47
stat_client_main_t * stat_client_get(void)
Definition: stat_client.c:46
void stat_segment_vec_free(void *vec)
Definition: stat_client.c:416
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
uint64_t error_value
Definition: stat_client.h:45
static void stat_segment_access_start(stat_segment_access_t *sa, stat_client_main_t *sm)
Definition: stat_client.c:294
int stat_segment_vec_len(void *vec)
Definition: stat_client.c:410
atomic_int_fast64_t error_offset
Definition: stat_segment.h:72
double stat_segment_heartbeat(void)
Definition: stat_client.c:192
void stat_segment_disconnect_r(stat_client_main_t *sm)
Definition: stat_client.c:170
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
atomic_int_fast64_t directory_offset
Definition: stat_segment.h:71
stat_directory_type_t type
Definition: stat_segment.h:51