FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
api_shared.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * api_shared.c - API message handling, common code for both clients
4  * and the vlib process itself.
5  *
6  *
7  * Copyright (c) 2009 Cisco and/or its affiliates.
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at:
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *------------------------------------------------------------------
20  */
21 
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <string.h>
26 #include <vppinfra/format.h>
27 #include <vppinfra/byte_order.h>
28 #include <vppinfra/error.h>
29 #include <vlib/vlib.h>
30 #include <vlib/unix/unix.h>
31 #include <vlibapi/api.h>
32 #include <vppinfra/elog.h>
33 
34 /* *INDENT-OFF* */
35 api_main_t api_main =
36  {
37  .region_name = "/unset",
38  .api_uid = -1,
39  .api_gid = -1,
40  };
41 /* *INDENT-ON* */
42 
43 void
45 {
46  api_main_t *am = &api_main;
47  am->missing_clients++;
48 }
49 
50 int
52 {
53  return (am->rx_trace && am->rx_trace->enabled);
54 }
55 
56 int
58 {
59  return (am->tx_trace && am->tx_trace->enabled);
60 }
61 
62 /*
63  * vl_msg_api_trace
64  */
65 void
67 {
68  u8 **this_trace;
69  u8 **old_trace;
70  u8 *msg_copy;
71  u32 length;
72  trace_cfg_t *cfgp;
73  u16 msg_id = ntohs (*((u16 *) msg));
74  msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
75 
76  cfgp = am->api_trace_cfg + msg_id;
77 
78  if (!cfgp || !cfgp->trace_enable)
79  return;
80 
81  msg_copy = 0;
82 
83  if (tp->nitems == 0)
84  {
85  clib_warning ("tp->nitems is 0");
86  return;
87  }
88 
89  if (vec_len (tp->traces) < tp->nitems)
90  {
91  vec_add1 (tp->traces, 0);
92  this_trace = tp->traces + vec_len (tp->traces) - 1;
93  }
94  else
95  {
96  tp->wrapped = 1;
97  old_trace = tp->traces + tp->curindex++;
98  if (tp->curindex == tp->nitems)
99  tp->curindex = 0;
100  vec_free (*old_trace);
101  this_trace = old_trace;
102  }
103 
104  length = clib_net_to_host_u32 (header->data_len);
105 
106  vec_validate (msg_copy, length - 1);
107  clib_memcpy_fast (msg_copy, msg, length);
108  *this_trace = msg_copy;
109 }
110 
111 int
113  int onoff)
114 {
115  vl_api_trace_t *tp;
116  int rv;
117 
118  switch (which)
119  {
120  case VL_API_TRACE_TX:
121  tp = am->tx_trace;
122  if (tp == 0)
123  {
124  vl_msg_api_trace_configure (am, which, 1024);
125  tp = am->tx_trace;
126  }
127  break;
128 
129  case VL_API_TRACE_RX:
130  tp = am->rx_trace;
131  if (tp == 0)
132  {
133  vl_msg_api_trace_configure (am, which, 1024);
134  tp = am->rx_trace;
135  }
136  break;
137 
138  default:
139  /* duh? */
140  return -1;
141  }
142 
143  /* Configured? */
144  if (tp == 0 || tp->nitems == 0)
145  return -1;
146 
147  rv = tp->enabled;
148  tp->enabled = onoff;
149 
150  return rv;
151 }
152 
153 int
155 {
156  vl_api_trace_t *tp;
157  int i;
158 
159  switch (which)
160  {
161  case VL_API_TRACE_TX:
162  tp = am->tx_trace;
163  break;
164 
165  case VL_API_TRACE_RX:
166  tp = am->rx_trace;
167  break;
168 
169  default:
170  /* duh? */
171  return -1;
172  }
173 
174  /* Configured? */
175  if (!tp || tp->nitems == 0)
176  return -1;
177 
178  tp->curindex = 0;
179  tp->wrapped = 0;
180 
181  for (i = 0; i < vec_len (tp->traces); i++)
182  {
183  vec_free (tp->traces[i]);
184  }
185  vec_free (tp->traces);
186 
187  return 0;
188 }
189 
190 int
192 {
193  vl_api_trace_t *tp;
194  vl_api_trace_file_header_t fh;
195  int i;
196  u8 *msg;
197 
198  switch (which)
199  {
200  case VL_API_TRACE_TX:
201  tp = am->tx_trace;
202  break;
203 
204  case VL_API_TRACE_RX:
205  tp = am->rx_trace;
206  break;
207 
208  default:
209  /* duh? */
210  return -1;
211  }
212 
213  /* Configured, data present? */
214  if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
215  return -1;
216 
217  /* "Dare to be stupid" check */
218  if (fp == 0)
219  {
220  return -2;
221  }
222 
223  /* Write the file header */
224  fh.nitems = vec_len (tp->traces);
225  fh.endian = tp->endian;
226  fh.wrapped = tp->wrapped;
227 
228  if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
229  {
230  return (-10);
231  }
232 
233  /* No-wrap case */
234  if (tp->wrapped == 0)
235  {
236  /*
237  * Note: vec_len return 0 when fed a NULL pointer.
238  * Unfortunately, the static analysis tool doesn't
239  * figure it out, hence the suppressed warnings.
240  * What a great use of my time.
241  */
242  for (i = 0; i < vec_len (tp->traces); i++)
243  {
244  u32 msg_length;
245  /*sa_ignore NO_NULL_CHK */
246  msg = tp->traces[i];
247  /*
248  * This retarded check required to pass
249  * [sic] SA-checking.
250  */
251  if (!msg)
252  continue;
253 
254  msg_length = clib_host_to_net_u32 (vec_len (msg));
255  if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
256  != sizeof (msg_length))
257  {
258  return (-14);
259  }
260  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
261  {
262  return (-11);
263  }
264  }
265  }
266  else
267  {
268  /* Wrap case: write oldest -> end of buffer */
269  for (i = tp->curindex; i < vec_len (tp->traces); i++)
270  {
271  u32 msg_length;
272  msg = tp->traces[i];
273  /*
274  * This retarded check required to pass
275  * [sic] SA-checking
276  */
277  if (!msg)
278  continue;
279 
280  msg_length = clib_host_to_net_u32 (vec_len (msg));
281  if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
282  != sizeof (msg_length))
283  {
284  return (-14);
285  }
286 
287  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
288  {
289  return (-12);
290  }
291  }
292  /* write beginning of buffer -> oldest-1 */
293  for (i = 0; i < tp->curindex; i++)
294  {
295  u32 msg_length;
296  /*sa_ignore NO_NULL_CHK */
297  msg = tp->traces[i];
298  /*
299  * This retarded check required to pass
300  * [sic] SA-checking
301  */
302  if (!msg)
303  continue;
304 
305  msg_length = clib_host_to_net_u32 (vec_len (msg));
306  if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
307  != sizeof (msg_length))
308  {
309  return (-14);
310  }
311 
312  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
313  {
314  return (-13);
315  }
316  }
317  }
318  return 0;
319 }
320 
321 int
323  u32 nitems)
324 {
325  vl_api_trace_t *tp;
326  int was_on = 0;
327 
328  switch (which)
329  {
330  case VL_API_TRACE_TX:
331  tp = am->tx_trace;
332  if (tp == 0)
333  {
334  vec_validate (am->tx_trace, 0);
335  tp = am->tx_trace;
336  }
337  break;
338 
339  case VL_API_TRACE_RX:
340  tp = am->rx_trace;
341  if (tp == 0)
342  {
343  vec_validate (am->rx_trace, 0);
344  tp = am->rx_trace;
345  }
346 
347  break;
348 
349  default:
350  return -1;
351 
352  }
353 
354  if (tp->enabled)
355  {
356  was_on = vl_msg_api_trace_onoff (am, which, 0);
357  }
358  if (tp->traces)
359  {
360  vl_msg_api_trace_free (am, which);
361  }
362 
363  clib_memset (tp, 0, sizeof (*tp));
364 
366  {
368  }
369  else
370  {
372  }
373 
374  tp->nitems = nitems;
375  if (was_on)
376  {
377  (void) vl_msg_api_trace_onoff (am, which, was_on);
378  }
379  return 0;
380 }
381 
382 void
384 {
385 }
386 
387 void
389 {
390 }
391 
392 always_inline void
394  void *the_msg, int trace_it, int do_it, int free_it)
395 {
396  u16 id = ntohs (*((u16 *) the_msg));
397  u8 *(*print_fp) (void *, void *);
398 
399  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
400  {
401  if (trace_it)
402  vl_msg_api_trace (am, am->rx_trace, the_msg);
403 
404  if (am->msg_print_flag)
405  {
406  fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
407  print_fp = (void *) am->msg_print_handlers[id];
408  if (print_fp == 0)
409  {
410  fformat (stdout, " [no registered print fn]\n");
411  }
412  else
413  {
414  (*print_fp) (the_msg, stdout);
415  }
416  }
417 
418  if (do_it)
419  {
420  if (!am->is_mp_safe[id])
421  {
424  }
425  (*am->msg_handlers[id]) (the_msg);
426  if (!am->is_mp_safe[id])
428  }
429  }
430  else
431  {
432  clib_warning ("no handler for msg id %d", id);
433  }
434 
435  if (free_it)
436  vl_msg_api_free (the_msg);
437 }
438 
439 static u32
440 elog_id_for_msg_name (vlib_main_t * vm, const char *msg_name)
441 {
442  uword *p, r;
443  static uword *h;
444  u8 *name_copy;
445 
446  if (!h)
447  h = hash_create_string (0, sizeof (uword));
448 
449  p = hash_get_mem (h, msg_name);
450  if (p)
451  return p[0];
452  r = elog_string (&vm->elog_main, "%s", msg_name);
453 
454  name_copy = format (0, "%s%c", msg_name, 0);
455 
456  hash_set_mem (h, name_copy, r);
457 
458  return r;
459 }
460 
461 /* This is only to be called from a vlib/vnet app */
462 void
464  void *the_msg, vlib_main_t * vm,
465  vlib_node_runtime_t * node)
466 {
467  u16 id = ntohs (*((u16 *) the_msg));
468  u8 *(*handler) (void *, void *, void *);
469  u8 *(*print_fp) (void *, void *);
470 
472  {
473  /* *INDENT-OFF* */
474  ELOG_TYPE_DECLARE (e) =
475  {
476  .format = "api-msg: %s",
477  .format_args = "T4",
478  };
479  /* *INDENT-ON* */
480  struct
481  {
482  u32 c;
483  } *ed;
484  ed = ELOG_DATA (&vm->elog_main, e);
485  if (id < vec_len (am->msg_names))
486  ed->c = elog_id_for_msg_name (vm, (const char *) am->msg_names[id]);
487  else
488  ed->c = elog_id_for_msg_name (vm, "BOGUS");
489  }
490 
491  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
492  {
493  handler = (void *) am->msg_handlers[id];
494 
495  if (PREDICT_FALSE (am->rx_trace && am->rx_trace->enabled))
496  vl_msg_api_trace (am, am->rx_trace, the_msg);
497 
498  if (PREDICT_FALSE (am->msg_print_flag))
499  {
500  fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
501  print_fp = (void *) am->msg_print_handlers[id];
502  if (print_fp == 0)
503  {
504  fformat (stdout, " [no registered print fn for msg %d]\n", id);
505  }
506  else
507  {
508  (*print_fp) (the_msg, vm);
509  }
510  }
511 
512  if (!am->is_mp_safe[id])
513  {
516  }
517  (*handler) (the_msg, vm, node);
518  if (!am->is_mp_safe[id])
520  }
521  else
522  {
523  clib_warning ("no handler for msg id %d", id);
524  }
525 
526  /*
527  * Special-case, so we can e.g. bounce messages off the vnet
528  * main thread without copying them...
529  */
530  if (!(am->message_bounce[id]))
531  vl_msg_api_free (the_msg);
532 
534  {
535  /* *INDENT-OFF* */
536  ELOG_TYPE_DECLARE (e) = {
537  .format = "api-msg-done: %s",
538  .format_args = "T4",
539  };
540  /* *INDENT-ON* */
541 
542  struct
543  {
544  u32 c;
545  } *ed;
546  ed = ELOG_DATA (&vm->elog_main, e);
547  if (id < vec_len (am->msg_names))
548  ed->c = elog_id_for_msg_name (vm, (const char *) am->msg_names[id]);
549  else
550  ed->c = elog_id_for_msg_name (vm, "BOGUS");
551  }
552 }
553 
554 void
555 vl_msg_api_handler (void *the_msg)
556 {
557  api_main_t *am = &api_main;
558 
559  msg_handler_internal (am, the_msg,
560  (am->rx_trace
561  && am->rx_trace->enabled) /* trace_it */ ,
562  1 /* do_it */ , 1 /* free_it */ );
563 }
564 
565 void
567 {
568  api_main_t *am = &api_main;
569  msg_handler_internal (am, the_msg,
570  (am->rx_trace
571  && am->rx_trace->enabled) /* trace_it */ ,
572  1 /* do_it */ , 0 /* free_it */ );
573 }
574 
575 void
577 {
578  api_main_t *am = &api_main;
579  msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
580  0 /* free_it */ );
581 }
582 
583 /*
584  * Add a trace record to the API message trace buffer, if
585  * API message tracing is enabled. Handy for adding sufficient
586  * data to the trace to reproduce autonomous state, as opposed to
587  * state downloaded via control-plane API messages. Example: the NAT
588  * application creates database entries based on packet traffic, not
589  * control-plane messages.
590  *
591  */
592 void
593 vl_msg_api_trace_only (void *the_msg)
594 {
595  api_main_t *am = &api_main;
596 
597  msg_handler_internal (am, the_msg,
598  (am->rx_trace
599  && am->rx_trace->enabled) /* trace_it */ ,
600  0 /* do_it */ , 0 /* free_it */ );
601 }
602 
603 void
605 {
606  api_main_t *am = &api_main;
607  u16 id = ntohs (*((u16 *) the_msg));
608 
609  if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
610  {
611  clib_warning ("_vl_msg_id too large: %d\n", id);
612  return;
613  }
614  if (am->msg_cleanup_handlers[id])
615  (*am->msg_cleanup_handlers[id]) (the_msg);
616 
617  vl_msg_api_free (the_msg);
618 }
619 
620 /*
621  * vl_msg_api_replay_handler
622  */
623 void
625 {
626  api_main_t *am = &api_main;
627 
628  u16 id = ntohs (*((u16 *) the_msg));
629 
630  if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
631  {
632  clib_warning ("_vl_msg_id too large: %d\n", id);
633  return;
634  }
635  /* do NOT trace the message... */
636  if (am->msg_handlers[id])
637  (*am->msg_handlers[id]) (the_msg);
638  /* do NOT free the message buffer... */
639 }
640 
641 u32
643 {
644  return vl_msg_api_get_msg_length_inline (msg_arg);
645 }
646 
647 /*
648  * vl_msg_api_socket_handler
649  */
650 void
652 {
653  api_main_t *am = &api_main;
654 
655  msg_handler_internal (am, the_msg,
656  (am->rx_trace
657  && am->rx_trace->enabled) /* trace_it */ ,
658  1 /* do_it */ , 0 /* free_it */ );
659 }
660 
661 #define foreach_msg_api_vector \
662 _(msg_names) \
663 _(msg_handlers) \
664 _(msg_cleanup_handlers) \
665 _(msg_endian_handlers) \
666 _(msg_print_handlers) \
667 _(api_trace_cfg) \
668 _(message_bounce) \
669 _(is_mp_safe)
670 
671 void
673 {
674  api_main_t *am = &api_main;
675 
676  /*
677  * This happens during the java core tests if the message
678  * dictionary is missing newly added xxx_reply_t messages.
679  * Should never happen, but since I shot myself in the foot once
680  * this way, I thought I'd make it easy to debug if I ever do
681  * it again... (;-)...
682  */
683  if (c->id == 0)
684  {
685  if (c->name)
686  clib_warning ("Trying to register %s with a NULL msg id!", c->name);
687  else
688  clib_warning ("Trying to register a NULL msg with a NULL msg id!");
689  clib_warning ("Did you forget to call setup_message_id_table?");
690  return;
691  }
692 
693 #define _(a) vec_validate (am->a, c->id);
695 #undef _
696 
697  if (am->msg_handlers[c->id] && am->msg_handlers[c->id] != c->handler)
699  ("BUG: re-registering 'vl_api_%s_t_handler'."
700  "Handler was %llx, replaced by %llx",
701  c->name, am->msg_handlers[c->id], c->handler);
702 
703  am->msg_names[c->id] = c->name;
704  am->msg_handlers[c->id] = c->handler;
705  am->msg_cleanup_handlers[c->id] = c->cleanup;
706  am->msg_endian_handlers[c->id] = c->endian;
707  am->msg_print_handlers[c->id] = c->print;
708  am->message_bounce[c->id] = c->message_bounce;
709  am->is_mp_safe[c->id] = c->is_mp_safe;
710 
711  am->api_trace_cfg[c->id].size = c->size;
712  am->api_trace_cfg[c->id].trace_enable = c->traced;
713  am->api_trace_cfg[c->id].replay_enable = c->replay;
714 }
715 
716 /*
717  * vl_msg_api_set_handlers
718  * preserve the old API for a while
719  */
720 void
721 vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
722  void *endian, void *print, int size, int traced)
723 {
725  vl_msg_api_msg_config_t *c = &cfg;
726 
727  clib_memset (c, 0, sizeof (*c));
728 
729  c->id = id;
730  c->name = name;
731  c->handler = handler;
732  c->cleanup = cleanup;
733  c->endian = endian;
734  c->print = print;
735  c->traced = traced;
736  c->replay = 1;
737  c->message_bounce = 0;
738  c->is_mp_safe = 0;
739  vl_msg_api_config (c);
740 }
741 
742 void
744 {
746  vl_msg_api_msg_config_t *c = &cfg;
747 
748  clib_memset (c, 0, sizeof (*c));
749 
750  c->id = msg_id;
751  vl_msg_api_config (c);
752 }
753 
754 void
755 vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
756 {
757  api_main_t *am = &api_main;
758  ASSERT (msg_id > 0);
759 
760  vec_validate (am->msg_cleanup_handlers, msg_id);
761  am->msg_cleanup_handlers[msg_id] = fp;
762 }
763 
764 void
766 {
767  uword msg;
768 
769  while (!svm_queue_sub (q, (u8 *) & msg, SVM_Q_WAIT, 0))
770  vl_msg_api_handler ((void *) msg);
771 }
772 
775 {
776  switch (which)
777  {
778  case VL_API_TRACE_RX:
779  return am->rx_trace;
780  case VL_API_TRACE_TX:
781  return am->tx_trace;
782  default:
783  return 0;
784  }
785 }
786 
787 void
788 vl_noop_handler (void *mp)
789 {
790 }
791 
792 
794 
795 void
797 {
798  post_mortem_dump_enabled = enable;
799 }
800 
801 void
803 {
804  api_main_t *am = &api_main;
805  FILE *fp;
806  char filename[64];
807  int rv;
808 
809  if (post_mortem_dump_enabled == 0)
810  return;
811 
812  snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
813  getpid ());
814 
815  fp = fopen (filename, "w");
816  if (fp == NULL)
817  {
818  rv = write (2, "Couldn't create ", 16);
819  rv = write (2, filename, strlen (filename));
820  rv = write (2, "\n", 1);
821  return;
822  }
823  rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
824  fclose (fp);
825  if (rv < 0)
826  {
827  rv = write (2, "Failed to save post-mortem API trace to ", 40);
828  rv = write (2, filename, strlen (filename));
829  rv = write (2, "\n", 1);
830  }
831 
832 }
833 
834 /* Layered message handling support */
835 
836 void
837 vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
838 {
839  api_main_t *am = &api_main;
840 
841  /* Mild idiot proofing */
842  if (msg_id_host_byte_order > 10000)
843  clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
844  msg_id_host_byte_order,
845  clib_net_to_host_u16 (msg_id_host_byte_order));
846  vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
847  am->pd_msg_handlers[msg_id_host_byte_order] = fp;
848 }
849 
850 int
851 vl_msg_api_pd_handler (void *mp, int rv)
852 {
853  api_main_t *am = &api_main;
854  int (*fp) (void *, int);
855  u16 msg_id;
856 
858  msg_id = clib_net_to_host_u16 (*((u16 *) mp));
859  else
860  msg_id = *((u16 *) mp);
861 
862  if (msg_id >= vec_len (am->pd_msg_handlers)
863  || am->pd_msg_handlers[msg_id] == 0)
864  return rv;
865 
866  fp = am->pd_msg_handlers[msg_id];
867  rv = (*fp) (mp, rv);
868  return rv;
869 }
870 
871 void
873 {
874  api_main_t *am = &api_main;
875 
876  am->first_available_msg_id = first_avail;
877 }
878 
879 u16
880 vl_msg_api_get_msg_ids (const char *name, int n)
881 {
882  api_main_t *am = &api_main;
883  u8 *name_copy;
884  vl_api_msg_range_t *rp;
885  uword *p;
886  u16 rv;
887 
888  if (am->msg_range_by_name == 0)
889  am->msg_range_by_name = hash_create_string (0, sizeof (uword));
890 
891  name_copy = format (0, "%s%c", name, 0);
892 
893  p = hash_get_mem (am->msg_range_by_name, name_copy);
894  if (p)
895  {
896  clib_warning ("WARNING: duplicate message range registration for '%s'",
897  name_copy);
898  vec_free (name_copy);
899  return ((u16) ~ 0);
900  }
901 
902  if (n < 0 || n > 1024)
903  {
905  ("WARNING: bad number of message-IDs (%d) requested by '%s'",
906  n, name_copy);
907  vec_free (name_copy);
908  return ((u16) ~ 0);
909  }
910 
911  vec_add2 (am->msg_ranges, rp, 1);
912 
913  rv = rp->first_msg_id = am->first_available_msg_id;
914  am->first_available_msg_id += n;
915  rp->last_msg_id = am->first_available_msg_id - 1;
916  rp->name = name_copy;
917 
918  hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
919 
920  return rv;
921 }
922 
923 void
924 vl_msg_api_add_msg_name_crc (api_main_t * am, const char *string, u32 id)
925 {
926  uword *p;
927 
928  if (am->msg_index_by_name_and_crc == 0)
930 
931  p = hash_get_mem (am->msg_index_by_name_and_crc, string);
932  if (p)
933  {
934  clib_warning ("attempt to redefine '%s' ignored...", string);
935  return;
936  }
937 
938  hash_set_mem (am->msg_index_by_name_and_crc, string, id);
939 }
940 
941 void
942 vl_msg_api_add_version (api_main_t * am, const char *string,
943  u32 major, u32 minor, u32 patch)
944 {
945  api_version_t version = {.major = major,.minor = minor,.patch = patch };
946  ASSERT (strlen (string) < 64);
947  strncpy (version.name, string, 64 - 1);
948  vec_add1 (am->api_version_list, version);
949 }
950 
951 u32
952 vl_msg_api_get_msg_index (u8 * name_and_crc)
953 {
954  api_main_t *am = &api_main;
955  uword *p;
956 
958  {
959  p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc);
960  if (p)
961  return p[0];
962  }
963  return ~0;
964 }
965 
966 void *
968 {
969  api_main_t *am = &api_main;
970  pthread_mutex_lock (&am->vlib_rp->mutex);
971  return svm_push_data_heap (am->vlib_rp);
972 }
973 
974 void
975 vl_msg_pop_heap (void *oldheap)
976 {
977  api_main_t *am = &api_main;
978  svm_pop_heap (oldheap);
979  pthread_mutex_unlock (&am->vlib_rp->mutex);
980 }
981 
982 
983 /*
984  * fd.io coding-style-patch-verification: ON
985  *
986  * Local Variables:
987  * eval: (c-set-style "gnu")
988  * End:
989  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
void vl_msg_api_set_first_available_msg_id(u16 first_avail)
Definition: api_shared.c:872
Message range (belonging to a plugin)
Definition: api_common.h:111
int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which, int onoff)
Definition: api_shared.c:112
int vl_msg_api_trace_save(api_main_t *am, vl_api_trace_which_t which, FILE *fp)
Definition: api_shared.c:191
void vl_msg_api_set_handlers(int id, char *name, void *handler, void *cleanup, void *endian, void *print, int size, int traced)
Definition: api_shared.c:721
int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which)
Definition: api_shared.c:154
int id
the message ID
Definition: api_common.h:121
u8 * name
name of the plugin
Definition: api_common.h:113
static void svm_pop_heap(void *oldheap)
Definition: svm.h:94
void vl_msg_api_set_cleanup_handler(int msg_id, void *fp)
Definition: api_shared.c:755
int vl_msg_api_pd_handler(void *mp, int rv)
Definition: api_shared.c:851
void vl_msg_api_handler(void *the_msg)
Definition: api_shared.c:555
void * print
message print function
Definition: api_common.h:127
u8 wrapped
trace has wrapped
Definition: api_common.h:93
static u64 do_it(pg_main_t *pg, pg_stream_t *s, u32 *buffers, u32 n_buffers, u32 lo_bit, u32 hi_bit, u64 v_min, u64 v_max, u64 v, pg_edit_type_t edit_type)
Definition: input.c:753
Optimized string handling code, including c11-compliant "safe C library" variants.
int size
for sanity checking
Definition: api_common.h:81
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
#define NULL
Definition: clib.h:58
static void msg_handler_internal(api_main_t *am, void *the_msg, int trace_it, int do_it, int free_it)
Definition: api_shared.c:393
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
int elog_trace_api_messages
Definition: main.h:175
u8 * message_bounce
Don&#39;t automatically free message buffer vetor.
Definition: api_common.h:222
static u8 post_mortem_dump_enabled
Definition: api_shared.c:793
Message configuration definition.
Definition: api_common.h:119
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
vl_api_trace_t * vl_msg_api_trace_get(api_main_t *am, vl_api_trace_which_t which)
Definition: api_shared.c:774
u32 vl_msg_api_get_msg_length(void *msg_arg)
Definition: api_shared.c:642
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
api_version_t * api_version_list
api version list
Definition: api_common.h:325
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which, u32 nitems)
Definition: api_shared.c:322
u8 data[128]
Definition: ipsec.api:248
#define vl_msg_api_barrier_trace_context(X)
Definition: api_common.h:168
void(** msg_cleanup_handlers)(void *)
non-default message cleanup handler vector
Definition: api_common.h:210
void vl_noop_handler(void *mp)
Definition: api_shared.c:788
void * cleanup
non-default message cleanup handler
Definition: api_common.h:125
unsigned char u8
Definition: types.h:56
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:249
void vl_msg_api_handler_no_trace_no_free(void *the_msg)
Definition: api_shared.c:576
int size
message size
Definition: api_common.h:128
static u32 elog_id_for_msg_name(vlib_main_t *vm, const char *msg_name)
Definition: api_shared.c:440
void vl_msg_api_cleanup_handler(void *the_msg)
Definition: api_shared.c:604
void * endian
message endian function
Definition: api_common.h:126
int svm_queue_sub(svm_queue_t *q, u8 *elem, svm_q_conditional_wait_t cond, u32 time)
Definition: queue.c:348
vl_api_trace_t * rx_trace
Received message trace configuration.
Definition: api_common.h:240
static void * svm_push_data_heap(svm_region_t *rp)
Definition: svm.h:86
#define always_inline
Definition: clib.h:98
void vl_msg_api_config(vl_msg_api_msg_config_t *c)
Definition: api_shared.c:672
void vl_msg_api_post_mortem_dump_enable_disable(int enable)
Definition: api_shared.c:796
#define clib_arch_is_little_endian
Definition: byte_order.h:54
svm_region_t * vlib_rp
Current binary api segment descriptor.
Definition: api_common.h:255
unsigned int u32
Definition: types.h:88
#define VL_API_BIG_ENDIAN
Definition: api_common.h:108
int vl_msg_api_tx_trace_enabled(api_main_t *am)
Definition: api_shared.c:57
char name[64]
Definition: api_common.h:198
void vl_msg_api_trace_only(void *the_msg)
Definition: api_shared.c:593
void vl_msg_api_clean_handlers(int msg_id)
Definition: api_shared.c:743
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
void vl_msg_api_handler_with_vm_node(api_main_t *am, void *the_msg, vlib_main_t *vm, vlib_node_runtime_t *node)
Definition: api_shared.c:463
u16 last_msg_id
last assigned message ID
Definition: api_common.h:115
uword size
void vl_msg_api_add_msg_name_crc(api_main_t *am, const char *string, u32 id)
Definition: api_shared.c:924
int vl_msg_api_rx_trace_enabled(api_main_t *am)
Definition: api_shared.c:51
void(** msg_print_handlers)(void *, void *)
Message print function vector.
Definition: api_common.h:216
int replay_enable
This message can be replayed.
Definition: api_common.h:83
unsigned short u16
Definition: types.h:57
int message_bounce
do not free message after processing
Definition: api_common.h:131
u32 curindex
Current index in circular buffer.
Definition: api_common.h:96
static void cleanup(void)
Definition: client.c:130
#define ELOG_DATA(em, f)
Definition: elog.h:484
#define PREDICT_FALSE(x)
Definition: clib.h:111
u8 name[64]
Definition: memclnt.api:152
word fformat(FILE *f, char *fmt,...)
Definition: format.c:462
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:202
u8 enabled
trace is enabled
Definition: api_common.h:92
The fine-grained event logger allows lightweight, thread-safe event logging at minimum cost...
#define clib_arch_is_big_endian
Definition: byte_order.h:53
svmdb_client_t * c
API trace state.
Definition: api_common.h:89
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
void vl_msg_api_barrier_release(void)
Definition: api_shared.c:388
vl_api_msg_range_t * msg_ranges
vector of message ranges
Definition: api_common.h:280
void vl_msg_api_post_mortem_dump(void)
Definition: api_shared.c:802
#define clib_warning(format, args...)
Definition: error.h:59
elog_main_t elog_main
Definition: main.h:172
u8 ** traces
Trace ring.
Definition: api_common.h:97
blocking call - best used in combination with condvars, for eventfds we don&#39;t yield the cpu ...
Definition: queue.h:42
#define ELOG_TYPE_DECLARE(f)
Definition: elog.h:442
const char ** msg_names
Message name vector.
Definition: api_common.h:219
int replay
is this message to be replayed?
Definition: api_common.h:130
void vl_msg_api_socket_handler(void *the_msg)
Definition: api_shared.c:651
api_main_t api_main
Definition: api_shared.c:35
vl_api_trace_t * tx_trace
Sent message trace configuration.
Definition: api_common.h:243
#define ASSERT(truth)
u32 data_len
message length not including header
Definition: api_common.h:139
Message header structure.
Definition: api_common.h:136
vl_api_trace_which_t
Trace RX / TX enum.
Definition: api_common.h:101
option version
Definition: memclnt.api:17
void vl_msg_api_replay_handler(void *the_msg)
Definition: api_shared.c:624
void vl_msg_api_add_version(api_main_t *am, const char *string, u32 major, u32 minor, u32 patch)
Definition: api_shared.c:942
void vl_msg_api_handler_no_free(void *the_msg)
Definition: api_shared.c:566
void vl_msg_api_free(void *)
u32 missing_clients
Number of missing clients / failed message sends.
Definition: api_common.h:237
void * vl_msg_push_heap(void)
Definition: api_shared.c:967
u32 vl_msg_api_get_msg_index(u8 *name_and_crc)
Definition: api_shared.c:952
void vl_msg_api_increment_missing_client_counter(void)
Definition: api_shared.c:44
u16 first_msg_id
first assigned message ID
Definition: api_common.h:114
void vl_msg_api_register_pd_handler(void *fp, u16 msg_id_host_byte_order)
Definition: api_shared.c:837
void(** msg_endian_handlers)(void *)
Message endian handler vector.
Definition: api_common.h:213
u32 elog_string(elog_main_t *em, char *fmt,...)
add a string to the event-log string table
Definition: elog.c:562
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
static u32 vl_msg_api_get_msg_length_inline(void *msg_arg)
Definition: api.h:91
int(** pd_msg_handlers)(void *, int)
Plaform-dependent (aka hardware) message handler vector.
Definition: api_common.h:207
#define foreach_msg_api_vector
Definition: api_shared.c:661
struct _svm_queue svm_queue_t
#define hash_get_mem(h, key)
Definition: hash.h:269
u16 vl_msg_api_get_msg_ids(const char *name, int n)
Definition: api_shared.c:880
u16 first_available_msg_id
First available message ID, for theplugin msg allocator.
Definition: api_common.h:274
void vl_msg_pop_heap(void *oldheap)
Definition: api_shared.c:975
u8 endian
trace endianness
Definition: api_common.h:91
void(** msg_handlers)(void *)
Message handler vector.
Definition: api_common.h:205
u8 * is_mp_safe
Message is mp safe vector.
Definition: api_common.h:225
void vl_msg_api_queue_handler(svm_queue_t *q)
Definition: api_shared.c:765
void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg)
Definition: api_shared.c:66
int trace_enable
trace this message
Definition: api_common.h:82
int msg_print_flag
Print every received message.
Definition: api_common.h:246
int is_mp_safe
worker thread barrier required?
Definition: api_common.h:132
u32 id
Definition: udp.api:45
int traced
is this message to be traced?
Definition: api_common.h:129
const char * region_name
Shared VM binary API region name.
Definition: api_common.h:328
Trace configuration for a single message.
Definition: api_common.h:79
#define VL_API_LITTLE_ENDIAN
Definition: api_common.h:107
uword * msg_index_by_name_and_crc
client message index hash table
Definition: api_common.h:322
uword * msg_range_by_name
Message range by name hash.
Definition: api_common.h:277
char * name
the message name
Definition: api_common.h:122
u32 nitems
Number of trace records.
Definition: api_common.h:95
void * handler
the message handler
Definition: api_common.h:124
pthread_mutex_t mutex
Definition: svm_common.h:37
void vl_msg_api_barrier_sync(void)
Definition: api_shared.c:383