src/plugins/flowprobe/flowprobe.c

   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
  38 flowprobe_main_t flowprobe_main;
  39 static vlib_node_registration_t flowprobe_timer_node;
  40 uword flowprobe_walker_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
  41                                 vlib_frame_t * f);
  42
  43 #define REPLY_MSG_ID_BASE fm->msg_id_base
  44 #include <vlibapi/api_helper_macros.h>
  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 *
  79 flowprobe_template_ip4_fields (ipfix_field_specifier_t * f)
  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 *
 102 flowprobe_template_ip6_fields (ipfix_field_specifier_t * f)
 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 *
 125 flowprobe_template_l2_fields (ipfix_field_specifier_t * f)
 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 *
 144 flowprobe_template_common_fields (ipfix_field_specifier_t * f)
 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 *
 176 flowprobe_template_l4_fields (ipfix_field_specifier_t * f)
 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 *
 205 flowprobe_template_rewrite_inline (flow_report_main_t * frm,
 206                                    flow_report_t * fr,
 207                                    ip4_address_t * collector_address,
 208                                    ip4_address_t * src_address,
 209                                    u16 collector_port,
 210                                    flowprobe_variant_t which)
 211 {
 212   ip4_header_t *ip;
 213   udp_header_t *udp;
 214   ipfix_message_header_t *h;
 215   ipfix_set_header_t *s;
 216   ipfix_template_header_t *t;
 217   ipfix_field_specifier_t *f;
 218   ipfix_field_specifier_t *first_field;
 219   u8 *rewrite = 0;
 220   ip4_ipfix_template_packet_t *tp;
 221   u32 field_count = 0;
 222   flow_report_stream_t *stream;
 223   flowprobe_main_t *fm = &flowprobe_main;
 224   flowprobe_record_t flags = fr->opaque.as_uword;
 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 */
 250   vec_validate_aligned
 251     (rewrite, sizeof (ip4_ipfix_template_packet_t)
 252      + field_count * sizeof (ipfix_field_specifier_t) - 1,
 253      CLIB_CACHE_LINE_BYTES);
 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 */
 277   f = flowprobe_template_common_fields (f);
 278
 279   if (flags & FLOW_RECORD_L2)
 280     f = flowprobe_template_l2_fields (f);
 281   if (collect_ip4)
 282     f = flowprobe_template_ip4_fields (f);
 283   if (collect_ip6)
 284     f = flowprobe_template_ip6_fields (f);
 285   if (flags & FLOW_RECORD_L4)
 286     f = flowprobe_template_l4_fields (f);
 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 *
 312 flowprobe_template_rewrite_ip6 (flow_report_main_t * frm,
 313                                 flow_report_t * fr,
 314                                 ip4_address_t * collector_address,
 315                                 ip4_address_t * src_address,
 316                                 u16 collector_port,
 317                                 ipfix_report_element_t * elts,
 318                                 u32 n_elts, u32 * stream_index)
 319 {
 320   return flowprobe_template_rewrite_inline
 321     (frm, fr, collector_address, src_address, collector_port,
 322      FLOW_VARIANT_IP6);
 323 }
 324
 325 static u8 *
 326 flowprobe_template_rewrite_ip4 (flow_report_main_t * frm,
 327                                 flow_report_t * fr,
 328                                 ip4_address_t * collector_address,
 329                                 ip4_address_t * src_address,
 330                                 u16 collector_port,
 331                                 ipfix_report_element_t * elts,
 332                                 u32 n_elts, u32 * stream_index)
 333 {
 334   return flowprobe_template_rewrite_inline
 335     (frm, fr, collector_address, src_address, collector_port,
 336      FLOW_VARIANT_IP4);
 337 }
 338
 339 static u8 *
 340 flowprobe_template_rewrite_l2 (flow_report_main_t * frm,
 341                                flow_report_t * fr,
 342                                ip4_address_t * collector_address,
 343                                ip4_address_t * src_address,
 344                                u16 collector_port,
 345                                ipfix_report_element_t * elts,
 346                                u32 n_elts, u32 * stream_index)
 347 {
 348   return flowprobe_template_rewrite_inline
 349     (frm, fr, collector_address, src_address, collector_port,
 350      FLOW_VARIANT_L2);
 351 }
 352
 353 static u8 *
 354 flowprobe_template_rewrite_l2_ip4 (flow_report_main_t * frm,
 355                                    flow_report_t * fr,
 356                                    ip4_address_t * collector_address,
 357                                    ip4_address_t * src_address,
 358                                    u16 collector_port,
 359                                    ipfix_report_element_t * elts,
 360                                    u32 n_elts, u32 * stream_index)
 361 {
 362   return flowprobe_template_rewrite_inline
 363     (frm, fr, collector_address, src_address, collector_port,
 364      FLOW_VARIANT_L2_IP4);
 365 }
 366
 367 static u8 *
 368 flowprobe_template_rewrite_l2_ip6 (flow_report_main_t * frm,
 369                                    flow_report_t * fr,
 370                                    ip4_address_t * collector_address,
 371                                    ip4_address_t * src_address,
 372                                    u16 collector_port,
 373                                    ipfix_report_element_t * elts,
 374                                    u32 n_elts, u32 * stream_index)
 375 {
 376   return flowprobe_template_rewrite_inline
 377     (frm, fr, collector_address, src_address, collector_port,
 378      FLOW_VARIANT_L2_IP6);
 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 *
 392 flowprobe_data_callback_ip4 (flow_report_main_t * frm,
 393                              flow_report_t * fr,
 394                              vlib_frame_t * f, u32 * to_next, u32 node_index)
 395 {
 396   flowprobe_flush_callback_ip4 ();
 397   return f;
 398 }
 399
 400 vlib_frame_t *
 401 flowprobe_data_callback_ip6 (flow_report_main_t * frm,
 402                              flow_report_t * fr,
 403                              vlib_frame_t * f, u32 * to_next, u32 node_index)
 404 {
 405   flowprobe_flush_callback_ip6 ();
 406   return f;
 407 }
 408
 409 vlib_frame_t *
 410 flowprobe_data_callback_l2 (flow_report_main_t * frm,
 411                             flow_report_t * fr,
 412                             vlib_frame_t * f, u32 * to_next, u32 node_index)
 413 {
 414   flowprobe_flush_callback_l2 ();
 415   return f;
 416 }
 417
 418 static int
 419 flowprobe_template_add_del (u32 domain_id, u16 src_port,
 420                             flowprobe_record_t flags,
 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 {
 425   flow_report_main_t *frm = &flow_report_main;
 426   vnet_flow_report_add_del_args_t a = {
 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
 438 flowprobe_expired_timer_callback (u32 * expired_timers)
 439 {
 440   vlib_main_t *vm = vlib_get_main ();
 441   flowprobe_main_t *fm = &flowprobe_main;
 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 *
 454 flowprobe_create_state_tables (u32 active_timer)
 455 {
 456   flowprobe_main_t *fm = &flowprobe_main;
 457   vlib_thread_main_t *tm = &vlib_thread_main;
 458   vlib_main_t *vm = vlib_get_main ();
 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 */
 467   fm->ht_log2len = FLOWPROBE_LOG2_HASHSIZE;
 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],
 487                                             flowprobe_expired_timer_callback,
 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
 505 validate_feature_on_interface (flowprobe_main_t * fm, u32 sw_if_index,
 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
 527 flowprobe_tx_interface_add_del_feature (flowprobe_main_t * fm,
 528                                         u32 sw_if_index, u8 which, int is_add)
 529 {
 530   vlib_main_t *vm = vlib_get_main ();
 531   int rv = 0;
 532   u16 template_id = 0;
 533   flowprobe_record_t flags = fm->record;
 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,
 548                                                flowprobe_data_callback_l2,
 549                                                flowprobe_template_rewrite_l2,
 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,
 555                                                flowprobe_data_callback_l2,
 556                                                flowprobe_template_rewrite_l2_ip4,
 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,
 562                                             flowprobe_data_callback_l2,
 563                                             flowprobe_template_rewrite_l2_ip6,
 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 */
 569               fm->context[FLOW_VARIANT_L2_IP4].flags =
 570                 flags | FLOW_RECORD_L2_IP4;
 571               fm->context[FLOW_VARIANT_L2_IP6].flags =
 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,
 579                                          flowprobe_data_callback_ip4,
 580                                          flowprobe_template_rewrite_ip4,
 581                                          is_add, &template_id);
 582       else if (which == FLOW_VARIANT_IP6)
 583         rv = flowprobe_template_add_del (1, UDP_DST_PORT_ipfix, flags,
 584                                          flowprobe_data_callback_ip6,
 585                                          flowprobe_template_rewrite_ip6,
 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     {
 613       flowprobe_create_state_tables (fm->active_timer);
 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  */
 625 void vl_api_flowprobe_tx_interface_add_del_t_handler
 626   (vl_api_flowprobe_tx_interface_add_del_t * mp)
 627 {
 628   flowprobe_main_t *fm = &flowprobe_main;
 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
 633   VALIDATE_SW_IF_INDEX (mp);
 634
 635   if (mp->which != FLOW_VARIANT_IP4 && mp->which != FLOW_VARIANT_L2
 636       && mp->which != FLOW_VARIANT_IP6)
 637     {
 638       rv = VNET_API_ERROR_UNIMPLEMENTED;
 639       goto out;
 640     }
 641
 642   if (fm->record == 0)
 643     {
 644       clib_warning ("Please specify flowprobe params record first...");
 645       rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
 646       goto out;
 647     }
 648
 649   rv = validate_feature_on_interface (fm, sw_if_index, mp->which);
 650   if ((rv == 1 && mp->is_add == 1) || rv == 0)
 651     {
 652       rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
 653       goto out;
 654     }
 655
 656   rv = flowprobe_tx_interface_add_del_feature
 657     (fm, sw_if_index, mp->which, mp->is_add);
 658
 659 out:
 660   BAD_SW_IF_INDEX_LABEL;
 661
 662   REPLY_MACRO (VL_API_FLOWPROBE_TX_INTERFACE_ADD_DEL_REPLY);
 663 }
 664
 665 /**
 666  * @brief API message custom-dump function
 667  * @param mp vl_api_flowprobe_tx_interface_add_del_t * mp the api message
 668  * @param handle void * print function handle
 669  * @returns u8 * output string
 670  */
 671 static void *vl_api_flowprobe_tx_interface_add_del_t_print
 672   (vl_api_flowprobe_tx_interface_add_del_t * mp, void *handle)
 673 {
 674   u8 *s;
 675
 676   s = format (0, "SCRIPT: flowprobe_tx_interface_add_del ");
 677   s = format (s, "sw_if_index %d is_add %d which %d ",
 678               clib_host_to_net_u32 (mp->sw_if_index),
 679               (int) mp->is_add, (int) mp->which);
 680   FINISH;
 681 }
 682
 683 #define vec_neg_search(v,E)         \
 684 ({              \
 685   word _v(i) = 0;         \
 686   while (_v(i) < vec_len(v) && v[_v(i)] == E)        \
 687   {             \
 688     _v(i)++;            \
 689   }             \
 690   if (_v(i) == vec_len(v))        \
 691     _v(i) = ~0;                 \
 692   _v(i);            \
 693 })
 694
 695 static int
 696 flowprobe_params (flowprobe_main_t * fm, u8 record_l2,
 697                   u8 record_l3, u8 record_l4,
 698                   u32 active_timer, u32 passive_timer)
 699 {
 700   flowprobe_record_t flags = 0;
 701
 702   if (vec_neg_search (fm->flow_per_interface, (u8) ~ 0) != ~0)
 703     return ~0;
 704
 705   if (record_l2)
 706     flags |= FLOW_RECORD_L2;
 707   if (record_l3)
 708     flags |= FLOW_RECORD_L3;
 709   if (record_l4)
 710     flags |= FLOW_RECORD_L4;
 711
 712   fm->record = flags;
 713
 714   /*
 715    * Timers: ~0 is default, 0 is off
 716    */
 717   fm->active_timer =
 718     (active_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_ACTIVE : active_timer);
 719   fm->passive_timer =
 720     (passive_timer == (u32) ~ 0 ? FLOWPROBE_TIMER_PASSIVE : passive_timer);
 721
 722   return 0;
 723 }
 724
 725 void
 726 vl_api_flowprobe_params_t_handler (vl_api_flowprobe_params_t * mp)
 727 {
 728   flowprobe_main_t *fm = &flowprobe_main;
 729   vl_api_flowprobe_params_reply_t *rmp;
 730   int rv = 0;
 731
 732   rv = flowprobe_params
 733     (fm, mp->record_l2, mp->record_l3, mp->record_l4,
 734      clib_net_to_host_u32 (mp->active_timer),
 735      clib_net_to_host_u32 (mp->passive_timer));
 736
 737   REPLY_MACRO (VL_API_FLOWPROBE_PARAMS_REPLY);
 738 }
 739
 740 /* *INDENT-OFF* */
 741 VLIB_PLUGIN_REGISTER () = {
 742     .version = VPP_BUILD_VER,
 743     .description = "Flow per Packet",
 744 };
 745 /* *INDENT-ON* */
 746
 747 u8 *
 748 format_flowprobe_entry (u8 * s, va_list * args)
 749 {
 750   flowprobe_entry_t *e = va_arg (*args, flowprobe_entry_t *);
 751   s = format (s, " %d/%d", e->key.rx_sw_if_index, e->key.tx_sw_if_index);
 752
 753   s = format (s, " %U %U", format_ethernet_address, &e->key.src_mac,
 754               format_ethernet_address, &e->key.dst_mac);
 755   s = format (s, " %U -> %U",
 756               format_ip46_address, &e->key.src_address, IP46_TYPE_ANY,
 757               format_ip46_address, &e->key.dst_address, IP46_TYPE_ANY);
 758   s = format (s, " %d", e->key.protocol);
 759   s = format (s, " %d %d\n", clib_net_to_host_u16 (e->key.src_port),
 760               clib_net_to_host_u16 (e->key.dst_port));
 761
 762   return s;
 763 }
 764
 765 static clib_error_t *
 766 flowprobe_show_table_fn (vlib_main_t * vm,
 767                          unformat_input_t * input, vlib_cli_command_t * cm)
 768 {
 769   flowprobe_main_t *fm = &flowprobe_main;
 770   int i;
 771   flowprobe_entry_t *e;
 772
 773   vlib_cli_output (vm, "Dumping IPFIX table");
 774
 775   for (i = 0; i < vec_len (fm->pool_per_worker); i++)
 776     {
 777       /* *INDENT-OFF* */
 778       pool_foreach (e, fm->pool_per_worker[i], (
 779         {
 780           vlib_cli_output (vm, "%U",
 781                            format_flowprobe_entry,
 782                            e);
 783         }));
 784       /* *INDENT-ON* */
 785
 786     }
 787   return 0;
 788 }
 789
 790 static clib_error_t *
 791 flowprobe_show_stats_fn (vlib_main_t * vm,
 792                          unformat_input_t * input, vlib_cli_command_t * cm)
 793 {
 794   flowprobe_main_t *fm = &flowprobe_main;
 795   int i;
 796
 797   vlib_cli_output (vm, "IPFIX table statistics");
 798   vlib_cli_output (vm, "Flow entry size: %d\n", sizeof (flowprobe_entry_t));
 799   vlib_cli_output (vm, "Flow pool size per thread: %d\n",
 800                    0x1 << FLOWPROBE_LOG2_HASHSIZE);
 801
 802   for (i = 0; i < vec_len (fm->pool_per_worker); i++)
 803     vlib_cli_output (vm, "Pool utilisation thread %d is %d%%\n", i,
 804                      (100 * pool_elts (fm->pool_per_worker[i])) /
 805                      (0x1 << FLOWPROBE_LOG2_HASHSIZE));
 806   return 0;
 807 }
 808
 809 static clib_error_t *
 810 flowprobe_tx_interface_add_del_feature_command_fn (vlib_main_t * vm,
 811                                                    unformat_input_t * input,
 812                                                    vlib_cli_command_t * cmd)
 813 {
 814   flowprobe_main_t *fm = &flowprobe_main;
 815   u32 sw_if_index = ~0;
 816   int is_add = 1;
 817   u8 which = FLOW_VARIANT_IP4;
 818   int rv;
 819
 820   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 821     {
 822       if (unformat (input, "disable"))
 823         is_add = 0;
 824       else if (unformat (input, "%U", unformat_vnet_sw_interface,
 825                          fm->vnet_main, &sw_if_index));
 826       else if (unformat (input, "ip4"))
 827         which = FLOW_VARIANT_IP4;
 828       else if (unformat (input, "ip6"))
 829         which = FLOW_VARIANT_IP6;
 830       else if (unformat (input, "l2"))
 831         which = FLOW_VARIANT_L2;
 832       else
 833         break;
 834     }
 835
 836   if (fm->record == 0)
 837     return clib_error_return (0,
 838                               "Please specify flowprobe params record first...");
 839
 840   if (sw_if_index == ~0)
 841     return clib_error_return (0, "Please specify an interface...");
 842
 843   rv = validate_feature_on_interface (fm, sw_if_index, which);
 844   if (rv == 1)
 845     {
 846       if (is_add)
 847         return clib_error_return (0,
 848                                   "Datapath is already enabled for given interface...");
 849     }
 850   else if (rv == 0)
 851     return clib_error_return (0,
 852                               "Interface has enable different datapath ...");
 853
 854   rv =
 855     flowprobe_tx_interface_add_del_feature (fm, sw_if_index, which, is_add);
 856   switch (rv)
 857     {
 858     case 0:
 859       break;
 860
 861     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 862       return clib_error_return
 863         (0, "Invalid interface, only works on physical ports");
 864       break;
 865
 866     case VNET_API_ERROR_UNIMPLEMENTED:
 867       return clib_error_return (0, "ip6 not supported");
 868       break;
 869
 870     default:
 871       return clib_error_return (0, "flowprobe_enable_disable returned %d",
 872                                 rv);
 873     }
 874   return 0;
 875 }
 876
 877 static clib_error_t *
 878 flowprobe_params_command_fn (vlib_main_t * vm,
 879                              unformat_input_t * input,
 880                              vlib_cli_command_t * cmd)
 881 {
 882   flowprobe_main_t *fm = &flowprobe_main;
 883   bool record_l2 = false, record_l3 = false, record_l4 = false;
 884   u32 active_timer = ~0;
 885   u32 passive_timer = ~0;
 886
 887   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 888     {
 889       if (unformat (input, "active %d", &active_timer))
 890         ;
 891       else if (unformat (input, "passive %d", &passive_timer))
 892         ;
 893       else if (unformat (input, "record"))
 894         while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 895           {
 896             if (unformat (input, "l2"))
 897               record_l2 = true;
 898             else if (unformat (input, "l3"))
 899               record_l3 = true;
 900             else if (unformat (input, "l4"))
 901               record_l4 = true;
 902             else
 903               break;
 904           }
 905       else
 906         break;
 907     }
 908
 909   if (passive_timer > 0 && active_timer > passive_timer)
 910     return clib_error_return (0,
 911                               "Passive timer has to be greater than active one...");
 912
 913   if (flowprobe_params (fm, record_l2, record_l3, record_l4,
 914                         active_timer, passive_timer))
 915     return clib_error_return (0,
 916                               "Couldn't change flowperpacket params when feature is enabled on some interface ...");
 917   return 0;
 918 }
 919
 920 /*?
 921  * '<em>flowprobe feature add-del</em>' commands to enable/disable
 922  * per-packet IPFIX flow record generation on an interface
 923  *
 924  * @cliexpar
 925  * @parblock
 926  * To enable per-packet IPFIX flow-record generation on an interface:
 927  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0}
 928  *
 929  * To disable per-packet IPFIX flow-record generation on an interface:
 930  * @cliexcmd{flowprobe feature add-del GigabitEthernet2/0/0 disable}
 931  * @cliexend
 932  * @endparblock
 933 ?*/
 934 /* *INDENT-OFF* */
 935 VLIB_CLI_COMMAND (flowprobe_enable_disable_command, static) = {
 936     .path = "flowprobe feature add-del",
 937     .short_help =
 938     "flowprobe feature add-del <interface-name> <l2|ip4|ip6> disable",
 939     .function = flowprobe_tx_interface_add_del_feature_command_fn,
 940 };
 941 VLIB_CLI_COMMAND (flowprobe_params_command, static) = {
 942     .path = "flowprobe params",
 943     .short_help =
 944     "flowprobe params record <[l2] [l3] [l4]> [active <timer> passive <timer>]",
 945     .function = flowprobe_params_command_fn,
 946 };
 947 VLIB_CLI_COMMAND (flowprobe_show_table_command, static) = {
 948     .path = "show flowprobe table",
 949     .short_help = "show flowprobe table",
 950     .function = flowprobe_show_table_fn,
 951 };
 952 VLIB_CLI_COMMAND (flowprobe_show_stats_command, static) = {
 953     .path = "show flowprobe statistics",
 954     .short_help = "show flowprobe statistics",
 955     .function = flowprobe_show_stats_fn,
 956 };
 957 /* *INDENT-ON* */
 958
 959 /*
 960  * Main-core process, sending an interrupt to the per worker input
 961  * process that spins the per worker timer wheel.
 962  */
 963 static uword
 964 timer_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
 965 {
 966   uword *event_data = 0;
 967   vlib_main_t **worker_vms = 0, *worker_vm;
 968   flowprobe_main_t *fm = &flowprobe_main;
 969
 970   /* Wait for Godot... */
 971   vlib_process_wait_for_event_or_clock (vm, 1e9);
 972   uword event_type = vlib_process_get_events (vm, &event_data);
 973   if (event_type != 1)
 974     clib_warning ("bogus kickoff event received, %d", event_type);
 975   vec_reset_length (event_data);
 976
 977   int i;
 978   if (vec_len (vlib_mains) == 0)
 979     vec_add1 (worker_vms, vm);
 980   else
 981     {
 982       for (i = 0; i < vec_len (vlib_mains); i++)
 983         {
 984           worker_vm = vlib_mains[i];
 985           if (worker_vm)
 986             vec_add1 (worker_vms, worker_vm);
 987         }
 988     }
 989   f64 sleep_duration = 0.1;
 990
 991   while (1)
 992     {
 993       /* Send an interrupt to each timer input node */
 994       sleep_duration = 0.1;
 995       for (i = 0; i < vec_len (worker_vms); i++)
 996         {
 997           worker_vm = worker_vms[i];
 998           if (worker_vm)
 999             {
1000               vlib_node_set_interrupt_pending (worker_vm,
1001                                                flowprobe_walker_node.index);
1002               sleep_duration =
1003                 (fm->expired_passive_per_worker[i] > 0) ? 1e-4 : 0.1;
1004             }
1005         }
1006       vlib_process_suspend (vm, sleep_duration);
1007     }
1008   return 0;                     /* or not */
1009 }
1010
1011 /* *INDENT-OFF* */
1012 VLIB_REGISTER_NODE (flowprobe_timer_node,static) = {
1013   .function = timer_process,
1014   .name = "flowprobe-timer-process",
1015   .type = VLIB_NODE_TYPE_PROCESS,
1016 };
1017 /* *INDENT-ON* */
1018
1019 #include <flowprobe/flowprobe.api.c>
1020
1021 /**
1022  * @brief Set up the API message handling tables
1023  * @param vm vlib_main_t * vlib main data structure pointer
1024  * @returns 0 to indicate all is well, or a clib_error_t
1025  */
1026 static clib_error_t *
1027 flowprobe_init (vlib_main_t * vm)
1028 {
1029   flowprobe_main_t *fm = &flowprobe_main;
1030   vlib_thread_main_t *tm = &vlib_thread_main;
1031   clib_error_t *error = 0;
1032   u32 num_threads;
1033   int i;
1034
1035   fm->vnet_main = vnet_get_main ();
1036
1037   /* Ask for a correctly-sized block of API message decode slots */
1038   fm->msg_id_base = setup_message_id_table ();
1039
1040   /* Set up time reference pair */
1041   fm->vlib_time_0 = vlib_time_now (vm);
1042   fm->nanosecond_time_0 = unix_time_now_nsec ();
1043
1044   clib_memset (fm->template_reports, 0, sizeof (fm->template_reports));
1045   clib_memset (fm->template_size, 0, sizeof (fm->template_size));
1046   clib_memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
1047
1048   /* Decide how many worker threads we have */
1049   num_threads = 1 /* main thread */  + tm->n_threads;
1050
1051   /* Allocate per worker thread vectors per flavour */
1052   for (i = 0; i < FLOW_N_VARIANTS; i++)
1053     {
1054       vec_validate (fm->context[i].buffers_per_worker, num_threads - 1);
1055       vec_validate (fm->context[i].frames_per_worker, num_threads - 1);
1056       vec_validate (fm->context[i].next_record_offset_per_worker,
1057                     num_threads - 1);
1058     }
1059
1060   fm->active_timer = FLOWPROBE_TIMER_ACTIVE;
1061   fm->passive_timer = FLOWPROBE_TIMER_PASSIVE;
1062
1063   return error;
1064 }
1065
1066 VLIB_INIT_FUNCTION (flowprobe_init);
1067
1068 /*
1069  * fd.io coding-style-patch-verification: ON
1070  *
1071  * Local Variables:
1072  * eval: (c-set-style "gnu")
1073  * End:
1074  */