| /* |
| *------------------------------------------------------------------ |
| * 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"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| *------------------------------------------------------------------ |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.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/vlib.h> |
| #include <vlib/unix/unix.h> |
| #include <vlibapi/api.h> |
| #include <vppinfra/elog.h> |
| |
| 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_release (void) __attribute__ ((weak)); |
| void |
| vl_msg_api_barrier_release (void) |
| { |
| } |
| |
| void |
| vl_msg_api_increment_missing_client_counter (void) |
| { |
| api_main_t *am = &api_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) |
| { |
| return (am->rx_trace && am->rx_trace->enabled); |
| } |
| |
| int |
| vl_msg_api_tx_trace_enabled (api_main_t * am) |
| { |
| 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) |
| { |
| 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; |
| |
| if (!cfgp || !cfgp->trace_enable) |
| return; |
| |
| msg_copy = 0; |
| |
| 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; |
| } |
| |
| 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) |
| { |
| vl_api_trace_t *tp; |
| int rv; |
| |
| 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; |
| |
| 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; |
| |
| default: |
| /* duh? */ |
| return -1; |
| } |
| |
| /* Configured? */ |
| if (tp == 0 || tp->nitems == 0) |
| return -1; |
| |
| rv = tp->enabled; |
| tp->enabled = onoff; |
| |
| return rv; |
| } |
| |
| int |
| vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which) |
| { |
| vl_api_trace_t *tp; |
| int i; |
| |
| 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? */ |
| if (!tp || tp->nitems == 0) |
| return -1; |
| |
| tp->curindex = 0; |
| tp->wrapped = 0; |
| |
| for (i = 0; i < vec_len (tp->traces); i++) |
| { |
| vec_free (tp->traces[i]); |
| } |
| vec_free (tp->traces); |
| |
| return 0; |
| } |
| |
| 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; |
| |
| 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; |
| } |
| |
| /* 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); |
| } |
| |
| /* 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); |
| } |
| } |
| } |
| return 0; |
| } |
| |
| 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; |
| |
| 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; |
| |
| case VL_API_TRACE_RX: |
| tp = am->rx_trace; |
| if (tp == 0) |
| { |
| vec_validate (am->rx_trace, 0); |
| tp = am->rx_trace; |
| } |
| |
| break; |
| |
| default: |
| return -1; |
| |
| } |
| |
| if (tp->enabled) |
| { |
| was_on = vl_msg_api_trace_onoff (am, which, 0); |
| } |
| if (tp->traces) |
| { |
| vl_msg_api_trace_free (am, which); |
| } |
| |
| memset (tp, 0, sizeof (*tp)); |
| |
| 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); |
| } |
| return 0; |
| } |
| |
| 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); |
| } |
| |
| 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; |
| } |
| #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) |
| { |
| u16 id = ntohs (*((u16 *) the_msg)); |
| u8 *(*handler) (void *, void *, void *); |
| |
| #if ELOG_API_MESSAGE_HANDLERS > 0 |
| { |
| /* *INDENT-OFF* */ |
| ELOG_TYPE_DECLARE (e) = |
| { |
| .format = "api-msg: %s", |
| .format_args = "T4", |
| }; |
| /* *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); |
| |
| #if ELOG_API_MESSAGE_HANDLERS > 0 |
| { |
| /* *INDENT-OFF* */ |
| ELOG_TYPE_DECLARE (e) = { |
| .format = "api-msg-done: %s", |
| .format_args = "T4", |
| }; |
| /* *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 |
| } |
| |
| void |
| vl_msg_api_handler (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 */ , 1 /* free_it */ ); |
| } |
| |
| 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 */ ); |
| } |
| |
| 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 */ ); |
| } |
| |
| /* |
| * 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 |
| * application creates database entries based on packet traffic, not |
| * control-plane messages. |
| * |
| */ |
| void |
| vl_msg_api_trace_only (void *the_msg) |
| { |
| 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 */ ); |
| } |
| |
| void |
| vl_msg_api_cleanup_handler (void *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 (am->msg_cleanup_handlers[id]) |
| (*am->msg_cleanup_handlers[id]) (the_msg); |
| |
| vl_msg_api_free (the_msg); |
| } |
| |
| /* |
| * vl_msg_api_replay_handler |
| */ |
| void |
| vl_msg_api_replay_handler (void *the_msg) |
| { |
| api_main_t *am = &api_main; |
| |
| 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; |
| } |
| /* 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) |
| { |
| 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 */ ); |
| } |
| |
| #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) |
| |
| void |
| vl_msg_api_config (vl_msg_api_msg_config_t * c) |
| { |
| api_main_t *am = &api_main; |
| |
| ASSERT (c->id > 0); |
| |
| #define _(a) vec_validate (am->a, c->id); |
| 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; |
| } |
| |
| /* |
| * 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) |
| { |
| 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) |
| { |
| 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; |
| } |
| |
| void |
| vl_msg_api_queue_handler (unix_shared_memory_queue_t * q) |
| { |
| uword 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) |
| { |
| switch (which) |
| { |
| case VL_API_TRACE_RX: |
| return am->rx_trace; |
| case VL_API_TRACE_TX: |
| return am->tx_trace; |
| default: |
| return 0; |
| } |
| } |
| |
| void |
| vl_noop_handler (void *mp) |
| { |
| } |
| |
| 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; |
| 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); |
| 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; |
| |
| 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; |
| } |
| 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); |
| munmap (hp, file_size); |
| 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); |
| munmap (hp, file_size); |
| 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); |
| } |
| |
| 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) |
| { |
| 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; |
| } |
| |
| VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace"); |
| |
| 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; |
| } |
| 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) |
| { |
| 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) |
| { |
| 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); |
| return rv; |
| } |
| |
| 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; |
| } |
| |
| 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); |
| } |
| |
| 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); |
| |
| 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); |
| |
| return rv; |
| } |
| |
| /* |
| * fd.io coding-style-patch-verification: ON |
| * |
| * Local Variables: |
| * eval: (c-set-style "gnu") |
| * End: |
| */ |