src/plugins/acl/dataplane_node.c

   1 /*
   2  * Copyright (c) 2016-2018 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 #include <stddef.h>
  16 #include <netinet/in.h>
  17
  18 #include <vlib/vlib.h>
  19 #include <vnet/vnet.h>
  20 #include <vnet/pg/pg.h>
  21 #include <vppinfra/error.h>
  22
  23
  24 #include <acl/acl.h>
  25 #include <vnet/ip/icmp46_packet.h>
  26
  27 #include <plugins/acl/fa_node.h>
  28 #include <plugins/acl/acl.h>
  29 #include <plugins/acl/lookup_context.h>
  30 #include <plugins/acl/public_inlines.h>
  31 #include <plugins/acl/session_inlines.h>
  32
  33 #include <vppinfra/bihash_40_8.h>
  34 #include <vppinfra/bihash_template.h>
  35
  36 typedef struct
  37 {
  38   u32 next_index;
  39   u32 sw_if_index;
  40   u32 lc_index;
  41   u32 match_acl_in_index;
  42   u32 match_rule_index;
  43   u64 packet_info[6];
  44   u32 trace_bitmap;
  45   u8 action;
  46 } acl_fa_trace_t;
  47
  48 /* *INDENT-OFF* */
  49 #define foreach_acl_fa_error \
  50 _(ACL_DROP, "ACL deny packets")  \
  51 _(ACL_PERMIT, "ACL permit packets")  \
  52 _(ACL_NEW_SESSION, "new sessions added") \
  53 _(ACL_EXIST_SESSION, "existing session packets") \
  54 _(ACL_CHECK, "checked packets") \
  55 _(ACL_RESTART_SESSION_TIMER, "restart session timer") \
  56 _(ACL_TOO_MANY_SESSIONS, "too many sessions to add new") \
  57 /* end  of errors */
  58
  59 typedef enum
  60 {
  61 #define _(sym,str) ACL_FA_ERROR_##sym,
  62   foreach_acl_fa_error
  63 #undef _
  64     ACL_FA_N_ERROR,
  65 } acl_fa_error_t;
  66
  67 /* *INDENT-ON* */
  68
  69 typedef struct
  70 {
  71   u32 next_index;
  72   u32 sw_if_index;
  73   u16 ethertype;
  74 } nonip_in_out_trace_t;
  75
  76 /* packet trace format function */
  77 static u8 *
  78 format_nonip_in_out_trace (u8 * s, u32 is_output, va_list * args)
  79 {
  80   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  81   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  82   nonip_in_out_trace_t *t = va_arg (*args, nonip_in_out_trace_t *);
  83
  84   s = format (s, "%s: sw_if_index %d next_index %x ethertype %x",
  85               is_output ? "OUT-ETHER-WHITELIST" : "IN-ETHER-WHITELIST",
  86               t->sw_if_index, t->next_index, t->ethertype);
  87   return s;
  88 }
  89
  90 static u8 *
  91 format_l2_nonip_in_trace (u8 * s, va_list * args)
  92 {
  93   return format_nonip_in_out_trace (s, 0, args);
  94 }
  95
  96 static u8 *
  97 format_l2_nonip_out_trace (u8 * s, va_list * args)
  98 {
  99   return format_nonip_in_out_trace (s, 1, args);
 100 }
 101
 102 #define foreach_nonip_in_error                    \
 103 _(DROP, "dropped inbound non-whitelisted non-ip packets") \
 104 _(PERMIT, "permitted inbound whitelisted non-ip packets") \
 105
 106
 107 #define foreach_nonip_out_error                    \
 108 _(DROP, "dropped outbound non-whitelisted non-ip packets") \
 109 _(PERMIT, "permitted outbound whitelisted non-ip packets") \
 110
 111
 112 /* *INDENT-OFF* */
 113
 114 typedef enum
 115 {
 116 #define _(sym,str) FA_IN_NONIP_ERROR_##sym,
 117   foreach_nonip_in_error
 118 #undef _
 119     FA_IN_NONIP_N_ERROR,
 120 } l2_in_feat_arc_error_t;
 121
 122 static char *fa_in_nonip_error_strings[] = {
 123 #define _(sym,string) string,
 124   foreach_nonip_in_error
 125 #undef _
 126 };
 127
 128 typedef enum
 129 {
 130 #define _(sym,str) FA_OUT_NONIP_ERROR_##sym,
 131   foreach_nonip_out_error
 132 #undef _
 133     FA_OUT_NONIP_N_ERROR,
 134 } l2_out_feat_arc_error_t;
 135
 136 static char *fa_out_nonip_error_strings[] = {
 137 #define _(sym,string) string,
 138   foreach_nonip_out_error
 139 #undef _
 140 };
 141 /* *INDENT-ON* */
 142
 143
 144 always_inline int
 145 is_permitted_ethertype (acl_main_t * am, int sw_if_index0, int is_output,
 146                         u16 ethertype)
 147 {
 148   u16 **v = is_output
 149     ? am->output_etype_whitelist_by_sw_if_index
 150     : am->input_etype_whitelist_by_sw_if_index;
 151   u16 *whitelist = vec_elt (v, sw_if_index0);
 152   int i;
 153
 154   if (vec_len (whitelist) == 0)
 155     return 1;
 156
 157   for (i = 0; i < vec_len (whitelist); i++)
 158     if (whitelist[i] == ethertype)
 159       return 1;
 160   return 0;
 161 }
 162
 163 #define get_u16(addr) ( *((u16 *)(addr)) )
 164
 165 always_inline uword
 166 nonip_in_out_node_fn (vlib_main_t * vm,
 167                       vlib_node_runtime_t * node, vlib_frame_t * frame,
 168                       int is_output)
 169 {
 170   acl_main_t *am = &acl_main;
 171   u32 n_left, *from;
 172   u16 nexts[VLIB_FRAME_SIZE], *next;
 173   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
 174   vlib_node_runtime_t *error_node;
 175
 176   from = vlib_frame_vector_args (frame);
 177   error_node = vlib_node_get_runtime (vm, node->node_index);
 178   vlib_get_buffers (vm, from, bufs, frame->n_vectors);
 179   /* set the initial values for the current buffer the next pointers */
 180   b = bufs;
 181   next = nexts;
 182
 183   n_left = frame->n_vectors;
 184   while (n_left > 0)
 185     {
 186       u32 next_index = 0;
 187       u32 sw_if_index0 =
 188         vnet_buffer (b[0])->sw_if_index[is_output ? VLIB_TX : VLIB_RX];
 189       u16 ethertype = 0;
 190
 191       int error0 = 0;
 192
 193       ethernet_header_t *h0 = vlib_buffer_get_current (b[0]);
 194       u8 *l3h0 = (u8 *) h0 + vnet_buffer (b[0])->l2.l2_len;
 195       ethertype = clib_net_to_host_u16 (get_u16 (l3h0 - 2));
 196
 197       if (is_permitted_ethertype (am, sw_if_index0, is_output, ethertype))
 198         vnet_feature_next (&next_index, b[0]);
 199
 200       next[0] = next_index;
 201
 202       if (0 == next[0])
 203         b[0]->error = error_node->errors[error0];
 204
 205       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
 206                          && (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
 207         {
 208           nonip_in_out_trace_t *t =
 209             vlib_add_trace (vm, node, b[0], sizeof (*t));
 210           t->sw_if_index = sw_if_index0;
 211           t->ethertype = ethertype;
 212           t->next_index = next[0];
 213         }
 214       next[0] = next[0] < node->n_next_nodes ? next[0] : 0;
 215
 216       next++;
 217       b++;
 218       n_left--;
 219     }
 220   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
 221
 222   return frame->n_vectors;
 223 }
 224
 225 VLIB_NODE_FN (acl_in_nonip_node) (vlib_main_t * vm,
 226                                   vlib_node_runtime_t * node,
 227                                   vlib_frame_t * frame)
 228 {
 229   return nonip_in_out_node_fn (vm, node, frame, 0);
 230 }
 231
 232 VLIB_NODE_FN (acl_out_nonip_node) (vlib_main_t * vm,
 233                                    vlib_node_runtime_t * node,
 234                                    vlib_frame_t * frame)
 235 {
 236   return nonip_in_out_node_fn (vm, node, frame, 1);
 237 }
 238
 239
 240 /* *INDENT-OFF* */
 241
 242 VLIB_REGISTER_NODE (acl_in_nonip_node) =
 243 {
 244   .name = "acl-plugin-in-nonip-l2",
 245   .vector_size = sizeof (u32),
 246   .format_trace = format_l2_nonip_in_trace,
 247   .type = VLIB_NODE_TYPE_INTERNAL,
 248   .n_errors = ARRAY_LEN (fa_in_nonip_error_strings),
 249   .error_strings = fa_in_nonip_error_strings,
 250   .n_next_nodes = ACL_FA_N_NEXT,
 251   .next_nodes =
 252   {
 253     [ACL_FA_ERROR_DROP] = "error-drop",
 254   }
 255 };
 256
 257 VNET_FEATURE_INIT (acl_in_l2_nonip_fa_feature, static) =
 258 {
 259   .arc_name = "l2-input-nonip",
 260   .node_name = "acl-plugin-in-nonip-l2",
 261   .runs_before = VNET_FEATURES ("l2-input-feat-arc-end"),
 262 };
 263
 264 VLIB_REGISTER_NODE (acl_out_nonip_node) =
 265 {
 266   .name = "acl-plugin-out-nonip-l2",
 267   .vector_size = sizeof (u32),
 268   .format_trace = format_l2_nonip_out_trace,
 269   .type = VLIB_NODE_TYPE_INTERNAL,
 270   .n_errors = ARRAY_LEN (fa_out_nonip_error_strings),
 271   .error_strings = fa_out_nonip_error_strings,
 272   .n_next_nodes = ACL_FA_N_NEXT,
 273   .next_nodes =
 274   {
 275     [ACL_FA_ERROR_DROP] = "error-drop",
 276   }
 277 };
 278
 279 VNET_FEATURE_INIT (acl_out_l2_nonip_fa_feature, static) =
 280 {
 281   .arc_name = "l2-output-nonip",
 282   .node_name = "acl-plugin-out-nonip-l2",
 283   .runs_before = VNET_FEATURES ("l2-output-feat-arc-end"),
 284 };
 285
 286 /* *INDENT-ON* */
 287
 288
 289
 290 always_inline u16
 291 get_current_policy_epoch (acl_main_t * am, int is_input, u32 sw_if_index0)
 292 {
 293   u32 **p_epoch_vec =
 294     is_input ? &am->input_policy_epoch_by_sw_if_index :
 295     &am->output_policy_epoch_by_sw_if_index;
 296   u16 current_policy_epoch =
 297     sw_if_index0 < vec_len (*p_epoch_vec) ? vec_elt (*p_epoch_vec,
 298                                                      sw_if_index0)
 299     : (is_input * FA_POLICY_EPOCH_IS_INPUT);
 300   return current_policy_epoch;
 301 }
 302
 303 always_inline void
 304 maybe_trace_buffer (vlib_main_t * vm, vlib_node_runtime_t * node,
 305                     vlib_buffer_t * b, u32 sw_if_index0, u32 lc_index0,
 306                     u16 next0, int match_acl_in_index, int match_rule_index,
 307                     fa_5tuple_t * fa_5tuple, u8 action, u32 trace_bitmap)
 308 {
 309   if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
 310     {
 311       acl_fa_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
 312       t->sw_if_index = sw_if_index0;
 313       t->lc_index = lc_index0;
 314       t->next_index = next0;
 315       t->match_acl_in_index = match_acl_in_index;
 316       t->match_rule_index = match_rule_index;
 317       t->packet_info[0] = fa_5tuple->kv_40_8.key[0];
 318       t->packet_info[1] = fa_5tuple->kv_40_8.key[1];
 319       t->packet_info[2] = fa_5tuple->kv_40_8.key[2];
 320       t->packet_info[3] = fa_5tuple->kv_40_8.key[3];
 321       t->packet_info[4] = fa_5tuple->kv_40_8.key[4];
 322       t->packet_info[5] = fa_5tuple->kv_40_8.value;
 323       t->action = action;
 324       t->trace_bitmap = trace_bitmap;
 325     }
 326 }
 327
 328
 329 always_inline int
 330 stale_session_deleted (acl_main_t * am, int is_input,
 331                        acl_fa_per_worker_data_t * pw, u64 now,
 332                        u32 sw_if_index0, fa_full_session_id_t f_sess_id)
 333 {
 334   u16 current_policy_epoch =
 335     get_current_policy_epoch (am, is_input, sw_if_index0);
 336
 337   /* if the MSB of policy epoch matches but not the LSB means it is a stale session */
 338   if ((0 ==
 339        ((current_policy_epoch ^
 340          f_sess_id.intf_policy_epoch) &
 341         FA_POLICY_EPOCH_IS_INPUT))
 342       && (current_policy_epoch != f_sess_id.intf_policy_epoch))
 343     {
 344       /* delete session and increment the counter */
 345       vec_validate (pw->fa_session_epoch_change_by_sw_if_index, sw_if_index0);
 346       vec_elt (pw->fa_session_epoch_change_by_sw_if_index, sw_if_index0)++;
 347       if (acl_fa_conn_list_delete_session (am, f_sess_id, now))
 348         {
 349           /* delete the session only if we were able to unlink it */
 350           acl_fa_two_stage_delete_session (am, sw_if_index0, f_sess_id, now);
 351         }
 352       return 1;
 353     }
 354   else
 355     return 0;
 356 }
 357
 358
 359
 360
 361
 362 always_inline void
 363 get_sw_if_index_xN (int vector_sz, int is_input, vlib_buffer_t ** b,
 364                     u32 * out_sw_if_index)
 365 {
 366   int ii;
 367   for (ii = 0; ii < vector_sz; ii++)
 368     if (is_input)
 369       out_sw_if_index[ii] = vnet_buffer (b[ii])->sw_if_index[VLIB_RX];
 370     else
 371       out_sw_if_index[ii] = vnet_buffer (b[ii])->sw_if_index[VLIB_TX];
 372 }
 373
 374 always_inline void
 375 fill_5tuple_xN (int vector_sz, acl_main_t * am, int is_ip6, int is_input,
 376                 int is_l2_path, vlib_buffer_t ** b, u32 * sw_if_index,
 377                 fa_5tuple_t * out_fa_5tuple)
 378 {
 379   int ii;
 380   for (ii = 0; ii < vector_sz; ii++)
 381     acl_fill_5tuple (am, sw_if_index[ii], b[ii], is_ip6,
 382                      is_input, is_l2_path, &out_fa_5tuple[ii]);
 383 }
 384
 385 always_inline void
 386 make_session_hash_xN (int vector_sz, acl_main_t * am, int is_ip6,
 387                       u32 * sw_if_index, fa_5tuple_t * fa_5tuple,
 388                       u64 * out_hash)
 389 {
 390   int ii;
 391   for (ii = 0; ii < vector_sz; ii++)
 392     out_hash[ii] =
 393       acl_fa_make_session_hash (am, is_ip6, sw_if_index[ii], &fa_5tuple[ii]);
 394 }
 395
 396 always_inline void
 397 prefetch_session_entry (acl_main_t * am, fa_full_session_id_t f_sess_id)
 398 {
 399   fa_session_t *sess = get_session_ptr_no_check (am, f_sess_id.thread_index,
 400                                                  f_sess_id.session_index);
 401   CLIB_PREFETCH (sess, 2 * CLIB_CACHE_LINE_BYTES, STORE);
 402 }
 403
 404 always_inline u8
 405 process_established_session (vlib_main_t * vm, acl_main_t * am,
 406                              u32 counter_node_index, int is_input, u64 now,
 407                              fa_full_session_id_t f_sess_id,
 408                              u32 * sw_if_index, fa_5tuple_t * fa_5tuple,
 409                              u32 pkt_len, int node_trace_on,
 410                              u32 * trace_bitmap)
 411 {
 412   u8 action = 0;
 413   fa_session_t *sess = get_session_ptr_no_check (am, f_sess_id.thread_index,
 414                                                  f_sess_id.session_index);
 415
 416   int old_timeout_type = fa_session_get_timeout_type (am, sess);
 417   action =
 418     acl_fa_track_session (am, is_input, sw_if_index[0], now,
 419                           sess, &fa_5tuple[0], pkt_len);
 420   int new_timeout_type = fa_session_get_timeout_type (am, sess);
 421   /* Tracking might have changed the session timeout type, e.g. from transient to established */
 422   if (PREDICT_FALSE (old_timeout_type != new_timeout_type))
 423     {
 424       acl_fa_restart_timer_for_session (am, now, f_sess_id);
 425       vlib_node_increment_counter (vm, counter_node_index,
 426                                    ACL_FA_ERROR_ACL_RESTART_SESSION_TIMER, 1);
 427       if (node_trace_on)
 428         *trace_bitmap |=
 429           0x00010000 + ((0xff & old_timeout_type) << 8) +
 430           (0xff & new_timeout_type);
 431     }
 432   /*
 433    * I estimate the likelihood to be very low - the VPP needs
 434    * to have >64K interfaces to start with and then on
 435    * exactly 64K indices apart needs to be exactly the same
 436    * 5-tuple... Anyway, since this probability is nonzero -
 437    * print an error and drop the unlucky packet.
 438    * If this shows up in real world, we would need to bump
 439    * the hash key length.
 440    */
 441   if (PREDICT_FALSE (sess->sw_if_index != sw_if_index[0]))
 442     {
 443       clib_warning
 444         ("BUG: session LSB16(sw_if_index)=%d and 5-tuple=%d collision!",
 445          sess->sw_if_index, sw_if_index[0]);
 446       action = 0;
 447     }
 448   return action;
 449
 450 }
 451
 452 #define ACL_PLUGIN_VECTOR_SIZE 4
 453 #define ACL_PLUGIN_PREFETCH_GAP 3
 454
 455 always_inline void
 456 acl_fa_node_common_prepare_fn (vlib_main_t * vm,
 457                                vlib_node_runtime_t * node,
 458                                vlib_frame_t * frame, int is_ip6, int is_input,
 459                                int is_l2_path, int with_stateful_datapath)
 460         /* , int node_trace_on,
 461            int reclassify_sessions) */
 462 {
 463   u32 n_left, *from;
 464   acl_main_t *am = &acl_main;
 465   uword thread_index = os_get_thread_index ();
 466   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 467
 468   vlib_buffer_t **b;
 469   u32 *sw_if_index;
 470   fa_5tuple_t *fa_5tuple;
 471   u64 *hash;
 472
 473
 474
 475   from = vlib_frame_vector_args (frame);
 476   vlib_get_buffers (vm, from, pw->bufs, frame->n_vectors);
 477
 478   /* set the initial values for the current buffer the next pointers */
 479   b = pw->bufs;
 480   sw_if_index = pw->sw_if_indices;
 481   fa_5tuple = pw->fa_5tuples;
 482   hash = pw->hashes;
 483
 484
 485   /*
 486    * fill the sw_if_index, 5tuple and session hash,
 487    * First in strides of size ACL_PLUGIN_VECTOR_SIZE,
 488    * with buffer prefetch being
 489    * ACL_PLUGIN_PREFETCH_GAP * ACL_PLUGIN_VECTOR_SIZE entries
 490    * in front. Then with a simple single loop.
 491    */
 492
 493   n_left = frame->n_vectors;
 494   while (n_left >= (ACL_PLUGIN_PREFETCH_GAP + 1) * ACL_PLUGIN_VECTOR_SIZE)
 495     {
 496       const int vec_sz = ACL_PLUGIN_VECTOR_SIZE;
 497       {
 498         int ii;
 499         for (ii = ACL_PLUGIN_PREFETCH_GAP * vec_sz;
 500              ii < (ACL_PLUGIN_PREFETCH_GAP + 1) * vec_sz; ii++)
 501           {
 502             CLIB_PREFETCH (b[ii], CLIB_CACHE_LINE_BYTES, LOAD);
 503             CLIB_PREFETCH (b[ii]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 504           }
 505       }
 506
 507
 508       get_sw_if_index_xN (vec_sz, is_input, b, sw_if_index);
 509       fill_5tuple_xN (vec_sz, am, is_ip6, is_input, is_l2_path, &b[0],
 510                       &sw_if_index[0], &fa_5tuple[0]);
 511       if (with_stateful_datapath)
 512         make_session_hash_xN (vec_sz, am, is_ip6, &sw_if_index[0],
 513                               &fa_5tuple[0], &hash[0]);
 514
 515       n_left -= vec_sz;
 516
 517       fa_5tuple += vec_sz;
 518       b += vec_sz;
 519       sw_if_index += vec_sz;
 520       hash += vec_sz;
 521     }
 522
 523   while (n_left > 0)
 524     {
 525       const int vec_sz = 1;
 526
 527       get_sw_if_index_xN (vec_sz, is_input, b, sw_if_index);
 528       fill_5tuple_xN (vec_sz, am, is_ip6, is_input, is_l2_path, &b[0],
 529                       &sw_if_index[0], &fa_5tuple[0]);
 530       if (with_stateful_datapath)
 531         make_session_hash_xN (vec_sz, am, is_ip6, &sw_if_index[0],
 532                               &fa_5tuple[0], &hash[0]);
 533
 534       n_left -= vec_sz;
 535
 536       fa_5tuple += vec_sz;
 537       b += vec_sz;
 538       sw_if_index += vec_sz;
 539       hash += vec_sz;
 540     }
 541 }
 542
 543
 544 always_inline uword
 545 acl_fa_inner_node_fn (vlib_main_t * vm,
 546                       vlib_node_runtime_t * node, vlib_frame_t * frame,
 547                       int is_ip6, int is_input, int is_l2_path,
 548                       int with_stateful_datapath, int node_trace_on,
 549                       int reclassify_sessions)
 550 {
 551   u32 n_left, *from;
 552   u32 pkts_exist_session = 0;
 553   u32 pkts_new_session = 0;
 554   u32 pkts_acl_permit = 0;
 555   u32 trace_bitmap = 0;
 556   acl_main_t *am = &acl_main;
 557   vlib_node_runtime_t *error_node;
 558   vlib_error_t no_error_existing_session;
 559   u64 now = clib_cpu_time_now ();
 560   uword thread_index = os_get_thread_index ();
 561   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 562
 563   u16 *next;
 564   vlib_buffer_t **b;
 565   u32 *sw_if_index;
 566   fa_5tuple_t *fa_5tuple;
 567   u64 *hash;
 568
 569   from = vlib_frame_vector_args (frame);
 570   error_node = vlib_node_get_runtime (vm, node->node_index);
 571   no_error_existing_session =
 572     error_node->errors[ACL_FA_ERROR_ACL_EXIST_SESSION];
 573
 574   b = pw->bufs;
 575   next = pw->nexts;
 576   sw_if_index = pw->sw_if_indices;
 577   fa_5tuple = pw->fa_5tuples;
 578   hash = pw->hashes;
 579
 580   /*
 581    * Now the "hard" work of session lookups and ACL lookups for new sessions.
 582    * Due to the complexity, do it for the time being in single loop with
 583    * the pipeline of three prefetches:
 584    *    1) bucket for the session bihash
 585    *    2) data for the session bihash
 586    *    3) worker session record
 587    */
 588
 589   fa_full_session_id_t f_sess_id_next = {.as_u64 = ~0ULL };
 590
 591   /* find the "next" session so we can kickstart the pipeline */
 592   if (with_stateful_datapath)
 593     acl_fa_find_session_with_hash (am, is_ip6, sw_if_index[0], hash[0],
 594                                    &fa_5tuple[0], &f_sess_id_next.as_u64);
 595
 596   n_left = frame->n_vectors;
 597   while (n_left > 0)
 598     {
 599       u8 action = 0;
 600       u32 lc_index0 = ~0;
 601       int acl_check_needed = 1;
 602       u32 match_acl_in_index = ~0;
 603       u32 match_acl_pos = ~0;
 604       u32 match_rule_index = ~0;
 605
 606       next[0] = 0;              /* drop by default */
 607
 608       /* Try to match an existing session first */
 609
 610       if (with_stateful_datapath)
 611         {
 612           fa_full_session_id_t f_sess_id = f_sess_id_next;
 613           switch (n_left)
 614             {
 615             default:
 616               acl_fa_prefetch_session_bucket_for_hash (am, is_ip6, hash[5]);
 617               /* fallthrough */
 618             case 5:
 619             case 4:
 620               acl_fa_prefetch_session_data_for_hash (am, is_ip6, hash[3]);
 621               /* fallthrough */
 622             case 3:
 623             case 2:
 624               acl_fa_find_session_with_hash (am, is_ip6, sw_if_index[1],
 625                                              hash[1], &fa_5tuple[1],
 626                                              &f_sess_id_next.as_u64);
 627               if (f_sess_id_next.as_u64 != ~0ULL)
 628                 {
 629                   prefetch_session_entry (am, f_sess_id_next);
 630                 }
 631               /* fallthrough */
 632             case 1:
 633               if (f_sess_id.as_u64 != ~0ULL)
 634                 {
 635                   if (node_trace_on)
 636                     {
 637                       trace_bitmap |= 0x80000000;
 638                     }
 639                   ASSERT (f_sess_id.thread_index < vec_len (vlib_mains));
 640                   b[0]->error = no_error_existing_session;
 641                   acl_check_needed = 0;
 642                   pkts_exist_session += 1;
 643                   action =
 644                     process_established_session (vm, am, node->node_index,
 645                                                  is_input, now, f_sess_id,
 646                                                  &sw_if_index[0],
 647                                                  &fa_5tuple[0],
 648                                                  b[0]->current_length,
 649                                                  node_trace_on,
 650                                                  &trace_bitmap);
 651
 652                   /* expose the session id to the tracer */
 653                   if (node_trace_on)
 654                     {
 655                       match_rule_index = f_sess_id.session_index;
 656                     }
 657
 658                   if (reclassify_sessions)
 659                     {
 660                       if (PREDICT_FALSE
 661                           (stale_session_deleted
 662                            (am, is_input, pw, now, sw_if_index[0],
 663                             f_sess_id)))
 664                         {
 665                           acl_check_needed = 1;
 666                           if (node_trace_on)
 667                             {
 668                               trace_bitmap |= 0x40000000;
 669                             }
 670                           /*
 671                            * If we have just deleted the session, and the next
 672                            * buffer is the same 5-tuple, that session prediction
 673                            * is wrong, correct it.
 674                            */
 675                           if ((f_sess_id_next.as_u64 != ~0ULL)
 676                               && 0 == memcmp (&fa_5tuple[1], &fa_5tuple[0],
 677                                               sizeof (fa_5tuple[1])))
 678                             f_sess_id_next.as_u64 = ~0ULL;
 679                         }
 680                     }
 681                 }
 682             }
 683
 684           if (acl_check_needed)
 685             {
 686               if (is_input)
 687                 lc_index0 = am->input_lc_index_by_sw_if_index[sw_if_index[0]];
 688               else
 689                 lc_index0 =
 690                   am->output_lc_index_by_sw_if_index[sw_if_index[0]];
 691
 692               action = 0;       /* deny by default */
 693               acl_plugin_match_5tuple_inline (am, lc_index0,
 694                                               (fa_5tuple_opaque_t *) &
 695                                               fa_5tuple[0], is_ip6, &action,
 696                                               &match_acl_pos,
 697                                               &match_acl_in_index,
 698                                               &match_rule_index,
 699                                               &trace_bitmap);
 700               b[0]->error = error_node->errors[action];
 701
 702               if (1 == action)
 703                 pkts_acl_permit++;
 704
 705               if (2 == action)
 706                 {
 707                   if (!acl_fa_can_add_session (am, is_input, sw_if_index[0]))
 708                     acl_fa_try_recycle_session (am, is_input,
 709                                                 thread_index,
 710                                                 sw_if_index[0], now);
 711
 712                   if (acl_fa_can_add_session (am, is_input, sw_if_index[0]))
 713                     {
 714                       u16 current_policy_epoch =
 715                         get_current_policy_epoch (am, is_input,
 716                                                   sw_if_index[0]);
 717                       fa_full_session_id_t f_sess_id =
 718                         acl_fa_add_session (am, is_input, is_ip6,
 719                                             sw_if_index[0],
 720                                             now, &fa_5tuple[0],
 721                                             current_policy_epoch);
 722
 723                       /* perform the accounting for the newly added session */
 724                       process_established_session (vm, am,
 725                                                    node->node_index,
 726                                                    is_input, now,
 727                                                    f_sess_id,
 728                                                    &sw_if_index[0],
 729                                                    &fa_5tuple[0],
 730                                                    b[0]->current_length,
 731                                                    node_trace_on,
 732                                                    &trace_bitmap);
 733                       pkts_new_session++;
 734                       /*
 735                        * If the next 5tuple is the same and we just added the session,
 736                        * the f_sess_id_next can not be ~0. Correct it.
 737                        */
 738                       if ((f_sess_id_next.as_u64 == ~0ULL)
 739                           && 0 == memcmp (&fa_5tuple[1], &fa_5tuple[0],
 740                                           sizeof (fa_5tuple[1])))
 741                         f_sess_id_next = f_sess_id;
 742                     }
 743                   else
 744                     {
 745                       action = 0;
 746                       b[0]->error =
 747                         error_node->errors
 748                         [ACL_FA_ERROR_ACL_TOO_MANY_SESSIONS];
 749                     }
 750                 }
 751
 752             }
 753
 754           {
 755             u32 next0;
 756             /* speculatively get the next0 */
 757             vnet_feature_next (&next0, b[0]);
 758             /* if the action is not deny - then use that next */
 759             next[0] = action ? next0 : 0;
 760           }
 761
 762           if (node_trace_on)    // PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
 763             {
 764               maybe_trace_buffer (vm, node, b[0], sw_if_index[0], lc_index0,
 765                                   next[0], match_acl_in_index,
 766                                   match_rule_index, &fa_5tuple[0], action,
 767                                   trace_bitmap);
 768             }
 769
 770           next++;
 771           b++;
 772           fa_5tuple++;
 773           sw_if_index++;
 774           hash++;
 775           n_left -= 1;
 776         }
 777     }
 778
 779   vlib_buffer_enqueue_to_next (vm, node, from, pw->nexts, frame->n_vectors);
 780
 781   vlib_node_increment_counter (vm, node->node_index,
 782                                ACL_FA_ERROR_ACL_CHECK, frame->n_vectors);
 783   vlib_node_increment_counter (vm, node->node_index,
 784                                ACL_FA_ERROR_ACL_EXIST_SESSION,
 785                                pkts_exist_session);
 786   vlib_node_increment_counter (vm, node->node_index,
 787                                ACL_FA_ERROR_ACL_NEW_SESSION,
 788                                pkts_new_session);
 789   vlib_node_increment_counter (vm, node->node_index,
 790                                ACL_FA_ERROR_ACL_PERMIT, pkts_acl_permit);
 791   return frame->n_vectors;
 792 }
 793
 794 always_inline uword
 795 acl_fa_outer_node_fn (vlib_main_t * vm,
 796                       vlib_node_runtime_t * node, vlib_frame_t * frame,
 797                       int is_ip6, int is_input, int is_l2_path,
 798                       int do_stateful_datapath)
 799 {
 800   acl_main_t *am = &acl_main;
 801
 802   acl_fa_node_common_prepare_fn (vm, node, frame, is_ip6, is_input,
 803                                  is_l2_path, do_stateful_datapath);
 804
 805   if (am->reclassify_sessions)
 806     {
 807       if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
 808         return acl_fa_inner_node_fn (vm, node, frame, is_ip6, is_input,
 809                                      is_l2_path, do_stateful_datapath,
 810                                      1 /* trace */ ,
 811                                      1 /* reclassify */ );
 812       else
 813         return acl_fa_inner_node_fn (vm, node, frame, is_ip6, is_input,
 814                                      is_l2_path, do_stateful_datapath, 0,
 815                                      1 /* reclassify */ );
 816     }
 817   else
 818     {
 819       if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
 820         return acl_fa_inner_node_fn (vm, node, frame, is_ip6, is_input,
 821                                      is_l2_path, do_stateful_datapath,
 822                                      1 /* trace */ ,
 823                                      0);
 824       else
 825         return acl_fa_inner_node_fn (vm, node, frame, is_ip6, is_input,
 826                                      is_l2_path, do_stateful_datapath, 0, 0);
 827     }
 828 }
 829
 830 always_inline uword
 831 acl_fa_node_fn (vlib_main_t * vm,
 832                 vlib_node_runtime_t * node, vlib_frame_t * frame, int is_ip6,
 833                 int is_input, int is_l2_path)
 834 {
 835   /* select the reclassify/no-reclassify version of the datapath */
 836   acl_main_t *am = &acl_main;
 837
 838   if (am->fa_sessions_hash_is_initialized)
 839     return acl_fa_outer_node_fn (vm, node, frame, is_ip6, is_input,
 840                                  is_l2_path, 1);
 841   else
 842     return acl_fa_outer_node_fn (vm, node, frame, is_ip6, is_input,
 843                                  is_l2_path, 0);
 844 }
 845
 846
 847 static u8 *
 848 format_fa_5tuple (u8 * s, va_list * args)
 849 {
 850   fa_5tuple_t *p5t = va_arg (*args, fa_5tuple_t *);
 851   void *paddr0;
 852   void *paddr1;
 853   void *format_address_func;
 854   void *ip_af;
 855   void *ip_frag_txt =
 856     p5t->pkt.is_nonfirst_fragment ? " non-initial fragment" : "";
 857
 858   if (p5t->pkt.is_ip6)
 859     {
 860       ip_af = "ip6";
 861       format_address_func = format_ip6_address;
 862       paddr0 = &p5t->ip6_addr[0];
 863       paddr1 = &p5t->ip6_addr[1];
 864     }
 865   else
 866     {
 867       ip_af = "ip4";
 868       format_address_func = format_ip4_address;
 869       paddr0 = &p5t->ip4_addr[0];
 870       paddr1 = &p5t->ip4_addr[1];
 871     }
 872
 873   s =
 874     format (s, "lc_index %d l3 %s%s ", p5t->pkt.lc_index, ip_af, ip_frag_txt);
 875   s =
 876     format (s, "%U -> %U ", format_address_func, paddr0, format_address_func,
 877             paddr1);
 878   s = format (s, "%U ", format_fa_session_l4_key, &p5t->l4);
 879   s = format (s, "tcp flags (%s) %02x rsvd %x",
 880               p5t->pkt.tcp_flags_valid ? "valid" : "invalid",
 881               p5t->pkt.tcp_flags, p5t->pkt.flags_reserved);
 882   return s;
 883 }
 884
 885 #ifndef CLIB_MARCH_VARIANT
 886 u8 *
 887 format_acl_plugin_5tuple (u8 * s, va_list * args)
 888 {
 889   return format_fa_5tuple (s, args);
 890 }
 891 #endif
 892
 893 /* packet trace format function */
 894 static u8 *
 895 format_acl_plugin_trace (u8 * s, va_list * args)
 896 {
 897   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 898   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 899   acl_fa_trace_t *t = va_arg (*args, acl_fa_trace_t *);
 900
 901   s =
 902     format (s,
 903             "acl-plugin: lc_index: %d, sw_if_index %d, next index %d, action: %d, match: acl %d rule %d trace_bits %08x\n"
 904             "  pkt info %016llx %016llx %016llx %016llx %016llx %016llx",
 905             t->lc_index, t->sw_if_index, t->next_index, t->action,
 906             t->match_acl_in_index, t->match_rule_index, t->trace_bitmap,
 907             t->packet_info[0], t->packet_info[1], t->packet_info[2],
 908             t->packet_info[3], t->packet_info[4], t->packet_info[5]);
 909
 910   /* Now also print out the packet_info in a form usable by humans */
 911   s = format (s, "\n   %U", format_fa_5tuple, t->packet_info);
 912   return s;
 913 }
 914
 915 /* *INDENT-OFF* */
 916
 917 static char *acl_fa_error_strings[] = {
 918 #define _(sym,string) string,
 919   foreach_acl_fa_error
 920 #undef _
 921 };
 922
 923 VLIB_NODE_FN (acl_in_l2_ip6_node) (vlib_main_t * vm,
 924                                    vlib_node_runtime_t * node,
 925                                    vlib_frame_t * frame)
 926 {
 927   return acl_fa_node_fn (vm, node, frame, 1, 1, 1);
 928 }
 929
 930 VLIB_NODE_FN (acl_in_l2_ip4_node) (vlib_main_t * vm,
 931                                    vlib_node_runtime_t * node,
 932                                    vlib_frame_t * frame)
 933 {
 934   return acl_fa_node_fn (vm, node, frame, 0, 1, 1);
 935 }
 936
 937 VLIB_NODE_FN (acl_out_l2_ip6_node) (vlib_main_t * vm,
 938                                     vlib_node_runtime_t * node,
 939                                     vlib_frame_t * frame)
 940 {
 941   return acl_fa_node_fn (vm, node, frame, 1, 0, 1);
 942 }
 943
 944 VLIB_NODE_FN (acl_out_l2_ip4_node) (vlib_main_t * vm,
 945                                     vlib_node_runtime_t * node,
 946                                     vlib_frame_t * frame)
 947 {
 948   return acl_fa_node_fn (vm, node, frame, 0, 0, 1);
 949 }
 950
 951 /**** L3 processing path nodes ****/
 952
 953 VLIB_NODE_FN (acl_in_fa_ip6_node) (vlib_main_t * vm,
 954                                    vlib_node_runtime_t * node,
 955                                    vlib_frame_t * frame)
 956 {
 957   return acl_fa_node_fn (vm, node, frame, 1, 1, 0);
 958 }
 959
 960 VLIB_NODE_FN (acl_in_fa_ip4_node) (vlib_main_t * vm,
 961                                    vlib_node_runtime_t * node,
 962                                    vlib_frame_t * frame)
 963 {
 964   return acl_fa_node_fn (vm, node, frame, 0, 1, 0);
 965 }
 966
 967 VLIB_NODE_FN (acl_out_fa_ip6_node) (vlib_main_t * vm,
 968                                     vlib_node_runtime_t * node,
 969                                     vlib_frame_t * frame)
 970 {
 971   return acl_fa_node_fn (vm, node, frame, 1, 0, 0);
 972 }
 973
 974 VLIB_NODE_FN (acl_out_fa_ip4_node) (vlib_main_t * vm,
 975                                     vlib_node_runtime_t * node,
 976                                     vlib_frame_t * frame)
 977 {
 978   return acl_fa_node_fn (vm, node, frame, 0, 0, 0);
 979 }
 980
 981 VLIB_REGISTER_NODE (acl_in_l2_ip6_node) =
 982 {
 983   .name = "acl-plugin-in-ip6-l2",
 984   .vector_size = sizeof (u32),
 985   .format_trace = format_acl_plugin_trace,
 986   .type = VLIB_NODE_TYPE_INTERNAL,
 987   .n_errors = ARRAY_LEN (acl_fa_error_strings),
 988   .error_strings = acl_fa_error_strings,
 989   .n_next_nodes = ACL_FA_N_NEXT,
 990   .next_nodes =
 991   {
 992     [ACL_FA_ERROR_DROP] = "error-drop",
 993   }
 994 };
 995
 996 VNET_FEATURE_INIT (acl_in_l2_ip6_fa_feature, static) =
 997 {
 998   .arc_name = "l2-input-ip6",
 999   .node_name = "acl-plugin-in-ip6-l2",
1000   .runs_before = VNET_FEATURES ("l2-input-feat-arc-end"),
1001 };
1002
1003 VLIB_REGISTER_NODE (acl_in_l2_ip4_node) =
1004 {
1005   .name = "acl-plugin-in-ip4-l2",
1006   .vector_size = sizeof (u32),
1007   .format_trace = format_acl_plugin_trace,
1008   .type = VLIB_NODE_TYPE_INTERNAL,
1009   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1010   .error_strings = acl_fa_error_strings,
1011   .n_next_nodes = ACL_FA_N_NEXT,
1012   .next_nodes =
1013   {
1014     [ACL_FA_ERROR_DROP] = "error-drop",
1015   }
1016 };
1017
1018 VNET_FEATURE_INIT (acl_in_l2_ip4_fa_feature, static) =
1019 {
1020   .arc_name = "l2-input-ip4",
1021   .node_name = "acl-plugin-in-ip4-l2",
1022   .runs_before = VNET_FEATURES ("l2-input-feat-arc-end"),
1023 };
1024
1025
1026 VLIB_REGISTER_NODE (acl_out_l2_ip6_node) =
1027 {
1028   .name = "acl-plugin-out-ip6-l2",
1029   .vector_size = sizeof (u32),
1030   .format_trace = format_acl_plugin_trace,
1031   .type = VLIB_NODE_TYPE_INTERNAL,
1032   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1033   .error_strings = acl_fa_error_strings,
1034   .n_next_nodes = ACL_FA_N_NEXT,
1035   .next_nodes =
1036   {
1037     [ACL_FA_ERROR_DROP] = "error-drop",
1038   }
1039 };
1040
1041 VNET_FEATURE_INIT (acl_out_l2_ip6_fa_feature, static) =
1042 {
1043   .arc_name = "l2-output-ip6",
1044   .node_name = "acl-plugin-out-ip6-l2",
1045   .runs_before = VNET_FEATURES ("l2-output-feat-arc-end"),
1046 };
1047
1048
1049 VLIB_REGISTER_NODE (acl_out_l2_ip4_node) =
1050 {
1051   .name = "acl-plugin-out-ip4-l2",
1052   .vector_size = sizeof (u32),
1053   .format_trace = format_acl_plugin_trace,
1054   .type = VLIB_NODE_TYPE_INTERNAL,
1055   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1056   .error_strings = acl_fa_error_strings,
1057   .n_next_nodes = ACL_FA_N_NEXT,
1058   .next_nodes =
1059   {
1060     [ACL_FA_ERROR_DROP] = "error-drop",
1061   }
1062 };
1063
1064 VNET_FEATURE_INIT (acl_out_l2_ip4_fa_feature, static) =
1065 {
1066   .arc_name = "l2-output-ip4",
1067   .node_name = "acl-plugin-out-ip4-l2",
1068   .runs_before = VNET_FEATURES ("l2-output-feat-arc-end"),
1069 };
1070
1071
1072 VLIB_REGISTER_NODE (acl_in_fa_ip6_node) =
1073 {
1074   .name = "acl-plugin-in-ip6-fa",
1075   .vector_size = sizeof (u32),
1076   .format_trace = format_acl_plugin_trace,
1077   .type = VLIB_NODE_TYPE_INTERNAL,
1078   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1079   .error_strings = acl_fa_error_strings,
1080   .n_next_nodes = ACL_FA_N_NEXT,
1081   .next_nodes =
1082   {
1083     [ACL_FA_ERROR_DROP] = "error-drop",
1084   }
1085 };
1086
1087 VNET_FEATURE_INIT (acl_in_ip6_fa_feature, static) =
1088 {
1089   .arc_name = "ip6-unicast",
1090   .node_name = "acl-plugin-in-ip6-fa",
1091   .runs_before = VNET_FEATURES ("ip6-flow-classify"),
1092 };
1093
1094 VLIB_REGISTER_NODE (acl_in_fa_ip4_node) =
1095 {
1096   .name = "acl-plugin-in-ip4-fa",
1097   .vector_size = sizeof (u32),
1098   .format_trace = format_acl_plugin_trace,
1099   .type = VLIB_NODE_TYPE_INTERNAL,
1100   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1101   .error_strings = acl_fa_error_strings,
1102   .n_next_nodes = ACL_FA_N_NEXT,
1103   .next_nodes =
1104   {
1105     [ACL_FA_ERROR_DROP] = "error-drop",
1106   }
1107 };
1108
1109 VNET_FEATURE_INIT (acl_in_ip4_fa_feature, static) =
1110 {
1111   .arc_name = "ip4-unicast",
1112   .node_name = "acl-plugin-in-ip4-fa",
1113   .runs_before = VNET_FEATURES ("ip4-flow-classify"),
1114 };
1115
1116
1117 VLIB_REGISTER_NODE (acl_out_fa_ip6_node) =
1118 {
1119   .name = "acl-plugin-out-ip6-fa",
1120   .vector_size = sizeof (u32),
1121   .format_trace = format_acl_plugin_trace,
1122   .type = VLIB_NODE_TYPE_INTERNAL,
1123   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1124   .error_strings = acl_fa_error_strings,
1125   .n_next_nodes = ACL_FA_N_NEXT,
1126   .next_nodes =
1127   {
1128     [ACL_FA_ERROR_DROP] = "error-drop",
1129   }
1130 };
1131
1132 VNET_FEATURE_INIT (acl_out_ip6_fa_feature, static) =
1133 {
1134   .arc_name = "ip6-output",
1135   .node_name = "acl-plugin-out-ip6-fa",
1136   .runs_before = VNET_FEATURES ("interface-output"),
1137 };
1138
1139 VLIB_REGISTER_NODE (acl_out_fa_ip4_node) =
1140 {
1141   .name = "acl-plugin-out-ip4-fa",
1142   .vector_size = sizeof (u32),
1143   .format_trace = format_acl_plugin_trace,
1144   .type = VLIB_NODE_TYPE_INTERNAL,
1145   .n_errors = ARRAY_LEN (acl_fa_error_strings),
1146   .error_strings = acl_fa_error_strings,
1147   .n_next_nodes = ACL_FA_N_NEXT,
1148     /* edit / add dispositions here */
1149   .next_nodes =
1150   {
1151     [ACL_FA_ERROR_DROP] = "error-drop",
1152   }
1153 };
1154
1155 VNET_FEATURE_INIT (acl_out_ip4_fa_feature, static) =
1156 {
1157   .arc_name = "ip4-output",
1158   .node_name = "acl-plugin-out-ip4-fa",
1159   .runs_before = VNET_FEATURES ("interface-output"),
1160 };
1161
1162 /* *INDENT-ON* */
1163
1164 /*
1165  * fd.io coding-style-patch-verification: ON
1166  *
1167  * Local Variables:
1168  * eval: (c-set-style "gnu")
1169  * End:
1170  */