FD.io VPP  v19.04-6-g6f05f72
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 */
36 
37 /* define message structures */
38 #define vl_typedefs
40 #undef vl_typedefs
41 
42 /* define generated endian-swappers */
43 #define vl_endianfun
45 #undef vl_endianfun
46 
47 /* instantiate all the print functions we know about */
48 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
49 #define vl_printfun
51 #undef vl_printfun
52 
57  vlib_frame_t * f);
58 
59 /* Get the API version number */
60 #define vl_api_version(n,v) static u32 api_version=(v);
62 #undef vl_api_version
63 
64 #define REPLY_MSG_ID_BASE fm->msg_id_base
66 
67 /* Define the per-interface configurable features */
68 /* *INDENT-OFF* */
69 VNET_FEATURE_INIT (flow_perpacket_ip4, static) =
70 {
71  .arc_name = "ip4-output",
72  .node_name = "flowprobe-ip4",
73  .runs_before = VNET_FEATURES ("interface-output"),
74 };
75 
76 VNET_FEATURE_INIT (flow_perpacket_ip6, static) =
77 {
78  .arc_name = "ip6-output",
79  .node_name = "flowprobe-ip6",
80  .runs_before = VNET_FEATURES ("interface-output"),
81 };
82 
83 VNET_FEATURE_INIT (flow_perpacket_l2, static) =
84 {
85  .arc_name = "interface-output",
86  .node_name = "flowprobe-l2",
87  .runs_before = VNET_FEATURES ("interface-tx"),
88 };
89 /* *INDENT-ON* */
90 
91 /* Macro to finish up custom dump fns */
92 #define FINISH \
93  vec_add1 (s, 0); \
94  vl_print (handle, (char *)s); \
95  vec_free (s); \
96  return handle;
97 
98 static inline ipfix_field_specifier_t *
100 {
101 #define flowprobe_template_ip4_field_count() 4
102  /* sourceIpv4Address, TLV type 8, u32 */
103  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
104  sourceIPv4Address, 4);
105  f++;
106  /* destinationIPv4Address, TLV type 12, u32 */
107  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
108  destinationIPv4Address, 4);
109  f++;
110  /* protocolIdentifier, TLV type 4, u8 */
111  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
112  protocolIdentifier, 1);
113  f++;
114  /* octetDeltaCount, TLV type 1, u64 */
115  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
116  octetDeltaCount, 8);
117  f++;
118  return f;
119 }
120 
121 static inline ipfix_field_specifier_t *
123 {
124 #define flowprobe_template_ip6_field_count() 4
125  /* sourceIpv6Address, TLV type 27, 16 octets */
126  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
127  sourceIPv6Address, 16);
128  f++;
129  /* destinationIPv6Address, TLV type 28, 16 octets */
130  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
131  destinationIPv6Address, 16);
132  f++;
133  /* protocolIdentifier, TLV type 4, u8 */
134  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
135  protocolIdentifier, 1);
136  f++;
137  /* octetDeltaCount, TLV type 1, u64 */
138  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
139  octetDeltaCount, 8);
140  f++;
141  return f;
142 }
143 
144 static inline ipfix_field_specifier_t *
146 {
147 #define flowprobe_template_l2_field_count() 3
148  /* sourceMacAddress, TLV type 56, u8[6] we hope */
149  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
150  sourceMacAddress, 6);
151  f++;
152  /* destinationMacAddress, TLV type 80, u8[6] we hope */
153  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
154  destinationMacAddress, 6);
155  f++;
156  /* ethernetType, TLV type 256, u16 */
157  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
158  ethernetType, 2);
159  f++;
160  return f;
161 }
162 
163 static inline ipfix_field_specifier_t *
165 {
166 #define flowprobe_template_common_field_count() 5
167  /* ingressInterface, TLV type 10, u32 */
168  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
169  ingressInterface, 4);
170  f++;
171 
172  /* egressInterface, TLV type 14, u32 */
173  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
174  egressInterface, 4);
175  f++;
176 
177  /* packetDeltaCount, TLV type 2, u64 */
178  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
179  packetDeltaCount, 8);
180  f++;
181 
182  /* flowStartNanoseconds, TLV type 156, u64 */
183  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
184  flowStartNanoseconds, 8);
185  f++;
186 
187  /* flowEndNanoseconds, TLV type 157, u64 */
188  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
189  flowEndNanoseconds, 8);
190  f++;
191 
192  return f;
193 }
194 
195 static inline ipfix_field_specifier_t *
197 {
198 #define flowprobe_template_l4_field_count() 3
199  /* sourceTransportPort, TLV type 7, u16 */
200  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
201  sourceTransportPort, 2);
202  f++;
203  /* destinationTransportPort, TLV type 11, u16 */
204  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
205  destinationTransportPort, 2);
206  f++;
207  /* tcpControlBits, TLV type 6, u16 */
208  f->e_id_length = ipfix_e_id_length (0 /* enterprise */ ,
209  tcpControlBits, 2);
210  f++;
211 
212  return f;
213 }
214 
215 /**
216  * @brief Create an IPFIX template packet rewrite string
217  * @param frm flow_report_main_t *
218  * @param fr flow_report_t *
219  * @param collector_address ip4_address_t * the IPFIX collector address
220  * @param src_address ip4_address_t * the source address we should use
221  * @param collector_port u16 the collector port we should use, host byte order
222  * @returns u8 * vector containing the indicated IPFIX template packet
223  */
224 static inline u8 *
226  flow_report_t * fr,
227  ip4_address_t * collector_address,
229  u16 collector_port,
230  flowprobe_variant_t which)
231 {
232  ip4_header_t *ip;
233  udp_header_t *udp;
238  ipfix_field_specifier_t *first_field;
239  u8 *rewrite = 0;
241  u32 field_count = 0;
242  flow_report_stream_t *stream;
245  bool collect_ip4 = false, collect_ip6 = false;
246 
247  stream = &frm->streams[fr->stream_index];
248 
249  if (flags & FLOW_RECORD_L3)
250  {
251  collect_ip4 = which == FLOW_VARIANT_L2_IP4 || which == FLOW_VARIANT_IP4;
252  collect_ip6 = which == FLOW_VARIANT_L2_IP6 || which == FLOW_VARIANT_IP6;
253  if (which == FLOW_VARIANT_L2_IP4)
254  flags |= FLOW_RECORD_L2_IP4;
255  if (which == FLOW_VARIANT_L2_IP6)
256  flags |= FLOW_RECORD_L2_IP6;
257  }
258 
259  field_count += flowprobe_template_common_field_count ();
260  if (flags & FLOW_RECORD_L2)
261  field_count += flowprobe_template_l2_field_count ();
262  if (collect_ip4)
263  field_count += flowprobe_template_ip4_field_count ();
264  if (collect_ip6)
265  field_count += flowprobe_template_ip6_field_count ();
266  if (flags & FLOW_RECORD_L4)
267  field_count += flowprobe_template_l4_field_count ();
268 
269  /* allocate rewrite space */
271  (rewrite, sizeof (ip4_ipfix_template_packet_t)
272  + field_count * sizeof (ipfix_field_specifier_t) - 1,
274 
275  tp = (ip4_ipfix_template_packet_t *) rewrite;
276  ip = (ip4_header_t *) & tp->ip4;
277  udp = (udp_header_t *) (ip + 1);
278  h = (ipfix_message_header_t *) (udp + 1);
279  s = (ipfix_set_header_t *) (h + 1);
280  t = (ipfix_template_header_t *) (s + 1);
281  first_field = f = (ipfix_field_specifier_t *) (t + 1);
282 
283  ip->ip_version_and_header_length = 0x45;
284  ip->ttl = 254;
285  ip->protocol = IP_PROTOCOL_UDP;
286  ip->src_address.as_u32 = src_address->as_u32;
287  ip->dst_address.as_u32 = collector_address->as_u32;
288  udp->src_port = clib_host_to_net_u16 (stream->src_port);
289  udp->dst_port = clib_host_to_net_u16 (collector_port);
290  udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
291 
292  /* FIXUP: message header export_time */
293  /* FIXUP: message header sequence_number */
294  h->domain_id = clib_host_to_net_u32 (stream->domain_id);
295 
296  /* Add TLVs to the template */
298 
299  if (flags & FLOW_RECORD_L2)
301  if (collect_ip4)
303  if (collect_ip6)
305  if (flags & FLOW_RECORD_L4)
307 
308  /* Back to the template packet... */
309  ip = (ip4_header_t *) & tp->ip4;
310  udp = (udp_header_t *) (ip + 1);
311 
312  ASSERT (f - first_field);
313  /* Field count in this template */
314  t->id_count = ipfix_id_count (fr->template_id, f - first_field);
315 
316  fm->template_size[flags] = (u8 *) f - (u8 *) s;
317 
318  /* set length in octets */
319  s->set_id_length =
320  ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
321 
322  /* message length in octets */
323  h->version_length = version_length ((u8 *) f - (u8 *) h);
324 
325  ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
326  ip->checksum = ip4_header_checksum (ip);
327 
328  return rewrite;
329 }
330 
331 static u8 *
333  flow_report_t * fr,
334  ip4_address_t * collector_address,
336  u16 collector_port,
337  ipfix_report_element_t * elts,
338  u32 n_elts, u32 * stream_index)
339 {
341  (frm, fr, collector_address, src_address, collector_port,
343 }
344 
345 static u8 *
347  flow_report_t * fr,
348  ip4_address_t * collector_address,
350  u16 collector_port,
351  ipfix_report_element_t * elts,
352  u32 n_elts, u32 * stream_index)
353 {
355  (frm, fr, collector_address, src_address, collector_port,
357 }
358 
359 static u8 *
361  flow_report_t * fr,
362  ip4_address_t * collector_address,
364  u16 collector_port,
365  ipfix_report_element_t * elts,
366  u32 n_elts, u32 * stream_index)
367 {
369  (frm, fr, collector_address, src_address, collector_port,
371 }
372 
373 static u8 *
375  flow_report_t * fr,
376  ip4_address_t * collector_address,
378  u16 collector_port,
379  ipfix_report_element_t * elts,
380  u32 n_elts, u32 * stream_index)
381 {
383  (frm, fr, collector_address, src_address, collector_port,
385 }
386 
387 static u8 *
389  flow_report_t * fr,
390  ip4_address_t * collector_address,
392  u16 collector_port,
393  ipfix_report_element_t * elts,
394  u32 n_elts, u32 * stream_index)
395 {
397  (frm, fr, collector_address, src_address, collector_port,
399 }
400 
401 /**
402  * @brief Flush accumulated data
403  * @param frm flow_report_main_t *
404  * @param fr flow_report_t *
405  * @param f vlib_frame_t *
406  *
407  * <em>Notes:</em>
408  * This function must simply return the incoming frame, or no template packets
409  * will be sent.
410  */
411 vlib_frame_t *
413  flow_report_t * fr,
414  vlib_frame_t * f, u32 * to_next, u32 node_index)
415 {
417  return f;
418 }
419 
420 vlib_frame_t *
422  flow_report_t * fr,
423  vlib_frame_t * f, u32 * to_next, u32 node_index)
424 {
426  return f;
427 }
428 
429 vlib_frame_t *
431  flow_report_t * fr,
432  vlib_frame_t * f, u32 * to_next, u32 node_index)
433 {
435  return f;
436 }
437 
438 static int
441  vnet_flow_data_callback_t * flow_data_callback,
442  vnet_flow_rewrite_callback_t * rewrite_callback,
443  bool is_add, u16 * template_id)
444 {
447  .rewrite_callback = rewrite_callback,
448  .flow_data_callback = flow_data_callback,
449  .is_add = is_add,
450  .domain_id = domain_id,
451  .src_port = src_port,
452  .opaque.as_uword = flags,
453  };
454  return vnet_flow_report_add_del (frm, &a, template_id);
455 }
456 
457 static void
459 {
462  u32 my_cpu_number = vm->thread_index;
463  int i;
464  u32 poolindex;
465 
466  for (i = 0; i < vec_len (expired_timers); i++)
467  {
468  poolindex = expired_timers[i] & 0x7FFFFFFF;
469  vec_add1 (fm->expired_passive_per_worker[my_cpu_number], poolindex);
470  }
471 }
472 
473 static clib_error_t *
475 {
479  clib_error_t *error = 0;
480  u32 num_threads;
481  int i;
482 
483  /* Decide how many worker threads we have */
484  num_threads = 1 /* main thread */ + tm->n_threads;
485 
486  /* Hash table per worker */
488 
489  /* Init per worker flow state and timer wheels */
490  if (active_timer)
491  {
492  vec_validate (fm->timers_per_worker, num_threads - 1);
493  vec_validate (fm->expired_passive_per_worker, num_threads - 1);
494  vec_validate (fm->hash_per_worker, num_threads - 1);
495  vec_validate (fm->pool_per_worker, num_threads - 1);
496 
497  for (i = 0; i < num_threads; i++)
498  {
499  int j;
500  pool_alloc (fm->pool_per_worker[i], 1 << fm->ht_log2len);
501  vec_resize (fm->hash_per_worker[i], 1 << fm->ht_log2len);
502  for (j = 0; j < (1 << fm->ht_log2len); j++)
503  fm->hash_per_worker[i][j] = ~0;
504  fm->timers_per_worker[i] =
505  clib_mem_alloc (sizeof (TWT (tw_timer_wheel)));
506  tw_timer_wheel_init_2t_1w_2048sl (fm->timers_per_worker[i],
508  1.0, 1024);
509  }
510  fm->disabled = true;
511  }
512  else
513  {
514  f64 now = vlib_time_now (vm);
515  vec_validate (fm->stateless_entry, num_threads - 1);
516  for (i = 0; i < num_threads; i++)
517  fm->stateless_entry[i].last_exported = now;
518  fm->disabled = false;
519  }
520  fm->initialized = true;
521  return error;
522 }
523 
524 static int
526  u8 which)
527 {
528  vec_validate_init_empty (fm->flow_per_interface, sw_if_index, ~0);
529 
530  if (fm->flow_per_interface[sw_if_index] == (u8) ~ 0)
531  return -1;
532  else if (fm->flow_per_interface[sw_if_index] != which)
533  return 0;
534  else
535  return 1;
536 }
537 
538 /**
539  * @brief configure / deconfigure the IPFIX flow-per-packet
540  * @param fm flowprobe_main_t * fm
541  * @param sw_if_index u32 the desired interface
542  * @param is_add int 1 to enable the feature, 0 to disable it
543  * @returns 0 if successful, non-zero otherwise
544  */
545 
546 static int
548  u32 sw_if_index, u8 which, int is_add)
549 {
551  int rv = 0;
552  u16 template_id = 0;
554 
555  fm->flow_per_interface[sw_if_index] = (is_add) ? which : (u8) ~ 0;
556  fm->template_per_flow[which] += (is_add) ? 1 : -1;
557  if (is_add && fm->template_per_flow[which] > 1)
558  template_id = fm->template_reports[flags];
559 
560  if ((is_add && fm->template_per_flow[which] == 1) ||
561  (!is_add && fm->template_per_flow[which] == 0))
562  {
563  if (which == FLOW_VARIANT_L2)
564  {
565  if (fm->record & FLOW_RECORD_L2)
566  {
567  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
570  is_add, &template_id);
571  }
572  if (fm->record & FLOW_RECORD_L3 || fm->record & FLOW_RECORD_L4)
573  {
574  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
577  is_add, &template_id);
578  fm->template_reports[flags | FLOW_RECORD_L2_IP4] =
579  (is_add) ? template_id : 0;
580  rv =
581  flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
584  is_add, &template_id);
585  fm->template_reports[flags | FLOW_RECORD_L2_IP6] =
586  (is_add) ? template_id : 0;
587 
588  /* Special case L2 */
590  flags | FLOW_RECORD_L2_IP4;
592  flags | FLOW_RECORD_L2_IP6;
593 
594  fm->template_reports[flags] = template_id;
595  }
596  }
597  else if (which == FLOW_VARIANT_IP4)
598  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
601  is_add, &template_id);
602  else if (which == FLOW_VARIANT_IP6)
603  rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
606  is_add, &template_id);
607  }
608  if (rv && rv != VNET_API_ERROR_VALUE_EXIST)
609  {
610  clib_warning ("vnet_flow_report_add_del returned %d", rv);
611  return -1;
612  }
613 
614  if (which != (u8) ~ 0)
615  {
616  fm->context[which].flags = fm->record;
617  fm->template_reports[flags] = (is_add) ? template_id : 0;
618  }
619 
620  if (which == FLOW_VARIANT_IP4)
621  vnet_feature_enable_disable ("ip4-output", "flowprobe-ip4",
622  sw_if_index, is_add, 0, 0);
623  else if (which == FLOW_VARIANT_IP6)
624  vnet_feature_enable_disable ("ip6-output", "flowprobe-ip6",
625  sw_if_index, is_add, 0, 0);
626  else if (which == FLOW_VARIANT_L2)
627  vnet_feature_enable_disable ("interface-output", "flowprobe-l2",
628  sw_if_index, is_add, 0, 0);
629 
630  /* Stateful flow collection */
631  if (is_add && !fm->initialized)
632  {
634  if (fm->active_timer)
635  vlib_process_signal_event (vm, flowprobe_timer_node.index, 1, 0);
636  }
637 
638  return 0;
639 }
640 
641 /**
642  * @brief API message handler
643  * @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
644  */
647 {
649  vl_api_flowprobe_tx_interface_add_del_reply_t *rmp;
650  u32 sw_if_index = ntohl (mp->sw_if_index);
651  int rv = 0;
652 
654 
655  if (mp->which != FLOW_VARIANT_IP4 && mp->which != FLOW_VARIANT_L2
656  && mp->which != FLOW_VARIANT_IP6)
657  {
658  rv = VNET_API_ERROR_UNIMPLEMENTED;
659  goto out;
660  }
661 
662  if (fm->record == 0)
663  {
664  clib_warning ("Please specify flowprobe params record first...");
665  rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
666  goto out;
667  }
668 
669  rv = validate_feature_on_interface (fm, sw_if_index, mp->which);
670  if ((rv == 1 && mp->is_add == 1) || rv == 0)
671  {
672  rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
673  goto out;
674  }
675 
677  (fm, sw_if_index, mp->which, mp->is_add);
678 
679 out:
681 
682  REPLY_MACRO (VL_API_FLOWPROBE_TX_INTERFACE_ADD_DEL_REPLY);
683 }
684 
685 /**
686  * @brief API message custom-dump function
687  * @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
688  * @param handle void * print function handle
689  * @returns u8 * output string
690  */
693 {
694  u8 *s;
695 
696  s = format (0, "SCRIPT: flowprobe_tx_interface_add_del ");
697  s = format (s, "sw_if_index %d is_add %d which %d ",
698  clib_host_to_net_u32 (mp->sw_if_index),
699  (int) mp->is_add, (int) mp->which);
700  FINISH;
701 }
702 
703 #define vec_neg_search(v,E) \
704 ({ \
705  word _v(i) = 0; \
706  while (_v(i) < vec_len(v) && v[_v(i)] == E) \
707  { \
708  _v(i)++; \
709  } \
710  if (_v(i) == vec_len(v)) \
711  _v(i) = ~0; \
712  _v(i); \
713 })
714 
715 static int
717  u8 record_l3, u8 record_l4,
718  u32 active_timer, u32 passive_timer)
719 {
721 
722  if (vec_neg_search (fm->flow_per_interface, (u8) ~ 0) != ~0)
723  return ~0;
724 
725  if (record_l2)
726  flags |= FLOW_RECORD_L2;
727  if (record_l3)
728  flags |= FLOW_RECORD_L3;
729  if (record_l4)
730  flags |= FLOW_RECORD_L4;
731 
732  fm->record = flags;
733 
734  /*
735  * Timers: ~0 is default, 0 is off
736  */
737  fm->active_timer =
738  (active_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_ACTIVE : active_timer);
739  fm->passive_timer =
740  (passive_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_PASSIVE : passive_timer);
741 
742  return 0;
743 }
744 
745 void
747 {
749  vl_api_flowprobe_params_reply_t *rmp;
750  int rv = 0;
751 
752  rv = flowprobe_params
753  (fm, mp->record_l2, mp->record_l3, mp->record_l4,
754  clib_net_to_host_u32 (mp->active_timer),
755  clib_net_to_host_u32 (mp->passive_timer));
756 
757  REPLY_MACRO (VL_API_FLOWPROBE_PARAMS_REPLY);
758 }
759 
760 /* List of message types that this plugin understands */
761 #define foreach_flowprobe_plugin_api_msg \
762 _(FLOWPROBE_TX_INTERFACE_ADD_DEL, flowprobe_tx_interface_add_del) \
763 _(FLOWPROBE_PARAMS, flowprobe_params)
764 
765 /* *INDENT-OFF* */
767  .version = VPP_BUILD_VER,
768  .description = "Flow per Packet",
769 };
770 /* *INDENT-ON* */
771 
772 u8 *
773 format_flowprobe_entry (u8 * s, va_list * args)
774 {
775  flowprobe_entry_t *e = va_arg (*args, flowprobe_entry_t *);
776  s = format (s, " %d/%d", e->key.rx_sw_if_index, e->key.tx_sw_if_index);
777 
778  s = format (s, " %U %U", format_ethernet_address, &e->key.src_mac,
780  s = format (s, " %U -> %U",
783  s = format (s, " %d", e->key.protocol);
784  s = format (s, " %d %d\n", clib_net_to_host_u16 (e->key.src_port),
785  clib_net_to_host_u16 (e->key.dst_port));
786 
787  return s;
788 }
789 
790 static clib_error_t *
792  unformat_input_t * input, vlib_cli_command_t * cm)
793 {
795  int i;
797 
798  vlib_cli_output (vm, "Dumping IPFIX table");
799 
800  for (i = 0; i < vec_len (fm->pool_per_worker); i++)
801  {
802  /* *INDENT-OFF* */
803  pool_foreach (e, fm->pool_per_worker[i], (
804  {
805  vlib_cli_output (vm, "%U",
806  format_flowprobe_entry,
807  e);
808  }));
809  /* *INDENT-ON* */
810 
811  }
812  return 0;
813 }
814 
815 static clib_error_t *
817  unformat_input_t * input, vlib_cli_command_t * cm)
818 {
820  int i;
821 
822  vlib_cli_output (vm, "IPFIX table statistics");
823  vlib_cli_output (vm, "Flow entry size: %d\n", sizeof (flowprobe_entry_t));
824  vlib_cli_output (vm, "Flow pool size per thread: %d\n",
825  0x1 << FLOWPROBE_LOG2_HASHSIZE);
826 
827  for (i = 0; i < vec_len (fm->pool_per_worker); i++)
828  vlib_cli_output (vm, "Pool utilisation thread %d is %d%%\n", i,
829  (100 * pool_elts (fm->pool_per_worker[i])) /
830  (0x1 << FLOWPROBE_LOG2_HASHSIZE));
831  return 0;
832 }
833 
834 static clib_error_t *
836  unformat_input_t * input,
837  vlib_cli_command_t * cmd)
838 {
840  u32 sw_if_index = ~0;
841  int is_add = 1;
842  u8 which = FLOW_VARIANT_IP4;
843  int rv;
844 
846  {
847  if (unformat (input, "disable"))
848  is_add = 0;
849  else if (unformat (input, "%U", unformat_vnet_sw_interface,
850  fm->vnet_main, &sw_if_index));
851  else if (unformat (input, "ip4"))
852  which = FLOW_VARIANT_IP4;
853  else if (unformat (input, "ip6"))
854  which = FLOW_VARIANT_IP6;
855  else if (unformat (input, "l2"))
856  which = FLOW_VARIANT_L2;
857  else
858  break;
859  }
860 
861  if (fm->record == 0)
862  return clib_error_return (0,
863  "Please specify flowprobe params record first...");
864 
865  if (sw_if_index == ~0)
866  return clib_error_return (0, "Please specify an interface...");
867 
868  rv = validate_feature_on_interface (fm, sw_if_index, which);
869  if (rv == 1)
870  {
871  if (is_add)
872  return clib_error_return (0,
873  "Datapath is already enabled for given interface...");
874  }
875  else if (rv == 0)
876  return clib_error_return (0,
877  "Interface has enable different datapath ...");
878 
879  rv =
880  flowprobe_tx_interface_add_del_feature (fm, sw_if_index, which, is_add);
881  switch (rv)
882  {
883  case 0:
884  break;
885 
886  case VNET_API_ERROR_INVALID_SW_IF_INDEX:
887  return clib_error_return
888  (0, "Invalid interface, only works on physical ports");
889  break;
890 
891  case VNET_API_ERROR_UNIMPLEMENTED:
892  return clib_error_return (0, "ip6 not supported");
893  break;
894 
895  default:
896  return clib_error_return (0, "flowprobe_enable_disable returned %d",
897  rv);
898  }
899  return 0;
900 }
901 
902 static clib_error_t *
904  unformat_input_t * input,
905  vlib_cli_command_t * cmd)
906 {
908  bool record_l2 = false, record_l3 = false, record_l4 = false;
909  u32 active_timer = ~0;
910  u32 passive_timer = ~0;
911 
913  {
914  if (unformat (input, "active %d", &active_timer))
915  ;
916  else if (unformat (input, "passive %d", &passive_timer))
917  ;
918  else if (unformat (input, "record"))
920  {
921  if (unformat (input, "l2"))
922  record_l2 = true;
923  else if (unformat (input, "l3"))
924  record_l3 = true;
925  else if (unformat (input, "l4"))
926  record_l4 = true;
927  else
928  break;
929  }
930  else
931  break;
932  }
933 
934  if (passive_timer > 0 && active_timer > passive_timer)
935  return clib_error_return (0,
936  "Passive timer has to be greater than active one...");
937 
938  if (flowprobe_params (fm, record_l2, record_l3, record_l4,
939  active_timer, passive_timer))
940  return clib_error_return (0,
941  "Couldn't change flowperpacket params when feature is enabled on some interface ...");
942  return 0;
943 }
944 
945 /*?
946  * '<em>flowprobe feature add-del</em>' commands to enable/disable
947  * per-packet IPFIX flow record generation on an interface
948  *
949  * @cliexpar
950  * @parblock
951  * To enable per-packet IPFIX flow-record generation on an interface:
952  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0}
953  *
954  * To disable per-packet IPFIX flow-record generation on an interface:
955  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0 disable}
956  * @cliexend
957  * @endparblock
958 ?*/
959 /* *INDENT-OFF* */
960 VLIB_CLI_COMMAND (flowprobe_enable_disable_command, static) = {
961  .path = "flowprobe feature add-del",
962  .short_help =
963  "flowprobe feature add-del <interface-name> <l2|ip4|ip6> disable",
965 };
966 VLIB_CLI_COMMAND (flowprobe_params_command, static) = {
967  .path = "flowprobe params",
968  .short_help =
969  "flowprobe params record <[l2] [l3] [l4]> [active <timer> passive <timer>]",
970  .function = flowprobe_params_command_fn,
971 };
972 VLIB_CLI_COMMAND (flowprobe_show_table_command, static) = {
973  .path = "show flowprobe table",
974  .short_help = "show flowprobe table",
975  .function = flowprobe_show_table_fn,
976 };
977 VLIB_CLI_COMMAND (flowprobe_show_stats_command, static) = {
978  .path = "show flowprobe statistics",
979  .short_help = "show flowprobe statistics",
980  .function = flowprobe_show_stats_fn,
981 };
982 /* *INDENT-ON* */
983 
984 /**
985  * @brief Set up the API message handling tables
986  * @param vm vlib_main_t * vlib main data structure pointer
987  * @returns 0 to indicate all is well
988  */
989 static clib_error_t *
991 {
993 #define _(N,n) \
994  vl_msg_api_set_handlers((VL_API_##N + fm->msg_id_base), \
995  #n, \
996  vl_api_##n##_t_handler, \
997  vl_noop_handler, \
998  vl_api_##n##_t_endian, \
999  vl_api_##n##_t_print, \
1000  sizeof(vl_api_##n##_t), 1);
1002 #undef _
1003 
1004  return 0;
1005 }
1006 
1007 #define vl_msg_name_crc_list
1009 #undef vl_msg_name_crc_list
1010 
1011 static void
1013 {
1014 #define _(id,n,crc) \
1015  vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + fm->msg_id_base);
1016  foreach_vl_msg_name_crc_flowprobe;
1017 #undef _
1018 }
1019 
1020 /*
1021  * Main-core process, sending an interrupt to the per worker input
1022  * process that spins the per worker timer wheel.
1023  */
1024 static uword
1026 {
1027  uword *event_data = 0;
1028  vlib_main_t **worker_vms = 0, *worker_vm;
1030 
1031  /* Wait for Godot... */
1033  uword event_type = vlib_process_get_events (vm, &event_data);
1034  if (event_type != 1)
1035  clib_warning ("bogus kickoff event received, %d", event_type);
1036  vec_reset_length (event_data);
1037 
1038  int i;
1039  if (vec_len (vlib_mains) == 0)
1040  vec_add1 (worker_vms, vm);
1041  else
1042  {
1043  for (i = 0; i < vec_len (vlib_mains); i++)
1044  {
1045  worker_vm = vlib_mains[i];
1046  if (worker_vm)
1047  vec_add1 (worker_vms, worker_vm);
1048  }
1049  }
1050  f64 sleep_duration = 0.1;
1051 
1052  while (1)
1053  {
1054  /* Send an interrupt to each timer input node */
1055  sleep_duration = 0.1;
1056  for (i = 0; i < vec_len (worker_vms); i++)
1057  {
1058  worker_vm = worker_vms[i];
1059  if (worker_vm)
1060  {
1062  flowprobe_walker_node.index);
1063  sleep_duration =
1064  (fm->expired_passive_per_worker[i] > 0) ? 1e-4 : 0.1;
1065  }
1066  }
1067  vlib_process_suspend (vm, sleep_duration);
1068  }
1069  return 0; /* or not */
1070 }
1071 
1072 /* *INDENT-OFF* */
1073 VLIB_REGISTER_NODE (flowprobe_timer_node,static) = {
1074  .function = timer_process,
1075  .name = "flowprobe-timer-process",
1076  .type = VLIB_NODE_TYPE_PROCESS,
1077 };
1078 /* *INDENT-ON* */
1079 
1080 /**
1081  * @brief Set up the API message handling tables
1082  * @param vm vlib_main_t * vlib main data structure pointer
1083  * @returns 0 to indicate all is well, or a clib_error_t
1084  */
1085 static clib_error_t *
1087 {
1090  clib_error_t *error = 0;
1091  u8 *name;
1092  u32 num_threads;
1093  int i;
1094 
1095  fm->vnet_main = vnet_get_main ();
1096 
1097  /* Construct the API name */
1098  name = format (0, "flowprobe_%08x%c", api_version, 0);
1099 
1100  /* Ask for a correctly-sized block of API message decode slots */
1102  ((char *) name, VL_MSG_FIRST_AVAILABLE);
1103 
1104  /* Hook up message handlers */
1105  error = flowprobe_plugin_api_hookup (vm);
1106 
1107  /* Add our API messages to the global name_crc hash table */
1109 
1110  vec_free (name);
1111 
1112  /* Set up time reference pair */
1113  fm->vlib_time_0 = vlib_time_now (vm);
1115 
1116  clib_memset (fm->template_reports, 0, sizeof (fm->template_reports));
1117  clib_memset (fm->template_size, 0, sizeof (fm->template_size));
1118  clib_memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
1119 
1120  /* Decide how many worker threads we have */
1121  num_threads = 1 /* main thread */ + tm->n_threads;
1122 
1123  /* Allocate per worker thread vectors per flavour */
1124  for (i = 0; i < FLOW_N_VARIANTS; i++)
1125  {
1126  vec_validate (fm->context[i].buffers_per_worker, num_threads - 1);
1127  vec_validate (fm->context[i].frames_per_worker, num_threads - 1);
1129  num_threads - 1);
1130  }
1131 
1134 
1135  return error;
1136 }
1137 
1139 
1140 /*
1141  * fd.io coding-style-patch-verification: ON
1142  *
1143  * Local Variables:
1144  * eval: (c-set-style "gnu")
1145  * End:
1146  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u32 sw_if_index
Definition: ipsec_gre.api:37
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:412
u32 flags
Definition: vhost_user.h:115
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:886
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:703
a
Definition: bitmap.h:538
ip46_address_t src_address
Definition: flowprobe.h:82
#define FLOWPROBE_TIMER_PASSIVE
Definition: flowprobe.h:32
static void setup_message_id_table(flowprobe_main_t *fm, api_main_t *am)
Definition: flowprobe.c:1012
ip4_address_t src_address
Definition: ip4_packet.h:170
static clib_error_t * flowprobe_plugin_api_hookup(vlib_main_t *vm)
Set up the API message handling tables.
Definition: flowprobe.c:990
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
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:332
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:341
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
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:255
flowprobe_key_t key
Definition: flowprobe.h:99
u32 stream_index
Definition: flow_report.h:91
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:197
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
opaque_t opaque
Definition: flow_report.h:99
int i
#define flowprobe_template_l2_field_count()
format_function_t format_ip46_address
Definition: format.h:61
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
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
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:450
u32 tx_sw_if_index
Definition: flowprobe.h:78
vlib_main_t ** vlib_mains
Definition: buffer.c:321
unsigned char u8
Definition: types.h:56
static ipfix_field_specifier_t * flowprobe_template_common_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:164
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
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
#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:17
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:452
static ipfix_field_specifier_t * flowprobe_template_ip4_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:99
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:493
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
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:546
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:346
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:360
#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:242
unsigned int u32
Definition: types.h:88
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
void flowprobe_flush_callback_ip4(void)
Definition: node.c:880
#define foreach_flowprobe_plugin_api_msg
Definition: flowprobe.c:761
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:716
u8 ht_log2len
Per CPU flow-state.
Definition: flowprobe.h:134
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:547
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:964
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()
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:388
vl_api_address_union_t src_address
Definition: ip_types.api:44
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:374
VLIB_PLUGIN_REGISTER()
static void flowprobe_expired_timer_callback(u32 *expired_timers)
Definition: flowprobe.c:458
static u32 version_length(u16 length)
Definition: ipfix_packet.h:33
u8 name[64]
Definition: memclnt.api:152
vlib_thread_main_t vlib_thread_main
Definition: threads.c:37
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:646
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:202
#define BAD_SW_IF_INDEX_LABEL
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
#define flowprobe_template_ip6_field_count()
vlib_main_t * vm
Definition: buffer.c:312
static clib_error_t * flowprobe_show_stats_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cm)
Definition: flowprobe.c:816
#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:439
f64 last_exported
Definition: flowprobe.h:105
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
vlib_node_registration_t flowprobe_walker_node
Definition: flowprobe.c:54
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:703
#define FINISH
Definition: flowprobe.c:92
static u64 unix_time_now_nsec(void)
Definition: time.h:255
static clib_error_t * flowprobe_init(vlib_main_t *vm)
Set up the API message handling tables.
Definition: flowprobe.c:1086
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
flowprobe_record_t
Definition: flowprobe.h:35
#define ASSERT(truth)
u8 is_add
Definition: ipsec_gre.api:36
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:430
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:122
static void * clib_mem_alloc(uword size)
Definition: mem.h:132
#define VNET_FEATURES(...)
Definition: feature.h:435
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
flowprobe_main_t flowprobe_main
Definition: flowprobe.c:53
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
#define flowprobe_template_common_field_count()
void flowprobe_flush_callback_l2(void)
Definition: node.c:892
#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:196
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:746
u8 * format_flowprobe_entry(u8 *s, va_list *args)
Definition: flowprobe.c:773
static ipfix_field_specifier_t * flowprobe_template_l2_fields(ipfix_field_specifier_t *f)
Definition: flowprobe.c:145
static int validate_feature_on_interface(flowprobe_main_t *fm, u32 sw_if_index, u8 which)
Definition: flowprobe.c:525
ip46_address_t dst_address
Definition: flowprobe.h:83
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:421
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:692
static uword timer_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: flowprobe.c:1025
#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:486
#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:791
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:835
api_main_t api_main
Definition: api_shared.c:35
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:903
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:225
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:725
static vlib_node_registration_t flowprobe_timer_node
(constructor) VLIB_REGISTER_NODE (flowprobe_timer_node)
Definition: flowprobe.c:55
static clib_error_t * flowprobe_create_state_tables(u32 active_timer)
Definition: flowprobe.c:474
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:972
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:274
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
#define VALIDATE_SW_IF_INDEX(mp)
u16 vl_msg_api_get_msg_ids(const char *name, int n)
Definition: api_shared.c:880
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128