Line data Source code
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 :
9 : #define STAT_SEGMENT_SOCKET_FILENAME "stats.sock"
10 :
11 : static u32 vlib_loops_stats_counter_index;
12 :
13 : static void
14 1256 : vector_rate_collector_fn (vlib_stats_collector_data_t *d)
15 : {
16 : vlib_main_t *this_vlib_main;
17 : counter_t **counters, **loops_counters;
18 : counter_t *cb, *loops_cb;
19 1256 : f64 vector_rate = 0.0;
20 1256 : u32 i, n_threads = vlib_get_n_threads ();
21 :
22 1256 : vlib_stats_validate (d->entry_index, 0, n_threads - 1);
23 1256 : counters = d->entry->data;
24 1256 : cb = counters[0];
25 :
26 1256 : vlib_stats_validate (vlib_loops_stats_counter_index, 0, n_threads - 1);
27 : loops_counters =
28 1256 : vlib_stats_get_entry_data_pointer (vlib_loops_stats_counter_index);
29 1256 : loops_cb = loops_counters[0];
30 :
31 2764 : for (i = 0; i < n_threads; i++)
32 : {
33 : f64 this_vector_rate;
34 1508 : this_vlib_main = vlib_get_main_by_index (i);
35 :
36 1508 : this_vector_rate = vlib_internal_node_vector_rate (this_vlib_main);
37 1508 : vlib_clear_internal_node_vector_rate (this_vlib_main);
38 1508 : cb[i] = this_vector_rate;
39 1508 : vector_rate += this_vector_rate;
40 :
41 1508 : loops_cb[i] = this_vlib_main->loops_per_second;
42 : }
43 :
44 : /* And set the system average rate */
45 1256 : vector_rate /= (f64) (i > 1 ? i - 1 : 1);
46 1256 : vlib_stats_set_gauge (d->private_data, vector_rate);
47 1256 : }
48 :
49 : clib_error_t *
50 575 : vlib_stats_init (vlib_main_t *vm)
51 : {
52 575 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
53 : vlib_stats_shared_header_t *shared_header;
54 575 : vlib_stats_collector_reg_t reg = {};
55 :
56 : uword memory_size, sys_page_sz;
57 : int mfd;
58 575 : char *mem_name = "stat segment";
59 : void *heap, *memaddr;
60 :
61 575 : memory_size = sm->memory_size;
62 575 : if (memory_size == 0)
63 575 : memory_size = STAT_SEGMENT_DEFAULT_SIZE;
64 :
65 575 : if (sm->log2_page_sz == CLIB_MEM_PAGE_SZ_UNKNOWN)
66 575 : sm->log2_page_sz = CLIB_MEM_PAGE_SZ_DEFAULT;
67 :
68 575 : mfd = clib_mem_vm_create_fd (sm->log2_page_sz, mem_name);
69 :
70 575 : if (mfd == -1)
71 0 : return clib_error_return (0, "stat segment memory fd failure: %U",
72 : format_clib_error, clib_mem_get_last_error ());
73 : /* Set size */
74 575 : if ((ftruncate (mfd, memory_size)) == -1)
75 : {
76 0 : close (mfd);
77 0 : return clib_error_return (0, "stat segment ftruncate failure");
78 : }
79 :
80 575 : memaddr = clib_mem_vm_map_shared (0, memory_size, mfd, 0, mem_name);
81 :
82 575 : if (memaddr == CLIB_MEM_VM_MAP_FAILED)
83 0 : return clib_error_return (0, "stat segment mmap failure");
84 :
85 575 : sys_page_sz = clib_mem_get_page_size ();
86 :
87 : heap =
88 575 : clib_mem_create_heap (((u8 *) memaddr) + sys_page_sz,
89 : memory_size - sys_page_sz, 1 /* locked */, mem_name);
90 575 : sm->heap = heap;
91 575 : sm->memfd = mfd;
92 :
93 575 : sm->directory_vector_by_name = hash_create_string (0, sizeof (uword));
94 575 : sm->shared_header = shared_header = memaddr;
95 :
96 575 : shared_header->version = STAT_SEGMENT_VERSION;
97 575 : shared_header->base = memaddr;
98 :
99 575 : sm->stat_segment_lockp = clib_mem_alloc (sizeof (clib_spinlock_t));
100 575 : sm->locking_thread_index = ~0;
101 575 : sm->n_locks = 0;
102 575 : clib_spinlock_init (sm->stat_segment_lockp);
103 :
104 : /* Set up the name to counter-vector hash table */
105 575 : sm->directory_vector =
106 575 : vec_new_heap (typeof (sm->directory_vector[0]), STAT_COUNTERS, heap);
107 575 : sm->dir_vector_first_free_elt = CLIB_U32_MAX;
108 :
109 575 : shared_header->epoch = 1;
110 :
111 : /* Scalar stats and node counters */
112 : #define _(E, t, n, p) \
113 : strcpy (sm->directory_vector[STAT_COUNTER_##E].name, p "/" #n); \
114 : sm->directory_vector[STAT_COUNTER_##E].type = STAT_DIR_TYPE_##t;
115 575 : foreach_stat_segment_counter_name
116 : #undef _
117 : /* Save the vector in the shared segment, for clients */
118 575 : shared_header->directory_vector = sm->directory_vector;
119 :
120 575 : vlib_stats_register_mem_heap (heap);
121 :
122 575 : reg.collect_fn = vector_rate_collector_fn;
123 575 : reg.private_data = vlib_stats_add_gauge ("/sys/vector_rate");
124 575 : reg.entry_index =
125 575 : vlib_stats_add_counter_vector ("/sys/vector_rate_per_worker");
126 575 : vlib_loops_stats_counter_index =
127 575 : vlib_stats_add_counter_vector ("/sys/loops_per_worker");
128 575 : vlib_stats_register_collector_fn (®);
129 575 : vlib_stats_validate (reg.entry_index, 0, vlib_get_n_threads ());
130 575 : vlib_stats_validate (vlib_loops_stats_counter_index, 0,
131 : vlib_get_n_threads ());
132 :
133 575 : return 0;
134 : }
135 :
136 : static clib_error_t *
137 575 : statseg_config (vlib_main_t *vm, unformat_input_t *input)
138 : {
139 575 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
140 575 : sm->update_interval = 10.0;
141 :
142 1152 : while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
143 : {
144 577 : if (unformat (input, "socket-name %s", &sm->socket_name))
145 : ;
146 : /* DEPRECATE: default (does nothing) */
147 2 : else if (unformat (input, "default"))
148 : ;
149 2 : else if (unformat (input, "size %U", unformat_memory_size,
150 : &sm->memory_size))
151 : ;
152 2 : else if (unformat (input, "page-size %U", unformat_log2_page_size,
153 : &sm->log2_page_sz))
154 : ;
155 2 : else if (unformat (input, "per-node-counters on"))
156 1 : sm->node_counters_enabled = 1;
157 1 : else if (unformat (input, "per-node-counters off"))
158 0 : sm->node_counters_enabled = 0;
159 1 : else if (unformat (input, "update-interval %f", &sm->update_interval))
160 : ;
161 : else
162 0 : return clib_error_return (0, "unknown input `%U'",
163 : format_unformat_error, input);
164 : }
165 :
166 : /*
167 : * NULL-terminate socket name string
168 : * clib_socket_init()->socket_config() use C str*
169 : */
170 575 : if (vec_len (sm->socket_name))
171 575 : vec_terminate_c_string (sm->socket_name);
172 :
173 575 : return 0;
174 : }
175 :
176 7514 : VLIB_EARLY_CONFIG_FUNCTION (statseg_config, "statseg");
177 :
178 : /*
179 : * Accept connection on the socket and exchange the fd for the shared
180 : * memory segment.
181 : */
182 : static clib_error_t *
183 549 : stats_socket_accept_ready (clib_file_t *uf)
184 : {
185 549 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
186 : clib_error_t *err;
187 549 : clib_socket_t client = { 0 };
188 :
189 549 : err = clib_socket_accept (sm->socket, &client);
190 549 : if (err)
191 : {
192 0 : clib_error_report (err);
193 0 : return err;
194 : }
195 :
196 : /* Send the fd across and close */
197 549 : err = clib_socket_sendmsg (&client, 0, 0, &sm->memfd, 1);
198 549 : if (err)
199 0 : clib_error_report (err);
200 549 : clib_socket_close (&client);
201 :
202 549 : return 0;
203 : }
204 :
205 : static clib_error_t *
206 575 : stats_segment_socket_init (void)
207 : {
208 575 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
209 : clib_error_t *error;
210 575 : clib_socket_t *s = clib_mem_alloc (sizeof (clib_socket_t));
211 :
212 575 : memset (s, 0, sizeof (clib_socket_t));
213 575 : s->config = (char *) sm->socket_name;
214 575 : s->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_SEQPACKET |
215 575 : CLIB_SOCKET_F_ALLOW_GROUP_WRITE | CLIB_SOCKET_F_PASSCRED;
216 :
217 575 : if ((error = clib_socket_init (s)))
218 0 : return error;
219 :
220 575 : clib_file_t template = { 0 };
221 575 : template.read_function = stats_socket_accept_ready;
222 575 : template.file_descriptor = s->fd;
223 575 : template.description = format (0, "stats segment listener %s", s->config);
224 575 : clib_file_add (&file_main, &template);
225 :
226 575 : sm->socket = s;
227 :
228 575 : return 0;
229 : }
230 :
231 : static clib_error_t *
232 575 : stats_segment_socket_exit (vlib_main_t *vm)
233 : {
234 : /*
235 : * cleanup the listener socket on exit.
236 : */
237 575 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
238 575 : unlink ((char *) sm->socket_name);
239 575 : return 0;
240 : }
241 :
242 1151 : VLIB_MAIN_LOOP_EXIT_FUNCTION (stats_segment_socket_exit);
243 :
244 : static clib_error_t *
245 575 : statseg_init (vlib_main_t *vm)
246 : {
247 575 : vlib_stats_segment_t *sm = vlib_stats_get_segment ();
248 :
249 : /* set default socket file name when statseg config stanza is empty. */
250 575 : if (!vec_len (sm->socket_name))
251 0 : sm->socket_name = format (0, "%s/%s%c", vlib_unix_get_runtime_dir (),
252 : STAT_SEGMENT_SOCKET_FILENAME, 0);
253 575 : return stats_segment_socket_init ();
254 : }
255 :
256 4031 : VLIB_INIT_FUNCTION (statseg_init) = {
257 : .runs_after = VLIB_INITS ("unix_input_init", "linux_epoll_input_init"),
258 : };
|
