aboutsummaryrefslogtreecommitdiffstats
path: root/vlib-api/vlibapi
diff options
context:
space:
mode:
Diffstat (limited to 'vlib-api/vlibapi')
-rw-r--r--vlib-api/vlibapi/api.h316
-rw-r--r--vlib-api/vlibapi/api_shared.c1758
-rw-r--r--vlib-api/vlibapi/node_serialize.c469
3 files changed, 1361 insertions, 1182 deletions
diff --git a/vlib-api/vlibapi/api.h b/vlib-api/vlibapi/api.h
index 3c4b68dc006..9d885c17930 100644
--- a/vlib-api/vlibapi/api.h
+++ b/vlib-api/vlibapi/api.h
@@ -1,7 +1,7 @@
/*
*------------------------------------------------------------------
* api.h
- *
+ *
* Copyright (c) 2009-2015 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -26,205 +26,221 @@
#include <vlibmemory/unix_shared_memory_queue.h>
#include <vlib/unix/unix.h>
-typedef enum {
- REGISTRATION_TYPE_FREE=0,
- REGISTRATION_TYPE_SHMEM,
- REGISTRATION_TYPE_SOCKET_LISTEN,
- REGISTRATION_TYPE_SOCKET_SERVER,
- REGISTRATION_TYPE_SOCKET_CLIENT,
+typedef enum
+{
+ REGISTRATION_TYPE_FREE = 0,
+ REGISTRATION_TYPE_SHMEM,
+ REGISTRATION_TYPE_SOCKET_LISTEN,
+ REGISTRATION_TYPE_SOCKET_SERVER,
+ REGISTRATION_TYPE_SOCKET_CLIENT,
} vl_registration_type_t;
-typedef struct vl_api_registration_ {
- vl_registration_type_t registration_type;
+typedef struct vl_api_registration_
+{
+ vl_registration_type_t registration_type;
+
+ /* Index in VLIB's brain (not shared memory). */
+ u32 vl_api_registration_pool_index;
- /* Index in VLIB's brain (not shared memory). */
- u32 vl_api_registration_pool_index;
-
- u8 *name;
+ u8 *name;
- /*
- * The following groups of data could be unioned, but my fingers are
- * going to be sore enough.
- */
+ /*
+ * The following groups of data could be unioned, but my fingers are
+ * going to be sore enough.
+ */
- /* shared memory only */
- unix_shared_memory_queue_t *vl_input_queue;
+ /* shared memory only */
+ unix_shared_memory_queue_t *vl_input_queue;
- /* socket server and client */
- u32 unix_file_index;
- i8 * unprocessed_input;
- u32 unprocessed_msg_length;
- u8 * output_vector;
+ /* socket server and client */
+ u32 unix_file_index;
+ i8 *unprocessed_input;
+ u32 unprocessed_msg_length;
+ u8 *output_vector;
- /* socket client only */
- u32 server_handle;
- u32 server_index;
+ /* socket client only */
+ u32 server_handle;
+ u32 server_index;
} vl_api_registration_t;
/* Trace configuration for a single message */
-typedef struct {
- int size;
- int trace_enable;
- int replay_enable;
+typedef struct
+{
+ int size;
+ int trace_enable;
+ int replay_enable;
} trace_cfg_t;
/*
* API recording
*/
-typedef struct {
- u8 endian;
- u8 enabled;
- u8 wrapped;
- u8 pad;
- u32 nitems;
- u32 curindex;
- u8 **traces;
+typedef struct
+{
+ u8 endian;
+ u8 enabled;
+ u8 wrapped;
+ u8 pad;
+ u32 nitems;
+ u32 curindex;
+ u8 **traces;
} vl_api_trace_t;
-typedef CLIB_PACKED (struct {
- u8 endian;
- u8 wrapped;
- u32 nitems;
-}) vl_api_trace_file_header_t;
+typedef CLIB_PACKED (struct
+ {
+ u8 endian; u8 wrapped;
+ u32 nitems;
+ }) vl_api_trace_file_header_t;
-typedef enum {
- VL_API_TRACE_TX,
- VL_API_TRACE_RX,
+typedef enum
+{
+ VL_API_TRACE_TX,
+ VL_API_TRACE_RX,
} vl_api_trace_which_t;
#define VL_API_LITTLE_ENDIAN 0x00
#define VL_API_BIG_ENDIAN 0x01
-typedef struct {
- u8 * name;
- u16 first_msg_id;
- u16 last_msg_id;
+typedef struct
+{
+ u8 *name;
+ u16 first_msg_id;
+ u16 last_msg_id;
} vl_api_msg_range_t;
-typedef struct {
- void (**msg_handlers)(void *);
- int (**pd_msg_handlers)(void *, int);
- void (**msg_cleanup_handlers)(void *);
- void (**msg_endian_handlers)(void *);
- void (**msg_print_handlers)(void *, void *);
- char **msg_names;
- u8 *message_bounce;
- u8 *is_mp_safe;
- struct ring_alloc_ *arings;
- u32 ring_misses;
- u32 missing_clients;
- vl_api_trace_t *rx_trace;
- vl_api_trace_t *tx_trace;
- int msg_print_flag;
- trace_cfg_t *api_trace_cfg;
- int our_pid;
- svm_region_t *vlib_rp;
- svm_region_t **mapped_shmem_regions;
- struct vl_shmem_hdr_ *shmem_hdr;
- vl_api_registration_t **vl_clients;
-
- /* For plugin msg allocator */
- u16 first_available_msg_id;
-
- /* message range by name hash */
- uword * msg_range_by_name;
-
- /* vector of message ranges */
- vl_api_msg_range_t *msg_ranges;
-
- /* gid for the api shared memory region */
- int api_gid;
- int api_uid;
-
- /* Client-only data structures */
- unix_shared_memory_queue_t *vl_input_queue;
-
- /*
- * All VLIB-side message handlers use my_client_index to identify
- * the queue / client. This works in sim replay.
- */
- int my_client_index;
- /*
- * This is the (shared VM) address of the registration,
- * don't use it to id the connection since it can't possibly
- * work in simulator replay.
- */
- vl_api_registration_t *my_registration;
-
- i32 vlib_signal;
-
- char *region_name;
- char *root_path;
+typedef struct
+{
+ void (**msg_handlers) (void *);
+ int (**pd_msg_handlers) (void *, int);
+ void (**msg_cleanup_handlers) (void *);
+ void (**msg_endian_handlers) (void *);
+ void (**msg_print_handlers) (void *, void *);
+ char **msg_names;
+ u8 *message_bounce;
+ u8 *is_mp_safe;
+ struct ring_alloc_ *arings;
+ u32 ring_misses;
+ u32 missing_clients;
+ vl_api_trace_t *rx_trace;
+ vl_api_trace_t *tx_trace;
+ int msg_print_flag;
+ trace_cfg_t *api_trace_cfg;
+ int our_pid;
+ svm_region_t *vlib_rp;
+ svm_region_t **mapped_shmem_regions;
+ struct vl_shmem_hdr_ *shmem_hdr;
+ vl_api_registration_t **vl_clients;
+
+ /* For plugin msg allocator */
+ u16 first_available_msg_id;
+
+ /* message range by name hash */
+ uword *msg_range_by_name;
+
+ /* vector of message ranges */
+ vl_api_msg_range_t *msg_ranges;
+
+ /* gid for the api shared memory region */
+ int api_gid;
+ int api_uid;
+
+ /* Client-only data structures */
+ unix_shared_memory_queue_t *vl_input_queue;
+
+ /*
+ * All VLIB-side message handlers use my_client_index to identify
+ * the queue / client. This works in sim replay.
+ */
+ int my_client_index;
+ /*
+ * This is the (shared VM) address of the registration,
+ * don't use it to id the connection since it can't possibly
+ * work in simulator replay.
+ */
+ vl_api_registration_t *my_registration;
+
+ i32 vlib_signal;
+
+ char *region_name;
+ char *root_path;
} api_main_t;
api_main_t api_main;
-typedef struct {
- int id;
- char *name;
- void *handler;
- void *cleanup;
- void *endian;
- void *print;
- int size;
- int traced;
- int replay;
- int message_bounce;
- int is_mp_safe;
+typedef struct
+{
+ int id;
+ char *name;
+ void *handler;
+ void *cleanup;
+ void *endian;
+ void *print;
+ int size;
+ int traced;
+ int replay;
+ int message_bounce;
+ int is_mp_safe;
} vl_msg_api_msg_config_t;
/* api_shared.c prototypes */
-int vl_msg_api_rx_trace_enabled(api_main_t *am);
-int vl_msg_api_tx_trace_enabled(api_main_t *am);
-void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg);
-int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which,
- int onoff);
-int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which);
-int vl_msg_api_trace_save(api_main_t *am,
- vl_api_trace_which_t which, FILE *fp);
-int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which,
- u32 nitems);
-void vl_msg_api_handler_with_vm_node (api_main_t *am,
- void *the_msg, vlib_main_t *vm,
- vlib_node_runtime_t *node);
+int vl_msg_api_rx_trace_enabled (api_main_t * am);
+int vl_msg_api_tx_trace_enabled (api_main_t * am);
+void vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg);
+int vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
+ int onoff);
+int vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which);
+int vl_msg_api_trace_save (api_main_t * am,
+ vl_api_trace_which_t which, FILE * fp);
+int vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
+ u32 nitems);
+void vl_msg_api_handler_with_vm_node (api_main_t * am,
+ void *the_msg, vlib_main_t * vm,
+ vlib_node_runtime_t * node);
void vl_msg_api_handler (void *the_msg);
void vl_msg_api_handler_no_free (void *the_msg);
void vl_msg_api_handler_no_trace_no_free (void *the_msg);
void vl_msg_api_trace_only (void *the_msg);
void vl_msg_api_cleanup_handler (void *the_msg);
-void vl_msg_api_replay_handler(void *the_msg);
-void vl_msg_api_socket_handler(void *the_msg);
-void vl_msg_api_set_handlers(int msg_id, char *msg_name,
- void *handler,
- void *cleanup,
- void *endian,
- void *print,
- int msg_size, int traced);
+void vl_msg_api_replay_handler (void *the_msg);
+void vl_msg_api_socket_handler (void *the_msg);
+void vl_msg_api_set_handlers (int msg_id, char *msg_name,
+ void *handler,
+ void *cleanup,
+ void *endian,
+ void *print, int msg_size, int traced);
void vl_msg_api_config (vl_msg_api_msg_config_t *);
-void vl_msg_api_set_cleanup_handler(int msg_id, void *fp);
-void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q);
-vl_api_trace_t *vl_msg_api_trace_get(api_main_t *am,
- vl_api_trace_which_t which);
+void vl_msg_api_set_cleanup_handler (int msg_id, void *fp);
+void vl_msg_api_queue_handler (unix_shared_memory_queue_t * q);
+vl_api_trace_t *vl_msg_api_trace_get (api_main_t * am,
+ vl_api_trace_which_t which);
void vl_msg_api_free (void *);
void vl_noop_handler (void *mp);
-clib_error_t *vl_api_init (vlib_main_t *vm);
-void vl_msg_api_increment_missing_client_counter(void);
+clib_error_t *vl_api_init (vlib_main_t * vm);
+void vl_msg_api_increment_missing_client_counter (void);
void vl_msg_api_post_mortem_dump (void);
-void vl_msg_api_register_pd_handler (void *handler, u16 msg_id_host_byte_order);
+void vl_msg_api_register_pd_handler (void *handler,
+ u16 msg_id_host_byte_order);
int vl_msg_api_pd_handler (void *mp, int rv);
void vl_msg_api_set_first_available_msg_id (u16 first_avail);
-u16 vl_msg_api_get_msg_ids (char * name, int n);
+u16 vl_msg_api_get_msg_ids (char *name, int n);
/* node_serialize.c prototypes */
-u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
- u32 max_threads, int include_nexts,
- int include_stats);
-vlib_node_t ** vlib_node_unserialize (u8 * vector);
+u8 *vlib_node_serialize (vlib_node_main_t * nm, u8 * vector,
+ u32 max_threads, int include_nexts,
+ int include_stats);
+vlib_node_t **vlib_node_unserialize (u8 * vector);
#define VLIB_API_INIT_FUNCTION(x) VLIB_DECLARE_INIT_FUNCTION(x,api_init)
#endif /* included_api_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vlib-api/vlibapi/api_shared.c b/vlib-api/vlibapi/api_shared.c
index 0600e621a4e..18b189e1837 100644
--- a/vlib-api/vlibapi/api_shared.c
+++ b/vlib-api/vlibapi/api_shared.c
@@ -1,8 +1,8 @@
-/*
+/*
*------------------------------------------------------------------
* api_shared.c - API message handling, common code for both clients
* and the vlib process itself.
- *
+ *
*
* Copyright (c) 2009 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -37,349 +37,394 @@
api_main_t api_main;
-void vl_msg_api_barrier_sync(void) __attribute__((weak));
-void vl_msg_api_barrier_sync(void) { }
+void vl_msg_api_barrier_sync (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_sync (void)
+{
+}
-void vl_msg_api_barrier_release(void) __attribute__((weak));
-void vl_msg_api_barrier_release(void) { }
+void vl_msg_api_barrier_release (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_release (void)
+{
+}
-void vl_msg_api_increment_missing_client_counter(void)
+void
+vl_msg_api_increment_missing_client_counter (void)
{
- api_main_t * am = &api_main;
- am->missing_clients++;
+ api_main_t *am = &api_main;
+ am->missing_clients++;
}
-typedef enum {
- DUMP,
- CUSTOM_DUMP,
- REPLAY,
- INITIALIZERS,
+typedef enum
+{
+ DUMP,
+ CUSTOM_DUMP,
+ REPLAY,
+ INITIALIZERS,
} vl_api_replay_t;
-int vl_msg_api_rx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_rx_trace_enabled (api_main_t * am)
{
- return (am->rx_trace && am->rx_trace->enabled);
+ return (am->rx_trace && am->rx_trace->enabled);
}
-int vl_msg_api_tx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_tx_trace_enabled (api_main_t * am)
{
- return (am->tx_trace && am->tx_trace->enabled);
+ return (am->tx_trace && am->tx_trace->enabled);
}
/*
* vl_msg_api_trace
*/
-void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg)
+void
+vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
{
- u8 **this_trace;
- u8 **old_trace;
- u8 *msg_copy;
- trace_cfg_t *cfgp;
- u16 msg_id = ntohs(*((u16 *)msg));
+ u8 **this_trace;
+ u8 **old_trace;
+ u8 *msg_copy;
+ trace_cfg_t *cfgp;
+ u16 msg_id = ntohs (*((u16 *) msg));
- cfgp = am->api_trace_cfg + msg_id;
+ cfgp = am->api_trace_cfg + msg_id;
- if (!cfgp || !cfgp->trace_enable)
- return;
+ if (!cfgp || !cfgp->trace_enable)
+ return;
- msg_copy = 0;
+ msg_copy = 0;
- if (tp->nitems == 0) {
- clib_warning ("tp->nitems is 0");
- return;
+ if (tp->nitems == 0)
+ {
+ clib_warning ("tp->nitems is 0");
+ return;
}
- if (vec_len(tp->traces) < tp->nitems) {
- vec_add1(tp->traces, 0);
- this_trace = tp->traces + vec_len(tp->traces) - 1;
- } else {
- tp->wrapped = 1;
- old_trace = tp->traces + tp->curindex++;
- if (tp->curindex == tp->nitems)
- tp->curindex = 0;
- vec_free(*old_trace);
- this_trace = old_trace;
+ if (vec_len (tp->traces) < tp->nitems)
+ {
+ vec_add1 (tp->traces, 0);
+ this_trace = tp->traces + vec_len (tp->traces) - 1;
+ }
+ else
+ {
+ tp->wrapped = 1;
+ old_trace = tp->traces + tp->curindex++;
+ if (tp->curindex == tp->nitems)
+ tp->curindex = 0;
+ vec_free (*old_trace);
+ this_trace = old_trace;
}
- vec_validate(msg_copy, cfgp->size - 1);
- clib_memcpy(msg_copy, msg, cfgp->size);
- *this_trace = msg_copy;
+ vec_validate (msg_copy, cfgp->size - 1);
+ clib_memcpy (msg_copy, msg, cfgp->size);
+ *this_trace = msg_copy;
}
-int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which,
- int onoff)
+int
+vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
+ int onoff)
{
- vl_api_trace_t *tp;
- int rv;
+ vl_api_trace_t *tp;
+ int rv;
- switch(which)
+ switch (which)
{
case VL_API_TRACE_TX:
- tp = am->tx_trace;
- if (tp == 0) {
- vl_msg_api_trace_configure (am, which, 1024);
- tp = am->tx_trace;
- }
- break;
-
+ tp = am->tx_trace;
+ if (tp == 0)
+ {
+ vl_msg_api_trace_configure (am, which, 1024);
+ tp = am->tx_trace;
+ }
+ break;
+
case VL_API_TRACE_RX:
- tp = am->rx_trace;
- if (tp == 0) {
- vl_msg_api_trace_configure (am, which, 1024);
- tp = am->rx_trace;
- }
- break;
-
+ tp = am->rx_trace;
+ if (tp == 0)
+ {
+ vl_msg_api_trace_configure (am, which, 1024);
+ tp = am->rx_trace;
+ }
+ break;
+
default:
- /* duh? */
- return -1;
+ /* duh? */
+ return -1;
}
- /* Configured? */
- if (tp == 0 || tp->nitems == 0)
- return -1;
+ /* Configured? */
+ if (tp == 0 || tp->nitems == 0)
+ return -1;
- rv = tp->enabled;
- tp->enabled = onoff;
+ rv = tp->enabled;
+ tp->enabled = onoff;
- return rv;
+ return rv;
}
-int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which)
+int
+vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
{
- vl_api_trace_t *tp;
- int i;
+ vl_api_trace_t *tp;
+ int i;
- switch(which)
+ switch (which)
{
case VL_API_TRACE_TX:
- tp = am->tx_trace;
- break;
-
+ tp = am->tx_trace;
+ break;
+
case VL_API_TRACE_RX:
- tp = am->rx_trace;
- break;
-
+ tp = am->rx_trace;
+ break;
+
default:
- /* duh? */
- return -1;
+ /* duh? */
+ return -1;
}
- /* Configured? */
- if (!tp || tp->nitems == 0)
- return -1;
+ /* Configured? */
+ if (!tp || tp->nitems == 0)
+ return -1;
- tp->curindex = 0;
- tp->wrapped = 0;
+ tp->curindex = 0;
+ tp->wrapped = 0;
- for (i = 0; i < vec_len(tp->traces); i++) {
- vec_free(tp->traces[i]);
+ for (i = 0; i < vec_len (tp->traces); i++)
+ {
+ vec_free (tp->traces[i]);
}
- vec_free(tp->traces);
+ vec_free (tp->traces);
- return 0;
+ return 0;
}
-int vl_msg_api_trace_save(api_main_t *am,
- vl_api_trace_which_t which, FILE *fp)
+int
+vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
{
- vl_api_trace_t *tp;
- vl_api_trace_file_header_t fh;
- int i;
- u8 *msg;
+ vl_api_trace_t *tp;
+ vl_api_trace_file_header_t fh;
+ int i;
+ u8 *msg;
- switch(which)
+ switch (which)
{
case VL_API_TRACE_TX:
- tp = am->tx_trace;
- break;
-
+ tp = am->tx_trace;
+ break;
+
case VL_API_TRACE_RX:
- tp = am->rx_trace;
- break;
-
+ tp = am->rx_trace;
+ break;
+
default:
- /* duh? */
- return -1;
+ /* duh? */
+ return -1;
}
- /* Configured, data present? */
- if (tp == 0 || tp->nitems == 0 || vec_len(tp->traces) == 0)
- 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;
+ /* "Dare to be stupid" check */
+ if (fp == 0)
+ {
+ return -2;
}
- /* Write the file header */
- fh.nitems = vec_len(tp->traces);
- fh.endian = tp->endian;
- fh.wrapped = tp->wrapped;
+ /* Write the file header */
+ fh.nitems = vec_len (tp->traces);
+ fh.endian = tp->endian;
+ fh.wrapped = tp->wrapped;
- if (fwrite(&fh, sizeof(fh), 1, fp) != 1) {
- return (-10);
+ if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
+ {
+ return (-10);
}
- /* 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++) {
- /*sa_ignore NO_NULL_CHK*/
- msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking.
- */
- if (!msg)
- continue;
- if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
- return (-11);
- }
- }
- } else {
- /* Wrap case: write oldest -> end of buffer */
- for (i = tp->curindex; i < vec_len(tp->traces); i++) {
- msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking
- */
- if (!msg)
- continue;
-
- if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
- return (-12);
- }
- }
- /* write beginning of buffer -> oldest-1 */
- for (i = 0; i < tp->curindex; i++) {
- /*sa_ignore NO_NULL_CHK*/
- msg = tp->traces[i];
- /*
- * This retarded check required to pass
- * [sic] SA-checking
- */
- if (!msg)
- continue;
-
- if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
- return (-13);
- }
- }
+ /* 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++)
+ {
+ /*sa_ignore NO_NULL_CHK */
+ msg = tp->traces[i];
+ /*
+ * This retarded check required to pass
+ * [sic] SA-checking.
+ */
+ if (!msg)
+ continue;
+ if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+ {
+ return (-11);
+ }
+ }
}
- return 0;
+ else
+ {
+ /* Wrap case: write oldest -> end of buffer */
+ for (i = tp->curindex; i < vec_len (tp->traces); i++)
+ {
+ msg = tp->traces[i];
+ /*
+ * This retarded check required to pass
+ * [sic] SA-checking
+ */
+ if (!msg)
+ continue;
+
+ if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+ {
+ return (-12);
+ }
+ }
+ /* write beginning of buffer -> oldest-1 */
+ for (i = 0; i < tp->curindex; i++)
+ {
+ /*sa_ignore NO_NULL_CHK */
+ msg = tp->traces[i];
+ /*
+ * This retarded check required to pass
+ * [sic] SA-checking
+ */
+ if (!msg)
+ continue;
+
+ if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+ {
+ return (-13);
+ }
+ }
+ }
+ return 0;
}
-int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which,
- u32 nitems)
+int
+vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
+ u32 nitems)
{
- vl_api_trace_t *tp;
- int was_on = 0;
+ vl_api_trace_t *tp;
+ int was_on = 0;
- switch(which)
+ switch (which)
{
case VL_API_TRACE_TX:
- tp = am->tx_trace;
- if (tp == 0) {
- vec_validate(am->tx_trace, 0);
- tp = am->tx_trace;
- }
- break;
-
+ tp = am->tx_trace;
+ if (tp == 0)
+ {
+ vec_validate (am->tx_trace, 0);
+ tp = am->tx_trace;
+ }
+ break;
+
case VL_API_TRACE_RX:
- tp = am->rx_trace;
- if (tp == 0) {
- vec_validate(am->rx_trace, 0);
- tp = am->rx_trace;
- }
+ tp = am->rx_trace;
+ if (tp == 0)
+ {
+ vec_validate (am->rx_trace, 0);
+ tp = am->rx_trace;
+ }
- break;
+ break;
default:
- return -1;
+ return -1;
}
- if (tp->enabled) {
- was_on = vl_msg_api_trace_onoff(am, which, 0);
+ if (tp->enabled)
+ {
+ was_on = vl_msg_api_trace_onoff (am, which, 0);
}
- if (tp->traces) {
- vl_msg_api_trace_free(am, which);
+ if (tp->traces)
+ {
+ vl_msg_api_trace_free (am, which);
}
- memset(tp, 0, sizeof(*tp));
+ memset (tp, 0, sizeof (*tp));
- if (clib_arch_is_big_endian) {
- tp->endian = VL_API_BIG_ENDIAN;
- } else {
- tp->endian = VL_API_LITTLE_ENDIAN;
+ if (clib_arch_is_big_endian)
+ {
+ tp->endian = VL_API_BIG_ENDIAN;
+ }
+ else
+ {
+ tp->endian = VL_API_LITTLE_ENDIAN;
}
- tp->nitems = nitems;
- if (was_on) {
- (void)vl_msg_api_trace_onoff(am, which, was_on);
+ tp->nitems = nitems;
+ if (was_on)
+ {
+ (void) vl_msg_api_trace_onoff (am, which, was_on);
}
- return 0;
+ return 0;
}
-always_inline void msg_handler_internal (api_main_t *am,
- void *the_msg,
- int trace_it,
- int do_it,
- int free_it)
+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));
- u8 *(*print_fp)(void *, void *);
-
- if (id < vec_len(am->msg_handlers) &&
- am->msg_handlers[id]) {
- if (trace_it)
- vl_msg_api_trace(am, am->rx_trace, the_msg);
-
- if (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]\n");
- } else {
- (*print_fp)(the_msg, stdout);
- }
- }
-
- if (do_it) {
- if (!am->is_mp_safe[id])
- vl_msg_api_barrier_sync();
- (*am->msg_handlers[id])(the_msg);
- if (!am->is_mp_safe[id])
- vl_msg_api_barrier_release();
- }
- } else {
- clib_warning("no handler for msg id %d", id);
+ u16 id = ntohs (*((u16 *) the_msg));
+ u8 *(*print_fp) (void *, void *);
+
+ if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
+ {
+ if (trace_it)
+ vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+ if (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]\n");
+ }
+ else
+ {
+ (*print_fp) (the_msg, stdout);
+ }
+ }
+
+ if (do_it)
+ {
+ if (!am->is_mp_safe[id])
+ vl_msg_api_barrier_sync ();
+ (*am->msg_handlers[id]) (the_msg);
+ if (!am->is_mp_safe[id])
+ vl_msg_api_barrier_release ();
+ }
+ }
+ else
+ {
+ clib_warning ("no handler for msg id %d", id);
}
- if (free_it)
- vl_msg_api_free(the_msg);
+ 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)
+static u32
+elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
{
- uword * p, r;
- static uword * h;
+ uword *p, r;
+ static uword *h;
u8 *name_copy;
- if (! h)
- h = hash_create_string (0, sizeof (uword));
+ if (!h)
+ h = hash_create_string (0, sizeof (uword));
p = hash_get_mem (h, msg_name);
if (p)
@@ -395,155 +440,181 @@ static u32 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
#endif
/* This is only to be called from a vlib/vnet app */
-void vl_msg_api_handler_with_vm_node (api_main_t *am,
- void *the_msg, vlib_main_t *vm,
- vlib_node_runtime_t *node)
+void
+vl_msg_api_handler_with_vm_node (api_main_t * am,
+ void *the_msg, vlib_main_t * vm,
+ vlib_node_runtime_t * node)
{
- u16 id = ntohs(*((u16 *)the_msg));
- u8 *(*handler)(void *, void *, void *);
-
+ u16 id = ntohs (*((u16 *) the_msg));
+ u8 *(*handler) (void *, void *, void *);
+
#if ELOG_API_MESSAGE_HANDLERS > 0
- {
- ELOG_TYPE_DECLARE (e) = {
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
.format = "api-msg: %s",
.format_args = "T4",
};
- struct { 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
-
- 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)
- vl_msg_api_trace(am, am->rx_trace, the_msg);
-
- if (!am->is_mp_safe[id])
- vl_msg_api_barrier_sync();
- (*handler)(the_msg, vm, node);
- if (!am->is_mp_safe[id])
- vl_msg_api_barrier_release();
- } else {
- clib_warning("no hander for msg id %d", id);
+ /* *INDENT-ON* */
+ struct
+ {
+ 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
+
+ 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)
+ vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+ if (!am->is_mp_safe[id])
+ vl_msg_api_barrier_sync ();
+ (*handler) (the_msg, vm, node);
+ if (!am->is_mp_safe[id])
+ vl_msg_api_barrier_release ();
+ }
+ else
+ {
+ clib_warning ("no hander for msg id %d", id);
+ }
+
+ /*
* 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);
+ 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* */
+
+ struct
{
- ELOG_TYPE_DECLARE (e) = {
- .format = "api-msg-done: %s",
- .format_args = "T4",
- };
- struct { 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");
- }
+ 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
}
-void vl_msg_api_handler (void *the_msg)
+void
+vl_msg_api_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = &api_main;
- msg_handler_internal (am, the_msg,
- (am->rx_trace
- && am->rx_trace->enabled) /* trace_it */,
- 1 /* do_it */, 1 /* free_it */);
+ msg_handler_internal (am, the_msg,
+ (am->rx_trace
+ && am->rx_trace->enabled) /* trace_it */ ,
+ 1 /* do_it */ , 1 /* free_it */ );
}
-void vl_msg_api_handler_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
- msg_handler_internal (am, the_msg,
- (am->rx_trace
- && am->rx_trace->enabled) /* trace_it */,
- 1 /* do_it */, 0 /* free_it */);
+ api_main_t *am = &api_main;
+ msg_handler_internal (am, the_msg,
+ (am->rx_trace
+ && am->rx_trace->enabled) /* trace_it */ ,
+ 1 /* do_it */ , 0 /* free_it */ );
}
-void vl_msg_api_handler_no_trace_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_trace_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
- msg_handler_internal (am, the_msg, 0/* trace_it */, 1 /* do_it */,
- 0 /* free_it */);
+ api_main_t *am = &api_main;
+ msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
+ 0 /* free_it */ );
}
/*
* Add a trace record to the API message trace buffer, if
* API message tracing is enabled. Handy for adding sufficient
* data to the trace to reproduce autonomous state, as opposed to
- * state downloaded via control-plane API messages. Example: the NAT
+ * state downloaded via control-plane API messages. Example: the NAT
* application creates database entries based on packet traffic, not
* control-plane messages.
*
*/
-void vl_msg_api_trace_only (void *the_msg)
+void
+vl_msg_api_trace_only (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = &api_main;
- msg_handler_internal (am, the_msg,
- (am->rx_trace
- && am->rx_trace->enabled) /* trace_it */,
- 0 /* do_it */, 0 /* free_it */);
+ msg_handler_internal (am, the_msg,
+ (am->rx_trace
+ && am->rx_trace->enabled) /* trace_it */ ,
+ 0 /* do_it */ , 0 /* free_it */ );
}
-void vl_msg_api_cleanup_handler (void *the_msg)
+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 = &api_main;
+ u16 id = ntohs (*((u16 *) the_msg));
- if (PREDICT_FALSE(id >= vec_len(am->msg_cleanup_handlers))) {
- clib_warning ("_vl_msg_id too large: %d\n", id);
- return;
+ if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
+ {
+ clib_warning ("_vl_msg_id too large: %d\n", id);
+ return;
}
- if (am->msg_cleanup_handlers[id])
- (*am->msg_cleanup_handlers[id])(the_msg);
+ if (am->msg_cleanup_handlers[id])
+ (*am->msg_cleanup_handlers[id]) (the_msg);
- vl_msg_api_free(the_msg);
+ vl_msg_api_free (the_msg);
}
/*
* vl_msg_api_replay_handler
*/
-void vl_msg_api_replay_handler(void *the_msg)
+void
+vl_msg_api_replay_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = &api_main;
- u16 id = ntohs(*((u16 *)the_msg));
+ u16 id = ntohs (*((u16 *) the_msg));
- if (PREDICT_FALSE(id >= vec_len(am->msg_handlers))) {
- clib_warning ("_vl_msg_id too large: %d\n", id);
- return;
+ if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
+ {
+ clib_warning ("_vl_msg_id too large: %d\n", id);
+ return;
}
- /* do NOT trace the message... */
- if (am->msg_handlers[id])
- (*am->msg_handlers[id])(the_msg);
- /* do NOT free the message buffer... */
+ /* do NOT trace the message... */
+ if (am->msg_handlers[id])
+ (*am->msg_handlers[id]) (the_msg);
+ /* do NOT free the message buffer... */
}
+
/*
* vl_msg_api_socket_handler
*/
-void vl_msg_api_socket_handler(void *the_msg)
+void
+vl_msg_api_socket_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = &api_main;
- msg_handler_internal (am, the_msg,
- (am->rx_trace
- && am->rx_trace->enabled) /* trace_it */,
- 1 /* do_it */, 0 /* free_it */);
+ msg_handler_internal (am, the_msg,
+ (am->rx_trace
+ && am->rx_trace->enabled) /* trace_it */ ,
+ 1 /* do_it */ , 0 /* free_it */ );
}
#define foreach_msg_api_vector \
@@ -556,592 +627,675 @@ _(api_trace_cfg) \
_(message_bounce) \
_(is_mp_safe)
-void vl_msg_api_config (vl_msg_api_msg_config_t *c)
+void
+vl_msg_api_config (vl_msg_api_msg_config_t * c)
{
- api_main_t *am = &api_main;
+ api_main_t *am = &api_main;
- ASSERT(c->id > 0);
+ ASSERT (c->id > 0);
#define _(a) vec_validate (am->a, c->id);
- foreach_msg_api_vector;
+ foreach_msg_api_vector;
#undef _
- 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->message_bounce[c->id] = c->message_bounce;
- am->is_mp_safe[c->id] = c->is_mp_safe;
-
- 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;
+ 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->message_bounce[c->id] = c->message_bounce;
+ am->is_mp_safe[c->id] = c->is_mp_safe;
+
+ 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;
}
-/*
+/*
* vl_msg_api_set_handlers
* preserve the old API for a while
*/
-void vl_msg_api_set_handlers(int id, char *name, void *handler, void *cleanup,
- void *endian, void *print, int size, int traced)
+void
+vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
+ void *endian, void *print, int size, int traced)
{
- vl_msg_api_msg_config_t cfg;
- vl_msg_api_msg_config_t *c = &cfg;
-
- c->id = id;
- c->name = name;
- c->handler = handler;
- c->cleanup = cleanup;
- c->endian = endian;
- c->print = print;
- c->size = size;
- c->traced = traced;
- c->replay = 1;
- c->message_bounce = 0;
- c->is_mp_safe = 0;
- vl_msg_api_config (c);
+ vl_msg_api_msg_config_t cfg;
+ vl_msg_api_msg_config_t *c = &cfg;
+
+ c->id = id;
+ c->name = name;
+ c->handler = handler;
+ c->cleanup = cleanup;
+ c->endian = endian;
+ c->print = print;
+ c->size = size;
+ c->traced = traced;
+ c->replay = 1;
+ c->message_bounce = 0;
+ c->is_mp_safe = 0;
+ vl_msg_api_config (c);
}
-void vl_msg_api_set_cleanup_handler(int msg_id, void *fp)
+void
+vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
{
- api_main_t *am = &api_main;
- ASSERT(msg_id > 0);
+ api_main_t *am = &api_main;
+ ASSERT (msg_id > 0);
- vec_validate(am->msg_cleanup_handlers, msg_id);
- am->msg_cleanup_handlers[msg_id] = fp;
+ vec_validate (am->msg_cleanup_handlers, msg_id);
+ am->msg_cleanup_handlers[msg_id] = fp;
}
-void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q)
+void
+vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
{
- uword msg;
+ uword msg;
- while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
- vl_msg_api_handler((void *)msg);
+ while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
+ vl_msg_api_handler ((void *) msg);
}
-vl_api_trace_t *vl_msg_api_trace_get(api_main_t *am, vl_api_trace_which_t which)
+vl_api_trace_t *
+vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
{
- switch(which)
+ switch (which)
{
case VL_API_TRACE_RX:
- return am->rx_trace;
+ return am->rx_trace;
case VL_API_TRACE_TX:
- return am->tx_trace;
+ return am->tx_trace;
default:
- return 0;
+ return 0;
}
}
-void vl_noop_handler (void *mp) { }
+void
+vl_noop_handler (void *mp)
+{
+}
clib_error_t *
-vl_api_init (vlib_main_t *vm)
+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);
+ 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) { }
+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)
+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;
- static u8 *tmpbuf;
- 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;
+ 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;
+ static u8 *tmpbuf;
+ 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);
- return;
+ if (fstat (fd, &statb) < 0)
+ {
+ vlib_cli_output (vm, "Couldn't stat %s\n", filename);
+ return;
}
- if (! (statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp))) {
- vlib_cli_output (vm, "File not plausible: %s\n", filename);
- return;
+ if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
+ {
+ vlib_cli_output (vm, "File not plausible: %s\n", filename);
+ return;
}
- file_size = statb.st_size;
- file_size = (file_size + 4095) & ~(4096);
+ file_size = statb.st_size;
+ file_size = (file_size + 4095) & ~(4096);
- hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
+ 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;
+ 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;
+ 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 (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);
- return;
+
+ 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);
+ 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);
+ 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;
-
- 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);
- return;
- }
- size = cfgp->size;
- msg += size;
+ msg = (u8 *) (hp + 1);
+
+ for (i = 0; i < first_index; i++)
+ {
+ trace_cfg_t *cfgp;
+ int size;
+ u16 msg_id;
+
+ 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);
+ return;
+ }
+ size = cfgp->size;
+ msg += size;
}
-
- 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);
-
- 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);
- return;
- }
- size = cfgp->size;
-
- /* 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);
- 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;
+
+ 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);
+
+ 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);
+ return;
+ }
+ size = cfgp->size;
+
+ /* 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);
+ 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);
+
+ 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);
+ munmap (hp, file_size);
}
-u8 * format_vl_msg_api_trace_status (u8 * s, va_list * args)
+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;
+ 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)
+ switch (which)
{
case VL_API_TRACE_TX:
- tp = am->tx_trace;
- trace_name = "TX trace";
- break;
-
+ tp = am->tx_trace;
+ trace_name = "TX trace";
+ break;
+
case VL_API_TRACE_RX:
- tp = am->rx_trace;
- trace_name = "RX trace";
- break;
+ tp = am->rx_trace;
+ trace_name = "RX trace";
+ break;
default:
- abort();
+ abort ();
}
- if (tp == 0) {
- s = format (s, "%s: not yet configured.\n", trace_name);
- return s;
+ 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;
+ 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)
+ 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 < 0)
- vlib_cli_output (vm, "ERROR: %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);
+ 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 < 0)
+ vlib_cli_output (vm, "ERROR: %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;
+ return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (api_trace_command, static) = {
.path = "api trace",
- .short_help =
+ .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)
{
- 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);
+ 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;
+ return 0;
}
VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
-void vl_msg_api_post_mortem_dump (void)
+void
+vl_msg_api_post_mortem_dump (void)
{
- api_main_t * am = &api_main;
- FILE *fp;
- char filename[64];
- int rv;
-
- if (post_mortem_dump_enabled == 0)
- return;
-
- snprintf (filename, sizeof(filename), "/tmp/api_post_mortem.%d",
- getpid());
-
- fp = fopen (filename, "w");
- if (fp == NULL) {
- rv = write (2, "Couldn't create ", 16);
- rv = write (2, filename, strlen(filename));
- rv = write (2, "\n", 1);
- return;
+ api_main_t *am = &api_main;
+ FILE *fp;
+ char filename[64];
+ int rv;
+
+ if (post_mortem_dump_enabled == 0)
+ return;
+
+ snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
+ getpid ());
+
+ fp = fopen (filename, "w");
+ if (fp == NULL)
+ {
+ rv = write (2, "Couldn't create ", 16);
+ rv = write (2, filename, strlen (filename));
+ rv = write (2, "\n", 1);
+ return;
}
- rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
- fclose (fp);
- if (rv < 0) {
- rv = write (2, "Failed to save post-mortem API trace to ", 40);
- rv = write (2, filename, strlen(filename));
- rv = write (2, "\n", 1);
+ rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
+ fclose (fp);
+ if (rv < 0)
+ {
+ rv = write (2, "Failed to save post-mortem API trace to ", 40);
+ rv = write (2, filename, strlen (filename));
+ rv = write (2, "\n", 1);
}
-
+
}
/* Layered message handling support */
-void vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
+void
+vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
{
- api_main_t * am = &api_main;
-
- /* Mild idiot proofing */
- if (msg_id_host_byte_order > 10000)
- clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
- msg_id_host_byte_order,
- clib_net_to_host_u16 (msg_id_host_byte_order));
- vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
- am->pd_msg_handlers[msg_id_host_byte_order] = fp;
+ api_main_t *am = &api_main;
+
+ /* Mild idiot proofing */
+ if (msg_id_host_byte_order > 10000)
+ clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
+ msg_id_host_byte_order,
+ clib_net_to_host_u16 (msg_id_host_byte_order));
+ vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
+ am->pd_msg_handlers[msg_id_host_byte_order] = fp;
}
-int vl_msg_api_pd_handler (void *mp, int rv)
+int
+vl_msg_api_pd_handler (void *mp, int rv)
{
- api_main_t * am = &api_main;
- int (*fp)(void *, int);
- u16 msg_id;
+ api_main_t *am = &api_main;
+ int (*fp) (void *, int);
+ u16 msg_id;
- if (clib_arch_is_little_endian)
- msg_id = clib_net_to_host_u16(*((u16 *)mp));
- else
- msg_id = *((u16 *)mp);
-
- if (msg_id >= vec_len (am->pd_msg_handlers)
- || am->pd_msg_handlers[msg_id] == 0)
- return rv;
-
- fp = am->pd_msg_handlers [msg_id];
- rv = (*fp)(mp, rv);
+ if (clib_arch_is_little_endian)
+ msg_id = clib_net_to_host_u16 (*((u16 *) mp));
+ else
+ msg_id = *((u16 *) mp);
+
+ if (msg_id >= vec_len (am->pd_msg_handlers)
+ || am->pd_msg_handlers[msg_id] == 0)
return rv;
+
+ fp = am->pd_msg_handlers[msg_id];
+ rv = (*fp) (mp, rv);
+ return rv;
}
-void vl_msg_api_set_first_available_msg_id (u16 first_avail)
+void
+vl_msg_api_set_first_available_msg_id (u16 first_avail)
{
- api_main_t * am = &api_main;
-
- am->first_available_msg_id = first_avail;
+ api_main_t *am = &api_main;
+
+ am->first_available_msg_id = first_avail;
}
-u16 vl_msg_api_get_msg_ids (char * name, int n)
+u16
+vl_msg_api_get_msg_ids (char *name, int n)
{
- api_main_t * am = &api_main;
- u8 * name_copy;
- vl_api_msg_range_t * rp;
- uword * p;
- u16 rv;
-
- if (am->msg_range_by_name == 0)
- am->msg_range_by_name = hash_create_string (0, sizeof(uword));
-
- name_copy = format (0, "%s%c", name, 0);
-
- p = hash_get_mem (am->msg_range_by_name, name_copy);
- if (p) {
- clib_warning ("WARNING: duplicate message range registration for '%s'",
- name_copy);
- vec_free(name_copy);
- return ((u16) ~0);
+ api_main_t *am = &api_main;
+ u8 *name_copy;
+ vl_api_msg_range_t *rp;
+ uword *p;
+ u16 rv;
+
+ if (am->msg_range_by_name == 0)
+ am->msg_range_by_name = hash_create_string (0, sizeof (uword));
+
+ name_copy = format (0, "%s%c", name, 0);
+
+ p = hash_get_mem (am->msg_range_by_name, name_copy);
+ if (p)
+ {
+ clib_warning ("WARNING: duplicate message range registration for '%s'",
+ name_copy);
+ vec_free (name_copy);
+ return ((u16) ~ 0);
}
- if (n < 0 || n > 1024) {
- clib_warning
- ("WARNING: bad number of message-IDs (%d) requested by '%s'",
- n, name_copy);
- vec_free(name_copy);
- return ((u16) ~0);
+ if (n < 0 || n > 1024)
+ {
+ clib_warning
+ ("WARNING: bad number of message-IDs (%d) requested by '%s'",
+ n, name_copy);
+ vec_free (name_copy);
+ return ((u16) ~ 0);
}
- vec_add2 (am->msg_ranges, rp, 1);
+ vec_add2 (am->msg_ranges, rp, 1);
- rv = rp->first_msg_id = am->first_available_msg_id;
- am->first_available_msg_id += n;
- rp->last_msg_id = am->first_available_msg_id - 1;
- rp->name = name_copy;
+ rv = rp->first_msg_id = am->first_available_msg_id;
+ am->first_available_msg_id += n;
+ rp->last_msg_id = am->first_available_msg_id - 1;
+ rp->name = name_copy;
- hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
+ hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
- return rv;
+ return rv;
}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vlib-api/vlibapi/node_serialize.c b/vlib-api/vlibapi/node_serialize.c
index 907ed4cdf8b..5eb530264e0 100644
--- a/vlib-api/vlibapi/node_serialize.c
+++ b/vlib-api/vlibapi/node_serialize.c
@@ -16,8 +16,8 @@
#include <vppinfra/serialize.h>
-extern void vl_msg_api_barrier_sync(void);
-extern void vl_msg_api_barrier_release(void);
+extern void vl_msg_api_barrier_sync (void);
+extern void vl_msg_api_barrier_release (void);
/* serialized representation of state strings */
@@ -31,68 +31,68 @@ _(STATE_POLLING, "polling") \
_(STATE_INTERRUPT_WAIT, "interrupt wait") \
_(STATE_INTERNAL, "internal")
-typedef enum {
+typedef enum
+{
#define _(a,b) a,
foreach_state_string_code
#undef _
} state_string_enum_t;
-static char *state_strings[] =
- {
+static char *state_strings[] = {
#define _(a,b) b,
- foreach_state_string_code
+ foreach_state_string_code
#undef _
- };
+};
-/*
+/*
* Serialize a vlib_node_main_t. Appends the result to vector.
* Pass 0 to create a new vector, use vec_reset_length(vector)
* to recycle a vector / avoid memory allocation, etc.
* Switch heaps before/after to serialize into API client shared memory.
*/
-u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
- u32 max_threads, int include_nexts,
- int include_stats)
+u8 *
+vlib_node_serialize (vlib_node_main_t * nm, u8 * vector,
+ u32 max_threads, int include_nexts, int include_stats)
{
- serialize_main_t _sm, *sm=&_sm;
- vlib_main_t * vm = vlib_get_main();
- vlib_node_t * n;
- static vlib_node_t *** node_dups;
- vlib_node_t ** nodes;
- static vlib_main_t ** stat_vms;
+ serialize_main_t _sm, *sm = &_sm;
+ vlib_main_t *vm = vlib_get_main ();
+ vlib_node_t *n;
+ static vlib_node_t ***node_dups;
+ vlib_node_t **nodes;
+ static vlib_main_t **stat_vms;
vlib_main_t *stat_vm;
- u8 * namep;
+ u8 *namep;
u32 name_bytes;
uword i, j, k;
u64 l, v, c, d;
state_string_enum_t state_code;
u32 threads_to_serialize;
-
- vec_reset_length(node_dups);
- if (vec_len(stat_vms) == 0)
+ vec_reset_length (node_dups);
+
+ if (vec_len (stat_vms) == 0)
{
- if (vec_len(vlib_mains) == 0)
- vec_add1 (stat_vms, vm);
+ if (vec_len (vlib_mains) == 0)
+ vec_add1 (stat_vms, vm);
else
- {
- for (i = 0; i < vec_len (vlib_mains); i++)
- {
- stat_vm = vlib_mains[i];
- if (stat_vm)
- vec_add1 (stat_vms, stat_vm);
- }
- }
+ {
+ for (i = 0; i < vec_len (vlib_mains); i++)
+ {
+ stat_vm = vlib_mains[i];
+ if (stat_vm)
+ vec_add1 (stat_vms, stat_vm);
+ }
+ }
}
threads_to_serialize = clib_min (max_threads, vec_len (stat_vms));
- /*
+ /*
* Barrier sync across stats scraping.
* Otherwise, the counts will be grossly inaccurate.
*/
- vl_msg_api_barrier_sync();
+ vl_msg_api_barrier_sync ();
for (j = 0; j < threads_to_serialize; j++)
{
@@ -100,134 +100,135 @@ u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
nm = &stat_vm->node_main;
if (include_stats)
- {
- for (i = 0; i < vec_len (nm->nodes); i++)
- {
- n = nm->nodes[i];
- vlib_node_sync_stats (stat_vm, n);
- }
- }
+ {
+ for (i = 0; i < vec_len (nm->nodes); i++)
+ {
+ n = nm->nodes[i];
+ vlib_node_sync_stats (stat_vm, n);
+ }
+ }
nodes = vec_dup (nm->nodes);
-
- vec_add1(node_dups, nodes);
+
+ vec_add1 (node_dups, nodes);
}
- vl_msg_api_barrier_release();
-
+ vl_msg_api_barrier_release ();
+
serialize_open_vector (sm, vector);
- serialize_likely_small_unsigned_integer (sm, vec_len(stat_vms));
-
+ serialize_likely_small_unsigned_integer (sm, vec_len (stat_vms));
+
for (j = 0; j < vec_len (stat_vms); j++)
{
stat_vm = stat_vms[j];
nodes = node_dups[j];
- serialize_likely_small_unsigned_integer (sm, vec_len(nodes));
+ serialize_likely_small_unsigned_integer (sm, vec_len (nodes));
for (i = 0; i < vec_len (nodes); i++)
- {
- n = nodes[i];
-
- l = n->stats_total.clocks - n->stats_last_clear.clocks;
- v = n->stats_total.vectors - n->stats_last_clear.vectors;
- c = n->stats_total.calls - n->stats_last_clear.calls;
- d = n->stats_total.suspends
- - n->stats_last_clear.suspends;
-
- state_code = STATE_INTERNAL;
-
- if (n->type == VLIB_NODE_TYPE_PROCESS)
- {
- vlib_process_t * p = vlib_get_process_from_node (vm, n);
-
- switch (p->flags
- & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
- | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
- {
- default:
- if (! (p->flags & VLIB_PROCESS_IS_RUNNING))
- state_code = STATE_DONE;
- break;
-
- case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
- state_code = STATE_TIME_WAIT;
- break;
-
- case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
- state_code = STATE_EVENT_WAIT;
- break;
-
- case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
- | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
- state_code = STATE_ANY_WAIT;
- break;
- }
- }
- else if (n->type != VLIB_NODE_TYPE_INTERNAL)
- {
- state_code = STATE_POLLING;
- if (n->state == VLIB_NODE_STATE_DISABLED)
- state_code = STATE_DISABLED;
- else if (n->state == VLIB_NODE_STATE_INTERRUPT)
- state_code = STATE_INTERRUPT_WAIT;
- }
-
- /* See unserialize_cstring */
- name_bytes = vec_len (n->name);
- serialize_likely_small_unsigned_integer(sm, name_bytes);
- namep = serialize_get (sm, name_bytes);
- memcpy (namep, n->name, name_bytes);
-
- serialize_likely_small_unsigned_integer (sm, (u64)state_code);
- serialize_likely_small_unsigned_integer (sm, n->type);
-
- if (include_nexts)
- {
- serialize_likely_small_unsigned_integer
- (sm, vec_len(n->next_nodes));
- for (k = 0; k < vec_len (n->next_nodes); k++)
- serialize_likely_small_unsigned_integer (sm, n->next_nodes[k]);
- }
- else
- serialize_likely_small_unsigned_integer (sm, 0);
-
- if (include_stats)
- {
- /* stats present */
- serialize_likely_small_unsigned_integer (sm, 1);
- /* total clocks */
- serialize_integer(sm, l, 8);
- /* Total calls */
- serialize_integer(sm, c, 8);
- /* Total vectors */
- serialize_integer(sm, v, 8);
- /* Total suspends */
- serialize_integer(sm, d, 8);
- }
- else /* no stats */
- serialize_likely_small_unsigned_integer (sm, 0);
- }
+ {
+ n = nodes[i];
+
+ l = n->stats_total.clocks - n->stats_last_clear.clocks;
+ v = n->stats_total.vectors - n->stats_last_clear.vectors;
+ c = n->stats_total.calls - n->stats_last_clear.calls;
+ d = n->stats_total.suspends - n->stats_last_clear.suspends;
+
+ state_code = STATE_INTERNAL;
+
+ if (n->type == VLIB_NODE_TYPE_PROCESS)
+ {
+ vlib_process_t *p = vlib_get_process_from_node (vm, n);
+
+ switch (p->flags
+ & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
+ | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
+ {
+ default:
+ if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
+ state_code = STATE_DONE;
+ break;
+
+ case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
+ state_code = STATE_TIME_WAIT;
+ break;
+
+ case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
+ state_code = STATE_EVENT_WAIT;
+ break;
+
+ case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
+ state_code =
+ STATE_ANY_WAIT;
+ break;
+ }
+ }
+ else if (n->type != VLIB_NODE_TYPE_INTERNAL)
+ {
+ state_code = STATE_POLLING;
+ if (n->state == VLIB_NODE_STATE_DISABLED)
+ state_code = STATE_DISABLED;
+ else if (n->state == VLIB_NODE_STATE_INTERRUPT)
+ state_code = STATE_INTERRUPT_WAIT;
+ }
+
+ /* See unserialize_cstring */
+ name_bytes = vec_len (n->name);
+ serialize_likely_small_unsigned_integer (sm, name_bytes);
+ namep = serialize_get (sm, name_bytes);
+ memcpy (namep, n->name, name_bytes);
+
+ serialize_likely_small_unsigned_integer (sm, (u64) state_code);
+ serialize_likely_small_unsigned_integer (sm, n->type);
+
+ if (include_nexts)
+ {
+ serialize_likely_small_unsigned_integer
+ (sm, vec_len (n->next_nodes));
+ for (k = 0; k < vec_len (n->next_nodes); k++)
+ serialize_likely_small_unsigned_integer (sm,
+ n->next_nodes[k]);
+ }
+ else
+ serialize_likely_small_unsigned_integer (sm, 0);
+
+ if (include_stats)
+ {
+ /* stats present */
+ serialize_likely_small_unsigned_integer (sm, 1);
+ /* total clocks */
+ serialize_integer (sm, l, 8);
+ /* Total calls */
+ serialize_integer (sm, c, 8);
+ /* Total vectors */
+ serialize_integer (sm, v, 8);
+ /* Total suspends */
+ serialize_integer (sm, d, 8);
+ }
+ else /* no stats */
+ serialize_likely_small_unsigned_integer (sm, 0);
+ }
vec_free (nodes);
}
return (serialize_close_vector (sm));
}
-vlib_node_t *** vlib_node_unserialize (u8 * vector)
+vlib_node_t ***
+vlib_node_unserialize (u8 * vector)
{
- serialize_main_t _sm, *sm=&_sm;
+ serialize_main_t _sm, *sm = &_sm;
u32 nnodes, nnexts;
u32 nstat_vms;
- vlib_node_t * node;
- vlib_node_t ** nodes;
- vlib_node_t *** nodes_by_thread = 0;
+ vlib_node_t *node;
+ vlib_node_t **nodes;
+ vlib_node_t ***nodes_by_thread = 0;
int i, j, k;
u64 l, v, c, d;
state_string_enum_t state_code;
int stats_present;
serialize_open_vector (sm, vector);
-
+
nstat_vms = unserialize_likely_small_unsigned_integer (sm);
vec_validate (nodes_by_thread, nstat_vms - 1);
@@ -238,85 +239,84 @@ vlib_node_t *** vlib_node_unserialize (u8 * vector)
nnodes = unserialize_likely_small_unsigned_integer (sm);
nodes = 0;
- vec_validate (nodes, nnodes-1);
+ vec_validate (nodes, nnodes - 1);
vec_add1 (nodes_by_thread, nodes);
for (j = 0; j < nnodes; j++)
- {
- node = 0;
- vec_validate (node,0);
- nodes[j] = node;
-
- unserialize_cstring (sm, (char **)&(node->name));
- state_code = unserialize_likely_small_unsigned_integer (sm);
- node->state_string = (u8 *) state_strings[state_code];
-
- node->type =
- unserialize_likely_small_unsigned_integer (sm);
- nnexts = unserialize_likely_small_unsigned_integer (sm);
- if (nnexts > 0)
- vec_validate (node->next_nodes, nnexts-1);
- for (k = 0; k < nnexts; k++)
- node->next_nodes[k] =
- unserialize_likely_small_unsigned_integer (sm);
-
- stats_present = unserialize_likely_small_unsigned_integer (sm);
-
- if (stats_present)
- {
- /* total clocks */
- unserialize_integer (sm, &l, 8);
- node->stats_total.clocks = l;
- node->stats_last_clear.clocks = 0;
-
- /* Total calls */
- unserialize_integer (sm, &c, 8);
- node->stats_total.calls = c;
-
- /* Total vectors */
- unserialize_integer (sm, &v, 8);
- node->stats_total.vectors = v;
-
- /* Total suspends */
- unserialize_integer (sm, &d, 8);
- node->stats_total.suspends = d;
- }
- }
+ {
+ node = 0;
+ vec_validate (node, 0);
+ nodes[j] = node;
+
+ unserialize_cstring (sm, (char **) &(node->name));
+ state_code = unserialize_likely_small_unsigned_integer (sm);
+ node->state_string = (u8 *) state_strings[state_code];
+
+ node->type = unserialize_likely_small_unsigned_integer (sm);
+ nnexts = unserialize_likely_small_unsigned_integer (sm);
+ if (nnexts > 0)
+ vec_validate (node->next_nodes, nnexts - 1);
+ for (k = 0; k < nnexts; k++)
+ node->next_nodes[k] =
+ unserialize_likely_small_unsigned_integer (sm);
+
+ stats_present = unserialize_likely_small_unsigned_integer (sm);
+
+ if (stats_present)
+ {
+ /* total clocks */
+ unserialize_integer (sm, &l, 8);
+ node->stats_total.clocks = l;
+ node->stats_last_clear.clocks = 0;
+
+ /* Total calls */
+ unserialize_integer (sm, &c, 8);
+ node->stats_total.calls = c;
+
+ /* Total vectors */
+ unserialize_integer (sm, &v, 8);
+ node->stats_total.vectors = v;
+
+ /* Total suspends */
+ unserialize_integer (sm, &d, 8);
+ node->stats_total.suspends = d;
+ }
+ }
}
- return nodes_by_thread;
+ return nodes_by_thread;
}
#if CLIB_DEBUG > 0
static clib_error_t *
test_node_serialize_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
{
- vlib_node_main_t * nm = &vm->node_main;
- u8 * vector = 0;
- vlib_node_t *** nodes_by_thread;
- vlib_node_t ** nodes;
- vlib_node_t * node;
- vlib_node_t * next_node;
+ vlib_node_main_t *nm = &vm->node_main;
+ u8 *vector = 0;
+ vlib_node_t ***nodes_by_thread;
+ vlib_node_t **nodes;
+ vlib_node_t *node;
+ vlib_node_t *next_node;
int i, j, k;
- u32 max_threads = (u32) ~0;
+ u32 max_threads = (u32) ~ 0;
int include_nexts = 0;
- int include_stats = 0;
+ int include_stats = 0;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "max-threads %d", &max_threads))
- ;
+ ;
else if (unformat (input, "stats"))
- include_stats = 1;
+ include_stats = 1;
else if (unformat (input, "nexts"))
- include_nexts = 1;
+ include_nexts = 1;
else
- break;
+ break;
}
- /*
+ /*
* Keep the number of memcpy ops to a minimum (e.g. 1).
* The current size of the serialized vector is
* slightly under 4K.
@@ -324,65 +324,74 @@ test_node_serialize_command_fn (vlib_main_t * vm,
vec_validate (vector, 16383);
vec_reset_length (vector);
- vector = vlib_node_serialize (nm, vector, max_threads,
- include_nexts, include_stats);
+ vector = vlib_node_serialize (nm, vector, max_threads,
+ include_nexts, include_stats);
- vlib_cli_output (vm, "result vector %d bytes", vec_len(vector));
+ vlib_cli_output (vm, "result vector %d bytes", vec_len (vector));
nodes_by_thread = vlib_node_unserialize (vector);
vec_free (vector);
-
- for (i = 0; i < vec_len(nodes_by_thread); i++)
+
+ for (i = 0; i < vec_len (nodes_by_thread); i++)
{
nodes = nodes_by_thread[i];
vlib_cli_output (vm, "thread %d", i);
- for (j = 0; j < vec_len(nodes); j++)
- {
- node = nodes[j];
-
- vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
- node->state_string);
-
- vlib_cli_output
- (vm, " clocks %lld calls %lld suspends"
- " %lld vectors %lld",
- node->stats_total.clocks,
- node->stats_total.calls,
- node->stats_total.suspends,
- node->stats_total.vectors);
-
- for (k = 0; k < vec_len (node->next_nodes); k++)
- {
- if (node->next_nodes[k] != ~0)
- next_node = nodes[node->next_nodes[k]];
- vlib_cli_output (vm, " [%d] %s", k, next_node->name);
- }
- }
- }
-
- for (j = 0; j < vec_len(nodes_by_thread); j++)
+ for (j = 0; j < vec_len (nodes); j++)
+ {
+ node = nodes[j];
+
+ vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
+ node->state_string);
+
+ vlib_cli_output
+ (vm, " clocks %lld calls %lld suspends"
+ " %lld vectors %lld",
+ node->stats_total.clocks,
+ node->stats_total.calls,
+ node->stats_total.suspends, node->stats_total.vectors);
+
+ for (k = 0; k < vec_len (node->next_nodes); k++)
+ {
+ if (node->next_nodes[k] != ~0)
+ next_node = nodes[node->next_nodes[k]];
+ vlib_cli_output (vm, " [%d] %s", k, next_node->name);
+ }
+ }
+ }
+
+ for (j = 0; j < vec_len (nodes_by_thread); j++)
{
nodes = nodes_by_thread[j];
- for (i = 0; i < vec_len(nodes); i++)
- {
- vec_free (nodes[i]->name);
- vec_free (nodes[i]->next_nodes);
- vec_free (nodes[i]);
- }
- vec_free(nodes);
+ for (i = 0; i < vec_len (nodes); i++)
+ {
+ vec_free (nodes[i]->name);
+ vec_free (nodes[i]->next_nodes);
+ vec_free (nodes[i]);
+ }
+ vec_free (nodes);
}
vec_free (nodes_by_thread);
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
.path = "test node serialize",
.short_help = "test node serialize [max-threads NN] nexts stats",
.function = test_node_serialize_command_fn,
};
+/* *INDENT-ON* */
#endif
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */