#include <stdlib.h>
#include <stddef.h>
#include <string.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
#include <vppinfra/format.h>
#include <vppinfra/byte_order.h>
#include <vppinfra/error.h>
#include <vlib/unix/unix.h>
#include <vlibapi/api.h>
#include <vppinfra/elog.h>
+#include <vppinfra/callback.h>
-api_main_t api_main;
+/* *INDENT-OFF* */
+api_main_t api_global_main =
+ {
+ .region_name = "/unset",
+ .api_uid = -1,
+ .api_gid = -1,
+ };
+/* *INDENT-ON* */
-void vl_msg_api_barrier_sync (void) __attribute__ ((weak));
-void
-vl_msg_api_barrier_sync (void)
-{
-}
+/* Please use vlibapi_get_main() to access my_api_main */
+__thread api_main_t *my_api_main = &api_global_main;
-void vl_msg_api_barrier_release (void) __attribute__ ((weak));
void
-vl_msg_api_barrier_release (void)
+vl_msg_api_set_global_main (void *am_arg)
{
+ ASSERT (am_arg);
+ my_api_main = (api_main_t *) am_arg;
}
void
vl_msg_api_increment_missing_client_counter (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->missing_clients++;
}
-typedef enum
-{
- DUMP,
- CUSTOM_DUMP,
- REPLAY,
- INITIALIZERS,
-} vl_api_replay_t;
-
int
vl_msg_api_rx_trace_enabled (api_main_t * am)
{
u8 *msg_copy;
u32 length;
trace_cfg_t *cfgp;
- u16 msg_id = ntohs (*((u16 *) msg));
+ u16 msg_id = clib_net_to_host_u16 (*((u16 *) msg));
msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
cfgp = am->api_trace_cfg + msg_id;
old_trace = tp->traces + tp->curindex++;
if (tp->curindex == tp->nitems)
tp->curindex = 0;
- vec_free (*old_trace);
+ /* Reuse the trace record, may save some memory allocator traffic */
+ msg_copy = *old_trace;
+ vec_reset_length (msg_copy);
this_trace = old_trace;
}
length = clib_net_to_host_u32 (header->data_len);
vec_validate (msg_copy, length - 1);
- clib_memcpy (msg_copy, msg, length);
+ clib_memcpy_fast (msg_copy, msg, length);
*this_trace = msg_copy;
}
return 0;
}
-int
-vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
+u8 *
+vl_api_serialize_message_table (api_main_t * am, u8 * vector)
{
- vl_api_trace_t *tp;
- vl_api_trace_file_header_t fh;
- int i;
- u8 *msg;
+ serialize_main_t _sm, *sm = &_sm;
+ hash_pair_t *hp;
+ u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
- switch (which)
- {
- case VL_API_TRACE_TX:
- tp = am->tx_trace;
- break;
+ serialize_open_vector (sm, vector);
- case VL_API_TRACE_RX:
- tp = am->rx_trace;
- break;
+ /* serialize the count */
+ serialize_integer (sm, nmsg, sizeof (u32));
- default:
- /* duh? */
- return -1;
- }
+ /* *INDENT-OFF* */
+ hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
+ ({
+ serialize_likely_small_unsigned_integer (sm, hp->value[0]);
+ serialize_cstring (sm, (char *) hp->key);
+ }));
+ /* *INDENT-ON* */
- /* Configured, data present? */
- if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
- return -1;
+ return serialize_close_vector (sm);
+}
- /* "Dare to be stupid" check */
- if (fp == 0)
- {
- return -2;
- }
+static int
+vl_msg_api_trace_write_one (api_main_t *am, u8 *msg, FILE *fp)
+{
+ u8 *tmpmem = 0;
+ int tlen, slen;
+ cJSON *(*tojson_fn) (void *);
- /* Write the file header */
- fh.nitems = vec_len (tp->traces);
- fh.endian = tp->endian;
- fh.wrapped = tp->wrapped;
+ u32 msg_length = vec_len (msg);
+ vec_validate (tmpmem, msg_length - 1);
+ clib_memcpy_fast (tmpmem, msg, msg_length);
+ u16 id = clib_net_to_host_u16 (*((u16 *) msg));
- if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
+ void (*endian_fp) (void *);
+ endian_fp = am->msg_endian_handlers[id];
+ (*endian_fp) (tmpmem);
+
+ if (id < vec_len (am->msg_tojson_handlers) && am->msg_tojson_handlers[id])
{
- return (-10);
+ tojson_fn = am->msg_tojson_handlers[id];
+ cJSON *o = tojson_fn (tmpmem);
+ char *s = cJSON_Print (o);
+ slen = strlen (s);
+ tlen = fwrite (s, 1, slen, fp);
+ cJSON_free (s);
+ cJSON_Delete (o);
+ vec_free (tmpmem);
+ if (tlen != slen)
+ {
+ fformat (stderr, "writing to file error\n");
+ return -11;
+ }
}
+ else
+ fformat (stderr, " [no registered tojson fn]\n");
+
+ return 0;
+}
+
+#define vl_msg_fwrite(_s, _f) fwrite (_s, 1, sizeof (_s) - 1, _f)
+
+typedef struct
+{
+ FILE *fp;
+ u32 n_traces;
+ u32 i;
+} vl_msg_write_json_args_t;
+
+static int
+vl_msg_write_json_fn (u8 *msg, void *ctx)
+{
+ vl_msg_write_json_args_t *arg = ctx;
+ FILE *fp = arg->fp;
+ api_main_t *am = vlibapi_get_main ();
+ int rc = vl_msg_api_trace_write_one (am, msg, fp);
+ if (rc < 0)
+ return rc;
+
+ if (arg->i < arg->n_traces - 1)
+ vl_msg_fwrite (",\n", fp);
+ arg->i++;
+ return 0;
+}
+
+static int
+vl_msg_api_trace_write_json (api_main_t *am, vl_api_trace_t *tp, FILE *fp)
+{
+ vl_msg_write_json_args_t args;
+ clib_memset (&args, 0, sizeof (args));
+ args.fp = fp;
+ args.n_traces = vec_len (tp->traces);
+ vl_msg_fwrite ("[\n", fp);
+
+ int rv = vl_msg_traverse_trace (tp, vl_msg_write_json_fn, &args);
+ if (rv < 0)
+ return rv;
+
+ vl_msg_fwrite ("]", fp);
+ return 0;
+}
+
+int
+vl_msg_traverse_trace (vl_api_trace_t *tp, vl_msg_traverse_trace_fn fn,
+ void *ctx)
+{
+ int i;
+ u8 *msg;
+ int rv = 0;
/* No-wrap case */
if (tp->wrapped == 0)
{
- /*
- * Note: vec_len return 0 when fed a NULL pointer.
- * Unfortunately, the static analysis tool doesn't
- * figure it out, hence the suppressed warnings.
- * What a great use of my time.
- */
for (i = 0; i < vec_len (tp->traces); i++)
{
- u32 msg_length;
/*sa_ignore NO_NULL_CHK */
msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking.
- */
if (!msg)
continue;
- msg_length = clib_host_to_net_u32 (vec_len (msg));
- if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
- != sizeof (msg_length))
- {
- return (-14);
- }
- if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
- {
- return (-11);
- }
+ rv = fn (msg, ctx);
+ if (rv < 0)
+ return rv;
}
}
else
/* Wrap case: write oldest -> end of buffer */
for (i = tp->curindex; i < vec_len (tp->traces); i++)
{
- u32 msg_length;
msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking
- */
if (!msg)
continue;
- msg_length = clib_host_to_net_u32 (vec_len (msg));
- if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
- != sizeof (msg_length))
- {
- return (-14);
- }
-
- if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
- {
- return (-12);
- }
+ rv = fn (msg, ctx);
+ if (rv < 0)
+ return rv;
}
/* write beginning of buffer -> oldest-1 */
for (i = 0; i < tp->curindex; i++)
{
- u32 msg_length;
/*sa_ignore NO_NULL_CHK */
msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking
- */
if (!msg)
continue;
- msg_length = clib_host_to_net_u32 (vec_len (msg));
- if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
- != sizeof (msg_length))
- {
- return (-14);
- }
-
- if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
- {
- return (-13);
- }
+ rv = fn (msg, ctx);
+ if (rv < 0)
+ return rv;
}
}
return 0;
}
+static int
+vl_api_msg_write_fn (u8 *msg, void *ctx)
+{
+ FILE *fp = ctx;
+ u32 msg_length = clib_host_to_net_u32 (vec_len (msg));
+ if (fwrite (&msg_length, 1, sizeof (msg_length), fp) != sizeof (msg_length))
+ {
+ return (-14);
+ }
+ if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+ {
+ return (-14);
+ }
+ return 0;
+}
+
+int
+vl_msg_api_trace_save (api_main_t *am, vl_api_trace_which_t which, FILE *fp,
+ u8 is_json)
+{
+ vl_api_trace_t *tp;
+ vl_api_trace_file_header_t fh;
+
+ switch (which)
+ {
+ case VL_API_TRACE_TX:
+ tp = am->tx_trace;
+ break;
+
+ case VL_API_TRACE_RX:
+ tp = am->rx_trace;
+ break;
+
+ default:
+ /* duh? */
+ return -1;
+ }
+
+ /* Configured, data present? */
+ if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
+ return -1;
+
+ /* "Dare to be stupid" check */
+ if (fp == 0)
+ {
+ return -2;
+ }
+
+ if (is_json)
+ return vl_msg_api_trace_write_json (am, tp, fp);
+
+ /* Write the file header */
+ fh.wrapped = tp->wrapped;
+ fh.nitems = clib_host_to_net_u32 (vec_len (tp->traces));
+
+ u8 *m = vl_api_serialize_message_table (am, 0);
+ fh.msgtbl_size = clib_host_to_net_u32 (vec_len (m));
+
+ if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
+ {
+ return (-10);
+ }
+
+ /* Write the message table */
+ if (fwrite (m, vec_len (m), 1, fp) != 1)
+ {
+ return (-14);
+ }
+ vec_free (m);
+
+ return vl_msg_traverse_trace (tp, vl_api_msg_write_fn, fp);
+}
+
int
vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
u32 nitems)
vl_msg_api_trace_free (am, which);
}
- memset (tp, 0, sizeof (*tp));
+ clib_memset (tp, 0, sizeof (*tp));
if (clib_arch_is_big_endian)
{
return 0;
}
+void
+vl_msg_api_barrier_sync (void)
+{
+}
+
+void
+vl_msg_api_barrier_release (void)
+{
+}
+
always_inline void
msg_handler_internal (api_main_t * am,
void *the_msg, int trace_it, int do_it, int free_it)
{
- u16 id = ntohs (*((u16 *) the_msg));
+ u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
u8 *(*print_fp) (void *, void *);
+ if (PREDICT_FALSE (am->elog_trace_api_messages))
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "api-msg: %s",
+ .format_args = "T4",
+ };
+ /* *INDENT-ON* */
+ struct
+ {
+ u32 c;
+ } *ed;
+ ed = ELOG_DATA (am->elog_main, e);
+ if (id < vec_len (am->msg_names) && am->msg_names[id])
+ ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
+ else
+ ed->c = elog_string (am->elog_main, "BOGUS");
+ }
+
if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
{
if (trace_it)
if (do_it)
{
if (!am->is_mp_safe[id])
- vl_msg_api_barrier_sync ();
+ {
+ vl_msg_api_barrier_trace_context (am->msg_names[id]);
+ vl_msg_api_barrier_sync ();
+ }
+
+ if (am->is_autoendian[id])
+ {
+ void (*endian_fp) (void *);
+ endian_fp = am->msg_endian_handlers[id];
+ (*endian_fp) (the_msg);
+ }
+
+ if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
+ clib_call_callbacks (am->perf_counter_cbs, am, id,
+ 0 /* before */ );
+
(*am->msg_handlers[id]) (the_msg);
+
+ if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
+ clib_call_callbacks (am->perf_counter_cbs, am, id,
+ 1 /* after */ );
if (!am->is_mp_safe[id])
vl_msg_api_barrier_release ();
}
if (free_it)
vl_msg_api_free (the_msg);
-}
-
-/* set to 1 if you want before/after message handler event logging */
-#define ELOG_API_MESSAGE_HANDLERS 0
-
-#if ELOG_API_MESSAGE_HANDLERS > 0
-static u32
-elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
-{
- uword *p, r;
- static uword *h;
- u8 *name_copy;
-
- if (!h)
- h = hash_create_string (0, sizeof (uword));
-
- p = hash_get_mem (h, msg_name);
- if (p)
- return p[0];
- r = elog_string (&vm->elog_main, "%s", msg_name);
- name_copy = format (0, "%s%c", msg_name, 0);
-
- hash_set_mem (h, name_copy, r);
-
- return r;
+ if (PREDICT_FALSE (am->elog_trace_api_messages))
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "api-msg-done(%s): %s",
+ .format_args = "t4T4",
+ .n_enum_strings = 2,
+ .enum_strings =
+ {
+ "barrier",
+ "mp-safe",
+ }
+ };
+ /* *INDENT-ON* */
+
+ struct
+ {
+ u32 barrier;
+ u32 c;
+ } *ed;
+ ed = ELOG_DATA (am->elog_main, e);
+ if (id < vec_len (am->msg_names) && am->msg_names[id])
+ {
+ ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
+ ed->barrier = !am->is_mp_safe[id];
+ }
+ else
+ {
+ ed->c = elog_string (am->elog_main, "BOGUS");
+ ed->barrier = 0;
+ }
+ }
}
-#endif
+
+void (*vl_msg_api_fuzz_hook) (u16, void *);
/* This is only to be called from a vlib/vnet app */
void
-vl_msg_api_handler_with_vm_node (api_main_t * am,
+vl_msg_api_handler_with_vm_node (api_main_t * am, svm_region_t * vlib_rp,
void *the_msg, vlib_main_t * vm,
- vlib_node_runtime_t * node)
+ vlib_node_runtime_t * node, u8 is_private)
{
- u16 id = ntohs (*((u16 *) the_msg));
+ u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
u8 *(*handler) (void *, void *, void *);
+ u8 *(*print_fp) (void *, void *);
+ svm_region_t *old_vlib_rp;
+ void *save_shmem_hdr;
+ int is_mp_safe = 1;
-#if ELOG_API_MESSAGE_HANDLERS > 0
- {
- /* *INDENT-OFF* */
- ELOG_TYPE_DECLARE (e) =
- {
- .format = "api-msg: %s",
- .format_args = "T4",
- };
- /* *INDENT-ON* */
- struct
+ if (PREDICT_FALSE (am->elog_trace_api_messages))
{
- u32 c;
- } *ed;
- ed = ELOG_DATA (&vm->elog_main, e);
- if (id < vec_len (am->msg_names))
- ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
- else
- ed->c = elog_id_for_msg_name (vm, "BOGUS");
- }
-#endif
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "api-msg: %s",
+ .format_args = "T4",
+ };
+ /* *INDENT-ON* */
+ struct
+ {
+ u32 c;
+ } *ed;
+ ed = ELOG_DATA (am->elog_main, e);
+ if (id < vec_len (am->msg_names) && am->msg_names[id])
+ ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
+ else
+ ed->c = elog_string (am->elog_main, "BOGUS");
+ }
if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
{
handler = (void *) am->msg_handlers[id];
- if (am->rx_trace && am->rx_trace->enabled)
+ if (PREDICT_FALSE (am->rx_trace && am->rx_trace->enabled))
vl_msg_api_trace (am, am->rx_trace, the_msg);
- if (!am->is_mp_safe[id])
- vl_msg_api_barrier_sync ();
+ if (PREDICT_FALSE (am->msg_print_flag))
+ {
+ fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
+ print_fp = (void *) am->msg_print_handlers[id];
+ if (print_fp == 0)
+ {
+ fformat (stdout, " [no registered print fn for msg %d]\n", id);
+ }
+ else
+ {
+ (*print_fp) (the_msg, vm);
+ }
+ }
+ is_mp_safe = am->is_mp_safe[id];
+
+ if (!is_mp_safe)
+ {
+ vl_msg_api_barrier_trace_context (am->msg_names[id]);
+ vl_msg_api_barrier_sync ();
+ }
+ if (is_private)
+ {
+ old_vlib_rp = am->vlib_rp;
+ save_shmem_hdr = am->shmem_hdr;
+ am->vlib_rp = vlib_rp;
+ am->shmem_hdr = (void *) vlib_rp->user_ctx;
+ }
+
+ if (PREDICT_FALSE (vl_msg_api_fuzz_hook != 0))
+ (*vl_msg_api_fuzz_hook) (id, the_msg);
+
+ if (am->is_autoendian[id])
+ {
+ void (*endian_fp) (void *);
+ endian_fp = am->msg_endian_handlers[id];
+ (*endian_fp) (the_msg);
+ }
+ if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
+ clib_call_callbacks (am->perf_counter_cbs, am, id, 0 /* before */ );
+
(*handler) (the_msg, vm, node);
- if (!am->is_mp_safe[id])
+
+ if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
+ clib_call_callbacks (am->perf_counter_cbs, am, id, 1 /* after */ );
+ if (is_private)
+ {
+ am->vlib_rp = old_vlib_rp;
+ am->shmem_hdr = save_shmem_hdr;
+ }
+ if (!is_mp_safe)
vl_msg_api_barrier_release ();
}
else
* Special-case, so we can e.g. bounce messages off the vnet
* main thread without copying them...
*/
- if (!(am->message_bounce[id]))
- vl_msg_api_free (the_msg);
-
-#if ELOG_API_MESSAGE_HANDLERS > 0
- {
- /* *INDENT-OFF* */
- ELOG_TYPE_DECLARE (e) = {
- .format = "api-msg-done: %s",
- .format_args = "T4",
- };
- /* *INDENT-ON* */
+ if (id >= vec_len (am->message_bounce) || !(am->message_bounce[id]))
+ {
+ if (is_private)
+ {
+ old_vlib_rp = am->vlib_rp;
+ save_shmem_hdr = am->shmem_hdr;
+ am->vlib_rp = vlib_rp;
+ am->shmem_hdr = (void *) vlib_rp->user_ctx;
+ }
+ vl_msg_api_free (the_msg);
+ if (is_private)
+ {
+ am->vlib_rp = old_vlib_rp;
+ am->shmem_hdr = save_shmem_hdr;
+ }
+ }
- struct
+ if (PREDICT_FALSE (am->elog_trace_api_messages))
{
- u32 c;
- } *ed;
- ed = ELOG_DATA (&vm->elog_main, e);
- if (id < vec_len (am->msg_names))
- ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
- else
- ed->c = elog_id_for_msg_name (vm, "BOGUS");
- }
-#endif
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "api-msg-done(%s): %s",
+ .format_args = "t4T4",
+ .n_enum_strings = 2,
+ .enum_strings =
+ {
+ "barrier",
+ "mp-safe",
+ }
+ };
+ /* *INDENT-ON* */
+
+ struct
+ {
+ u32 barrier;
+ u32 c;
+ } *ed;
+ ed = ELOG_DATA (am->elog_main, e);
+ if (id < vec_len (am->msg_names) && am->msg_names[id])
+ ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
+ else
+ ed->c = elog_string (am->elog_main, "BOGUS");
+ ed->barrier = is_mp_safe;
+ }
}
void
vl_msg_api_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
void
vl_msg_api_handler_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
&& am->rx_trace->enabled) /* trace_it */ ,
void
vl_msg_api_handler_no_trace_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
0 /* free_it */ );
}
void
vl_msg_api_trace_only (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
void
vl_msg_api_cleanup_handler (void *the_msg)
{
- api_main_t *am = &api_main;
- u16 id = ntohs (*((u16 *) the_msg));
+ api_main_t *am = vlibapi_get_main ();
+ u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
{
void
vl_msg_api_replay_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
- u16 id = ntohs (*((u16 *) the_msg));
+ u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
{
/* do NOT free the message buffer... */
}
+u32
+vl_msg_api_get_msg_length (void *msg_arg)
+{
+ return vl_msg_api_get_msg_length_inline (msg_arg);
+}
+
/*
* vl_msg_api_socket_handler
*/
void
vl_msg_api_socket_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
1 /* do_it */ , 0 /* free_it */ );
}
-#define foreach_msg_api_vector \
-_(msg_names) \
-_(msg_handlers) \
-_(msg_cleanup_handlers) \
-_(msg_endian_handlers) \
-_(msg_print_handlers) \
-_(api_trace_cfg) \
-_(message_bounce) \
-_(is_mp_safe)
+#define foreach_msg_api_vector \
+ _ (msg_names) \
+ _ (msg_handlers) \
+ _ (msg_cleanup_handlers) \
+ _ (msg_endian_handlers) \
+ _ (msg_print_handlers) \
+ _ (msg_print_json_handlers) \
+ _ (msg_tojson_handlers) \
+ _ (msg_fromjson_handlers) \
+ _ (api_trace_cfg) \
+ _ (message_bounce) \
+ _ (is_mp_safe) \
+ _ (is_autoendian)
void
vl_msg_api_config (vl_msg_api_msg_config_t * c)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
- ASSERT (c->id > 0);
+ /*
+ * This happens during the java core tests if the message
+ * dictionary is missing newly added xxx_reply_t messages.
+ * Should never happen, but since I shot myself in the foot once
+ * this way, I thought I'd make it easy to debug if I ever do
+ * it again... (;-)...
+ */
+ if (c->id == 0)
+ {
+ if (c->name)
+ clib_warning ("Trying to register %s with a NULL msg id!", c->name);
+ else
+ clib_warning ("Trying to register a NULL msg with a NULL msg id!");
+ clib_warning ("Did you forget to call setup_message_id_table?");
+ return;
+ }
#define _(a) vec_validate (am->a, c->id);
foreach_msg_api_vector;
#undef _
- if (am->msg_names[c->id])
- clib_warning ("BUG: multiple registrations of 'vl_api_%s_t_handler'",
- c->name);
+ if (am->msg_handlers[c->id] && am->msg_handlers[c->id] != c->handler)
+ clib_warning
+ ("BUG: re-registering 'vl_api_%s_t_handler'."
+ "Handler was %llx, replaced by %llx",
+ c->name, am->msg_handlers[c->id], c->handler);
am->msg_names[c->id] = c->name;
am->msg_handlers[c->id] = c->handler;
am->msg_cleanup_handlers[c->id] = c->cleanup;
am->msg_endian_handlers[c->id] = c->endian;
am->msg_print_handlers[c->id] = c->print;
+ am->msg_print_json_handlers[c->id] = c->print_json;
+ am->msg_tojson_handlers[c->id] = c->tojson;
+ am->msg_fromjson_handlers[c->id] = c->fromjson;
am->message_bounce[c->id] = c->message_bounce;
am->is_mp_safe[c->id] = c->is_mp_safe;
+ am->is_autoendian[c->id] = c->is_autoendian;
am->api_trace_cfg[c->id].size = c->size;
am->api_trace_cfg[c->id].trace_enable = c->traced;
am->api_trace_cfg[c->id].replay_enable = c->replay;
+
+ if (!am->msg_id_by_name)
+ am->msg_id_by_name = hash_create_string (0, sizeof (uword));
+
+ hash_set_mem (am->msg_id_by_name, c->name, c->id);
}
/*
*/
void
vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
- void *endian, void *print, int size, int traced)
+ void *endian, void *print, int size, int traced,
+ void *print_json, void *tojson, void *fromjson)
{
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
c->id = id;
c->name = name;
c->replay = 1;
c->message_bounce = 0;
c->is_mp_safe = 0;
+ c->is_autoendian = 0;
+ c->tojson = tojson;
+ c->fromjson = fromjson;
+ c->print_json = print_json;
+ vl_msg_api_config (c);
+}
+
+void
+vl_msg_api_clean_handlers (int msg_id)
+{
+ vl_msg_api_msg_config_t cfg;
+ vl_msg_api_msg_config_t *c = &cfg;
+
+ clib_memset (c, 0, sizeof (*c));
+
+ c->id = msg_id;
vl_msg_api_config (c);
}
void
vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
ASSERT (msg_id > 0);
vec_validate (am->msg_cleanup_handlers, msg_id);
}
void
-vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
+vl_msg_api_queue_handler (svm_queue_t * q)
{
uword msg;
- while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
+ while (!svm_queue_sub (q, (u8 *) & msg, SVM_Q_WAIT, 0))
vl_msg_api_handler ((void *) msg);
}
+u32
+vl_msg_api_max_length (void *mp)
+{
+ msgbuf_t *mb;
+ u32 data_len = ~0;
+
+ /* Work out the maximum sane message length, and return it */
+ if (PREDICT_TRUE (mp != 0))
+ {
+ mb = (msgbuf_t *) (((u8 *) mp) - offsetof (msgbuf_t, data));
+ data_len = clib_net_to_host_u32 (mb->data_len);
+ }
+ return data_len;
+}
+
vl_api_trace_t *
vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
{
{
}
-clib_error_t *
-vl_api_init (vlib_main_t * vm)
-{
- static u8 once;
- api_main_t *am = &api_main;
-
- if (once)
- return 0;
-
- once = 1;
-
- am->region_name = "/unset";
- /*
- * Eventually passed to fchown, -1 => "current user"
- * instead of 0 => "root". A very fine disctinction at best.
- */
- if (am->api_uid == 0)
- am->api_uid = -1;
- if (am->api_gid == 0)
- am->api_gid = -1;
-
- return (0);
-}
-
-void vl_msg_api_custom_dump_configure (api_main_t * am)
- __attribute__ ((weak));
-void
-vl_msg_api_custom_dump_configure (api_main_t * am)
-{
-}
-
-VLIB_INIT_FUNCTION (vl_api_init);
-
-static void
-vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
- u32 first_index, u32 last_index,
- vl_api_replay_t which)
-{
- vl_api_trace_file_header_t *hp;
- int i, fd;
- struct stat statb;
- size_t file_size;
- u8 *msg;
- u8 endian_swap_needed = 0;
- api_main_t *am = &api_main;
- u8 *tmpbuf = 0;
- u32 nitems;
- void **saved_print_handlers = 0;
-
- fd = open ((char *) filename, O_RDONLY);
-
- if (fd < 0)
- {
- vlib_cli_output (vm, "Couldn't open %s\n", filename);
- return;
- }
-
- if (fstat (fd, &statb) < 0)
- {
- vlib_cli_output (vm, "Couldn't stat %s\n", filename);
- close (fd);
- return;
- }
-
- if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
- {
- vlib_cli_output (vm, "File not plausible: %s\n", filename);
- close (fd);
- return;
- }
-
- file_size = statb.st_size;
- file_size = (file_size + 4095) & ~(4096);
-
- hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
-
- if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
- {
- vlib_cli_output (vm, "mmap failed: %s\n", filename);
- close (fd);
- return;
- }
- close (fd);
-
- if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
- || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
- endian_swap_needed = 1;
-
- if (endian_swap_needed)
- nitems = ntohl (hp->nitems);
- else
- nitems = hp->nitems;
-
- if (last_index == (u32) ~ 0)
- {
- last_index = nitems - 1;
- }
-
- if (first_index >= nitems || last_index >= nitems)
- {
- vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
- first_index, last_index, nitems - 1);
- munmap (hp, file_size);
- return;
- }
- if (hp->wrapped)
- vlib_cli_output (vm,
- "Note: wrapped/incomplete trace, results may vary\n");
-
- if (which == CUSTOM_DUMP)
- {
- saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
- vl_msg_api_custom_dump_configure (am);
- }
-
-
- msg = (u8 *) (hp + 1);
-
- for (i = 0; i < first_index; i++)
- {
- trace_cfg_t *cfgp;
- int size;
- u16 msg_id;
-
- size = clib_host_to_net_u32 (*(u32 *) msg);
- msg += sizeof (u32);
-
- if (clib_arch_is_little_endian)
- msg_id = ntohs (*((u16 *) msg));
- else
- msg_id = *((u16 *) msg);
-
- cfgp = am->api_trace_cfg + msg_id;
- if (!cfgp)
- {
- vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
- munmap (hp, file_size);
- return;
- }
- msg += size;
- }
-
- if (which == REPLAY)
- am->replay_in_progress = 1;
-
- for (; i <= last_index; i++)
- {
- trace_cfg_t *cfgp;
- u16 *msg_idp;
- u16 msg_id;
- int size;
-
- if (which == DUMP)
- vlib_cli_output (vm, "---------- trace %d -----------\n", i);
-
- size = clib_host_to_net_u32 (*(u32 *) msg);
- msg += sizeof (u32);
-
- if (clib_arch_is_little_endian)
- msg_id = ntohs (*((u16 *) msg));
- else
- msg_id = *((u16 *) msg);
-
- cfgp = am->api_trace_cfg + msg_id;
- if (!cfgp)
- {
- vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
- munmap (hp, file_size);
- vec_free (tmpbuf);
- am->replay_in_progress = 0;
- return;
- }
-
- /* Copy the buffer (from the read-only mmap'ed file) */
- vec_validate (tmpbuf, size - 1 + sizeof (uword));
- clib_memcpy (tmpbuf + sizeof (uword), msg, size);
- memset (tmpbuf, 0xf, sizeof (uword));
-
- /*
- * Endian swap if needed. All msg data is supposed to be
- * in network byte order. All msg handlers are supposed to
- * know that. The generic message dumpers don't know that.
- * One could fix apigen, I suppose.
- */
- if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
- {
- void (*endian_fp) (void *);
- if (msg_id >= vec_len (am->msg_endian_handlers)
- || (am->msg_endian_handlers[msg_id] == 0))
- {
- vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
- munmap (hp, file_size);
- vec_free (tmpbuf);
- am->replay_in_progress = 0;
- return;
- }
- endian_fp = am->msg_endian_handlers[msg_id];
- (*endian_fp) (tmpbuf + sizeof (uword));
- }
-
- /* msg_id always in network byte order */
- if (clib_arch_is_little_endian)
- {
- msg_idp = (u16 *) (tmpbuf + sizeof (uword));
- *msg_idp = msg_id;
- }
-
- switch (which)
- {
- case CUSTOM_DUMP:
- case DUMP:
- if (msg_id < vec_len (am->msg_print_handlers) &&
- am->msg_print_handlers[msg_id])
- {
- u8 *(*print_fp) (void *, void *);
-
- print_fp = (void *) am->msg_print_handlers[msg_id];
- (*print_fp) (tmpbuf + sizeof (uword), vm);
- }
- else
- {
- vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
- msg_id);
- break;
- }
- break;
-
- case INITIALIZERS:
- if (msg_id < vec_len (am->msg_print_handlers) &&
- am->msg_print_handlers[msg_id])
- {
- u8 *s;
- int j;
- u8 *(*print_fp) (void *, void *);
-
- print_fp = (void *) am->msg_print_handlers[msg_id];
-
- vlib_cli_output (vm, "/*");
-
- (*print_fp) (tmpbuf + sizeof (uword), vm);
- vlib_cli_output (vm, "*/\n");
-
- s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
- am->msg_names[msg_id], i,
- am->api_trace_cfg[msg_id].size);
-
- for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
- {
- if ((j & 7) == 0)
- s = format (s, "\n ");
- s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
- }
- s = format (s, "\n};\n%c", 0);
- vlib_cli_output (vm, (char *) s);
- vec_free (s);
- }
- break;
-
- case REPLAY:
- if (msg_id < vec_len (am->msg_print_handlers) &&
- am->msg_print_handlers[msg_id] && cfgp->replay_enable)
- {
- void (*handler) (void *);
-
- handler = (void *) am->msg_handlers[msg_id];
-
- if (!am->is_mp_safe[msg_id])
- vl_msg_api_barrier_sync ();
- (*handler) (tmpbuf + sizeof (uword));
- if (!am->is_mp_safe[msg_id])
- vl_msg_api_barrier_release ();
- }
- else
- {
- if (cfgp->replay_enable)
- vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
- msg_id);
- break;
- }
- break;
- }
-
- _vec_len (tmpbuf) = 0;
- msg += size;
- }
-
- if (saved_print_handlers)
- {
- clib_memcpy (am->msg_print_handlers, saved_print_handlers,
- vec_len (am->msg_print_handlers) * sizeof (void *));
- vec_free (saved_print_handlers);
- }
-
- munmap (hp, file_size);
- vec_free (tmpbuf);
- am->replay_in_progress = 0;
-}
-
-u8 *
-format_vl_msg_api_trace_status (u8 * s, va_list * args)
-{
- api_main_t *am = va_arg (*args, api_main_t *);
- vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
- vl_api_trace_t *tp;
- char *trace_name;
-
- switch (which)
- {
- case VL_API_TRACE_TX:
- tp = am->tx_trace;
- trace_name = "TX trace";
- break;
-
- case VL_API_TRACE_RX:
- tp = am->rx_trace;
- trace_name = "RX trace";
- break;
-
- default:
- abort ();
- }
-
- if (tp == 0)
- {
- s = format (s, "%s: not yet configured.\n", trace_name);
- return s;
- }
-
- s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
- trace_name, vec_len (tp->traces), tp->nitems,
- tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
- return s;
-}
static u8 post_mortem_dump_enabled;
-static clib_error_t *
-api_trace_command_fn (vlib_main_t * vm,
- unformat_input_t * input, vlib_cli_command_t * cmd)
-{
- u32 nitems = 256 << 10;
- api_main_t *am = &api_main;
- vl_api_trace_which_t which = VL_API_TRACE_RX;
- u8 *filename;
- u32 first = 0;
- u32 last = (u32) ~ 0;
- FILE *fp;
- int rv;
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (input, "on") || unformat (input, "enable"))
- {
- if (unformat (input, "nitems %d", &nitems))
- ;
- vl_msg_api_trace_configure (am, which, nitems);
- vl_msg_api_trace_onoff (am, which, 1 /* on */ );
- }
- else if (unformat (input, "off"))
- {
- vl_msg_api_trace_onoff (am, which, 0);
- }
- else if (unformat (input, "save %s", &filename))
- {
- u8 *chroot_filename;
- if (strstr ((char *) filename, "..")
- || index ((char *) filename, '/'))
- {
- vlib_cli_output (vm, "illegal characters in filename '%s'",
- filename);
- return 0;
- }
-
- chroot_filename = format (0, "/tmp/%s%c", filename, 0);
-
- vec_free (filename);
-
- fp = fopen ((char *) chroot_filename, "w");
- if (fp == NULL)
- {
- vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
- return 0;
- }
- rv = vl_msg_api_trace_save (am, which, fp);
- fclose (fp);
- if (rv == -1)
- vlib_cli_output (vm, "API Trace data not present\n");
- else if (rv == -2)
- vlib_cli_output (vm, "File for writing is closed\n");
- else if (rv == -10)
- vlib_cli_output (vm, "Error while writing header to file\n");
- else if (rv == -11)
- vlib_cli_output (vm, "Error while writing trace to file\n");
- else if (rv == -12)
- vlib_cli_output (vm,
- "Error while writing end of buffer trace to file\n");
- else if (rv == -13)
- vlib_cli_output (vm,
- "Error while writing start of buffer trace to file\n");
- else if (rv < 0)
- vlib_cli_output (vm, "Unkown error while saving: %d", rv);
- else
- vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
- vec_free (chroot_filename);
- }
- else if (unformat (input, "dump %s", &filename))
- {
- vl_msg_api_process_file (vm, filename, first, last, DUMP);
- }
- else if (unformat (input, "custom-dump %s", &filename))
- {
- vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
- }
- else if (unformat (input, "replay %s", &filename))
- {
- vl_msg_api_process_file (vm, filename, first, last, REPLAY);
- }
- else if (unformat (input, "initializers %s", &filename))
- {
- vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
- }
- else if (unformat (input, "tx"))
- {
- which = VL_API_TRACE_TX;
- }
- else if (unformat (input, "first %d", &first))
- {
- ;
- }
- else if (unformat (input, "last %d", &last))
- {
- ;
- }
- else if (unformat (input, "status"))
- {
- vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
- am, which);
- }
- else if (unformat (input, "free"))
- {
- vl_msg_api_trace_onoff (am, which, 0);
- vl_msg_api_trace_free (am, which);
- }
- else if (unformat (input, "post-mortem-on"))
- post_mortem_dump_enabled = 1;
- else if (unformat (input, "post-mortem-off"))
- post_mortem_dump_enabled = 0;
- else
- return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
- }
- return 0;
-}
-
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (api_trace_command, static) = {
- .path = "api trace",
- .short_help =
- "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]",
- .function = api_trace_command_fn,
-};
-/* *INDENT-ON* */
-
-static clib_error_t *
-api_config_fn (vlib_main_t * vm, unformat_input_t * input)
+void
+vl_msg_api_post_mortem_dump_enable_disable (int enable)
{
- u32 nitems = 256 << 10;
- vl_api_trace_which_t which = VL_API_TRACE_RX;
- api_main_t *am = &api_main;
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (input, "on") || unformat (input, "enable"))
- {
- if (unformat (input, "nitems %d", &nitems))
- ;
- vl_msg_api_trace_configure (am, which, nitems);
- vl_msg_api_trace_onoff (am, which, 1 /* on */ );
- post_mortem_dump_enabled = 1;
- }
- else
- return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
- }
- return 0;
+ post_mortem_dump_enabled = enable;
}
-VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
-
void
vl_msg_api_post_mortem_dump (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
FILE *fp;
char filename[64];
int rv;
rv = write (2, "\n", 1);
return;
}
- rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
+ rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp, 0);
fclose (fp);
if (rv < 0)
{
void
vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* Mild idiot proofing */
if (msg_id_host_byte_order > 10000)
int
vl_msg_api_pd_handler (void *mp, int rv)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int (*fp) (void *, int);
u16 msg_id;
void
vl_msg_api_set_first_available_msg_id (u16 first_avail)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->first_available_msg_id = first_avail;
}
u16
-vl_msg_api_get_msg_ids (char *name, int n)
+vl_msg_api_get_msg_ids (const char *name, int n)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *name_copy;
vl_api_msg_range_t *rp;
uword *p;
}
void
-vl_msg_api_add_msg_name_crc (api_main_t * am, char *string, u32 id)
+vl_msg_api_add_msg_name_crc (api_main_t * am, const char *string, u32 id)
{
uword *p;
hash_set_mem (am->msg_index_by_name_and_crc, string, id);
}
+void
+vl_msg_api_add_version (api_main_t * am, const char *string,
+ u32 major, u32 minor, u32 patch)
+{
+ api_version_t version = {.major = major,.minor = minor,.patch = patch };
+ ASSERT (strlen (string) < 64);
+ strncpy (version.name, string, 64 - 1);
+ vec_add1 (am->api_version_list, version);
+}
+
+u32
+vl_msg_api_get_msg_index (u8 * name_and_crc)
+{
+ api_main_t *am = vlibapi_get_main ();
+ uword *p;
+
+ if (am->msg_index_by_name_and_crc)
+ {
+ p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc);
+ if (p)
+ return p[0];
+ }
+ return ~0;
+}
+
+void *
+vl_msg_push_heap_w_region (svm_region_t * vlib_rp)
+{
+ pthread_mutex_lock (&vlib_rp->mutex);
+ return svm_push_data_heap (vlib_rp);
+}
+
+void *
+vl_msg_push_heap (void)
+{
+ api_main_t *am = vlibapi_get_main ();
+ return vl_msg_push_heap_w_region (am->vlib_rp);
+}
+
+void
+vl_msg_pop_heap_w_region (svm_region_t * vlib_rp, void *oldheap)
+{
+ svm_pop_heap (oldheap);
+ pthread_mutex_unlock (&vlib_rp->mutex);
+}
+
+void
+vl_msg_pop_heap (void *oldheap)
+{
+ api_main_t *am = vlibapi_get_main ();
+ vl_msg_pop_heap_w_region (am->vlib_rp, oldheap);
+}
+
+/* Must be nul terminated */
+int
+vl_api_c_string_to_api_string (const char *buf, vl_api_string_t * str)
+{
+ /* copy without nul terminator */
+ u32 len = strlen (buf);
+ if (len > 0)
+ clib_memcpy_fast (str->buf, buf, len);
+ str->length = htonl (len);
+ return len + sizeof (u32);
+}
+
+/* Must NOT be nul terminated */
+int
+vl_api_vec_to_api_string (const u8 * vec, vl_api_string_t * str)
+{
+ u32 len = vec_len (vec);
+ clib_memcpy (str->buf, vec, len);
+ str->length = htonl (len);
+ return len + sizeof (u32);
+}
+
+u32
+vl_api_string_len (vl_api_string_t * astr)
+{
+ return clib_net_to_host_u32 (astr->length);
+}
+
+u8 *
+vl_api_format_string (u8 * s, va_list * args)
+{
+ vl_api_string_t *a = va_arg (*args, vl_api_string_t *);
+ vec_add (s, a->buf, clib_net_to_host_u32 (a->length));
+ return s;
+}
+
+/*
+ * Returns a new vector. Remember to free it after use.
+ * NOT nul terminated.
+ */
+u8 *
+vl_api_from_api_to_new_vec (void *mp, vl_api_string_t * astr)
+{
+ u8 *v = 0;
+
+ if (vl_msg_api_max_length (mp) < clib_net_to_host_u32 (astr->length))
+ return format (0, "insane astr->length %u%c",
+ clib_net_to_host_u32 (astr->length), 0);
+ vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
+ return v;
+}
+
+/*
+ * Returns a new vector. Remember to free it after use.
+ * Nul terminated.
+ */
+char *
+vl_api_from_api_to_new_c_string (vl_api_string_t * astr)
+{
+ char *v = 0;
+ if (clib_net_to_host_u32 (astr->length) > 0)
+ {
+ vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
+ vec_add1 (v, 0);
+ }
+ return v;
+}
+
+void
+vl_api_set_elog_main (elog_main_t * m)
+{
+ api_main_t *am = vlibapi_get_main ();
+ am->elog_main = m;
+}
+
+int
+vl_api_set_elog_trace_api_messages (int enable)
+{
+ int rv;
+ api_main_t *am = vlibapi_get_main ();
+
+ rv = am->elog_trace_api_messages;
+ am->elog_trace_api_messages = enable;
+ return rv;
+}
+
+int
+vl_api_get_elog_trace_api_messages (void)
+{
+ api_main_t *am = vlibapi_get_main ();
+
+ return am->elog_trace_api_messages;
+}
/*
* fd.io coding-style-patch-verification: ON
Code Review / vpp.git / blobdiff