Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: Apache-2.0 |
| 2 | * Copyright(c) 2022 Cisco Systems, Inc. |
| 3 | */ |
| 4 | |
| 5 | #include <vlib/vlib.h> |
| 6 | #include <vlib/unix/unix.h> |
| 7 | #include <vlib/stats/stats.h> |
| 8 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 9 | enum |
| 10 | { |
| 11 | NODE_CLOCKS, |
| 12 | NODE_VECTORS, |
| 13 | NODE_CALLS, |
| 14 | NODE_SUSPENDS, |
| 15 | N_NODE_COUNTERS |
| 16 | }; |
| 17 | |
| 18 | struct |
| 19 | { |
| 20 | u32 entry_index; |
| 21 | char *name; |
| 22 | } node_counters[] = { |
| 23 | [NODE_CLOCKS] = { .name = "clocks" }, |
| 24 | [NODE_VECTORS] = { .name = "vectors" }, |
| 25 | [NODE_CALLS] = { .name = "calls" }, |
| 26 | [NODE_SUSPENDS] = { .name = "suspends" }, |
| 27 | }; |
| 28 | |
| 29 | static struct |
| 30 | { |
| 31 | u8 *name; |
| 32 | u32 symlinks[N_NODE_COUNTERS]; |
| 33 | } *node_data = 0; |
| 34 | |
| 35 | static vlib_stats_string_vector_t node_names = 0; |
| 36 | |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 37 | static inline void |
| 38 | update_node_counters (vlib_stats_segment_t *sm) |
| 39 | { |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 40 | clib_bitmap_t *bmp = 0; |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 41 | vlib_main_t **stat_vms = 0; |
| 42 | vlib_node_t ***node_dups = 0; |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 43 | u32 n_nodes; |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 44 | int i, j; |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 45 | |
| 46 | vlib_node_get_nodes (0 /* vm, for barrier sync */, |
| 47 | (u32) ~0 /* all threads */, 1 /* include stats */, |
| 48 | 0 /* barrier sync */, &node_dups, &stat_vms); |
| 49 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 50 | n_nodes = vec_len (node_dups[0]); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 51 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 52 | vec_validate (node_data, n_nodes - 1); |
| 53 | |
| 54 | for (i = 0; i < n_nodes; i++) |
| 55 | if (vec_is_equal (node_data[i].name, node_dups[0][i]) == 0) |
| 56 | bmp = clib_bitmap_set (bmp, i, 1); |
| 57 | |
| 58 | if (bmp) |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 59 | { |
Damjan Marion | b3a5b39 | 2022-03-31 17:56:58 +0200 | [diff] [blame] | 60 | u32 last_thread = vlib_get_n_threads (); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 61 | vlib_stats_segment_lock (); |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 62 | clib_bitmap_foreach (i, bmp) |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 63 | { |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 64 | if (node_data[i].name) |
| 65 | { |
| 66 | vec_free (node_data[i].name); |
| 67 | for (j = 0; j < ARRAY_LEN (node_data->symlinks); j++) |
| 68 | vlib_stats_remove_entry (node_data[i].symlinks[j]); |
| 69 | } |
Arthur de Kerhor | add6a38 | 2022-05-16 19:46:22 +0200 | [diff] [blame^] | 70 | } |
| 71 | /* We can't merge the loops because a node index corresponding to a given |
| 72 | * node name can change between 2 updates. Otherwise, we could add |
| 73 | * already existing symlinks or delete valid ones. |
| 74 | */ |
| 75 | clib_bitmap_foreach (i, bmp) |
| 76 | { |
| 77 | vlib_node_t *n = node_dups[0][i]; |
| 78 | node_data[i].name = vec_dup (n->name); |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 79 | vlib_stats_set_string_vector (&node_names, n->index, "%v", n->name); |
| 80 | |
| 81 | for (int j = 0; j < ARRAY_LEN (node_counters); j++) |
| 82 | { |
| 83 | vlib_stats_validate (node_counters[j].entry_index, last_thread, |
| 84 | n_nodes - 1); |
| 85 | node_data[i].symlinks[j] = vlib_stats_add_symlink ( |
| 86 | node_counters[j].entry_index, n->index, "/nodes/%U/%s", |
| 87 | format_vlib_stats_symlink, n->name, node_counters[j].name); |
| 88 | ASSERT (node_data[i].symlinks[j] != CLIB_U32_MAX); |
| 89 | } |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 90 | } |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 91 | vlib_stats_segment_unlock (); |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 92 | vec_free (bmp); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 93 | } |
| 94 | |
| 95 | for (j = 0; j < vec_len (node_dups); j++) |
| 96 | { |
| 97 | vlib_node_t **nodes = node_dups[j]; |
| 98 | |
| 99 | for (i = 0; i < vec_len (nodes); i++) |
| 100 | { |
| 101 | counter_t **counters; |
| 102 | counter_t *c; |
| 103 | vlib_node_t *n = nodes[i]; |
| 104 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 105 | counters = vlib_stats_get_entry_data_pointer ( |
| 106 | node_counters[NODE_CLOCKS].entry_index); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 107 | c = counters[j]; |
| 108 | c[n->index] = n->stats_total.clocks - n->stats_last_clear.clocks; |
| 109 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 110 | counters = vlib_stats_get_entry_data_pointer ( |
| 111 | node_counters[NODE_VECTORS].entry_index); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 112 | c = counters[j]; |
| 113 | c[n->index] = n->stats_total.vectors - n->stats_last_clear.vectors; |
| 114 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 115 | counters = vlib_stats_get_entry_data_pointer ( |
| 116 | node_counters[NODE_CALLS].entry_index); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 117 | c = counters[j]; |
| 118 | c[n->index] = n->stats_total.calls - n->stats_last_clear.calls; |
| 119 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 120 | counters = vlib_stats_get_entry_data_pointer ( |
| 121 | node_counters[NODE_SUSPENDS].entry_index); |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 122 | c = counters[j]; |
| 123 | c[n->index] = n->stats_total.suspends - n->stats_last_clear.suspends; |
| 124 | } |
| 125 | vec_free (node_dups[j]); |
| 126 | } |
| 127 | vec_free (node_dups); |
| 128 | vec_free (stat_vms); |
| 129 | } |
| 130 | |
| 131 | static void |
| 132 | do_stat_segment_updates (vlib_main_t *vm, vlib_stats_segment_t *sm) |
| 133 | { |
| 134 | if (sm->node_counters_enabled) |
| 135 | update_node_counters (sm); |
| 136 | |
| 137 | vlib_stats_collector_t *c; |
| 138 | pool_foreach (c, sm->collectors) |
| 139 | { |
| 140 | vlib_stats_collector_data_t data = { |
| 141 | .entry_index = c->entry_index, |
| 142 | .vector_index = c->vector_index, |
| 143 | .private_data = c->private_data, |
| 144 | .entry = sm->directory_vector + c->entry_index, |
| 145 | }; |
| 146 | c->fn (&data); |
| 147 | } |
| 148 | |
| 149 | /* Heartbeat, so clients detect we're still here */ |
| 150 | sm->directory_vector[STAT_COUNTER_HEARTBEAT].value++; |
| 151 | } |
| 152 | |
| 153 | static uword |
| 154 | stat_segment_collector_process (vlib_main_t *vm, vlib_node_runtime_t *rt, |
| 155 | vlib_frame_t *f) |
| 156 | { |
| 157 | vlib_stats_segment_t *sm = vlib_stats_get_segment (); |
| 158 | |
Damjan Marion | c5d81b9 | 2022-04-15 15:53:17 +0200 | [diff] [blame] | 159 | if (sm->node_counters_enabled) |
| 160 | { |
| 161 | node_names = vlib_stats_add_string_vector ("/sys/node/names"); |
| 162 | ASSERT (node_names); |
| 163 | |
| 164 | for (int x = 0; x < ARRAY_LEN (node_counters); x++) |
| 165 | { |
| 166 | node_counters[x].entry_index = vlib_stats_add_counter_vector ( |
| 167 | "/sys/node/%s", node_counters[x].name); |
| 168 | ASSERT (node_counters[x].entry_index != CLIB_U32_MAX); |
| 169 | } |
| 170 | } |
| 171 | |
Damjan Marion | 8973b07 | 2022-03-01 15:51:18 +0100 | [diff] [blame] | 172 | while (1) |
| 173 | { |
| 174 | do_stat_segment_updates (vm, sm); |
| 175 | vlib_process_suspend (vm, sm->update_interval); |
| 176 | } |
| 177 | return 0; /* or not */ |
| 178 | } |
| 179 | |
| 180 | VLIB_REGISTER_NODE (stat_segment_collector, static) = { |
| 181 | .function = stat_segment_collector_process, |
| 182 | .name = "statseg-collector-process", |
| 183 | .type = VLIB_NODE_TYPE_PROCESS, |
| 184 | }; |