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 int send_template_packet (flow_report_main_t *frm,
  22                           flow_report_t *fr,
  23                           u32 * buffer_indexp)
  24 {
  25   u32 bi0;
  26   vlib_buffer_t * b0;
  27   ip4_ipfix_template_packet_t * tp;
  28   ipfix_message_header_t * h;
  29   ip4_header_t * ip;
  30   udp_header_t * udp;
  31   vlib_main_t * vm = frm->vlib_main;
  32
  33   ASSERT (buffer_indexp);
  34
  35   if (fr->update_rewrite || fr->rewrite == 0)
  36     {
  37       if (frm->ipfix_collector.as_u32 == 0
  38           || frm->src_address.as_u32 == 0)
  39         {
  40           clib_warning ("no collector: disabling flow collector process");
  41           vlib_node_set_state (frm->vlib_main, flow_report_process_node.index,
  42                                VLIB_NODE_STATE_DISABLED);
  43           return -1;
  44         }
  45       vec_free (fr->rewrite);
  46       fr->update_rewrite = 1;
  47     }
  48
  49   if (fr->update_rewrite)
  50     {
  51       fr->rewrite = fr->rewrite_callback (frm, fr,
  52                                           &frm->ipfix_collector,
  53                                           &frm->src_address);
  54       fr->update_rewrite = 0;
  55     }
  56
  57   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
  58     return -1;
  59
  60   b0 = vlib_get_buffer (vm, bi0);
  61
  62   ASSERT (vec_len (fr->rewrite) < VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES);
  63
  64   clib_memcpy (b0->data, fr->rewrite, vec_len (fr->rewrite));
  65   b0->current_data = 0;
  66   b0->current_length = vec_len (fr->rewrite);
  67   b0->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  68   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
  69   vnet_buffer (b0)->sw_if_index[VLIB_TX] = frm->fib_index;
  70
  71   tp = vlib_buffer_get_current (b0);
  72   ip = (ip4_header_t *) &tp->ip4;
  73   udp = (udp_header_t *) (ip+1);
  74   h = (ipfix_message_header_t *)(udp+1);
  75
  76   /* FIXUP: message header export_time */
  77   h->export_time = (u32)
  78     (((f64)frm->unix_time_0) +
  79      (vlib_time_now(frm->vlib_main) - frm->vlib_time_0));
  80   h->export_time = clib_host_to_net_u32(h->export_time);
  81
  82   /* FIXUP: message header sequence_number. Templates do not increase it */
  83   h->sequence_number = clib_host_to_net_u32(fr->sequence_number);
  84
  85   /* FIXUP: udp length */
  86   udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
  87
  88   *buffer_indexp = bi0;
  89
  90   fr->last_template_sent = vlib_time_now (vm);
  91
  92   return 0;
  93 }
  94
  95 static uword
  96 flow_report_process (vlib_main_t * vm,
  97                      vlib_node_runtime_t * rt,
  98                      vlib_frame_t * f)
  99 {
 100   flow_report_main_t * frm = &flow_report_main;
 101   flow_report_t * fr;
 102   u32 ip4_lookup_node_index;
 103   vlib_node_t * ip4_lookup_node;
 104   vlib_frame_t * nf = 0;
 105   u32 template_bi;
 106   u32 * to_next;
 107   int send_template;
 108   f64 now;
 109   int rv;
 110   uword event_type;
 111   uword *event_data = 0;
 112
 113   /* Wait for Godot... */
 114   vlib_process_wait_for_event_or_clock (vm, 1e9);
 115   event_type = vlib_process_get_events (vm, &event_data);
 116   if (event_type != 1)
 117       clib_warning ("bogus kickoff event received, %d", event_type);
 118   vec_reset_length (event_data);
 119
 120   /* Enqueue pkts to ip4-lookup */
 121   ip4_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip4-lookup");
 122   ip4_lookup_node_index = ip4_lookup_node->index;
 123
 124   while (1)
 125     {
 126       vlib_process_suspend (vm, 5.0);
 127
 128       vec_foreach (fr, frm->reports)
 129         {
 130           now = vlib_time_now (vm);
 131
 132           /* Need to send a template packet? */
 133           send_template = now > (fr->last_template_sent + 20.0);
 134           send_template += fr->last_template_sent == 0;
 135           template_bi = ~0;
 136           rv = 0;
 137
 138           if (send_template)
 139             rv = send_template_packet (frm, fr, &template_bi);
 140
 141           if (rv < 0)
 142             continue;
 143
 144           nf = vlib_get_frame_to_node (vm, ip4_lookup_node_index);
 145           nf->n_vectors = 0;
 146           to_next = vlib_frame_vector_args (nf);
 147
 148           if (template_bi != ~0)
 149             {
 150               to_next[0] = template_bi;
 151               to_next++;
 152               nf->n_vectors++;
 153             }
 154
 155           nf = fr->flow_data_callback (frm, fr,
 156                                        nf, to_next, ip4_lookup_node_index);
 157           if (nf)
 158             vlib_put_frame_to_node (vm, ip4_lookup_node_index, nf);
 159         }
 160     }
 161
 162   return 0; /* not so much */
 163 }
 164
 165 VLIB_REGISTER_NODE (flow_report_process_node) = {
 166     .function = flow_report_process,
 167     .type = VLIB_NODE_TYPE_PROCESS,
 168     .name = "flow-report-process",
 169 };
 170
 171 int vnet_flow_report_add_del (flow_report_main_t *frm,
 172                               vnet_flow_report_add_del_args_t *a)
 173 {
 174   int i;
 175   int found_index = ~0;
 176   flow_report_t *fr;
 177
 178   for (i = 0; i < vec_len(frm->reports); i++)
 179     {
 180       fr = vec_elt_at_index (frm->reports, i);
 181       if (fr->opaque == a->opaque
 182           && fr->rewrite_callback == a->rewrite_callback
 183           && fr->flow_data_callback == a->flow_data_callback)
 184         {
 185           found_index = i;
 186           break;
 187         }
 188     }
 189
 190   if (a->is_add == 0)
 191     {
 192       if (found_index != ~0)
 193         {
 194           vec_delete (frm->reports, 1, found_index);
 195           return 0;
 196         }
 197       return VNET_API_ERROR_NO_SUCH_ENTRY;
 198     }
 199
 200   vec_add2 (frm->reports, fr, 1);
 201
 202   fr->sequence_number = 0;
 203   fr->domain_id = a->domain_id;
 204   fr->update_rewrite = 1;
 205   fr->opaque = a->opaque;
 206   fr->rewrite_callback = a->rewrite_callback;
 207   fr->flow_data_callback = a->flow_data_callback;
 208
 209   return 0;
 210 }
 211
 212 static clib_error_t *
 213 set_ipfix_command_fn (vlib_main_t * vm,
 214                  unformat_input_t * input,
 215                  vlib_cli_command_t * cmd)
 216 {
 217   flow_report_main_t * frm = &flow_report_main;
 218   ip4_address_t collector, src;
 219   u32 fib_id;
 220   u32 fib_index = ~0;
 221
 222   collector.as_u32 = 0;
 223   src.as_u32 = 0;
 224
 225   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
 226     if (unformat (input, "collector %U", unformat_ip4_address, &collector))
 227       ;
 228     else if (unformat (input, "src %U", unformat_ip4_address, &src))
 229       ;
 230     else if (unformat (input, "fib-id %u", &fib_id))
 231       {
 232         ip4_main_t * im = &ip4_main;
 233         uword * p = hash_get (im->fib_index_by_table_id, fib_id);
 234         if (! p)
 235           return clib_error_return (0, "fib ID %d doesn't exist\n",
 236                                     fib_id);
 237         fib_index = p[0];
 238       }
 239     else
 240       break;
 241   }
 242
 243   if (collector.as_u32 == 0)
 244     return clib_error_return (0, "collector address required");
 245
 246   if (src.as_u32 == 0)
 247     return clib_error_return (0, "src address required");
 248
 249   frm->ipfix_collector.as_u32 = collector.as_u32;
 250   frm->src_address.as_u32 = src.as_u32;
 251   frm->fib_index = fib_index;
 252
 253   vlib_cli_output (vm, "Collector %U, src address %U, fib index %d",
 254                    format_ip4_address, &frm->ipfix_collector,
 255                    format_ip4_address, &frm->src_address, fib_index);
 256
 257   /* Turn on the flow reporting process */
 258   vlib_process_signal_event (vm, flow_report_process_node.index,
 259                              1, 0);
 260   return 0;
 261 }
 262
 263 VLIB_CLI_COMMAND (set_ipfix_command, static) = {
 264     .path = "set ipfix",
 265     .short_help = "set ipfix collector <ip4-address> "
 266                   "src <ip4-address> [fib-id <fib-id>]",
 267     .function = set_ipfix_command_fn,
 268 };
 269
 270 static clib_error_t *
 271 flow_report_init (vlib_main_t *vm)
 272 {
 273   flow_report_main_t * frm = &flow_report_main;
 274
 275   frm->vlib_main = vm;
 276   frm->vnet_main = vnet_get_main();
 277   frm->unix_time_0 = time(0);
 278   frm->vlib_time_0 = vlib_time_now(frm->vlib_main);
 279
 280   return 0;
 281 }
 282
 283 VLIB_INIT_FUNCTION (flow_report_init)