FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
flowprobe.c
Go to the documentation of this file.
1 /*
2  * flowprobe.c - ipfix probe plugin
3  *
4  * Copyright (c) 2016 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 /**
19  * @file
20  * @brief Per-packet IPFIX flow record generator plugin
21  *
22  * This file implements vpp plugin registration mechanics,
23  * debug CLI, and binary API handling.
24  */
25 
26 #include <vnet/vnet.h>
27 #include <vpp/app/version.h>
28 #include <vnet/plugin/plugin.h>
29 #include <flowprobe/flowprobe.h>
30 
31 #include <vlibapi/api.h>
32 #include <vlibmemory/api.h>
33 
34 /* define message IDs */
35 #include <flowprobe/flowprobe.api_enum.h>
36 #include <flowprobe/flowprobe.api_types.h>
37 
41  vlib_frame_t * f);
42 
43 #define REPLY_MSG_ID_BASE fm->msg_id_base
45 
46 /* Define the per-interface configurable features */
47 /* *INDENT-OFF* */
48 VNET_FEATURE_INIT (flow_perpacket_ip4, static) =
49 {
50  .arc_name = "ip4-output",
51  .node_name = "flowprobe-ip4",
52  .runs_before = VNET_FEATURES ("interface-output"),
53 };
54 
55 VNET_FEATURE_INIT (flow_perpacket_ip6, static) =
56 {
57  .arc_name = "ip6-output",
58  .node_name = "flowprobe-ip6",
59  .runs_before = VNET_FEATURES ("interface-output"),
60 };
61 
62 VNET_FEATURE_INIT (flow_perpacket_l2, static) =
63 {
64  .arc_name = "interface-output",
65  .node_name = "flowprobe-l2",
66  .runs_before = VNET_FEATURES ("interface-tx"),
67 };
68 /* *INDENT-ON* */
69 
70 /* Macro to finish up custom dump fns */
71 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
72 #define FINISH \
73  vec_add1 (s, 0); \
74  vl_print (handle, (char *)s); \
75  vec_free (s); \
76  return handle;
77 
78 static inline ipfix_field_specifier_t *
80 {
81 #define flowprobe_template_ip4_field_count() 4
82  /* sourceIpv4Address, TLV type 8, u32 */
83  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
84  sourceIPv4Address, 4);
85  f++;
86  /* destinationIPv4Address, TLV type 12, u32 */
87  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
88  destinationIPv4Address, 4);
89  f++;
90  /* protocolIdentifier, TLV type 4, u8 */
91  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
92  protocolIdentifier, 1);
93  f++;
94  /* octetDeltaCount, TLV type 1, u64 */
95  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
96  octetDeltaCount, 8);
97  f++;
98  return f;
99 }
100 
101 static inline ipfix_field_specifier_t *
103 {
104 #define flowprobe_template_ip6_field_count() 4
105  /* sourceIpv6Address, TLV type 27, 16 octets */
106  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
107  sourceIPv6Address, 16);
108  f++;
109  /* destinationIPv6Address, TLV type 28, 16 octets */
110  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
111  destinationIPv6Address, 16);
112  f++;
113  /* protocolIdentifier, TLV type 4, u8 */
114  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
115  protocolIdentifier, 1);
116  f++;
117  /* octetDeltaCount, TLV type 1, u64 */
118  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
119  octetDeltaCount, 8);
120  f++;
121  return f;
122 }
123 
124 static inline ipfix_field_specifier_t *
126 {
127 #define flowprobe_template_l2_field_count() 3
128  /* sourceMacAddress, TLV type 56, u8[6] we hope */
129  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
130  sourceMacAddress, 6);
131  f++;
132  /* destinationMacAddress, TLV type 80, u8[6] we hope */
133  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
134  destinationMacAddress, 6);
135  f++;
136  /* ethernetType, TLV type 256, u16 */
137  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
138  ethernetType, 2);
139  f++;
140  return f;
141 }
142 
143 static inline ipfix_field_specifier_t *
145 {
146 #define flowprobe_template_common_field_count() 5
147  /* ingressInterface, TLV type 10, u32 */
148  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
149  ingressInterface, 4);
150  f++;
151 
152  /* egressInterface, TLV type 14, u32 */
153  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
154  egressInterface, 4);
155  f++;
156 
157  /* packetDeltaCount, TLV type 2, u64 */
158  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
159  packetDeltaCount, 8);
160  f++;
161 
162  /* flowStartNanoseconds, TLV type 156, u64 */
163  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
164  flowStartNanoseconds, 8);
165  f++;
166 
167  /* flowEndNanoseconds, TLV type 157, u64 */
168  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
169  flowEndNanoseconds, 8);
170  f++;
171 
172  return f;
173 }
174 
175 static inline ipfix_field_specifier_t *
177 {
178 #define flowprobe_template_l4_field_count() 3
179  /* sourceTransportPort, TLV type 7, u16 */
180  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
181  sourceTransportPort, 2);
182  f++;
183  /* destinationTransportPort, TLV type 11, u16 */
184  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
185  destinationTransportPort, 2);
186  f++;
187  /* tcpControlBits, TLV type 6, u16 */
188  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
189  tcpControlBits, 2);
190  f++;
191 
192  return f;
193 }
194 
195 /**
196  * @brief Create an IPFIX template packet rewrite string
197  * @param frm flow_report_main_t *
198  * @param fr flow_report_t *
199  * @param collector_address ip4_address_t * the IPFIX collector address
200  * @param src_address ip4_address_t * the source address we should use
201  * @param collector_port u16 the collector port we should use, host byte order
202  * @returns u8 * vector containing the indicated IPFIX template packet
203  */
204 static inline u8 *
206  flow_report_t * fr,
207  ip4_address_t * collector_address,
209  u16 collector_port,
210  flowprobe_variant_t which)
211 {
212  ip4_header_t *ip;
213  udp_header_t *udp;
218  ipfix_field_specifier_t *first_field;
219  u8 *rewrite = 0;
221  u32 field_count = 0;
222  flow_report_stream_t *stream;
225  bool collect_ip4 = false, collect_ip6 = false;
226 
227  stream = &frm->streams[fr->stream_index];
228 
229  if (flags & FLOW_RECORD_L3)
230  {
231  collect_ip4 = which == FLOW_VARIANT_L2_IP4 || which == FLOW_VARIANT_IP4;
232  collect_ip6 = which == FLOW_VARIANT_L2_IP6 || which == FLOW_VARIANT_IP6;
233  if (which == FLOW_VARIANT_L2_IP4)
234  flags |= FLOW_RECORD_L2_IP4;
235  if (which == FLOW_VARIANT_L2_IP6)
236  flags |= FLOW_RECORD_L2_IP6;
237  }
238 
239  field_count += flowprobe_template_common_field_count ();
240  if (flags & FLOW_RECORD_L2)
241  field_count += flowprobe_template_l2_field_count ();
242  if (collect_ip4)
243  field_count += flowprobe_template_ip4_field_count ();
244  if (collect_ip6)
245  field_count += flowprobe_template_ip6_field_count ();
246  if (flags & FLOW_RECORD_L4)
247  field_count += flowprobe_template_l4_field_count ();
248 
249  /* allocate rewrite space */
251  (rewrite, sizeof (ip4_ipfix_template_packet_t)
252  + field_count * sizeof (ipfix_field_specifier_t) - 1,
254 
255  tp = (ip4_ipfix_template_packet_t *) rewrite;
256  ip = (ip4_header_t *) & tp->ip4;
257  udp = (udp_header_t *) (ip + 1);
258  h = (ipfix_message_header_t *) (udp + 1);
259  s = (ipfix_set_header_t *) (h + 1);
260  t = (ipfix_template_header_t *) (s + 1);
261  first_field = f = (ipfix_field_specifier_t *) (t + 1);
262 
263  ip->ip_version_and_header_length = 0x45;
264  ip->ttl = 254;
265  ip->protocol = IP_PROTOCOL_UDP;
266  ip->src_address.as_u32 = src_address->as_u32;
267  ip->dst_address.as_u32 = collector_address->as_u32;
268  udp->src_port = clib_host_to_net_u16 (stream->src_port);
269  udp->dst_port = clib_host_to_net_u16 (collector_port);
270  udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
271 
272  /* FIXUP: message header export_time */
273  /* FIXUP: message header sequence_number */
274  h->domain_id = clib_host_to_net_u32 (stream->domain_id);
275 
276  /* Add TLVs to the template */
278 
279  if (flags & FLOW_RECORD_L2)
281  if (collect_ip4)
283  if (collect_ip6)
285  if (flags & FLOW_RECORD_L4)
287 
288  /* Back to the template packet... */
289  ip = (ip4_header_t *) & tp->ip4;
290  udp = (udp_header_t *) (ip + 1);
291 
292  ASSERT (f - first_field);
293  /* Field count in this template */
294  t->id_count = ipfix_id_count (fr->template_id, f - first_field);
295 
296  fm->template_size[flags] = (u8 *) f - (u8 *) s;
297 
298  /* set length in octets */
299  s->set_id_length =
300  ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
301 
302  /* message length in octets */
303  h->version_length = version_length ((u8 *) f - (u8 *) h);
304 
305  ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
306  ip->checksum = ip4_header_checksum (ip);
307 
308  return rewrite;
309 }
310 
311 static u8 *
313  flow_report_t * fr,
314  ip4_address_t * collector_address,
316  u16 collector_port,
317  ipfix_report_element_t * elts,
318  u32 n_elts, u32 * stream_index)
319 {
321  (frm, fr, collector_address, src_address, collector_port,
323 }
324 
325 static u8 *
327  flow_report_t * fr,
328  ip4_address_t * collector_address,
330  u16 collector_port,
331  ipfix_report_element_t * elts,
332  u32 n_elts, u32 * stream_index)
333 {
335  (frm, fr, collector_address, src_address, collector_port,
337 }
338 
339 static u8 *
341  flow_report_t * fr,
342  ip4_address_t * collector_address,
344  u16 collector_port,
345  ipfix_report_element_t * elts,
346  u32 n_elts, u32 * stream_index)
347 {
349  (frm, fr, collector_address, src_address, collector_port,
351 }
352 
353 static u8 *
355  flow_report_t * fr,
356  ip4_address_t * collector_address,
358  u16 collector_port,
359  ipfix_report_element_t * elts,
360  u32 n_elts, u32 * stream_index)
361 {
363  (frm, fr, collector_address, src_address, collector_port,
365 }
366 
367 static u8 *
369  flow_report_t * fr,
370  ip4_address_t * collector_address,
372  u16 collector_port,
373  ipfix_report_element_t * elts,
374  u32 n_elts, u32 * stream_index)
375 {
377  (frm, fr, collector_address, src_address, collector_port,
379 }
380 
381 /**
382  * @brief Flush accumulated data
383  * @param frm flow_report_main_t *
384  * @param fr flow_report_t *
385  * @param f vlib_frame_t *
386  *
387  * <em>Notes:</em>
388  * This function must simply return the incoming frame, or no template packets
389  * will be sent.
390  */
391 vlib_frame_t *
393  flow_report_t * fr,
394  vlib_frame_t * f, u32 * to_next, u32 node_index)
395 {
397  return f;
398 }
399 
400 vlib_frame_t *
402  flow_report_t * fr,
403  vlib_frame_t * f, u32 * to_next, u32 node_index)
404 {
406  return f;
407 }
408 
409 vlib_frame_t *
411  flow_report_t * fr,
412  vlib_frame_t * f, u32 * to_next, u32 node_index)
413 {
415  return f;
416 }
417 
418 static int
421  vnet_flow_data_callback_t * flow_data_callback,
422  vnet_flow_rewrite_callback_t * rewrite_callback,
423  bool is_add, u16 * template_id)
424 {
427  .rewrite_callback = rewrite_callback,
428  .flow_data_callback = flow_data_callback,
429  .is_add = is_add,
430  .domain_id = domain_id,
431  .src_port = src_port,
432  .opaque.as_uword = flags,
433  };
434  return vnet_flow_report_add_del (frm, &a, template_id);
435 }
436 
437 static void
439 {
442  u32 my_cpu_number = vm->thread_index;
443  int i;
444  u32 poolindex;
445 
446  for (i = 0; i < vec_len (expired_timers); i++)
447  {
448  poolindex = expired_timers[i] & 0x7FFFFFFF;
449  vec_add1 (fm->expired_passive_per_worker[my_cpu_number], poolindex);
450  }
451 }
452 
453 static clib_error_t *
455 {
459  clib_error_t *error = 0;
460  u32 num_threads;
461  int i;
462 
463  /* Decide how many worker threads we have */
464  num_threads = 1 /* main thread */ + tm->n_threads;
465 
466  /* Hash table per worker */
468 
469  /* Init per worker flow state and timer wheels */
470  if (active_timer)
471  {
472  vec_validate (fm->timers_per_worker, num_threads - 1);
473  vec_validate (fm->expired_passive_per_worker, num_threads - 1);
474  vec_validate (fm->hash_per_worker, num_threads - 1);
475  vec_validate (fm->pool_per_worker, num_threads - 1);
476 
477  for (i = 0; i < num_threads; i++)
478  {
479  int j;
480  pool_alloc (fm->pool_per_worker[i], 1 << fm->ht_log2len);
481  vec_resize (fm->hash_per_worker[i], 1 << fm->ht_log2len);
482  for (j = 0; j < (1 << fm->ht_log2len); j++)
483  fm->hash_per_worker[i][j] = ~0;
484  fm->timers_per_worker[i] =
485  clib_mem_alloc (sizeof (TWT (tw_timer_wheel)));
486  tw_timer_wheel_init_2t_1w_2048sl (fm->timers_per_worker[i],
488  1.0, 1024);
489  }
490  fm->disabled = true;
491  }
492  else
493  {
494  f64 now = vlib_time_now (vm);
495  vec_validate (fm->stateless_entry, num_threads - 1);
496  for (i = 0; i < num_threads; i++)
497  fm->stateless_entry[i].last_exported = now;
498  fm->disabled = false;
499  }
500  fm->initialized = true;
501  return error;
502 }
503 
504 static int
506  u8 which)
507 {
508  vec_validate_init_empty (fm->flow_per_interface, sw_if_index, ~0);
509 
510  if (fm->flow_per_interface[sw_if_index] == (u8) ~ 0)
511  return -1;
512  else if (fm->flow_per_interface[sw_if_index] != which)
513  return 0;
514  else
515  return 1;
516 }
517 
518 /**
519  * @brief configure / deconfigure the IPFIX flow-per-packet
520  * @param fm flowprobe_main_t * fm
521  * @param sw_if_index u32 the desired interface
522  * @param is_add int 1 to enable the feature, 0 to disable it
523  * @returns 0 if successful, non-zero otherwise
524  */
525 
526 static int
528  u32 sw_if_index, u8 which, int is_add)
529 {
531  int rv = 0;
532  u16 template_id = 0;
534 
535  fm->flow_per_interface[sw_if_index] = (is_add) ? which : (u8) ~ 0;
536  fm->template_per_flow[which] += (is_add) ? 1 : -1;
537  if (is_add && fm->template_per_flow[which] > 1)
538  template_id = fm->template_reports[flags];
539 
540  if ((is_add && fm->template_per_flow[which] == 1) ||
541  (!is_add && fm->template_per_flow[which] == 0))
542  {
543  if (which == FLOW_VARIANT_L2)
544  {
545  if (fm->record & FLOW_RECORD_L2)
546  {
547  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
550  is_add, &template_id);
551  }
552  if (fm->record & FLOW_RECORD_L3 || fm->record & FLOW_RECORD_L4)
553  {
554  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
557  is_add, &template_id);
558  fm->template_reports[flags | FLOW_RECORD_L2_IP4] =
559  (is_add) ? template_id : 0;
560  rv =
561  flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
564  is_add, &template_id);
565  fm->template_reports[flags | FLOW_RECORD_L2_IP6] =
566  (is_add) ? template_id : 0;
567 
568  /* Special case L2 */
570  flags | FLOW_RECORD_L2_IP4;
572  flags | FLOW_RECORD_L2_IP6;
573 
574  fm->template_reports[flags] = template_id;
575  }
576  }
577  else if (which == FLOW_VARIANT_IP4)
578  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
581  is_add, &template_id);
582  else if (which == FLOW_VARIANT_IP6)
583  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
586  is_add, &template_id);
587  }
588  if (rv && rv != VNET_API_ERROR_VALUE_EXIST)
589  {
590  clib_warning ("vnet_flow_report_add_del returned %d", rv);
591  return -1;
592  }
593 
594  if (which != (u8) ~ 0)
595  {
596  fm->context[which].flags = fm->record;
597  fm->template_reports[flags] = (is_add) ? template_id : 0;
598  }
599 
600  if (which == FLOW_VARIANT_IP4)
601  vnet_feature_enable_disable ("ip4-output", "flowprobe-ip4",
602  sw_if_index, is_add, 0, 0);
603  else if (which == FLOW_VARIANT_IP6)
604  vnet_feature_enable_disable ("ip6-output", "flowprobe-ip6",
605  sw_if_index, is_add, 0, 0);
606  else if (which == FLOW_VARIANT_L2)
607  vnet_feature_enable_disable ("interface-output", "flowprobe-l2",
608  sw_if_index, is_add, 0, 0);
609 
610  /* Stateful flow collection */
611  if (is_add && !fm->initialized)
612  {
614  if (fm->active_timer)
615  vlib_process_signal_event (vm, flowprobe_timer_node.index, 1, 0);
616  }
617 
618  return 0;
619 }
620 
621 /**
622  * @brief API message handler
623  * @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
624  */
627 {
629  vl_api_flowprobe_tx_interface_add_del_reply_t *rmp;
630  u32 sw_if_index = ntohl (mp->sw_if_index);
631  int rv = 0;
632 
634 
635  if (fm->record == 0)
636  {
637  clib_warning ("Please specify flowprobe params record first...");
638  rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
639  goto out;
640  }
641 
642  rv = validate_feature_on_interface (fm, sw_if_index, mp->which);
643  if ((rv == 1 && mp->is_add == 1) || rv == 0)
644  {
645  rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
646  goto out;
647  }
648 
650  (fm, sw_if_index, mp->which, mp->is_add);
651 
652 out:
654 
655  REPLY_MACRO (VL_API_FLOWPROBE_TX_INTERFACE_ADD_DEL_REPLY);
656 }
657 
658 /**
659  * @brief API message custom-dump function
660  * @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
661  * @param handle void * print function handle
662  * @returns u8 * output string
663  */
666 {
667  u8 *s;
668 
669  s = format (0, "SCRIPT: flowprobe_tx_interface_add_del ");
670  s = format (s, "sw_if_index %d is_add %d which %d ",
671  clib_host_to_net_u32 (mp->sw_if_index),
672  (int) mp->is_add, (int) mp->which);
673  FINISH;
674 }
675 
676 #define vec_neg_search(v,E) \
677 ({ \
678  word _v(i) = 0; \
679  while (_v(i) < vec_len(v) && v[_v(i)] == E) \
680  { \
681  _v(i)++; \
682  } \
683  if (_v(i) == vec_len(v)) \
684  _v(i) = ~0; \
685  _v(i); \
686 })
687 
688 static int
690  u8 record_l3, u8 record_l4,
691  u32 active_timer, u32 passive_timer)
692 {
694 
695  if (vec_neg_search (fm->flow_per_interface, (u8) ~ 0) != ~0)
696  return ~0;
697 
698  if (record_l2)
699  flags |= FLOW_RECORD_L2;
700  if (record_l3)
701  flags |= FLOW_RECORD_L3;
702  if (record_l4)
703  flags |= FLOW_RECORD_L4;
704 
705  fm->record = flags;
706 
707  /*
708  * Timers: ~0 is default, 0 is off
709  */
710  fm->active_timer =
711  (active_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_ACTIVE : active_timer);
712  fm->passive_timer =
713  (passive_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_PASSIVE : passive_timer);
714 
715  return 0;
716 }
717 
718 void
720 {
722  vl_api_flowprobe_params_reply_t *rmp;
723  int rv = 0;
724 
725  rv = flowprobe_params
726  (fm,
730  clib_net_to_host_u32 (mp->active_timer),
731  clib_net_to_host_u32 (mp->passive_timer));
732 
733  REPLY_MACRO (VL_API_FLOWPROBE_PARAMS_REPLY);
734 }
735 
736 /* *INDENT-OFF* */
738  .version = VPP_BUILD_VER,
739  .description = "Flow per Packet",
740 };
741 /* *INDENT-ON* */
742 
743 u8 *
744 format_flowprobe_entry (u8 * s, va_list * args)
745 {
746  flowprobe_entry_t *e = va_arg (*args, flowprobe_entry_t *);
747  s = format (s, " %d/%d", e->key.rx_sw_if_index, e->key.tx_sw_if_index);
748 
749  s = format (s, " %U %U", format_ethernet_address, &e->key.src_mac,
751  s = format (s, " %U -> %U",
754  s = format (s, " %d", e->key.protocol);
755  s = format (s, " %d %d\n", clib_net_to_host_u16 (e->key.src_port),
756  clib_net_to_host_u16 (e->key.dst_port));
757 
758  return s;
759 }
760 
761 static clib_error_t *
764 {
766  int i;
768 
769  vlib_cli_output (vm, "Dumping IPFIX table");
770 
771  for (i = 0; i < vec_len (fm->pool_per_worker); i++)
772  {
773  /* *INDENT-OFF* */
774  pool_foreach (e, fm->pool_per_worker[i], (
775  {
776  vlib_cli_output (vm, "%U",
777  format_flowprobe_entry,
778  e);
779  }));
780  /* *INDENT-ON* */
781 
782  }
783  return 0;
784 }
785 
786 static clib_error_t *
789 {
791  int i;
792 
793  vlib_cli_output (vm, "IPFIX table statistics");
794  vlib_cli_output (vm, "Flow entry size: %d\n", sizeof (flowprobe_entry_t));
795  vlib_cli_output (vm, "Flow pool size per thread: %d\n",
796  0x1 << FLOWPROBE_LOG2_HASHSIZE);
797 
798  for (i = 0; i < vec_len (fm->pool_per_worker); i++)
799  vlib_cli_output (vm, "Pool utilisation thread %d is %d%%\n", i,
800  (100 * pool_elts (fm->pool_per_worker[i])) /
801  (0x1 << FLOWPROBE_LOG2_HASHSIZE));
802  return 0;
803 }
804 
805 static clib_error_t *
807  unformat_input_t * input,
808  vlib_cli_command_t * cmd)
809 {
811  u32 sw_if_index = ~0;
812  int is_add = 1;
813  u8 which = FLOW_VARIANT_IP4;
814  int rv;
815 
817  {
818  if (unformat (input, "disable"))
819  is_add = 0;
820  else if (unformat (input, "%U", unformat_vnet_sw_interface,
821  fm->vnet_main, &sw_if_index));
822  else if (unformat (input, "ip4"))
823  which = FLOW_VARIANT_IP4;
824  else if (unformat (input, "ip6"))
825  which = FLOW_VARIANT_IP6;
826  else if (unformat (input, "l2"))
827  which = FLOW_VARIANT_L2;
828  else
829  break;
830  }
831 
832  if (fm->record == 0)
833  return clib_error_return (0,
834  "Please specify flowprobe params record first...");
835 
836  if (sw_if_index == ~0)
837  return clib_error_return (0, "Please specify an interface...");
838 
839  rv = validate_feature_on_interface (fm, sw_if_index, which);
840  if (rv == 1)
841  {
842  if (is_add)
843  return clib_error_return (0,
844  "Datapath is already enabled for given interface...");
845  }
846  else if (rv == 0)
847  return clib_error_return (0,
848  "Interface has enable different datapath ...");
849 
850  rv =
851  flowprobe_tx_interface_add_del_feature (fm, sw_if_index, which, is_add);
852  switch (rv)
853  {
854  case 0:
855  break;
856 
857  case VNET_API_ERROR_INVALID_SW_IF_INDEX:
858  return clib_error_return
859  (0, "Invalid interface, only works on physical ports");
860  break;
861 
862  case VNET_API_ERROR_UNIMPLEMENTED:
863  return clib_error_return (0, "ip6 not supported");
864  break;
865 
866  default:
867  return clib_error_return (0, "flowprobe_enable_disable returned %d",
868  rv);
869  }
870  return 0;
871 }
872 
873 static clib_error_t *
875  unformat_input_t * input,
876  vlib_cli_command_t * cmd)
877 {
879  bool record_l2 = false, record_l3 = false, record_l4 = false;
880  u32 active_timer = ~0;
881  u32 passive_timer = ~0;
882 
884  {
885  if (unformat (input, "active %d", &active_timer))
886  ;
887  else if (unformat (input, "passive %d", &passive_timer))
888  ;
889  else if (unformat (input, "record"))
891  {
892  if (unformat (input, "l2"))
893  record_l2 = true;
894  else if (unformat (input, "l3"))
895  record_l3 = true;
896  else if (unformat (input, "l4"))
897  record_l4 = true;
898  else
899  break;
900  }
901  else
902  break;
903  }
904 
905  if (passive_timer > 0 && active_timer > passive_timer)
906  return clib_error_return (0,
907  "Passive timer has to be greater than active one...");
908 
909  if (flowprobe_params (fm, record_l2, record_l3, record_l4,
910  active_timer, passive_timer))
911  return clib_error_return (0,
912  "Couldn't change flowperpacket params when feature is enabled on some interface ...");
913  return 0;
914 }
915 
916 /*?
917  * '<em>flowprobe feature add-del</em>' commands to enable/disable
918  * per-packet IPFIX flow record generation on an interface
919  *
920  * @cliexpar
921  * @parblock
922  * To enable per-packet IPFIX flow-record generation on an interface:
923  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0}
924  *
925  * To disable per-packet IPFIX flow-record generation on an interface:
926  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0 disable}
927  * @cliexend
928  * @endparblock
929 ?*/
930 /* *INDENT-OFF* */
931 VLIB_CLI_COMMAND (flowprobe_enable_disable_command, static) = {
932  .path = "flowprobe feature add-del",
933  .short_help =
934  "flowprobe feature add-del <interface-name> <l2|ip4|ip6> disable",
936 };
937 VLIB_CLI_COMMAND (flowprobe_params_command, static) = {
938  .path = "flowprobe params",
939  .short_help =
940  "flowprobe params record <[l2] [l3] [l4]> [active <timer> passive <timer>]",
941  .function = flowprobe_params_command_fn,
942 };
943 VLIB_CLI_COMMAND (flowprobe_show_table_command, static) = {
944  .path = "show flowprobe table",
945  .short_help = "show flowprobe table",
946  .function = flowprobe_show_table_fn,
947 };
948 VLIB_CLI_COMMAND (flowprobe_show_stats_command, static) = {
949  .path = "show flowprobe statistics",
950  .short_help = "show flowprobe statistics",
951  .function = flowprobe_show_stats_fn,
952 };
953 /* *INDENT-ON* */
954 
955 /*
956  * Main-core process, sending an interrupt to the per worker input
957  * process that spins the per worker timer wheel.
958  */
959 static uword
961 {
962  uword *event_data = 0;
963  vlib_main_t **worker_vms = 0, *worker_vm;
965 
966  /* Wait for Godot... */
968  uword event_type = vlib_process_get_events (vm, &event_data);
969  if (event_type != 1)
970  clib_warning ("bogus kickoff event received, %d", event_type);
971  vec_reset_length (event_data);
972 
973  int i;
974  if (vec_len (vlib_mains) == 0)
975  vec_add1 (worker_vms, vm);
976  else
977  {
978  for (i = 0; i < vec_len (vlib_mains); i++)
979  {
980  worker_vm = vlib_mains[i];
981  if (worker_vm)
982  vec_add1 (worker_vms, worker_vm);
983  }
984  }
985  f64 sleep_duration = 0.1;
986 
987  while (1)
988  {
989  /* Send an interrupt to each timer input node */
990  sleep_duration = 0.1;
991  for (i = 0; i < vec_len (worker_vms); i++)
992  {
993  worker_vm = worker_vms[i];
994  if (worker_vm)
995  {
997  flowprobe_walker_node.index);
998  sleep_duration =
999  (fm->expired_passive_per_worker[i] > 0) ? 1e-4 : 0.1;
1000  }
1001  }
1002  vlib_process_suspend (vm, sleep_duration);
1003  }
1004  return 0; /* or not */
1005 }
1006 
1007 /* *INDENT-OFF* */
1008 VLIB_REGISTER_NODE (flowprobe_timer_node,static) = {
1009  .function = timer_process,
1010  .name = "flowprobe-timer-process",
1011  .type = VLIB_NODE_TYPE_PROCESS,
1012 };
1013 /* *INDENT-ON* */
1014 
1015 #include <flowprobe/flowprobe.api.c>
1016 
1017 /**
1018  * @brief Set up the API message handling tables
1019  * @param vm vlib_main_t * vlib main data structure pointer
1020  * @returns 0 to indicate all is well, or a clib_error_t
1021  */
1022 static clib_error_t *
1024 {
1027  clib_error_t *error = 0;
1028  u32 num_threads;
1029  int i;
1030 
1031  fm->vnet_main = vnet_get_main ();
1032 
1033  /* Ask for a correctly-sized block of API message decode slots */
1035 
1036  /* Set up time reference pair */
1037  fm->vlib_time_0 = vlib_time_now (vm);
1039 
1040  clib_memset (fm->template_reports, 0, sizeof (fm->template_reports));
1041  clib_memset (fm->template_size, 0, sizeof (fm->template_size));
1042  clib_memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
1043 
1044  /* Decide how many worker threads we have */
1045  num_threads = 1 /* main thread */ + tm->n_threads;
1046 
1047  /* Allocate per worker thread vectors per flavour */
1048  for (i = 0; i < FLOW_N_VARIANTS; i++)
1049  {
1050  vec_validate (fm->context[i].buffers_per_worker, num_threads - 1);
1051  vec_validate (fm->context[i].frames_per_worker, num_threads - 1);
1053  num_threads - 1);
1054  }
1055 
1058 
1059  return error;
1060 }
1061 
1063 
1064 /*
1065  * fd.io coding-style-patch-verification: ON
1066  *
1067  * Local Variables:
1068  * eval: (c-set-style "gnu")
1069  * End:
1070  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:507
uword flowprobe_walker_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
flowprobe_protocol_context_t context[FLOW_N_VARIANTS]
Definition: flowprobe.h:125
flowprobe_variant_t
Definition: flowprobe.h:46
vlib_frame_t * flowprobe_data_callback_ip4(flow_report_main_t *frm, flow_report_t *fr, vlib_frame_t *f, u32 *to_next, u32 node_index)
Flush accumulated data.
Definition: flowprobe.c:392
u32 ** expired_passive_per_worker
Definition: flowprobe.h:140
#define FLOWPROBE_LOG2_HASHSIZE
Definition: flowprobe.h:33
void flowprobe_flush_callback_ip6(void)
Definition: node.c:887
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:673
vl_api_interface_index_t sw_if_index
Definition: flowprobe.api:46
a
Definition: bitmap.h:538
ip46_address_t src_address
Definition: flowprobe.h:82
#define FLOWPROBE_TIMER_PASSIVE
Definition: flowprobe.h:32
ip4_address_t src_address
Definition: ip4_packet.h:170
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static u8 * flowprobe_template_rewrite_ip6(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flowprobe.c:312
uword as_uword
Definition: flow_report.h:74
#define pool_alloc(P, N)
Allocate N more free elements to pool (unspecified alignment).
Definition: pool.h:361
static void vlib_node_set_interrupt_pending(vlib_main_t *vm, u32 node_index)
Definition: node_funcs.h:197
static u32 ipfix_e_id_length(int e, u16 id, u16 length)
Definition: ipfix_packet.h:77
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:291
flowprobe_key_t key
Definition: flowprobe.h:99
u32 stream_index
Definition: flow_report.h:91
vl_api_flowprobe_which_flags_t which
Definition: flowprobe.api:43
int vnet_flow_report_add_del(flow_report_main_t *frm, vnet_flow_report_add_del_args_t *a, u16 *template_id)
Definition: flow_report.c:334
flowprobe_record_t record
Definition: flowprobe.h:142
u32 thread_index
Definition: main.h:218
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:590
opaque_t opaque
Definition: flow_report.h:99
#define flowprobe_template_l2_field_count()
flowprobe_entry_t * stateless_entry
Definition: flowprobe.h:145
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u16 template_reports[FLOW_N_RECORDS]
Definition: flowprobe.h:126
unformat_function_t unformat_vnet_sw_interface
vlib_frame_t *() vnet_flow_data_callback_t(struct flow_report_main *, struct flow_report *, vlib_frame_t *, u32 *, u32)
Definition: flow_report.h:52
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:518
u32 tx_sw_if_index
Definition: flowprobe.h:78
vlib_main_t ** vlib_mains
Definition: buffer.c:332
unsigned char u8
Definition: types.h:56
static ipfix_field_specifier_t * flowprobe_template_common_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:144
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
#define fm
u8 * flow_per_interface
Definition: flowprobe.h:151
flowprobe_entry_t ** pool_per_worker
Definition: flowprobe.h:136
Enable / disable per-packet IPFIX recording on an interface.
Definition: flowprobe.api:33
u16 src_port
Definition: udp.api:41
flow_report_stream_t * streams
Definition: flow_report.h:114
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:422
static ipfix_field_specifier_t * flowprobe_template_ip4_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:79
flow-per-packet plugin header file
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
vl_api_interface_index_t sw_if_index
Definition: gre.api:53
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:516
ip4_address_t dst_address
Definition: ip4_packet.h:170
vlib_frame_t ** frames_per_worker
frames containing ipfix buffers, per-worker thread
Definition: flowprobe.h:70
u32 ** hash_per_worker
Definition: flowprobe.h:135
static u8 * flowprobe_template_rewrite_ip4(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flowprobe.c:326
static u8 * flowprobe_template_rewrite_l2(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flowprobe.c:340
#define flowprobe_template_l4_field_count()
#define clib_error_return(e, args...)
Definition: error.h:99
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:281
unsigned int u32
Definition: types.h:88
void flowprobe_flush_callback_ip4(void)
Definition: node.c:881
u64 nanosecond_time_0
Time reference pair.
Definition: flowprobe.h:130
static int flowprobe_params(flowprobe_main_t *fm, u8 record_l2, u8 record_l3, u8 record_l4, u32 active_timer, u32 passive_timer)
Definition: flowprobe.c:689
u8 ht_log2len
Per CPU flow-state.
Definition: flowprobe.h:134
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
flow_report_main_t flow_report_main
Definition: flow_report.c:21
static int flowprobe_tx_interface_add_del_feature(flowprobe_main_t *fm, u32 sw_if_index, u8 which, int is_add)
configure / deconfigure the IPFIX flow-per-packet
Definition: flowprobe.c:527
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
VNET_FEATURE_INIT(flow_perpacket_ip4, static)
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
#define flowprobe_template_ip4_field_count()
vec_header_t h
Definition: buffer.c:322
u32 rx_sw_if_index
Definition: flowprobe.h:77
u16 template_per_flow[FLOW_N_VARIANTS]
Definition: flowprobe.h:150
#define REPLY_MACRO(t)
static u8 * flowprobe_template_rewrite_l2_ip6(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flowprobe.c:368
vl_api_address_union_t src_address
Definition: ip_types.api:99
static u8 * flowprobe_template_rewrite_l2_ip4(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flowprobe.c:354
VLIB_PLUGIN_REGISTER()
u8 *() vnet_flow_rewrite_callback_t(struct flow_report_main *, struct flow_report *, ip4_address_t *, ip4_address_t *, u16, ipfix_report_element_t *elts, u32 n_elts, u32 *stream_index)
Definition: flow_report.h:57
static void flowprobe_expired_timer_callback(u32 *expired_timers)
Definition: flowprobe.c:438
static u32 version_length(u16 length)
Definition: ipfix_packet.h:33
vlib_thread_main_t vlib_thread_main
Definition: threads.c:35
vlib_main_t * vm
Definition: in2out_ed.c:1599
void vl_api_flowprobe_tx_interface_add_del_t_handler(vl_api_flowprobe_tx_interface_add_del_t *mp)
API message handler.
Definition: flowprobe.c:626
format_function_t format_ip46_address
Definition: ip46_address.h:50
#define BAD_SW_IF_INDEX_LABEL
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u32 flags
Definition: vhost_user.h:248
#define flowprobe_template_ip6_field_count()
static clib_error_t * flowprobe_show_stats_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cm)
Definition: flowprobe.c:787
#define FLOWPROBE_TIMER_ACTIVE
Definition: flowprobe.h:31
static int flowprobe_template_add_del(u32 domain_id, u16 src_port, flowprobe_record_t flags, vnet_flow_data_callback_t *flow_data_callback, vnet_flow_rewrite_callback_t *rewrite_callback, bool is_add, u16 *template_id)
Definition: flowprobe.c:419
f64 last_exported
Definition: flowprobe.h:105
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
vnet_main_t * vnet_main
convenience vnet_main_t pointer
Definition: flowprobe.h:156
static u32 ipfix_id_count(u16 id, u16 count)
Definition: ipfix_packet.h:184
#define clib_warning(format, args...)
Definition: error.h:59
#define vec_neg_search(v, E)
Definition: flowprobe.c:676
#define FINISH
Definition: flowprobe.c:72
static u64 unix_time_now_nsec(void)
Definition: time.h:270
static clib_error_t * flowprobe_init(vlib_main_t *vm)
Set up the API message handling tables.
Definition: flowprobe.c:1023
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:152
flowprobe_record_t
Definition: flowprobe.h:35
#define ASSERT(truth)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
vlib_frame_t * flowprobe_data_callback_l2(flow_report_main_t *frm, flow_report_t *fr, vlib_frame_t *f, u32 *to_next, u32 node_index)
Definition: flowprobe.c:410
u16 template_id
Definition: flow_report.h:90
static ipfix_field_specifier_t * flowprobe_template_ip6_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:102
static void * clib_mem_alloc(uword size)
Definition: mem.h:157
#define VNET_FEATURES(...)
Definition: feature.h:470
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
flowprobe_main_t flowprobe_main
Definition: flowprobe.c:38
struct _vlib_node_registration vlib_node_registration_t
static u32 ipfix_set_id_length(u16 set_id, u16 length)
Definition: ipfix_packet.h:121
vlib_buffer_t ** buffers_per_worker
ipfix buffers under construction, per-worker thread
Definition: flowprobe.h:68
vl_api_address_t ip
Definition: l2.api:501
#define flowprobe_template_common_field_count()
void flowprobe_flush_callback_l2(void)
Definition: node.c:893
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
u16 template_size[FLOW_N_RECORDS]
Definition: flowprobe.h:127
static ipfix_field_specifier_t * flowprobe_template_l4_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:176
u16 msg_id_base
API message ID base.
Definition: flowprobe.h:123
void vl_api_flowprobe_params_t_handler(vl_api_flowprobe_params_t *mp)
Definition: flowprobe.c:719
u8 * format_flowprobe_entry(u8 *s, va_list *args)
Definition: flowprobe.c:744
static ipfix_field_specifier_t * flowprobe_template_l2_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:125
static int validate_feature_on_interface(flowprobe_main_t *fm, u32 sw_if_index, u8 which)
Definition: flowprobe.c:505
ip46_address_t dst_address
Definition: flowprobe.h:83
static void setup_message_id_table(snat_main_t *sm, api_main_t *am)
Definition: nat_api.c:3256
vlib_node_registration_t flowprobe_walker_node
(constructor) VLIB_REGISTER_NODE (flowprobe_walker_node)
Definition: node.c:1034
vlib_frame_t * flowprobe_data_callback_ip6(flow_report_main_t *frm, flow_report_t *fr, vlib_frame_t *f, u32 *to_next, u32 node_index)
Definition: flowprobe.c:401
u8 ip_version_and_header_length
Definition: ip4_packet.h:138
u16 * next_record_offset_per_worker
next record offset, per worker thread
Definition: flowprobe.h:72
static void * vl_api_flowprobe_tx_interface_add_del_t_print(vl_api_flowprobe_tx_interface_add_del_t *mp, void *handle)
API message custom-dump function.
Definition: flowprobe.c:665
static uword timer_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: flowprobe.c:960
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:554
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static clib_error_t * flowprobe_show_table_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cm)
Definition: flowprobe.c:762
static clib_error_t * flowprobe_tx_interface_add_del_feature_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: flowprobe.c:806
flowprobe_record_t flags
Definition: flowprobe.h:66
static clib_error_t * flowprobe_params_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: flowprobe.c:874
static u8 * flowprobe_template_rewrite_inline(flow_report_main_t *frm, flow_report_t *fr, ip4_address_t *collector_address, ip4_address_t *src_address, u16 collector_port, flowprobe_variant_t which)
Create an IPFIX template packet rewrite string.
Definition: flowprobe.c:205
static vlib_node_registration_t flowprobe_timer_node
(constructor) VLIB_REGISTER_NODE (flowprobe_timer_node)
Definition: flowprobe.c:39
static clib_error_t * flowprobe_create_state_tables(u32 active_timer)
Definition: flowprobe.c:454
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:247
Definition: flowprobe.h:97
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:304
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
#define VALIDATE_SW_IF_INDEX(mp)
vl_api_flowprobe_record_flags_t record_flags
Definition: flowprobe.api:54
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128