src/plugins/perfmon/perfmon.h

   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 #ifndef __perfmon_perfmon_h
  17 #define __perfmon_perfmon_h
  18
  19 #include <linux/perf_event.h>
  20 #include <vppinfra/clib.h>
  21 #include <vppinfra/format.h>
  22 #include <vppinfra/error.h>
  23 #include <vppinfra/cpu.h>
  24 #include <vlib/vlib.h>
  25
  26 #define PERF_MAX_EVENTS 7 /* 3 fixed and 4 programmable */
  27
  28 typedef enum
  29 {
  30   PERFMON_BUNDLE_TYPE_UNKNOWN,
  31   PERFMON_BUNDLE_TYPE_NODE,
  32   PERFMON_BUNDLE_TYPE_THREAD,
  33   PERFMON_BUNDLE_TYPE_SYSTEM,
  34   PERFMON_BUNDLE_TYPE_MAX,
  35 } perfmon_bundle_type_t;
  36
  37 typedef enum
  38 {
  39   PERFMON_OFFSET_TYPE_MMAP,
  40   PERFMON_OFFSET_TYPE_METRICS,
  41   PERFMON_OFFSET_TYPE_MAX,
  42 } perfmon_offset_type_t;
  43
  44 typedef struct
  45 {
  46   u32 type_from_instance : 1;
  47   u32 exclude_kernel : 1;
  48   union
  49   {
  50     u32 type;
  51     u32 instance_type;
  52   };
  53   u64 config;
  54   char *name;
  55   char *description;
  56 } perfmon_event_t;
  57
  58 typedef struct
  59 {
  60   u32 type;
  61   int cpu;
  62   pid_t pid;
  63   char *name;
  64 } perfmon_instance_t;
  65
  66 typedef struct
  67 {
  68   char *name;
  69   perfmon_instance_t *instances;
  70 } perfmon_instance_type_t;
  71
  72 struct perfmon_source;
  73 vlib_node_function_t perfmon_dispatch_wrapper_mmap;
  74 vlib_node_function_t perfmon_dispatch_wrapper_metrics;
  75
  76 #define foreach_permon_offset_type                                            \
  77   _ (PERFMON_OFFSET_TYPE_MMAP, perfmon_dispatch_wrapper_mmap)                 \
  78   _ (PERFMON_OFFSET_TYPE_METRICS, perfmon_dispatch_wrapper_metrics)
  79
  80 typedef clib_error_t *(perfmon_source_init_fn_t) (vlib_main_t *vm,
  81                                                   struct perfmon_source *);
  82 typedef struct perfmon_source
  83 {
  84   char *name;
  85   char *description;
  86   struct perfmon_source *next;
  87   perfmon_event_t *events;
  88   u32 n_events;
  89   perfmon_instance_type_t *instances_by_type;
  90   format_function_t *format_config;
  91   perfmon_source_init_fn_t *init_fn;
  92 } perfmon_source_t;
  93
  94 struct perfmon_bundle;
  95
  96 typedef clib_error_t *(perfmon_bundle_init_fn_t) (vlib_main_t *vm,
  97                                                   struct perfmon_bundle *);
  98
  99 typedef struct
 100 {
 101   clib_cpu_supports_func_t cpu_supports;
 102   perfmon_bundle_type_t bundle_type;
 103 } perfmon_cpu_supports_t;
 104
 105 typedef struct perfmon_bundle
 106 {
 107   char *name;
 108   char *description;
 109   char *source;
 110   char *footer;
 111   perfmon_bundle_type_t type;
 112   perfmon_offset_type_t offset_type;
 113   u32 events[PERF_MAX_EVENTS];
 114   u32 n_events;
 115
 116   u32 metrics[PERF_MAX_EVENTS];
 117   u32 n_metrics;
 118
 119   perfmon_cpu_supports_t *cpu_supports;
 120   u32 n_cpu_supports;
 121
 122   perfmon_bundle_init_fn_t *init_fn;
 123
 124   char **column_headers;
 125   format_function_t *format_fn;
 126
 127   /* do not set manually */
 128   perfmon_source_t *src;
 129   struct perfmon_bundle *next;
 130 } perfmon_bundle_t;
 131
 132 typedef struct
 133 {
 134   u64 nr;
 135   u64 time_enabled;
 136   u64 time_running;
 137   u64 value[PERF_MAX_EVENTS];
 138 } perfmon_reading_t;
 139
 140 typedef struct
 141 {
 142   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 143   u64 n_calls;
 144   u64 n_packets;
 145   union
 146   {
 147     struct
 148     {
 149       u64 value[PERF_MAX_EVENTS];
 150     } t[2];
 151     u64 value[PERF_MAX_EVENTS * 2];
 152   };
 153 } perfmon_node_stats_t;
 154
 155 typedef struct
 156 {
 157   u8 n_events;
 158   u16 n_nodes;
 159   perfmon_node_stats_t *node_stats;
 160   perfmon_bundle_t *bundle;
 161   struct perf_event_mmap_page *mmap_pages[PERF_MAX_EVENTS];
 162 } perfmon_thread_runtime_t;
 163
 164 typedef struct
 165 {
 166   perfmon_thread_runtime_t *thread_runtimes;
 167   perfmon_bundle_t *bundles;
 168   uword *bundle_by_name;
 169   perfmon_source_t *sources;
 170   uword *source_by_name;
 171   perfmon_bundle_t *active_bundle;
 172   int is_running;
 173   f64 sample_time;
 174   int *group_fds;
 175   int *fds_to_close;
 176   perfmon_instance_type_t *default_instance_type;
 177   perfmon_instance_type_t *active_instance_type;
 178 } perfmon_main_t;
 179
 180 extern perfmon_main_t perfmon_main;
 181
 182 always_inline uword
 183 perfmon_cpu_supported_bundle_type (perfmon_bundle_t *b)
 184 {
 185   perfmon_cpu_supports_t *supports = b->cpu_supports;
 186   uword type = 0;
 187
 188   /* if nothing specific for this bundle, go with the default */
 189   if (!supports)
 190     return b->type;
 191
 192   /* the last specified type, will always win */
 193   for (int i = 0; i < b->n_cpu_supports; ++i)
 194     if (supports[i].cpu_supports ())
 195       type = supports[i].bundle_type;
 196
 197   return type;
 198 }
 199
 200 #define PERFMON_REGISTER_SOURCE(x)                                            \
 201   perfmon_source_t __perfmon_source_##x;                                      \
 202   static void __clib_constructor __perfmon_source_registration_##x (void)     \
 203   {                                                                           \
 204     perfmon_main_t *pm = &perfmon_main;                                       \
 205     __perfmon_source_##x.next = pm->sources;                                  \
 206     pm->sources = &__perfmon_source_##x;                                      \
 207   }                                                                           \
 208   perfmon_source_t __perfmon_source_##x
 209
 210 #define PERFMON_REGISTER_BUNDLE(x)                                            \
 211   perfmon_bundle_t __perfmon_bundle_##x;                                      \
 212   static void __clib_constructor __perfmon_bundle_registration_##x (void)     \
 213   {                                                                           \
 214     perfmon_main_t *pm = &perfmon_main;                                       \
 215     __perfmon_bundle_##x.next = pm->bundles;                                  \
 216     __perfmon_bundle_##x.type =                                               \
 217       perfmon_cpu_supported_bundle_type (&__perfmon_bundle_##x);              \
 218     pm->bundles = &__perfmon_bundle_##x;                                      \
 219   }                                                                           \
 220   perfmon_bundle_t __perfmon_bundle_##x
 221
 222 void perfmon_reset (vlib_main_t *vm);
 223 clib_error_t *perfmon_start (vlib_main_t *vm, perfmon_bundle_t *);
 224 clib_error_t *perfmon_stop (vlib_main_t *vm);
 225
 226 #define PERFMON_STRINGS(...)                                                  \
 227   (char *[]) { __VA_ARGS__, 0 }
 228
 229 #endif