src/plugins/perfmon/cli.c

   1 /*
   2  * Copyright (c) 2020 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 <vnet/vnet.h>
  17 #include <perfmon/perfmon.h>
  18 #include <perfmon/table.h>
  19
  20 uword
  21 unformat_perfmon_bundle_name (unformat_input_t *input, va_list *args)
  22 {
  23   perfmon_main_t *pm = &perfmon_main;
  24   perfmon_bundle_t **b = va_arg (*args, perfmon_bundle_t **);
  25   uword *p;
  26   u8 *str = 0;
  27
  28   if (unformat (input, "%s", &str) == 0)
  29     return 0;
  30
  31   p = hash_get_mem (pm->bundle_by_name, str);
  32
  33   if (p)
  34     b[0] = (perfmon_bundle_t *) p[0];
  35
  36   vec_free (str);
  37   return p ? 1 : 0;
  38 }
  39
  40 uword
  41 unformat_perfmon_source_name (unformat_input_t *input, va_list *args)
  42 {
  43   perfmon_main_t *pm = &perfmon_main;
  44   perfmon_source_t **b = va_arg (*args, perfmon_source_t **);
  45   uword *p;
  46   u8 *str = 0;
  47
  48   if (unformat (input, "%s", &str) == 0)
  49     return 0;
  50
  51   p = hash_get_mem (pm->source_by_name, str);
  52
  53   if (p)
  54     b[0] = (perfmon_source_t *) p[0];
  55
  56   vec_free (str);
  57   return p ? 1 : 0;
  58 }
  59
  60 u8 *
  61 format_perfmon_bundle (u8 *s, va_list *args)
  62 {
  63   perfmon_bundle_t *b = va_arg (*args, perfmon_bundle_t *);
  64   int verbose = va_arg (*args, int);
  65
  66   const char *bundle_type[] = {
  67     [PERFMON_BUNDLE_TYPE_NODE] = "node",
  68     [PERFMON_BUNDLE_TYPE_THREAD] = "thread",
  69     [PERFMON_BUNDLE_TYPE_SYSTEM] = "system",
  70   };
  71
  72   if (b == 0)
  73     return format (s, "%-20s%-10s%-20s%s", "Name", "Type", "Source",
  74                    "Description");
  75
  76   if (verbose)
  77     {
  78       s = format (s, "name: %s\n", b->name);
  79       s = format (s, "description: %s\n", b->description);
  80       s = format (s, "source: %s\n", b->src->name);
  81       for (int i = 0; i < b->n_events; i++)
  82         {
  83           perfmon_event_t *e = b->src->events + b->events[i];
  84           s = format (s, "event %u: %s\n", i, e->name);
  85         }
  86     }
  87   else
  88     s = format (s, "%-20s%-10s%-20s%s", b->name, bundle_type[b->type],
  89                 b->src->name, b->description);
  90
  91   return s;
  92 }
  93
  94 static clib_error_t *
  95 show_perfmon_bundle_command_fn (vlib_main_t *vm, unformat_input_t *input,
  96                                 vlib_cli_command_t *cmd)
  97 {
  98   perfmon_main_t *pm = &perfmon_main;
  99   unformat_input_t _line_input, *line_input = &_line_input;
 100   perfmon_bundle_t *b = 0, **vb = 0;
 101   int verbose = 0;
 102
 103   if (unformat_user (input, unformat_line_input, line_input))
 104     {
 105       while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 106         {
 107           if (unformat (line_input, "verbose"))
 108             verbose = 1;
 109           else if (unformat (line_input, "%U", unformat_perfmon_bundle_name,
 110                              &b))
 111             vec_add (vb, &b, 1);
 112           else
 113             return clib_error_return (0, "unknown input `%U'",
 114                                       format_unformat_error, line_input);
 115         }
 116       unformat_free (line_input);
 117     }
 118
 119   if (vb == 0)
 120     {
 121       char *key;
 122       hash_foreach_mem (key, b, pm->bundle_by_name, vec_add (vb, &b, 1););
 123     }
 124   else
 125     verbose = 1;
 126
 127   if (verbose == 0)
 128     vlib_cli_output (vm, "%U\n", format_perfmon_bundle, 0, 0);
 129
 130   for (int i = 0; i < vec_len (vb); i++)
 131     vlib_cli_output (vm, "%U\n", format_perfmon_bundle, vb[i], verbose);
 132
 133   vec_free (vb);
 134   return 0;
 135 }
 136
 137 VLIB_CLI_COMMAND (show_perfmon_bundle_command, static) = {
 138   .path = "show perfmon bundle",
 139   .short_help = "show perfmon bundle [<bundle-name>] [verbose]",
 140   .function = show_perfmon_bundle_command_fn,
 141   .is_mp_safe = 1,
 142 };
 143
 144 u8 *
 145 format_perfmon_source (u8 *s, va_list *args)
 146 {
 147   perfmon_source_t *src = va_arg (*args, perfmon_source_t *);
 148   int verbose = va_arg (*args, int);
 149
 150   if (src == 0)
 151     return format (s, "%-20s%-9s %s", "Name", "NumEvents", "Description");
 152
 153   if (verbose)
 154     {
 155       s = format (s, "name:        %s\n", src->name);
 156       s = format (s, "description: %s\n", src->description);
 157       s = format (s, "Events:\n");
 158       for (int i = 0; i < src->n_events; i++)
 159         {
 160           perfmon_event_t *e = src->events + i;
 161           s = format (s, "  %s", e->name);
 162           if (src->format_config)
 163             s = format (s, " (%U)\n", src->format_config, e->config);
 164           else
 165             s = format (s, " (0x%x)\n", e->config);
 166           if (e->description)
 167             s = format (s, "    %s\n", e->description);
 168         }
 169
 170       if (src->instances_by_type)
 171         {
 172           s = format (s, "Instances:\n");
 173           for (int i = 0; i < vec_len (src->instances_by_type); i++)
 174             {
 175               perfmon_instance_type_t *it;
 176               it = vec_elt_at_index (src->instances_by_type, i);
 177               if (vec_len (it->instances) == 0)
 178                 continue;
 179               s = format (s, "  %s:\n   ", it->name);
 180               for (int j = 0; j < vec_len (it->instances); j++)
 181                 {
 182                   perfmon_instance_t *in = vec_elt_at_index (it->instances, j);
 183                   s = format (s, " %s", in->name);
 184                 }
 185               s = format (s, "\n");
 186             }
 187         }
 188     }
 189   else
 190     s = format (s, "%-20s%9u %s", src->name, src->n_events, src->description);
 191
 192   return s;
 193 }
 194
 195 static clib_error_t *
 196 show_perfmon_source_command_fn (vlib_main_t *vm, unformat_input_t *input,
 197                                 vlib_cli_command_t *cmd)
 198 {
 199   perfmon_main_t *pm = &perfmon_main;
 200   unformat_input_t _line_input, *line_input = &_line_input;
 201   perfmon_source_t *s = 0, **vs = 0;
 202   int verbose = 0;
 203
 204   if (unformat_user (input, unformat_line_input, line_input))
 205     {
 206       while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 207         {
 208           if (unformat (line_input, "verbose"))
 209             verbose = 1;
 210           else if (unformat (line_input, "%U", unformat_perfmon_source_name,
 211                              &s))
 212             vec_add (vs, &s, 1);
 213           else
 214             return clib_error_return (0, "unknown input `%U'",
 215                                       format_unformat_error, line_input);
 216         }
 217       unformat_free (line_input);
 218     }
 219
 220   if (vs == 0)
 221     {
 222       char *key;
 223       hash_foreach_mem (key, s, pm->source_by_name, vec_add (vs, &s, 1););
 224     }
 225   else
 226     verbose = 1;
 227
 228   if (verbose == 0)
 229     vlib_cli_output (vm, "%U\n", format_perfmon_source, 0, 0);
 230
 231   for (int i = 0; i < vec_len (vs); i++)
 232     vlib_cli_output (vm, "%U\n", format_perfmon_source, vs[i], verbose);
 233
 234   vec_free (vs);
 235   return 0;
 236 }
 237
 238 VLIB_CLI_COMMAND (show_perfmon_source_command, static) = {
 239   .path = "show perfmon source",
 240   .short_help = "show perfmon source [<source-name>] [verbose]",
 241   .function = show_perfmon_source_command_fn,
 242   .is_mp_safe = 1,
 243 };
 244
 245 static clib_error_t *
 246 show_perfmon_active_bundle_command_fn (vlib_main_t *vm,
 247                                        unformat_input_t *input,
 248                                        vlib_cli_command_t *cmd)
 249 {
 250   perfmon_main_t *pm = &perfmon_main;
 251
 252   vlib_cli_output (vm, "%U\n", format_perfmon_bundle, pm->active_bundle, 1);
 253
 254   return 0;
 255 }
 256
 257 VLIB_CLI_COMMAND (show_perfmon_active_bundle_command, static) = {
 258   .path = "show perfmon active-bundle",
 259   .short_help = "show perfmon active-bundle",
 260   .function = show_perfmon_active_bundle_command_fn,
 261   .is_mp_safe = 1,
 262 };
 263
 264 static clib_error_t *
 265 show_perfmon_stats_command_fn (vlib_main_t *vm, unformat_input_t *input,
 266                                vlib_cli_command_t *cmd)
 267 {
 268   perfmon_main_t *pm = &perfmon_main;
 269   perfmon_bundle_t *b = pm->active_bundle;
 270   clib_error_t *err = 0;
 271   table_t table = {}, *t = &table;
 272   u32 n_instances;
 273   perfmon_reading_t *r, *readings = 0;
 274   perfmon_instance_type_t *it = pm->active_instance_type;
 275   perfmon_instance_t *in;
 276   u8 *s = 0;
 277   int n_row = 0;
 278
 279   if (b == 0)
 280     return clib_error_return (0, "no budle selected");
 281
 282   n_instances = vec_len (it->instances);
 283   vec_validate (readings, n_instances - 1);
 284
 285   for (int i = 0; i < n_instances; i++)
 286     {
 287       in = vec_elt_at_index (it->instances, i);
 288       r = vec_elt_at_index (readings, i);
 289
 290       if (read (pm->group_fds[i], r, (b->n_events + 3) * sizeof (u64)) == -1)
 291         {
 292           err = clib_error_return_unix (0, "read");
 293           goto done;
 294         }
 295     }
 296
 297   table_format_title (t, "%s", b->description);
 298
 299   table_add_header_col (t, 0);
 300   table_add_header_row (t, 0);
 301
 302   if (b->column_headers)
 303     {
 304       char **hdr = b->column_headers;
 305       while (hdr[0])
 306         table_format_cell (t, -1, n_row++, "%s", hdr++[0]);
 307     }
 308
 309   int col = 0;
 310   for (int i = 0; i < n_instances; i++)
 311     {
 312       in = vec_elt_at_index (it->instances, i);
 313       r = vec_elt_at_index (readings, i);
 314       table_format_cell (t, col, -1, "%s", in->name);
 315       if (b->type == PERFMON_BUNDLE_TYPE_NODE)
 316         {
 317           perfmon_thread_runtime_t *tr;
 318           tr = vec_elt_at_index (pm->thread_runtimes, i);
 319           for (int j = 0; j < tr->n_nodes; j++)
 320             if (tr->node_stats[j].n_calls)
 321               {
 322                 perfmon_node_stats_t ns;
 323                 table_format_cell (t, ++col, -1, "%U", format_vlib_node_name,
 324                                    vm, j);
 325                 table_set_cell_align (t, col, -1, TTAA_RIGHT);
 326                 table_set_cell_fg_color (t, col, -1, TTAC_CYAN);
 327                 clib_memcpy_fast (&ns, tr->node_stats + j, sizeof (ns));
 328                 for (int j = 0; j < n_row; j++)
 329                   table_format_cell (t, col, j, "%U", b->format_fn, &ns, j);
 330               }
 331         }
 332       else
 333         {
 334           for (int j = 0; j < n_row; j++)
 335             table_format_cell (t, i, j, "%U", b->format_fn, r, j);
 336         }
 337       col++;
 338     }
 339
 340   vlib_cli_output (vm, "%U\n", format_table, t);
 341   table_free (t);
 342
 343   if (b->footer)
 344     vlib_cli_output (vm, "\n%s\n", b->footer);
 345
 346 done:
 347   vec_free (readings);
 348   vec_free (s);
 349   return err;
 350 }
 351
 352 VLIB_CLI_COMMAND (show_perfmon_stats_command, static) = {
 353   .path = "show perfmon statistics",
 354   .short_help = "show perfmon statistics",
 355   .function = show_perfmon_stats_command_fn,
 356   .is_mp_safe = 1,
 357 };
 358
 359 static clib_error_t *
 360 set_perfmon_bundle_command_fn (vlib_main_t *vm, unformat_input_t *input,
 361                                vlib_cli_command_t *cmd)
 362 {
 363   perfmon_main_t *pm = &perfmon_main;
 364   unformat_input_t _line_input, *line_input = &_line_input;
 365   perfmon_bundle_t *b = 0;
 366
 367   if (unformat_user (input, unformat_line_input, line_input) == 0)
 368     return clib_error_return (0, "please specify bundle name");
 369
 370   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 371     {
 372       if (unformat (line_input, "%U", unformat_perfmon_bundle_name, &b))
 373         ;
 374       else
 375         return clib_error_return (0, "unknown input '%U'",
 376                                   format_unformat_error, line_input);
 377     }
 378   unformat_free (line_input);
 379
 380   if (b == 0)
 381     return clib_error_return (0, "please specify bundle name");
 382
 383   if (pm->is_running)
 384     return clib_error_return (0, "please stop first");
 385
 386   return perfmon_set (vm, b);
 387 }
 388
 389 VLIB_CLI_COMMAND (set_perfmon_bundle_command, static) = {
 390   .path = "set perfmon bundle",
 391   .short_help = "set perfmon bundle [<bundle-name>]",
 392   .function = set_perfmon_bundle_command_fn,
 393   .is_mp_safe = 1,
 394 };
 395
 396 static clib_error_t *
 397 perfmon_reset_command_fn (vlib_main_t *vm, unformat_input_t *input,
 398                           vlib_cli_command_t *cmd)
 399 {
 400   perfmon_reset (vm);
 401   return 0;
 402 }
 403
 404 VLIB_CLI_COMMAND (perfmon_reset_command, static) = {
 405   .path = "perfmon reset",
 406   .short_help = "perfmon reset",
 407   .function = perfmon_reset_command_fn,
 408   .is_mp_safe = 1,
 409 };
 410
 411 static clib_error_t *
 412 perfmon_start_command_fn (vlib_main_t *vm, unformat_input_t *input,
 413                           vlib_cli_command_t *cmd)
 414 {
 415   return perfmon_start (vm);
 416 }
 417
 418 VLIB_CLI_COMMAND (perfmon_start_command, static) = {
 419   .path = "perfmon start",
 420   .short_help = "perfmon start",
 421   .function = perfmon_start_command_fn,
 422   .is_mp_safe = 1,
 423 };
 424
 425 static clib_error_t *
 426 perfmon_stop_command_fn (vlib_main_t *vm, unformat_input_t *input,
 427                          vlib_cli_command_t *cmd)
 428 {
 429   return perfmon_stop (vm);
 430 }
 431
 432 VLIB_CLI_COMMAND (perfmon_stop_command, static) = {
 433   .path = "perfmon stop",
 434   .short_help = "perfmon stop",
 435   .function = perfmon_stop_command_fn,
 436   .is_mp_safe = 1,
 437 };