FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * api.c - message handler registration
4  *
5  * Copyright (c) 2010-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 <stdlib.h>
22 #include <string.h>
23 #include <sys/types.h>
24 #include <sys/mman.h>
25 #include <sys/stat.h>
26 #include <netinet/in.h>
27 #include <signal.h>
28 #include <pthread.h>
29 #include <unistd.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #include <string.h>
33 #include <pwd.h>
34 #include <grp.h>
35 
36 #include <vppinfra/clib.h>
37 #include <vppinfra/vec.h>
38 #include <vppinfra/hash.h>
39 #include <vppinfra/bitmap.h>
40 #include <vppinfra/fifo.h>
41 #include <vppinfra/time.h>
42 #include <vppinfra/heap.h>
43 #include <vppinfra/pool.h>
44 #include <vppinfra/format.h>
45 #include <vppinfra/error.h>
46 
47 #include <vnet/api_errno.h>
48 #include <vnet/vnet.h>
49 
50 #include <vlib/log.h>
51 #include <vlib/vlib.h>
52 #include <vlib/unix/unix.h>
53 #include <vlibapi/api.h>
54 #include <vlibmemory/api.h>
55 
56 #undef BIHASH_TYPE
57 #undef __included_bihash_template_h__
58 
59 #include <vnet/ip/format.h>
60 
61 #include <vpp/api/vpe_msg_enum.h>
62 #include <vpp/api/types.h>
63 
64 #define vl_typedefs /* define message structures */
65 #include <vpp/api/vpe_all_api_h.h>
66 #undef vl_typedefs
67 #define vl_endianfun /* define message structures */
68 #include <vpp/api/vpe_all_api_h.h>
69 #undef vl_endianfun
70 /* instantiate all the print functions we know about */
71 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
72 #define vl_printfun
73 #include <vpp/api/vpe_all_api_h.h>
74 #undef vl_printfun
76 
77 #define foreach_vpe_api_msg \
78 _(CONTROL_PING, control_ping) \
79 _(CLI, cli) \
80 _(CLI_INBAND, cli_inband) \
81 _(GET_NODE_INDEX, get_node_index) \
82 _(ADD_NODE_NEXT, add_node_next) \
83 _(SHOW_VERSION, show_version) \
84 _(SHOW_THREADS, show_threads) \
85 _(GET_NODE_GRAPH, get_node_graph) \
86 _(GET_NEXT_INDEX, get_next_index) \
87 _(LOG_DUMP, log_dump) \
88 _(SHOW_VPE_SYSTEM_TIME, show_vpe_system_time) \
89 _(GET_F64_ENDIAN_VALUE, get_f64_endian_value) \
90 _(GET_F64_INCREMENT_BY_ONE, get_f64_increment_by_one) \
91 
92 #define QUOTE_(x) #x
93 #define QUOTE(x) QUOTE_(x)
94 
95 typedef enum
96 {
99 } resolve_t;
100 
102 
103 /* Clean up all registrations belonging to the indicated client */
104 static clib_error_t *
106 {
109  uword *p;
110 
111 #define _(a) \
112  p = hash_get (vam->a##_registration_hash, client_index); \
113  if (p) { \
114  rp = pool_elt_at_index (vam->a##_registrations, p[0]); \
115  pool_put (vam->a##_registrations, rp); \
116  hash_unset (vam->a##_registration_hash, client_index); \
117  }
119 #undef _
120  return 0;
121 }
122 
124 
125 static void
127 {
129  int rv = 0;
130 
131  /* *INDENT-OFF* */
132  REPLY_MACRO2(VL_API_CONTROL_PING_REPLY,
133  ({
134  rmp->vpe_pid = ntohl (getpid());
135  }));
136  /* *INDENT-ON* */
137 }
138 
139 static void
140 shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
141 {
142  u8 **shmem_vecp = (u8 **) arg;
143  u8 *shmem_vec;
144  void *oldheap;
145  u32 offset;
146 
147  shmem_vec = *shmem_vecp;
148 
149  offset = vec_len (shmem_vec);
150 
151  oldheap = vl_msg_push_heap ();
152 
153  vec_validate (shmem_vec, offset + buffer_bytes - 1);
154 
155  clib_memcpy (shmem_vec + offset, buffer, buffer_bytes);
156 
157  vl_msg_pop_heap (oldheap);
158 
159  *shmem_vecp = shmem_vec;
160 }
161 
162 
163 static void
165 {
166  vl_api_cli_reply_t *rp;
169  unformat_input_t input;
170  u8 *shmem_vec = 0;
171  void *oldheap;
172 
174  if (!reg)
175  return;;
176 
177  rp = vl_msg_api_alloc (sizeof (*rp));
178  rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY);
179  rp->context = mp->context;
180 
181  unformat_init_vector (&input, (u8 *) (uword) mp->cmd_in_shmem);
182 
183  vlib_cli_input (vm, &input, shmem_cli_output, (uword) & shmem_vec);
184 
185  oldheap = vl_msg_push_heap ();
186  vec_add1 (shmem_vec, 0);
187  vl_msg_pop_heap (oldheap);
188 
189  rp->reply_in_shmem = (uword) shmem_vec;
190 
191  vl_api_send_msg (reg, (u8 *) rp);
192 }
193 
194 static void
195 inband_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
196 {
197  u8 **mem_vecp = (u8 **) arg;
198  u8 *mem_vec = *mem_vecp;
199  u32 offset = vec_len (mem_vec);
200 
201  vec_validate (mem_vec, offset + buffer_bytes - 1);
202  clib_memcpy (mem_vec + offset, buffer, buffer_bytes);
203  *mem_vecp = mem_vec;
204 }
205 
206 static void
208 {
210  int rv = 0;
212  unformat_input_t input;
213  u8 *out_vec = 0;
214  u8 *cmd_vec = 0;
215 
216  if (vl_msg_api_get_msg_length (mp) <
217  vl_api_string_len (&mp->cmd) + sizeof (*mp))
218  {
219  rv = -1;
220  goto error;
221  }
222 
223  cmd_vec = vl_api_from_api_to_new_vec (mp, &mp->cmd);
224 
225  unformat_init_string (&input, (char *) cmd_vec,
226  vl_api_string_len (&mp->cmd));
227  rv = vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec);
228  unformat_free (&input);
229 
230 error:
231  /* *INDENT-OFF* */
232  REPLY_MACRO3(VL_API_CLI_INBAND_REPLY, vec_len (out_vec),
233  ({
234  vl_api_vec_to_api_string(out_vec, &rmp->reply);
235  }));
236  /* *INDENT-ON* */
237  vec_free (out_vec);
238  vec_free (cmd_vec);
239 }
240 
241 static void
243 {
245  int rv = 0;
246  char *vpe_api_get_build_directory (void);
247  char *vpe_api_get_version (void);
248  char *vpe_api_get_build_date (void);
249 
250  /* *INDENT-OFF* */
251  REPLY_MACRO2(VL_API_SHOW_VERSION_REPLY,
252  ({
253  strncpy ((char *) rmp->program, "vpe", ARRAY_LEN(rmp->program)-1);
254  strncpy ((char *) rmp->build_directory, vpe_api_get_build_directory(),
255  ARRAY_LEN(rmp->build_directory)-1);
256  strncpy ((char *) rmp->version, vpe_api_get_version(),
257  ARRAY_LEN(rmp->version)-1);
258  strncpy ((char *) rmp->build_date, vpe_api_get_build_date(),
259  ARRAY_LEN(rmp->build_date)-1);
260  }));
261  /* *INDENT-ON* */
262 }
263 
264 static void
265 get_thread_data (vl_api_thread_data_t * td, int index)
266 {
268  td->id = htonl (index);
269  if (w->name)
270  strncpy ((char *) td->name, (char *) w->name, ARRAY_LEN (td->name) - 1);
271  if (w->registration)
272  strncpy ((char *) td->type, (char *) w->registration->name,
273  ARRAY_LEN (td->type) - 1);
274  td->pid = htonl (w->lwp);
275  td->cpu_id = htonl (w->cpu_id);
276  td->core = htonl (w->core_id);
277  td->cpu_socket = htonl (w->numa_id);
278 }
279 
280 static void
282 {
283  int count = 0;
284 
285 #if !defined(__powerpc64__)
288  vl_api_thread_data_t *td;
289  int i, msg_size = 0;
291  if (!count)
292  return;
293 
294  msg_size = sizeof (*rmp) + sizeof (rmp->thread_data[0]) * count;
296  if (!reg)
297  return;
298 
299  rmp = vl_msg_api_alloc (msg_size);
300  clib_memset (rmp, 0, msg_size);
301  rmp->_vl_msg_id = htons (VL_API_SHOW_THREADS_REPLY);
302  rmp->context = mp->context;
303  rmp->count = htonl (count);
304  td = rmp->thread_data;
305 
306  for (i = 0; i < count; i++)
307  {
308  get_thread_data (&td[i], i);
309  }
310 
311  vl_api_send_msg (reg, (u8 *) rmp);
312 #else
313 
314  /* unimplemented support */
315  rv = -9;
316  clib_warning ("power pc does not support show threads api");
317  /* *INDENT-OFF* */
318  REPLY_MACRO2(VL_API_SHOW_THREADS_REPLY,
319  ({
320  rmp->count = htonl(count);
321  }));
322  /* *INDENT-ON* */
323 #endif
324 }
325 
326 static void
328 {
331  vlib_node_t *n;
332  int rv = 0;
333  u32 node_index = ~0;
334 
336 
337  if (n == 0)
338  rv = VNET_API_ERROR_NO_SUCH_NODE;
339  else
340  node_index = n->index;
341 
342  /* *INDENT-OFF* */
343  REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
344  ({
345  rmp->node_index = htonl(node_index);
346  }));
347  /* *INDENT-ON* */
348 }
349 
350 static void
352 {
355  vlib_node_t *node, *next_node;
356  int rv = 0;
357  u32 next_node_index = ~0, next_index = ~0;
358  uword *p;
359 
361 
362  if (node == 0)
363  {
364  rv = VNET_API_ERROR_NO_SUCH_NODE;
365  goto out;
366  }
367 
368  next_node = vlib_get_node_by_name (vm, mp->next_name);
369 
370  if (next_node == 0)
371  {
372  rv = VNET_API_ERROR_NO_SUCH_NODE2;
373  goto out;
374  }
375  else
376  next_node_index = next_node->index;
377 
378  p = hash_get (node->next_slot_by_node, next_node_index);
379 
380  if (p == 0)
381  {
382  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
383  goto out;
384  }
385  else
386  next_index = p[0];
387 
388 out:
389  /* *INDENT-OFF* */
390  REPLY_MACRO2(VL_API_GET_NEXT_INDEX_REPLY,
391  ({
392  rmp->next_index = htonl(next_index);
393  }));
394  /* *INDENT-ON* */
395 }
396 
397 static void
399 {
402  vlib_node_t *n, *next;
403  int rv = 0;
404  u32 next_index = ~0;
405 
407 
408  if (n == 0)
409  {
410  rv = VNET_API_ERROR_NO_SUCH_NODE;
411  goto out;
412  }
413 
415 
416  if (next == 0)
417  rv = VNET_API_ERROR_NO_SUCH_NODE2;
418  else
419  next_index = vlib_node_add_next (vm, n->index, next->index);
420 
421 out:
422  /* *INDENT-OFF* */
423  REPLY_MACRO2(VL_API_ADD_NODE_NEXT_REPLY,
424  ({
425  rmp->next_index = htonl(next_index);
426  }));
427  /* *INDENT-ON* */
428 }
429 
430 static void
432 {
433  int rv = 0;
434  u8 *vector = 0;
436  void *oldheap;
438  static vlib_node_t ***node_dups;
439  static vlib_main_t **stat_vms;
440 
441  oldheap = vl_msg_push_heap ();
442 
443  /*
444  * Keep the number of memcpy ops to a minimum (e.g. 1).
445  */
446  vec_validate (vector, 16384);
447  vec_reset_length (vector);
448 
449  vlib_node_get_nodes (vm, 0 /* main threads */ ,
450  0 /* include stats */ ,
451  1 /* barrier sync */ ,
452  &node_dups, &stat_vms);
453  vector = vlib_node_serialize (vm, node_dups, vector, 1 /* include nexts */ ,
454  1 /* include stats */ );
455 
456  vl_msg_pop_heap (oldheap);
457 
458  /* *INDENT-OFF* */
459  REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY,
460  ({
461  rmp->reply_in_shmem = (uword) vector;
462  }));
463  /* *INDENT-ON* */
464 }
465 
466 static void
468  f64 timestamp,
469  vl_api_log_level_t * level, u8 * msg_class, u8 * message)
470 {
471  u32 msg_size;
472 
474  int class_len =
475  clib_min (vec_len (msg_class) + 1, ARRAY_LEN (rmp->msg_class));
476  int message_len =
477  clib_min (vec_len (message) + 1, ARRAY_LEN (rmp->message));
478  msg_size = sizeof (*rmp) + class_len + message_len;
479 
480  rmp = vl_msg_api_alloc (msg_size);
481  clib_memset (rmp, 0, msg_size);
482  rmp->_vl_msg_id = ntohs (VL_API_LOG_DETAILS);
483 
484  rmp->context = context;
486  rmp->level = htonl (*level);
487 
488  memcpy (rmp->msg_class, msg_class, class_len - 1);
489  memcpy (rmp->message, message, message_len - 1);
490  /* enforced by memset() above */
491  ASSERT (0 == rmp->msg_class[class_len - 1]);
492  ASSERT (0 == rmp->message[message_len - 1]);
493 
494  vl_api_send_msg (reg, (u8 *) rmp);
495 }
496 
497 static void
499 {
500 
501  /* from log.c */
502  vlib_log_main_t *lm = &log_main;
503  vlib_log_entry_t *e;
504  int i = last_log_entry ();
505  int count = lm->count;
506  f64 time_offset, start_time;
508 
510  if (reg == 0)
511  return;
512 
513  start_time = clib_net_to_host_f64 (mp->start_timestamp);
514 
515  time_offset = (f64) lm->time_zero_timeval.tv_sec
516  + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero;
517 
518  while (count--)
519  {
520  e = vec_elt_at_index (lm->entries, i);
521  if (start_time <= e->timestamp + time_offset)
522  show_log_details (reg, mp->context, e->timestamp + time_offset,
523  (vl_api_log_level_t *) & e->level,
524  format (0, "%U", format_vlib_log_class, e->class),
525  e->string);
526  i = (i + 1) % lm->size;
527  }
528 
529 }
530 
531 static void
533 {
534  int rv = 0;
536  /* *INDENT-OFF* */
537  REPLY_MACRO2(VL_API_SHOW_VPE_SYSTEM_TIME_REPLY,
538  ({
540  }));
541  /* *INDENT-ON* */
542 }
543 
544 static void
546 {
547  int rv = 0;
548  f64 one = 1.0;
550  if (1.0 != clib_net_to_host_f64 (mp->f64_one))
551  rv = VNET_API_ERROR_API_ENDIAN_FAILED;
552 
553  /* *INDENT-OFF* */
554  REPLY_MACRO2(VL_API_GET_F64_ENDIAN_VALUE_REPLY,
555  ({
557  }));
558  /* *INDENT-ON* */
559 }
560 
561 static void
563  mp)
564 {
565  int rv = 0;
567 
568  /* *INDENT-OFF* */
569  REPLY_MACRO2(VL_API_GET_F64_INCREMENT_BY_ONE_REPLY,
570  ({
572  }));
573  /* *INDENT-ON* */
574 }
575 
576 #define BOUNCE_HANDLER(nn) \
577 static void vl_api_##nn##_t_handler ( \
578  vl_api_##nn##_t *mp) \
579 { \
580  vpe_client_registration_t *reg; \
581  vpe_api_main_t * vam = &vpe_api_main; \
582  svm_queue_t * q; \
583  \
584  /* One registration only... */ \
585  pool_foreach (reg, vam->nn##_registrations) \
586  ({ \
587  q = vl_api_client_index_to_input_queue (reg->client_index); \
588  if (q) { \
589  /* \
590  * If the queue is stuffed, turf the msg and complain \
591  * It's unlikely that the intended recipient is \
592  * alive; avoid deadlock at all costs. \
593  */ \
594  if (q->cursize == q->maxsize) { \
595  clib_warning ("ERROR: receiver queue full, drop msg"); \
596  vl_msg_api_free (mp); \
597  return; \
598  } \
599  vl_msg_api_send_shmem (q, (u8 *)&mp); \
600  return; \
601  } \
602  })); \
603  vl_msg_api_free (mp); \
604 }
605 
606 static void setup_message_id_table (api_main_t * am);
607 
608 /*
609  * vpe_api_hookup
610  * Add vpe's API message handlers to the table.
611  * vlib has already mapped shared memory and
612  * added the client registration handlers.
613  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
614  */
615 static clib_error_t *
617 {
619 
620 #define _(N,n) \
621  vl_msg_api_set_handlers(VL_API_##N, #n, \
622  vl_api_##n##_t_handler, \
623  vl_noop_handler, \
624  vl_api_##n##_t_endian, \
625  vl_api_##n##_t_print, \
626  sizeof(vl_api_##n##_t), 1);
628 #undef _
629 
630  /*
631  * Trace space for classifier mask+match
632  */
633  am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_TABLE].size += 5 * sizeof (u32x4);
634  am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size +=
635  5 * sizeof (u32x4);
636 
637  /*
638  * Thread-safe API messages
639  */
640  am->is_mp_safe[VL_API_CONTROL_PING] = 1;
641  am->is_mp_safe[VL_API_CONTROL_PING_REPLY] = 1;
642  am->is_mp_safe[VL_API_IP_ROUTE_ADD_DEL] = 1;
643  am->is_mp_safe[VL_API_GET_NODE_GRAPH] = 1;
644 
645  /*
646  * Set up the (msg_name, crc, message-id) table
647  */
649 
650  return 0;
651 }
652 
654 
655 clib_error_t *
657 {
659 
660  am->vlib_main = vm;
661  am->vnet_main = vnet_get_main ();
662 #define _(a) \
663  am->a##_registration_hash = hash_create (0, sizeof (uword));
665 #undef _
666 
667  vl_set_memory_region_name ("/vpe-api");
668  vl_mem_api_enable_disable (vm, 1 /* enable it */ );
669 
670  return 0;
671 }
672 
673 static clib_error_t *
675 {
676  u8 *chroot_path;
677  u64 baseva, size, pvt_heap_size;
678  int uid, gid, rv;
679  const int max_buf_size = 4096;
680  char *s, *buf;
681  struct passwd _pw, *pw;
682  struct group _grp, *grp;
683  clib_error_t *e;
684  buf = vec_new (char, 128);
686  {
687  if (unformat (input, "prefix %s", &chroot_path))
688  {
689  vec_add1 (chroot_path, 0);
690  vl_set_memory_root_path ((char *) chroot_path);
691  }
692  else if (unformat (input, "uid %d", &uid))
693  vl_set_memory_uid (uid);
694  else if (unformat (input, "gid %d", &gid))
695  vl_set_memory_gid (gid);
696  else if (unformat (input, "baseva %llx", &baseva))
698  else if (unformat (input, "global-size %lldM", &size))
699  vl_set_global_memory_size (size * (1ULL << 20));
700  else if (unformat (input, "global-size %lldG", &size))
701  vl_set_global_memory_size (size * (1ULL << 30));
702  else if (unformat (input, "global-size %lld", &size))
704  else if (unformat (input, "global-pvt-heap-size %lldM", &pvt_heap_size))
705  vl_set_global_pvt_heap_size (pvt_heap_size * (1ULL << 20));
706  else if (unformat (input, "global-pvt-heap-size size %lld",
707  &pvt_heap_size))
708  vl_set_global_pvt_heap_size (pvt_heap_size);
709  else if (unformat (input, "api-pvt-heap-size %lldM", &pvt_heap_size))
710  vl_set_api_pvt_heap_size (pvt_heap_size * (1ULL << 20));
711  else if (unformat (input, "api-pvt-heap-size size %lld",
712  &pvt_heap_size))
713  vl_set_api_pvt_heap_size (pvt_heap_size);
714  else if (unformat (input, "api-size %lldM", &size))
715  vl_set_api_memory_size (size * (1ULL << 20));
716  else if (unformat (input, "api-size %lldG", &size))
717  vl_set_api_memory_size (size * (1ULL << 30));
718  else if (unformat (input, "api-size %lld", &size))
720  else if (unformat (input, "uid %s", &s))
721  {
722  /* lookup the username */
723  pw = NULL;
724  while (((rv =
725  getpwnam_r (s, &_pw, buf, vec_len (buf), &pw)) == ERANGE)
726  && (vec_len (buf) <= max_buf_size))
727  {
728  vec_resize (buf, vec_len (buf) * 2);
729  }
730  if (rv < 0)
731  {
732  e = clib_error_return_code (0, rv,
735  "cannot fetch username %s", s);
736  vec_free (s);
737  vec_free (buf);
738  return e;
739  }
740  if (pw == NULL)
741  {
742  e =
743  clib_error_return_fatal (0, "username %s does not exist", s);
744  vec_free (s);
745  vec_free (buf);
746  return e;
747  }
748  vec_free (s);
749  vl_set_memory_uid (pw->pw_uid);
750  }
751  else if (unformat (input, "gid %s", &s))
752  {
753  /* lookup the group name */
754  grp = NULL;
755  while (((rv =
756  getgrnam_r (s, &_grp, buf, vec_len (buf),
757  &grp)) == ERANGE)
758  && (vec_len (buf) <= max_buf_size))
759  {
760  vec_resize (buf, vec_len (buf) * 2);
761  }
762  if (rv != 0)
763  {
764  e = clib_error_return_code (0, rv,
767  "cannot fetch group %s", s);
768  vec_free (s);
769  vec_free (buf);
770  return e;
771  }
772  if (grp == NULL)
773  {
774  e = clib_error_return_fatal (0, "group %s does not exist", s);
775  vec_free (s);
776  vec_free (buf);
777  return e;
778  }
779  vec_free (s);
780  vec_free (buf);
781  vl_set_memory_gid (grp->gr_gid);
782  }
783  else
784  return clib_error_return (0, "unknown input `%U'",
785  format_unformat_error, input);
786  }
787  return 0;
788 }
789 
791 
792 void *
794 {
795  return (void *) &unformat_vnet_sw_interface;
796 }
797 
798 #define vl_msg_name_crc_list
800 #undef vl_msg_name_crc_list
801 
802 static void
804 {
805 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
806  foreach_vl_msg_name_crc_memclnt;
807  foreach_vl_msg_name_crc_vpe;
808 #undef _
809 
810 #define vl_api_version_tuple(n,mj, mi, p) \
811  vl_msg_api_add_version (am, #n, mj, mi, p);
812 #include <vpp/api/vpe_all_api_h.h>
813 #undef vl_api_version_tuple
814 }
815 
816 
817 /*
818  * fd.io coding-style-patch-verification: ON
819  *
820  * Local Variables:
821  * eval: (c-set-style "gnu")
822  * End:
823  */
vl_api_control_ping_t_handler
static void vl_api_control_ping_t_handler(vl_api_control_ping_t *mp)
Definition: api.c:126
vec_reset_length
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Definition: vec_bootstrap.h:194
vlib_log_entry_t::level
vlib_log_level_t level
Definition: log.h:44
vlib.h
vl_api_cli_t_handler
static void vl_api_cli_t_handler(vl_api_cli_t *mp)
Definition: api.c:164
vlib_node_get_nodes
void vlib_node_get_nodes(vlib_main_t *vm, u32 max_threads, int include_stats, int barrier_sync, vlib_node_t ****node_dupsp, vlib_main_t ***stat_vmsp)
Get list of nodes.
Definition: node.c:603
vpe_api_main
vpe_api_main_t vpe_api_main
Definition: interface_api.c:55
vlib_log_main_t::count
int count
Definition: log.h:97
vl_api_show_threads_t
show_threads display the information about vpp threads running on system along with their process id,...
Definition: vpe.api:198
foreach_registration_hash
#define foreach_registration_hash
Definition: api_helper_macros.h:394
vl_api_add_node_next_reply_t::next_index
u32 next_index
Definition: vpe.api:163
vl_api_client_index_to_registration
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
api.h
vlib_log_main_t::entries
vlib_log_entry_t * entries
Definition: log.h:95
vl_api_add_node_next_t::node_name
string node_name[64]
Definition: vpe.api:150
while
while(n_left_from > 0)
Definition: nat44_ei_hairpinning.c:419
vpe_api_get_build_date
char * vpe_api_get_build_date(void)
return the build date
Definition: version.c:161
unix_time_now
static f64 unix_time_now(void)
Definition: time.h:255
unformat_init_vector
void unformat_init_vector(unformat_input_t *input, u8 *vector_string)
Definition: unformat.c:1037
vl_api_get_f64_increment_by_one_t::f64_value
f64 f64_value[default=1.0]
Definition: vpe.api:357
ntohs
#define ntohs(x)
Definition: af_xdp.bpf.c:29
vl_api_cli_t::cmd_in_shmem
u64 cmd_in_shmem
Definition: vpe.api:89
vl_api_get_next_index_reply_t::next_index
u32 next_index
Definition: vpe.api:285
buffer
char * buffer
Definition: cJSON.h:163
REPLY_MACRO2
#define REPLY_MACRO2(t, body)
Definition: api_helper_macros.h:65
vlib_node_add_next
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1177
vec_new
#define vec_new(T, N)
Create new vector of given type and length (unspecified alignment, no header).
Definition: vec.h:365
vl_api_show_vpe_system_time_reply_t
Reply for show vpe system time.
Definition: vpe.api:317
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
vl_api_log_dump_t::start_timestamp
vl_api_timestamp_t start_timestamp
Definition: vpe.api:291
vl_api_send_msg
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
vl_api_show_vpe_system_time_t
Show the current system timestamp.
Definition: vpe.api:306
vpe_api_hookup
static clib_error_t * vpe_api_hookup(vlib_main_t *vm)
Definition: api.c:612
clib_host_to_net_f64
static f64 clib_host_to_net_f64(f64 x)
Definition: byte_order.h:178
vl_api_show_threads_reply_t::count
u32 count
Definition: vpe.api:237
bitmap.h
clib.h
vl_api_cli_inband_t
Definition: vpe.api:91
next
u16 * next
Definition: nat44_ei_out2in.c:718
string.h
vpe_api_main_t
Definition: api_helper_macros.h:414
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
vl_api_get_node_graph_t_handler
static void vl_api_get_node_graph_t_handler(vl_api_get_node_graph_t *mp)
Definition: api.c:431
CLIB_ERROR_FATAL
@ CLIB_ERROR_FATAL
Definition: error_bootstrap.h:48
vl_api_cli_t::client_index
u32 client_index
Definition: vpe.api:87
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
vl_api_log_details_t::message
string message[256]
Definition: vpe.api:299
api_segment_config
static clib_error_t * api_segment_config(vlib_main_t *vm, unformat_input_t *input)
Definition: api.c:670
vl_api_log_details_t::level
vl_api_log_level_t level
Definition: vpe.api:297
memclnt_delete_callback
static clib_error_t * memclnt_delete_callback(u32 client_index)
Definition: api.c:105
foreach_vpe_api_msg
#define foreach_vpe_api_msg
Definition: api.c:77
vl_api_get_next_index_t
Query relative index via node names.
Definition: vpe.api:268
am
app_main_t * am
Definition: application.c:489
vl_api_get_next_index_t::node_name
string node_name[64]
Definition: vpe.api:272
vl_set_memory_uid
void vl_set_memory_uid(int uid)
Definition: memory_shared.c:351
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
api.h
fifo.h
node_index
node node_index
Definition: interface_output.c:420
shmem_cli_output
static void shmem_cli_output(uword arg, u8 *buffer, uword buffer_bytes)
Definition: api.c:140
vl_api_add_node_next_t::next_name
string next_name[64]
Definition: vpe.api:151
unformat_input_t
struct _unformat_input_t unformat_input_t
vl_api_log_details_t::msg_class
string msg_class[32]
Definition: vpe.api:298
vlib_worker_threads
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:35
vl_api_get_node_graph_reply_t
get_node_graph_reply
Definition: vpe.api:255
RESOLVE_IP4_ADD_DEL_ROUTE
@ RESOLVE_IP4_ADD_DEL_ROUTE
Definition: api.c:97
error
Definition: cJSON.c:88
VLIB_EARLY_CONFIG_FUNCTION
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
Definition: init.h:220
vpe_api_get_version
char * vpe_api_get_version(void)
Return the image version string.
Definition: version.c:154
vl_api_add_node_next_t
Set the next node for a given node request.
Definition: vpe.api:146
vl_set_global_pvt_heap_size
void vl_set_global_pvt_heap_size(u64 size)
Definition: memory_shared.c:391
resolve_t
resolve_t
Definition: api.c:95
vl_set_api_pvt_heap_size
void vl_set_api_pvt_heap_size(u64 size)
Definition: memory_shared.c:399
vlib_worker_thread_t::core_id
int core_id
Definition: threads.h:111
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
vpe_api_get_build_directory
char * vpe_api_get_build_directory(void)
Return the image build directory name.
Definition: version.c:147
vl_api_control_ping_reply_t
Control ping from the client to the server response.
Definition: vpe.api:72
vlib_log_entry_t::class
vlib_log_class_t class
Definition: log.h:45
vl_api_get_next_index_t_handler
static void vl_api_get_next_index_t_handler(vl_api_get_next_index_t *mp)
Definition: api.c:351
clib_error_return_code
#define clib_error_return_code(e, code, flags, args...)
Definition: error.h:93
count
u8 count
Definition: dhcp.api:208
vl_set_memory_region_name
void vl_set_memory_region_name(const char *name)
Definition: memory_api.c:980
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
unformat_free
static void unformat_free(unformat_input_t *i)
Definition: format.h:155
vl_msg_api_get_msg_length
u32 vl_msg_api_get_msg_length(void *msg_arg)
Definition: api_shared.c:791
vlib_node_t::index
u32 index
Definition: node.h:269
error.h
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
vec_elt_at_index
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
Definition: vec_bootstrap.h:203
vnet_get_main
vnet_main_t * vnet_get_main(void)
Definition: pnat_test_stubs.h:56
vl_api_get_node_index_t
Get node index using name request.
Definition: vpe.api:121
format.h
offset
struct clib_bihash_value offset
template key/value backing page structure
vl_api_get_f64_increment_by_one_t_handler
static void vl_api_get_f64_increment_by_one_t_handler(vl_api_get_f64_increment_by_one_t *mp)
Definition: api.c:562
vl_api_registration_
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
ARRAY_LEN
#define ARRAY_LEN(x)
Definition: clib.h:70
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
vlib_config_function_runtime_t
Definition: init.h:68
vl_api_get_node_index_t::node_name
string node_name[64]
Definition: vpe.api:125
vl_api_show_version_t_handler
static void vl_api_show_version_t_handler(vl_api_show_version_t *mp)
Definition: api.c:242
log.h
vl_api_show_version_reply_t::program
string program[32]
Definition: vpe.api:187
last_log_entry
int last_log_entry()
Definition: log.c:62
uword
u64 uword
Definition: types.h:112
vl_api_get_f64_endian_value_t
f64 types are not standardized across the wire.
Definition: vpe.api:329
RESOLVE_IP6_ADD_DEL_ROUTE
@ RESOLVE_IP6_ADD_DEL_ROUTE
Definition: api.c:98
vlib_worker_thread_t::cpu_id
int cpu_id
Definition: threads.h:110
hash_get
#define hash_get(h, key)
Definition: hash.h:249
vlib_cli_input
int vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
Definition: cli.c:675
vl_api_cli_reply_t
vpe parser cli string response
Definition: vpe.api:103
CLIB_ERROR_ERRNO_VALID
@ CLIB_ERROR_ERRNO_VALID
Definition: error_bootstrap.h:51
vl_api_get_f64_endian_value_t_handler
static void vl_api_get_f64_endian_value_t_handler(vl_api_get_f64_endian_value_t *mp)
Definition: api.c:545
vl_set_memory_root_path
void vl_set_memory_root_path(const char *name)
Definition: memory_shared.c:343
pool.h
Fixed length block allocator. Pools are built from clib vectors and bitmaps. Use pools when repeatedl...
VLIB_API_INIT_FUNCTION
VLIB_API_INIT_FUNCTION(af_xdp_plugin_api_hookup)
vlibapi_get_main
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:390
time.h
vl_api_get_node_graph_reply_t::reply_in_shmem
u64 reply_in_shmem
Definition: vpe.api:259
vlib_log_entry_t
Definition: log.h:42
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
vl_api_get_next_index_reply_t
Reply for get next node index.
Definition: vpe.api:281
f64
double f64
Definition: types.h:142
vlib_log_main_t::size
int size
Definition: log.h:97
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
vlib_worker_thread_t::lwp
long lwp
Definition: threads.h:109
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
vlib_worker_thread_t::numa_id
int numa_id
Definition: threads.h:112
format.h
vl_api_get_f64_endian_value_reply_t
get_f64_endian_value reply message
Definition: vpe.api:341
log_main
vlib_log_main_t log_main
Definition: log.c:23
vl_api_get_f64_increment_by_one_t
Verify f64 wire format by sending a value and receiving the value + 1.0.
Definition: vpe.api:353
setup_message_id_table
static void setup_message_id_table(api_main_t *am)
Definition: api.c:799
vl_api_log_dump_t_handler
static void vl_api_log_dump_t_handler(vl_api_log_dump_t *mp)
Definition: api.c:498
vl_api_cli_inband_t_handler
static void vl_api_cli_inband_t_handler(vl_api_cli_inband_t *mp)
Definition: api.c:207
clib_min
#define clib_min(x, y)
Definition: clib.h:342
vl_api_cli_inband_reply_t::reply
string reply[]
Definition: vpe.api:113
vpe_all_api_h.h
REPLY_MACRO3
#define REPLY_MACRO3(t, n, body)
Definition: api_helper_macros.h:141
vl_api_get_node_index_t_handler
static void vl_api_get_node_index_t_handler(vl_api_get_node_index_t *mp)
Definition: api.c:327
vl_api_add_node_next_t_handler
static void vl_api_add_node_next_t_handler(vl_api_add_node_next_t *mp)
Definition: api.c:398
vl_api_show_threads_t_handler
static void vl_api_show_threads_t_handler(vl_api_show_threads_t *mp)
Definition: api.c:281
vl_api_string_len
u32 vl_api_string_len(vl_api_string_t *astr)
Definition: api_shared.c:1184
vl_api_show_threads_reply_t::context
u32 context
Definition: vpe.api:235
vl_api_get_f64_endian_value_reply_t::f64_one_result
f64 f64_one_result
Definition: vpe.api:345
api_main_t
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:228
vl_api_get_f64_endian_value_t::f64_one
f64 f64_one[default=1.0]
Definition: vpe.api:333
vl_api_log_dump_t::client_index
u32 client_index
Definition: vpe.api:289
vlib_log_main_t::time_zero
f64 time_zero
Definition: log.h:107
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
vlib_worker_thread_t::registration
vlib_thread_registration_t * registration
Definition: threads.h:101
size
u32 size
Definition: vhost_user.h:125
vl_api_log_details_t
Definition: vpe.api:294
index
u32 index
Definition: flow_types.api:221
clib_bihash_value
template key/value backing page structure
Definition: bihash_doc.h:44
vlib_get_node_by_name
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
inband_cli_output
static void inband_cli_output(uword arg, u8 *buffer, uword buffer_bytes)
Definition: api.c:195
vl_api_get_f64_increment_by_one_reply_t
get_f64_increment_by_one reply
Definition: vpe.api:365
vl_api_control_ping_t
Control ping from client to api server request.
Definition: vpe.api:60
vl_api_log_details_t::timestamp
vl_api_timestamp_t timestamp
Definition: vpe.api:296
vl_api_show_version_reply_t::build_directory
string build_directory[256]
Definition: vpe.api:190
types.h
vl_api_show_version_t
show version
Definition: vpe.api:170
vl_api_vec_to_api_string
int vl_api_vec_to_api_string(const u8 *vec, vl_api_string_t *str)
Definition: api_shared.c:1175
unformat_init_string
void unformat_init_string(unformat_input_t *input, char *string, int string_len)
Definition: unformat.c:1029
u64
unsigned long u64
Definition: types.h:89
vl_api_show_threads_reply_t::thread_data
vl_api_thread_data_t thread_data[count]
Definition: vpe.api:238
vl_set_api_memory_size
void vl_set_api_memory_size(u64 size)
Definition: memory_shared.c:383
vl_api_cli_t
Process a vpe parser cli string request.
Definition: vpe.api:85
get_thread_data
static void get_thread_data(vl_api_thread_data_t *td, int index)
Definition: api.c:265
unformat_vnet_sw_interface
unformat_function_t unformat_vnet_sw_interface
Definition: interface_funcs.h:459
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
vl_api_cli_t::context
u32 context
Definition: vpe.api:88
show_log_details
static void show_log_details(vl_api_registration_t *reg, u32 context, f64 timestamp, vl_api_log_level_t *level, u8 *msg_class, u8 *message)
Definition: api.c:467
vl_api_cli_inband_reply_t
Definition: vpe.api:109
buf
u64 buf
Definition: application.c:493
u32
unsigned int u32
Definition: types.h:88
vl_msg_push_heap
void * vl_msg_push_heap(void)
Definition: cli.c:745
VL_MSG_API_REAPER_FUNCTION
VL_MSG_API_REAPER_FUNCTION(memclnt_delete_callback)
vl_api_show_threads_t::client_index
u32 client_index
Definition: vpe.api:200
vl_api_show_vpe_system_time_reply_t::vpe_system_time
vl_api_timestamp_t vpe_system_time
Definition: vpe.api:321
vl_set_global_memory_size
void vl_set_global_memory_size(u64 size)
Definition: memory_shared.c:375
vlib_log_main_t::time_zero_timeval
struct timeval time_zero_timeval
Definition: log.h:106
vpe_msg_enum.h
api_helper_macros.h
vpe_api_init
clib_error_t * vpe_api_init(vlib_main_t *vm)
Definition: api.c:652
vlib_worker_thread_t
Definition: threads.h:85
u32x4
unsigned long long u32x4
Definition: ixge.c:28
vlib_log_entry_t::string
u8 * string
Definition: log.h:47
vl_api_log_details_t::context
u32 context
Definition: vpe.api:295
get_unformat_vnet_sw_interface
void * get_unformat_vnet_sw_interface(void)
Definition: api.c:789
vec_resize
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V,...
Definition: vec.h:296
vl_api_log_dump_t
Definition: vpe.api:288
vl_api_show_vpe_system_time_t_handler
static void vl_api_show_vpe_system_time_t_handler(vl_api_show_vpe_system_time_t *mp)
Definition: api.c:532
vlib_thread_registration_::name
char * name
Definition: threads.h:33
vl_api_from_api_to_new_vec
u8 * vl_api_from_api_to_new_vec(void *mp, vl_api_string_t *astr)
Definition: api_shared.c:1202
vec.h
vl_api_show_version_reply_t
show version response
Definition: vpe.api:183
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
clib_error_return_fatal
#define clib_error_return_fatal(e, args...)
Definition: error.h:105
vlib_log_entry_t::timestamp
f64 timestamp
Definition: log.h:46
vl_set_global_memory_baseva
void vl_set_global_memory_baseva(u64 baseva)
Definition: memory_shared.c:367
vlib_node_t
Definition: node.h:247
vl_api_control_ping_reply_t::vpe_pid
u32 vpe_pid
Definition: vpe.api:77
hash.h
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
unix.h
vl_api_show_version_reply_t::build_date
string build_date[32]
Definition: vpe.api:189
vl_api_log_dump_t::context
u32 context
Definition: vpe.api:290
clib_net_to_host_f64
static f64 clib_net_to_host_f64(f64 x)
Definition: byte_order.h:177
vlib_log_main_t
Definition: log.h:93
vl_api_show_threads_t::context
u32 context
Definition: vpe.api:201
vlib_worker_thread_t::name
u8 * name
Definition: threads.h:102
vl_api_add_node_next_reply_t
IP Set the next node for a given node response.
Definition: vpe.api:159
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
context
u32 context
Definition: ip.api:780
rv
int __clib_unused rv
Definition: application.c:491
vl_api_get_next_index_t::next_name
string next_name[64]
Definition: vpe.api:273
vnet.h
api_errno.h
vl_msg_pop_heap
void vl_msg_pop_heap(void *oldheap)
Definition: cli.c:752
vl_api_get_node_graph_t
Definition: vpe.api:241
vl_api_get_node_index_reply_t
Get node index using name request.
Definition: vpe.api:133
vpe_client_registration_t
Definition: api_helper_macros.h:408
vl_api_show_threads_reply_t
show_threads_reply
Definition: vpe.api:233
vl_api_cli_inband_t::cmd
string cmd[]
Definition: vpe.api:95
timestamp
f64 timestamp
Definition: vpe_types.api:28
vl_api_show_version_reply_t::version
string version[32]
Definition: vpe.api:188
vl_api_cli_reply_t::reply_in_shmem
u64 reply_in_shmem
Definition: vpe.api:107
format_vlib_log_class
u8 * format_vlib_log_class(u8 *s, va_list *args)
Definition: log.c:89
vlib_node_serialize
u8 * vlib_node_serialize(vlib_main_t *vm, vlib_node_t ***node_dups, u8 *vector, int include_nexts, int include_stats)
Definition: node_serialize.c:51
heap.h
vl_api_cli_reply_t::context
u32 context
Definition: vpe.api:105
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
vl_set_memory_gid
void vl_set_memory_gid(int gid)
Definition: memory_shared.c:359
vl_api_get_node_index_reply_t::node_index
u32 node_index
Definition: vpe.api:137
vl_api_get_f64_increment_by_one_reply_t::f64_value
f64 f64_value
Definition: vpe.api:369
vl_msg_api_alloc
void * vl_msg_api_alloc(int nbytes)
Definition: memory_shared.c:199
vl_mem_api_enable_disable
void vl_mem_api_enable_disable(vlib_main_t *vm, int yesno)
Definition: vlib_api.c:445