From aa6920e0a80d8271be1dda59f613a1d2b0e1d3e6 Mon Sep 17 00:00:00 2001 From: Dave Barach Date: Mon, 27 Jun 2016 09:25:13 -0400 Subject: More janitorial work Install vpp api header files in /usr/include/vpp-api, instead of /usr/include/api. Someone will eventually complain if we continue with the status quo. Generate /usr/bin/vpp_plugin_configure, to correctly configure standalone plugin compilation against header files installed from the dev package. If a plugin's CFLAGS don't precisely match the installed vpp engine binary, subtle misbehavior can and will occur. Example: the ip4/ip6 main_t structure size / member offsets depend on DPDK=[0|1]. Screw that one up, and your brand-new configurable ip feature will mysteriously fail to appear, even though the plugin loads perfectly. Change-Id: I20c97fe1042808a79935863209d995c31953b98c Signed-off-by: Dave Barach --- vpp/vpp-api/gmon.c | 293 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 293 insertions(+) create mode 100644 vpp/vpp-api/gmon.c (limited to 'vpp/vpp-api/gmon.c') diff --git a/vpp/vpp-api/gmon.c b/vpp/vpp-api/gmon.c new file mode 100644 index 00000000..9d37155f --- /dev/null +++ b/vpp/vpp-api/gmon.c @@ -0,0 +1,293 @@ +/* + * Copyright (c) 2012 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +typedef struct { + svmdb_client_t *svmdb_client; + f64 *vector_rate_ptr; + f64 *input_rate_ptr; + f64 *sig_error_rate_ptr; + pid_t *vpef_pid_ptr; + u64 last_sig_errors; + u64 current_sig_errors; + uword * sig_error_bitmap; + vlib_main_t *vlib_main; + vlib_main_t ** my_vlib_mains; + +} gmon_main_t; + +#if DPDK == 0 +static inline u64 vnet_get_aggregate_rx_packets (void) +{ return 0; } +#else +#include +#include +#include +#endif + +gmon_main_t gmon_main; + +static u64 get_significant_errors(gmon_main_t * gm) +{ + vlib_main_t * this_vlib_main; + vlib_error_main_t * em; + uword code; + int vm_index; + u64 significant_errors = 0; + + clib_bitmap_foreach (code, gm->sig_error_bitmap, + ({ + for (vm_index = 0; vm_index < vec_len (gm->my_vlib_mains); vm_index++) + { + this_vlib_main = gm->my_vlib_mains[vm_index]; + em = &this_vlib_main->error_main; + significant_errors += em->counters[code] - + ((vec_len(em->counters_last_clear) > code) ? + em->counters_last_clear[code] : 0); + } + })); + + return (significant_errors); +} + +static clib_error_t * +publish_pid (vlib_main_t *vm) +{ + gmon_main_t *gm = &gmon_main; + + *gm->vpef_pid_ptr = getpid(); + + return 0; +} +VLIB_API_INIT_FUNCTION(publish_pid); + + +static uword +gmon_process (vlib_main_t * vm, + vlib_node_runtime_t * rt, + vlib_frame_t * f) +{ + f64 vector_rate; + u64 input_packets, last_input_packets, new_sig_errors; + f64 last_runtime, dt, now; + gmon_main_t *gm = &gmon_main; + int i; + + last_runtime = 0.0; + last_input_packets = 0; + + last_runtime = 0.0; + last_input_packets = 0; + + /* Initial wait for the world to settle down */ + vlib_process_suspend (vm, 5.0); + + if (vec_len(vlib_mains) == 0) + vec_add1(gm->my_vlib_mains, &vlib_global_main); + else + { + for (i = 0; i < vec_len(vlib_mains); i++) + vec_add1 (gm->my_vlib_mains, vlib_mains[i]); + } + + while (1) { + vlib_process_suspend (vm, 5.0); + vector_rate = vlib_last_vector_length_per_node (vm); + *gm->vector_rate_ptr = vector_rate; + now = vlib_time_now(vm); + dt = now - last_runtime; + input_packets = vnet_get_aggregate_rx_packets(); + *gm->input_rate_ptr = (f64)(input_packets - last_input_packets) / dt; + last_runtime = now; + last_input_packets = input_packets; + + new_sig_errors = get_significant_errors(gm); + *gm->sig_error_rate_ptr = + ((f64)(new_sig_errors - gm->last_sig_errors)) / dt; + gm->last_sig_errors = new_sig_errors; + } + + return 0; /* not so much */ +} + +VLIB_REGISTER_NODE (gmon_process_node,static) = { + .function = gmon_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "gmon-process", +}; + +static clib_error_t * +gmon_init (vlib_main_t *vm) +{ + gmon_main_t *gm = &gmon_main; + api_main_t * am = &api_main; + pid_t *swp = 0; + f64 *v = 0; + clib_error_t * error; + + if ((error = vlib_call_init_function(vm, vpe_api_init))) + return(error); + + /* Make sure that /global-vm is owned as directed */ + svm_region_init_chroot_uid_gid (am->root_path, am->api_uid, am->api_gid); + + gm->vlib_main = vm; + gm->svmdb_client = svmdb_map_chroot(am->root_path); + + /* Find or create, set to zero */ + vec_add1 (v, 0.0); + svmdb_local_set_vec_variable(gm->svmdb_client, + "vpp_vector_rate", + (char *)v, sizeof (*v)); + vec_free(v); + vec_add1 (v, 0.0); + svmdb_local_set_vec_variable(gm->svmdb_client, + "vpp_input_rate", + (char *)v, sizeof (*v)); + vec_free(v); + vec_add1 (v, 0.0); + svmdb_local_set_vec_variable(gm->svmdb_client, + "vpp_sig_error_rate", + (char *)v, sizeof (*v)); + vec_free(v); + + vec_add1 (swp, 0.0); + svmdb_local_set_vec_variable(gm->svmdb_client, + "vpp_pid", + (char *)swp, sizeof (*swp)); + vec_free(swp); + + /* the value cells will never move, so acquire references to them */ + gm->vector_rate_ptr = + svmdb_local_get_variable_reference (gm->svmdb_client, + SVMDB_NAMESPACE_VEC, + "vpp_vector_rate"); + gm->input_rate_ptr = + svmdb_local_get_variable_reference (gm->svmdb_client, + SVMDB_NAMESPACE_VEC, + "vpp_input_rate"); + gm->sig_error_rate_ptr = + svmdb_local_get_variable_reference (gm->svmdb_client, + SVMDB_NAMESPACE_VEC, + "vpp_sig_error_rate"); + gm->vpef_pid_ptr = + svmdb_local_get_variable_reference (gm->svmdb_client, + SVMDB_NAMESPACE_VEC, + "vpp_pid"); + return 0; +} + +VLIB_INIT_FUNCTION (gmon_init); + +static clib_error_t *gmon_exit (vlib_main_t *vm) +{ + gmon_main_t *gm = &gmon_main; + + if (gm->vector_rate_ptr) { + *gm->vector_rate_ptr = 0.0; + *gm->vpef_pid_ptr = 0; + *gm->input_rate_ptr = 0.0; + *gm->sig_error_rate_ptr = 0.0; + svm_region_unmap ((void *) gm->svmdb_client->db_rp); + vec_free(gm->svmdb_client); + } + return 0; +} +VLIB_MAIN_LOOP_EXIT_FUNCTION (gmon_exit); + +static int +significant_error_enable_disable (gmon_main_t * gm, + u32 index, int enable) +{ + vlib_main_t * vm = gm->vlib_main; + vlib_error_main_t * em = &vm->error_main; + + if (index >= vec_len (em->counters)) + return VNET_API_ERROR_NO_SUCH_ENTRY; + + gm->sig_error_bitmap = clib_bitmap_set (gm->sig_error_bitmap, index, enable); + return 0; +} + +static clib_error_t * +set_significant_error_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + u32 index; + int enable = 1; + int rv; + gmon_main_t *gm = &gmon_main; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat (input, "%d", &index)) + ; + else if (unformat (input, "disable")) + enable = 0; + else + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); + } + + rv = significant_error_enable_disable (gm, index, enable); + + switch (rv) + { + case 0: + break; + + default: + return clib_error_return + (0, "significant_error_enable_disable returned %d", rv); + } + + return 0; +} + +VLIB_CLI_COMMAND (set_significant_error_command, static) = { + .path = "set significant error", + .short_help = "set significant error ", + .function = set_significant_error_command_fn, +}; -- cgit 1.2.3-korg