vnet/vnet/flow/flow_report.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * flow_report.c
  17  */
  18 #include <vnet/flow/flow_report.h>
  19 #include <vnet/api_errno.h>
  20
  21 flow_report_main_t flow_report_main;
  22
  23 int send_template_packet (flow_report_main_t *frm,
  24                           flow_report_t *fr,
  25                           u32 * buffer_indexp)
  26 {
  27   u32 bi0;
  28   vlib_buffer_t * b0;
  29   ip4_ipfix_template_packet_t * tp;
  30   ipfix_message_header_t * h;
  31   ip4_header_t * ip;
  32   udp_header_t * udp;
  33   vlib_main_t * vm = frm->vlib_main;
  34
  35   ASSERT (buffer_indexp);
  36
  37   if (fr->update_rewrite || fr->rewrite == 0)
  38     {
  39       if (frm->ipfix_collector.as_u32 == 0
  40           || frm->src_address.as_u32 == 0)
  41         {
  42           clib_warning ("no collector: disabling flow collector process");
  43           vlib_node_set_state (frm->vlib_main, flow_report_process_node.index,
  44                                VLIB_NODE_STATE_DISABLED);
  45           return -1;
  46         }
  47       vec_free (fr->rewrite);
  48       fr->update_rewrite = 1;
  49     }
  50
  51   if (fr->update_rewrite)
  52     {
  53       fr->rewrite = fr->rewrite_callback (frm, fr,
  54                                           &frm->ipfix_collector,
  55                                           &frm->src_address,
  56                                           frm->collector_port);
  57       fr->update_rewrite = 0;
  58     }
  59
  60   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
  61     return -1;
  62
  63   b0 = vlib_get_buffer (vm, bi0);
  64
  65   ASSERT (vec_len (fr->rewrite) < VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES);
  66
  67   clib_memcpy (b0->data, fr->rewrite, vec_len (fr->rewrite));
  68   b0->current_data = 0;
  69   b0->current_length = vec_len (fr->rewrite);
  70   b0->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  71   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
  72   vnet_buffer (b0)->sw_if_index[VLIB_TX] = frm->fib_index;
  73
  74   tp = vlib_buffer_get_current (b0);
  75   ip = (ip4_header_t *) &tp->ip4;
  76   udp = (udp_header_t *) (ip+1);
  77   h = (ipfix_message_header_t *)(udp+1);
  78
  79   /* FIXUP: message header export_time */
  80   h->export_time = (u32)
  81     (((f64)frm->unix_time_0) +
  82      (vlib_time_now(frm->vlib_main) - frm->vlib_time_0));
  83   h->export_time = clib_host_to_net_u32(h->export_time);
  84
  85   /* FIXUP: message header sequence_number. Templates do not increase it */
  86   h->sequence_number = clib_host_to_net_u32(fr->sequence_number);
  87
  88   /* FIXUP: udp length */
  89   udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
  90
  91   *buffer_indexp = bi0;
  92
  93   fr->last_template_sent = vlib_time_now (vm);
  94
  95   return 0;
  96 }
  97
  98 static uword
  99 flow_report_process (vlib_main_t * vm,
 100                      vlib_node_runtime_t * rt,
 101                      vlib_frame_t * f)
 102 {
 103   flow_report_main_t * frm = &flow_report_main;
 104   flow_report_t * fr;
 105   u32 ip4_lookup_node_index;
 106   vlib_node_t * ip4_lookup_node;
 107   vlib_frame_t * nf = 0;
 108   u32 template_bi;
 109   u32 * to_next;
 110   int send_template;
 111   f64 now;
 112   int rv;
 113   uword event_type;
 114   uword *event_data = 0;
 115
 116   /* Wait for Godot... */
 117   vlib_process_wait_for_event_or_clock (vm, 1e9);
 118   event_type = vlib_process_get_events (vm, &event_data);
 119   if (event_type != 1)
 120       clib_warning ("bogus kickoff event received, %d", event_type);
 121   vec_reset_length (event_data);
 122
 123   /* Enqueue pkts to ip4-lookup */
 124   ip4_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip4-lookup");
 125   ip4_lookup_node_index = ip4_lookup_node->index;
 126
 127   while (1)
 128     {
 129       vlib_process_suspend (vm, 5.0);
 130
 131       vec_foreach (fr, frm->reports)
 132         {
 133           now = vlib_time_now (vm);
 134
 135           /* Need to send a template packet? */
 136           send_template =
 137               now > (fr->last_template_sent + frm->template_interval);
 138           send_template += fr->last_template_sent == 0;
 139           template_bi = ~0;
 140           rv = 0;
 141
 142           if (send_template)
 143             rv = send_template_packet (frm, fr, &template_bi);
 144
 145           if (rv < 0)
 146             continue;
 147
 148           nf = vlib_get_frame_to_node (vm, ip4_lookup_node_index);
 149           nf->n_vectors = 0;
 150           to_next = vlib_frame_vector_args (nf);
 151
 152           if (template_bi != ~0)
 153             {
 154               to_next[0] = template_bi;
 155               to_next++;
 156               nf->n_vectors++;
 157             }
 158
 159           nf = fr->flow_data_callback (frm, fr,
 160                                        nf, to_next, ip4_lookup_node_index);
 161           if (nf)
 162             vlib_put_frame_to_node (vm, ip4_lookup_node_index, nf);
 163         }
 164     }
 165
 166   return 0; /* not so much */
 167 }
 168
 169 VLIB_REGISTER_NODE (flow_report_process_node) = {
 170     .function = flow_report_process,
 171     .type = VLIB_NODE_TYPE_PROCESS,
 172     .name = "flow-report-process",
 173 };
 174
 175 int vnet_flow_report_add_del (flow_report_main_t *frm,
 176                               vnet_flow_report_add_del_args_t *a)
 177 {
 178   int i;
 179   int found_index = ~0;
 180   flow_report_t *fr;
 181
 182   for (i = 0; i < vec_len(frm->reports); i++)
 183     {
 184       fr = vec_elt_at_index (frm->reports, i);
 185       if (fr->opaque == a->opaque
 186           && fr->rewrite_callback == a->rewrite_callback
 187           && fr->flow_data_callback == a->flow_data_callback)
 188         {
 189           found_index = i;
 190           break;
 191         }
 192     }
 193
 194   if (a->is_add == 0)
 195     {
 196       if (found_index != ~0)
 197         {
 198           vec_delete (frm->reports, 1, found_index);
 199           return 0;
 200         }
 201       return VNET_API_ERROR_NO_SUCH_ENTRY;
 202     }
 203
 204   vec_add2 (frm->reports, fr, 1);
 205
 206   fr->sequence_number = 0;
 207   fr->domain_id = a->domain_id;
 208   fr->src_port = a->src_port;
 209   fr->update_rewrite = 1;
 210   fr->opaque = a->opaque;
 211   fr->rewrite_callback = a->rewrite_callback;
 212   fr->flow_data_callback = a->flow_data_callback;
 213
 214   return 0;
 215 }
 216
 217 void vnet_flow_reports_reset (flow_report_main_t * frm)
 218 {
 219   flow_report_t *fr;
 220   vec_foreach (fr, frm->reports)
 221     {
 222           fr->sequence_number = 0;
 223       fr->update_rewrite = 1;
 224       fr->last_template_sent = 0;
 225     }
 226 }
 227
 228 static clib_error_t *
 229 set_ipfix_command_fn (vlib_main_t * vm,
 230                  unformat_input_t * input,
 231                  vlib_cli_command_t * cmd)
 232 {
 233   flow_report_main_t * frm = &flow_report_main;
 234   ip4_address_t collector, src;
 235   u16 collector_port = UDP_DST_PORT_ipfix;
 236   u32 fib_id;
 237   u32 fib_index = ~0;
 238
 239   collector.as_u32 = 0;
 240   src.as_u32 = 0;
 241   u32 path_mtu = 512; // RFC 7011 section 10.3.3.
 242   u32 template_interval = 20;
 243
 244   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
 245     if (unformat (input, "collector %U", unformat_ip4_address, &collector))
 246       ;
 247     else if (unformat (input, "port %u", &collector_port))
 248       ;
 249     else if (unformat (input, "src %U", unformat_ip4_address, &src))
 250       ;
 251     else if (unformat (input, "fib-id %u", &fib_id))
 252       {
 253         ip4_main_t * im = &ip4_main;
 254         uword * p = hash_get (im->fib_index_by_table_id, fib_id);
 255         if (! p)
 256           return clib_error_return (0, "fib ID %d doesn't exist\n",
 257                                     fib_id);
 258         fib_index = p[0];
 259       }
 260     else if (unformat (input, "path-mtu %u", &path_mtu))
 261       ;
 262     else if (unformat (input, "template-interval %u", &template_interval))
 263       ;
 264     else
 265       break;
 266   }
 267
 268   if (collector.as_u32 == 0)
 269     return clib_error_return (0, "collector address required");
 270
 271   if (src.as_u32 == 0)
 272     return clib_error_return (0, "src address required");
 273
 274   if (path_mtu > 1450 /* vpp does not support fragmentation */)
 275         return clib_error_return (0, "too big path-mtu value, maximum is 1450");
 276
 277   if (path_mtu < 68)
 278         return clib_error_return (0, "too small path-mtu value, minimum is 68");
 279
 280   /* Reset report streams if we are reconfiguring IP addresses */
 281   if (frm->ipfix_collector.as_u32 != collector.as_u32 ||
 282       frm->src_address.as_u32 != src.as_u32 ||
 283       frm->collector_port != collector_port)
 284     vnet_flow_reports_reset(frm);
 285
 286   frm->ipfix_collector.as_u32 = collector.as_u32;
 287   frm->collector_port = collector_port;
 288   frm->src_address.as_u32 = src.as_u32;
 289   frm->fib_index = fib_index;
 290   frm->path_mtu = path_mtu;
 291   frm->template_interval = template_interval;
 292
 293   vlib_cli_output (vm, "Collector %U, src address %U, "
 294                            "fib index %d, path MTU %u, "
 295                            "template resend interval %us",
 296                    format_ip4_address, &frm->ipfix_collector,
 297                    format_ip4_address, &frm->src_address,
 298                    fib_index, path_mtu, template_interval);
 299
 300   /* Turn on the flow reporting process */
 301   vlib_process_signal_event (vm, flow_report_process_node.index,
 302                              1, 0);
 303   return 0;
 304 }
 305
 306 VLIB_CLI_COMMAND (set_ipfix_command, static) = {
 307     .path = "set ipfix",
 308     .short_help = "set ipfix collector <ip4-address> "
 309                   "[port <port>] "
 310                   "src <ip4-address> [fib-id <fib-id>] "
 311                   "[path-mtu <path-mtu>] "
 312                   "[template-interval <template-interval>]",
 313     .function = set_ipfix_command_fn,
 314 };
 315
 316 static clib_error_t *
 317 flow_report_init (vlib_main_t *vm)
 318 {
 319   flow_report_main_t * frm = &flow_report_main;
 320
 321   frm->vlib_main = vm;
 322   frm->vnet_main = vnet_get_main();
 323   frm->unix_time_0 = time(0);
 324   frm->vlib_time_0 = vlib_time_now(frm->vlib_main);
 325
 326   return 0;
 327 }
 328
 329 VLIB_INIT_FUNCTION (flow_report_init)