vpp/vpp-api/gmon.c

   1 /*
   2  * Copyright (c) 2012 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <sys/types.h>
  19 #include <sys/mman.h>
  20 #include <sys/stat.h>
  21 #include <netinet/in.h>
  22 #include <signal.h>
  23 #include <pthread.h>
  24 #include <unistd.h>
  25 #include <time.h>
  26 #include <fcntl.h>
  27 #include <string.h>
  28 #include <vppinfra/clib.h>
  29 #include <vppinfra/vec.h>
  30 #include <vppinfra/hash.h>
  31 #include <vppinfra/bitmap.h>
  32 #include <vppinfra/fifo.h>
  33 #include <vppinfra/time.h>
  34 #include <vppinfra/mheap.h>
  35 #include <vppinfra/heap.h>
  36 #include <vppinfra/pool.h>
  37 #include <vppinfra/format.h>
  38 #include <vlibapi/api.h>
  39 #include <vlibmemory/api.h>
  40
  41 #include <vlib/vlib.h>
  42 #include <vlib/unix/unix.h>
  43 #include <vnet/api_errno.h>
  44
  45 #include <svmdb.h>
  46
  47 typedef struct {
  48   svmdb_client_t *svmdb_client;
  49   f64 *vector_rate_ptr;
  50   f64 *input_rate_ptr;
  51   f64 *sig_error_rate_ptr;
  52   pid_t *vpef_pid_ptr;
  53   u64 last_sig_errors;
  54   u64 current_sig_errors;
  55   uword * sig_error_bitmap;
  56   vlib_main_t *vlib_main;
  57   vlib_main_t ** my_vlib_mains;
  58
  59 } gmon_main_t;
  60
  61 #if DPDK == 0
  62 static inline u64 vnet_get_aggregate_rx_packets (void)
  63 { return 0; }
  64 #else
  65 #include <vlib/vlib.h>
  66 #include <vnet/vnet.h>
  67 #include <vnet/devices/dpdk/dpdk.h>
  68 #endif
  69
  70 gmon_main_t gmon_main;
  71
  72 static u64 get_significant_errors(gmon_main_t * gm)
  73 {
  74   vlib_main_t * this_vlib_main;
  75   vlib_error_main_t * em;
  76   uword code;
  77   int vm_index;
  78   u64 significant_errors = 0;
  79
  80   clib_bitmap_foreach (code, gm->sig_error_bitmap,
  81   ({
  82     for (vm_index = 0; vm_index < vec_len (gm->my_vlib_mains); vm_index++)
  83       {
  84         this_vlib_main = gm->my_vlib_mains[vm_index];
  85         em = &this_vlib_main->error_main;
  86         significant_errors += em->counters[code] -
  87           ((vec_len(em->counters_last_clear) > code) ?
  88            em->counters_last_clear[code] : 0);
  89       }
  90   }));
  91
  92   return (significant_errors);
  93 }
  94
  95 static clib_error_t *
  96 publish_pid (vlib_main_t *vm)
  97 {
  98   gmon_main_t *gm = &gmon_main;
  99
 100   *gm->vpef_pid_ptr = getpid();
 101
 102   return 0;
 103 }
 104 VLIB_API_INIT_FUNCTION(publish_pid);
 105
 106
 107 static uword
 108 gmon_process (vlib_main_t * vm,
 109               vlib_node_runtime_t * rt,
 110               vlib_frame_t * f)
 111 {
 112     f64 vector_rate;
 113     u64 input_packets, last_input_packets, new_sig_errors;
 114     f64 last_runtime, dt, now;
 115     gmon_main_t *gm = &gmon_main;
 116     int i;
 117
 118     last_runtime = 0.0;
 119     last_input_packets = 0;
 120
 121     last_runtime = 0.0;
 122     last_input_packets = 0;
 123
 124     /* Initial wait for the world to settle down */
 125     vlib_process_suspend (vm, 5.0);
 126
 127     if (vec_len(vlib_mains) == 0)
 128       vec_add1(gm->my_vlib_mains, &vlib_global_main);
 129     else
 130       {
 131         for (i = 0; i < vec_len(vlib_mains); i++)
 132           vec_add1 (gm->my_vlib_mains, vlib_mains[i]);
 133       }
 134
 135     while (1) {
 136         vlib_process_suspend (vm, 5.0);
 137         vector_rate = vlib_last_vector_length_per_node (vm);
 138         *gm->vector_rate_ptr = vector_rate;
 139         now = vlib_time_now(vm);
 140         dt = now - last_runtime;
 141         input_packets =  vnet_get_aggregate_rx_packets();
 142         *gm->input_rate_ptr = (f64)(input_packets - last_input_packets) / dt;
 143         last_runtime = now;
 144         last_input_packets = input_packets;
 145
 146         new_sig_errors = get_significant_errors(gm);
 147         *gm->sig_error_rate_ptr =
 148             ((f64)(new_sig_errors - gm->last_sig_errors)) / dt;
 149         gm->last_sig_errors = new_sig_errors;
 150     }
 151
 152     return 0; /* not so much */
 153 }
 154
 155 VLIB_REGISTER_NODE (gmon_process_node,static) = {
 156     .function = gmon_process,
 157     .type = VLIB_NODE_TYPE_PROCESS,
 158     .name = "gmon-process",
 159 };
 160
 161 static clib_error_t *
 162 gmon_init (vlib_main_t *vm)
 163 {
 164     gmon_main_t *gm = &gmon_main;
 165     api_main_t * am = &api_main;
 166     pid_t *swp = 0;
 167     f64 *v = 0;
 168     clib_error_t * error;
 169     svmdb_map_args_t _ma, *ma= &_ma;
 170
 171     if ((error = vlib_call_init_function(vm, vpe_api_init)))
 172         return(error);
 173
 174     /* Make sure that /global-vm is owned as directed */
 175     svm_region_init_chroot_uid_gid (am->root_path, am->api_uid, am->api_gid);
 176
 177     gm->vlib_main = vm;
 178
 179     memset (ma, 0, sizeof (*ma));
 180     ma->root_path = am->root_path;
 181     ma->uid = am->api_uid;
 182     ma->gid = am->api_gid;
 183
 184     gm->svmdb_client = svmdb_map (ma);
 185
 186     /* Find or create, set to zero */
 187     vec_add1 (v, 0.0);
 188     svmdb_local_set_vec_variable(gm->svmdb_client,
 189                                  "vpp_vector_rate",
 190                                  (char *)v, sizeof (*v));
 191     vec_free(v);
 192     vec_add1 (v, 0.0);
 193     svmdb_local_set_vec_variable(gm->svmdb_client,
 194                                  "vpp_input_rate",
 195                                  (char *)v, sizeof (*v));
 196     vec_free(v);
 197     vec_add1 (v, 0.0);
 198     svmdb_local_set_vec_variable(gm->svmdb_client,
 199                                  "vpp_sig_error_rate",
 200                                  (char *)v, sizeof (*v));
 201     vec_free(v);
 202
 203     vec_add1 (swp, 0.0);
 204     svmdb_local_set_vec_variable(gm->svmdb_client,
 205                                  "vpp_pid",
 206                                  (char *)swp, sizeof (*swp));
 207     vec_free(swp);
 208
 209     /* the value cells will never move, so acquire references to them */
 210     gm->vector_rate_ptr =
 211         svmdb_local_get_variable_reference (gm->svmdb_client,
 212                                             SVMDB_NAMESPACE_VEC,
 213                                             "vpp_vector_rate");
 214     gm->input_rate_ptr =
 215         svmdb_local_get_variable_reference (gm->svmdb_client,
 216                                             SVMDB_NAMESPACE_VEC,
 217                                             "vpp_input_rate");
 218     gm->sig_error_rate_ptr =
 219         svmdb_local_get_variable_reference (gm->svmdb_client,
 220                                             SVMDB_NAMESPACE_VEC,
 221                                             "vpp_sig_error_rate");
 222     gm->vpef_pid_ptr =
 223         svmdb_local_get_variable_reference (gm->svmdb_client,
 224                                             SVMDB_NAMESPACE_VEC,
 225                                             "vpp_pid");
 226     return 0;
 227 }
 228
 229 VLIB_INIT_FUNCTION (gmon_init);
 230
 231 static clib_error_t *gmon_exit (vlib_main_t *vm)
 232 {
 233     gmon_main_t *gm = &gmon_main;
 234
 235     if (gm->vector_rate_ptr) {
 236         *gm->vector_rate_ptr = 0.0;
 237         *gm->vpef_pid_ptr = 0;
 238         *gm->input_rate_ptr = 0.0;
 239         *gm->sig_error_rate_ptr = 0.0;
 240         svm_region_unmap ((void *) gm->svmdb_client->db_rp);
 241         vec_free(gm->svmdb_client);
 242     }
 243     return 0;
 244 }
 245 VLIB_MAIN_LOOP_EXIT_FUNCTION (gmon_exit);
 246
 247 static int
 248 significant_error_enable_disable (gmon_main_t * gm,
 249                                   u32 index, int enable)
 250 {
 251   vlib_main_t * vm = gm->vlib_main;
 252   vlib_error_main_t * em = &vm->error_main;
 253
 254   if (index >= vec_len (em->counters))
 255     return VNET_API_ERROR_NO_SUCH_ENTRY;
 256
 257   gm->sig_error_bitmap = clib_bitmap_set (gm->sig_error_bitmap, index, enable);
 258   return 0;
 259 }
 260
 261 static clib_error_t *
 262 set_significant_error_command_fn (vlib_main_t * vm,
 263                  unformat_input_t * input,
 264                  vlib_cli_command_t * cmd)
 265 {
 266   u32 index;
 267   int enable = 1;
 268   int rv;
 269   gmon_main_t *gm = &gmon_main;
 270
 271   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
 272     if (unformat (input, "%d", &index))
 273       ;
 274     else if (unformat (input, "disable"))
 275       enable = 0;
 276     else
 277       return clib_error_return (0, "unknown input `%U'",
 278                                 format_unformat_error, input);
 279   }
 280
 281   rv = significant_error_enable_disable (gm, index, enable);
 282
 283   switch (rv)
 284     {
 285     case 0:
 286       break;
 287
 288     default:
 289       return clib_error_return
 290         (0, "significant_error_enable_disable returned %d", rv);
 291     }
 292
 293   return 0;
 294 }
 295
 296 VLIB_CLI_COMMAND (set_significant_error_command, static) = {
 297     .path = "set significant error",
 298     .short_help = "set significant error <counter-index-nnn> [disable]",
 299     .function = set_significant_error_command_fn,
 300 };