FD.io VPP  v19.04.2-12-g66b1689
Vector Packet Processing
node_serialize.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 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 #include <vlib/vlib.h>
16 
17 #include <vppinfra/serialize.h>
18 
19 /* serialized representation of state strings */
20 
21 #define foreach_state_string_code \
22 _(STATE_DONE, "done") \
23 _(STATE_DISABLED, "disabled") \
24 _(STATE_TIME_WAIT, "time wait") \
25 _(STATE_EVENT_WAIT, "event wait") \
26 _(STATE_ANY_WAIT, "any wait") \
27 _(STATE_POLLING, "polling") \
28 _(STATE_INTERRUPT_WAIT, "interrupt wait") \
29 _(STATE_INTERNAL, "internal")
30 
31 typedef enum
32 {
33 #define _(a,b) a,
35 #undef _
37 
38 static char *state_strings[] = {
39 #define _(a,b) b,
41 #undef _
42 };
43 
44 /*
45  * Serialize a vlib_node_main_t. Appends the result to vector.
46  * Pass 0 to create a new vector, use vec_reset_length(vector)
47  * to recycle a vector / avoid memory allocation, etc.
48  * Switch heaps before/after to serialize into API client shared memory.
49  */
50 u8 *
51 vlib_node_serialize (vlib_main_t * vm, vlib_node_t *** node_dups, u8 * vector,
52  int include_nexts, int include_stats)
53 {
54  serialize_main_t _sm, *sm = &_sm;
55  vlib_node_t *n;
56  vlib_node_t **nodes;
57  u8 *namep;
58  u32 name_bytes;
59  uword i, j, k;
60  u64 l, v, c, d;
61  state_string_enum_t state_code;
62 
63  serialize_open_vector (sm, vector);
65 
66  for (j = 0; j < vec_len (node_dups); j++)
67  {
68  nodes = node_dups[j];
69 
70  serialize_likely_small_unsigned_integer (sm, vec_len (nodes));
71 
72  for (i = 0; i < vec_len (nodes); i++)
73  {
74  n = nodes[i];
75 
80 
81  state_code = STATE_INTERNAL;
82 
83  if (n->type == VLIB_NODE_TYPE_PROCESS)
84  {
86 
87  switch (p->flags
90  {
91  default:
92  if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
93  state_code = STATE_DONE;
94  break;
95 
97  state_code = STATE_TIME_WAIT;
98  break;
99 
101  state_code = STATE_EVENT_WAIT;
102  break;
103 
105  state_code =
106  STATE_ANY_WAIT;
107  break;
108  }
109  }
110  else if (n->type != VLIB_NODE_TYPE_INTERNAL)
111  {
112  state_code = STATE_POLLING;
113  if (n->state == VLIB_NODE_STATE_DISABLED)
114  state_code = STATE_DISABLED;
115  else if (n->state == VLIB_NODE_STATE_INTERRUPT)
116  state_code = STATE_INTERRUPT_WAIT;
117  }
118 
119  /* See unserialize_cstring */
120  name_bytes = vec_len (n->name);
122  namep = serialize_get (sm, name_bytes);
123  memcpy (namep, n->name, name_bytes);
124 
125  serialize_likely_small_unsigned_integer (sm, (u64) state_code);
128 
129  if (include_nexts)
130  {
132  (sm, vec_len (n->next_nodes));
133  for (k = 0; k < vec_len (n->next_nodes); k++)
135  n->next_nodes[k]);
136  }
137  else
139 
140  if (include_stats)
141  {
142  /* stats present */
144  /* total clocks */
145  serialize_integer (sm, l, 8);
146  /* Total calls */
147  serialize_integer (sm, c, 8);
148  /* Total vectors */
149  serialize_integer (sm, v, 8);
150  /* Total suspends */
151  serialize_integer (sm, d, 8);
152  }
153  else /* no stats */
155  }
156  }
157  return (serialize_close_vector (sm));
158 }
159 
160 vlib_node_t ***
162 {
163  serialize_main_t _sm, *sm = &_sm;
164  u32 nnodes, nnexts;
165  u32 nstat_vms;
166  vlib_node_t *node;
167  vlib_node_t **nodes;
168  vlib_node_t ***nodes_by_thread = 0;
169  int i, j, k;
170  u64 l, v, c, d;
171  state_string_enum_t state_code;
172  int stats_present;
173 
174  serialize_open_vector (sm, vector);
175 
177 
178  vec_validate (nodes_by_thread, nstat_vms - 1);
179  _vec_len (nodes_by_thread) = 0;
180 
181  for (i = 0; i < nstat_vms; i++)
182  {
184 
185  nodes = 0;
186  vec_validate (nodes, nnodes - 1);
187  vec_add1 (nodes_by_thread, nodes);
188 
189  for (j = 0; j < nnodes; j++)
190  {
191  node = 0;
192  vec_validate (node, 0);
193  nodes[j] = node;
194 
195  unserialize_cstring (sm, (char **) &(node->name));
197  node->state_string = (u8 *) state_strings[state_code];
198 
202  if (nnexts > 0)
203  vec_validate (node->next_nodes, nnexts - 1);
204  for (k = 0; k < nnexts; k++)
205  node->next_nodes[k] =
207 
208  stats_present = unserialize_likely_small_unsigned_integer (sm);
209 
210  if (stats_present)
211  {
212  /* total clocks */
213  unserialize_integer (sm, &l, 8);
214  node->stats_total.clocks = l;
215  node->stats_last_clear.clocks = 0;
216 
217  /* Total calls */
218  unserialize_integer (sm, &c, 8);
219  node->stats_total.calls = c;
220 
221  /* Total vectors */
222  unserialize_integer (sm, &v, 8);
223  node->stats_total.vectors = v;
224 
225  /* Total suspends */
226  unserialize_integer (sm, &d, 8);
227  node->stats_total.suspends = d;
228  }
229  }
230  }
231  return nodes_by_thread;
232 }
233 
234 #if TEST_CODE
235 
236 static clib_error_t *
237 test_node_serialize_command_fn (vlib_main_t * vm,
238  unformat_input_t * input,
239  vlib_cli_command_t * cmd)
240 {
241  vlib_node_main_t *nm = &vm->node_main;
242  u8 *vector = 0;
243  vlib_node_t ***nodes_by_thread;
244  vlib_node_t **nodes;
245  vlib_node_t *node;
246  vlib_node_t *next_node;
247  int i, j, k;
248  u32 max_threads = (u32) ~ 0;
249  int include_nexts = 0;
250  int include_stats = 0;
251 
253  {
254  if (unformat (input, "max-threads %d", &max_threads))
255  ;
256  else if (unformat (input, "stats"))
257  include_stats = 1;
258  else if (unformat (input, "nexts"))
259  include_nexts = 1;
260  else
261  break;
262  }
263 
264  /*
265  * Keep the number of memcpy ops to a minimum (e.g. 1).
266  * The current size of the serialized vector is
267  * slightly under 4K.
268  */
269  vec_validate (vector, 16383);
270  vec_reset_length (vector);
271 
272  vector = vlib_node_serialize (nm, vector, max_threads,
273  include_nexts, include_stats);
274 
275  vlib_cli_output (vm, "result vector %d bytes", vec_len (vector));
276 
277  nodes_by_thread = vlib_node_unserialize (vector);
278 
279  vec_free (vector);
280 
281  for (i = 0; i < vec_len (nodes_by_thread); i++)
282  {
283  nodes = nodes_by_thread[i];
284 
285  vlib_cli_output (vm, "thread %d", i);
286 
287  for (j = 0; j < vec_len (nodes); j++)
288  {
289  node = nodes[j];
290 
291  vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
292  node->state_string);
293 
295  (vm, " clocks %lld calls %lld suspends"
296  " %lld vectors %lld",
297  node->stats_total.clocks,
298  node->stats_total.calls,
299  node->stats_total.suspends, node->stats_total.vectors);
300 
301  for (k = 0; k < vec_len (node->next_nodes); k++)
302  {
303  if (node->next_nodes[k] != ~0)
304  {
305  next_node = nodes[node->next_nodes[k]];
306  vlib_cli_output (vm, " [%d] %s", k, next_node->name);
307  }
308  }
309  }
310  }
311 
312  for (j = 0; j < vec_len (nodes_by_thread); j++)
313  {
314  nodes = nodes_by_thread[j];
315 
316  for (i = 0; i < vec_len (nodes); i++)
317  {
318  vec_free (nodes[i]->name);
319  vec_free (nodes[i]->next_nodes);
320  vec_free (nodes[i]);
321  }
322  vec_free (nodes);
323  }
324  vec_free (nodes_by_thread);
325 
326  return 0;
327 }
328 
329 /* *INDENT-OFF* */
330 VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
331  .path = "test node serialize",
332  .short_help = "test node serialize [max-threads NN] nexts stats",
333  .function = test_node_serialize_command_fn,
334 };
335 /* *INDENT-ON* */
336 #endif
337 
338 /*
339  * fd.io coding-style-patch-verification: ON
340  *
341  * Local Variables:
342  * eval: (c-set-style "gnu")
343  * End:
344  */
u32 * next_nodes
Definition: node.h:333
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u8 * state_string
Definition: node.h:367
static u64 unserialize_likely_small_unsigned_integer(serialize_main_t *m)
Definition: serialize.h:254
unsigned long u64
Definition: types.h:89
u16 flags
Definition: node.h:288
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
int i
state_string_enum_t
#define foreach_state_string_code
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u8 * vlib_node_serialize(vlib_main_t *vm, vlib_node_t ***node_dups, u8 *vector, int include_nexts, int include_stats)
u8 state
Definition: node.h:307
vlib_node_stats_t stats_last_clear
Definition: node.h:273
static void * serialize_get(serialize_main_t *m, uword n_bytes)
Definition: serialize.h:178
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
Definition: node.h:567
unsigned int u32
Definition: types.h:88
#define VLIB_PROCESS_IS_RUNNING
Definition: node.h:573
vlib_node_stats_t stats_total
Definition: node.h:269
static void serialize_likely_small_unsigned_integer(serialize_main_t *m, u64 x)
Definition: serialize.h:218
struct _unformat_input_t unformat_input_t
u8 name[64]
Definition: memclnt.api:152
void unserialize_cstring(serialize_main_t *m, char **s)
Definition: serialize.c:178
u8 * name
Definition: node.h:263
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
svmdb_client_t * c
void serialize_open_vector(serialize_main_t *m, u8 *vector)
Definition: serialize.c:909
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
static void unserialize_integer(serialize_main_t *m, void *x, u32 n_bytes)
Definition: serialize.h:201
static void serialize_integer(serialize_main_t *m, u64 x, u32 n_bytes)
Definition: serialize.h:185
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vlib_node_main_t node_main
Definition: main.h:135
u64 uword
Definition: types.h:112
static char * state_strings[]
u16 flags
Definition: node.h:566
vlib_node_type_t type
Definition: node.h:276
static vlib_process_t * vlib_get_process_from_node(vlib_main_t *vm, vlib_node_t *node)
Definition: node_funcs.h:208
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
Definition: node.h:568
vlib_node_t *** vlib_node_unserialize(u8 *vector)
void * serialize_close_vector(serialize_main_t *m)
Definition: serialize.c:919
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170