src/plugins/acl/session_inlines.h

   1 /*
   2  * Copyright (c) 2016 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
  17 /* ICMPv4 invert type for stateful ACL */
  18 static const u8 icmp4_invmap[] = {
  19   [ICMP4_echo_reply] = ICMP4_echo_request + 1,
  20   [ICMP4_timestamp_reply] = ICMP4_timestamp_request + 1,
  21   [ICMP4_information_reply] = ICMP4_information_request + 1,
  22   [ICMP4_address_mask_reply] = ICMP4_address_mask_request + 1
  23 };
  24
  25 /* Supported ICMPv4 messages for session creation */
  26 static const u8 icmp4_valid_new[] = {
  27   [ICMP4_echo_request] = 1,
  28   [ICMP4_timestamp_request] = 1,
  29   [ICMP4_information_request] = 1,
  30   [ICMP4_address_mask_request] = 1
  31 };
  32
  33 /* ICMPv6 invert type for stateful ACL */
  34 static const u8 icmp6_invmap[] = {
  35   [ICMP6_echo_reply - 128] = ICMP6_echo_request + 1,
  36   [ICMP6_node_information_response - 128] = ICMP6_node_information_request + 1
  37 };
  38
  39 /* Supported ICMPv6 messages for session creation */
  40 static const u8 icmp6_valid_new[] = {
  41   [ICMP6_echo_request - 128] = 1,
  42   [ICMP6_node_information_request - 128] = 1
  43 };
  44
  45 /* IP4 and IP6 protocol numbers of ICMP */
  46 static u8 icmp_protos[] = { IP_PROTOCOL_ICMP, IP_PROTOCOL_ICMP6 };
  47
  48
  49
  50 always_inline int
  51 acl_fa_ifc_has_sessions (acl_main_t * am, int sw_if_index0)
  52 {
  53   return am->fa_sessions_hash_is_initialized;
  54 }
  55
  56 always_inline int
  57 acl_fa_ifc_has_in_acl (acl_main_t * am, int sw_if_index0)
  58 {
  59   int it_has = clib_bitmap_get (am->fa_in_acl_on_sw_if_index, sw_if_index0);
  60   return it_has;
  61 }
  62
  63 always_inline int
  64 acl_fa_ifc_has_out_acl (acl_main_t * am, int sw_if_index0)
  65 {
  66   int it_has = clib_bitmap_get (am->fa_out_acl_on_sw_if_index, sw_if_index0);
  67   return it_has;
  68 }
  69
  70 always_inline int
  71 fa_session_get_timeout_type (acl_main_t * am, fa_session_t * sess)
  72 {
  73   /* seen both SYNs and ACKs but not FINs means we are in establshed state */
  74   u16 masked_flags =
  75     sess->tcp_flags_seen.as_u16 & ((TCP_FLAGS_RSTFINACKSYN << 8) +
  76                                    TCP_FLAGS_RSTFINACKSYN);
  77   switch (sess->info.l4.proto)
  78     {
  79     case IPPROTO_TCP:
  80       if (((TCP_FLAGS_ACKSYN << 8) + TCP_FLAGS_ACKSYN) == masked_flags)
  81         {
  82           return ACL_TIMEOUT_TCP_IDLE;
  83         }
  84       else
  85         {
  86           return ACL_TIMEOUT_TCP_TRANSIENT;
  87         }
  88       break;
  89     case IPPROTO_UDP:
  90       return ACL_TIMEOUT_UDP_IDLE;
  91       break;
  92     default:
  93       return ACL_TIMEOUT_UDP_IDLE;
  94     }
  95 }
  96
  97 /*
  98  * Get the idle timeout of a session.
  99  */
 100
 101 always_inline u64
 102 fa_session_get_timeout (acl_main_t * am, fa_session_t * sess)
 103 {
 104   u64 timeout = (am->vlib_main->clib_time.clocks_per_second);
 105   if (sess->link_list_id == ACL_TIMEOUT_PURGATORY)
 106     {
 107       timeout /= (1000000 / SESSION_PURGATORY_TIMEOUT_USEC);
 108     }
 109   else
 110     {
 111       int timeout_type = fa_session_get_timeout_type (am, sess);
 112       timeout *= am->session_timeout_sec[timeout_type];
 113     }
 114   return timeout;
 115 }
 116
 117
 118
 119 always_inline fa_session_t *
 120 get_session_ptr (acl_main_t * am, u16 thread_index, u32 session_index)
 121 {
 122   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 123   if (session_index >= vec_len (pw->fa_sessions_pool))
 124     return 0;
 125
 126   return pool_elt_at_index (pw->fa_sessions_pool, session_index);
 127 }
 128
 129 always_inline int
 130 is_valid_session_ptr (acl_main_t * am, u16 thread_index, fa_session_t * sess)
 131 {
 132   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 133   return ((sess != 0)
 134           && ((sess - pw->fa_sessions_pool) <
 135               pool_len (pw->fa_sessions_pool)));
 136 }
 137
 138 always_inline void
 139 acl_fa_conn_list_add_session (acl_main_t * am, fa_full_session_id_t sess_id,
 140                               u64 now)
 141 {
 142   fa_session_t *sess =
 143     get_session_ptr (am, sess_id.thread_index, sess_id.session_index);
 144   u8 list_id =
 145     sess->deleted ? ACL_TIMEOUT_PURGATORY : fa_session_get_timeout_type (am,
 146                                                                          sess);
 147   uword thread_index = os_get_thread_index ();
 148   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 149   /* the retrieved session thread index must be necessarily the same as the one in the key */
 150   ASSERT (sess->thread_index == sess_id.thread_index);
 151   /* the retrieved session thread index must be the same as current thread */
 152   ASSERT (sess->thread_index == thread_index);
 153   sess->link_enqueue_time = now;
 154   sess->link_list_id = list_id;
 155   sess->link_next_idx = FA_SESSION_BOGUS_INDEX;
 156   sess->link_prev_idx = pw->fa_conn_list_tail[list_id];
 157   if (FA_SESSION_BOGUS_INDEX != pw->fa_conn_list_tail[list_id])
 158     {
 159       fa_session_t *prev_sess =
 160         get_session_ptr (am, thread_index, pw->fa_conn_list_tail[list_id]);
 161       prev_sess->link_next_idx = sess_id.session_index;
 162       /* We should never try to link with a session on another thread */
 163       ASSERT (prev_sess->thread_index == sess->thread_index);
 164     }
 165   pw->fa_conn_list_tail[list_id] = sess_id.session_index;
 166
 167 #ifdef FA_NODE_VERBOSE_DEBUG
 168   clib_warning
 169     ("FA-SESSION-DEBUG: add session id %d on thread %d sw_if_index %d",
 170      sess_id.session_index, thread_index, sess->sw_if_index);
 171 #endif
 172   pw->serviced_sw_if_index_bitmap =
 173     clib_bitmap_set (pw->serviced_sw_if_index_bitmap, sess->sw_if_index, 1);
 174
 175   if (FA_SESSION_BOGUS_INDEX == pw->fa_conn_list_head[list_id])
 176     {
 177       pw->fa_conn_list_head[list_id] = sess_id.session_index;
 178       /* set the head expiry time because it is the first element */
 179       pw->fa_conn_list_head_expiry_time[list_id] =
 180         now + fa_session_get_timeout (am, sess);
 181     }
 182 }
 183
 184 static int
 185 acl_fa_conn_list_delete_session (acl_main_t * am,
 186                                  fa_full_session_id_t sess_id, u64 now)
 187 {
 188   uword thread_index = os_get_thread_index ();
 189   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 190   if (thread_index != sess_id.thread_index)
 191     {
 192       /* If another thread attempts to delete the session, fail it. */
 193 #ifdef FA_NODE_VERBOSE_DEBUG
 194       clib_warning ("thread id in key %d != curr thread index, not deleting");
 195 #endif
 196       return 0;
 197     }
 198   fa_session_t *sess =
 199     get_session_ptr (am, sess_id.thread_index, sess_id.session_index);
 200   u64 next_expiry_time = ~0ULL;
 201   /* we should never try to delete the session with another thread index */
 202   if (sess->thread_index != os_get_thread_index ())
 203     {
 204       clib_error
 205         ("Attempting to delete session belonging to thread %d by thread %d",
 206          sess->thread_index, thread_index);
 207     }
 208   if (FA_SESSION_BOGUS_INDEX != sess->link_prev_idx)
 209     {
 210       fa_session_t *prev_sess =
 211         get_session_ptr (am, thread_index, sess->link_prev_idx);
 212       /* the previous session must be in the same list as this one */
 213       ASSERT (prev_sess->link_list_id == sess->link_list_id);
 214       prev_sess->link_next_idx = sess->link_next_idx;
 215     }
 216   if (FA_SESSION_BOGUS_INDEX != sess->link_next_idx)
 217     {
 218       fa_session_t *next_sess =
 219         get_session_ptr (am, thread_index, sess->link_next_idx);
 220       /* The next session must be in the same list as the one we are deleting */
 221       ASSERT (next_sess->link_list_id == sess->link_list_id);
 222       next_sess->link_prev_idx = sess->link_prev_idx;
 223       next_expiry_time = now + fa_session_get_timeout (am, next_sess);
 224     }
 225   if (pw->fa_conn_list_head[sess->link_list_id] == sess_id.session_index)
 226     {
 227       pw->fa_conn_list_head[sess->link_list_id] = sess->link_next_idx;
 228       pw->fa_conn_list_head_expiry_time[sess->link_list_id] =
 229         next_expiry_time;
 230     }
 231   if (pw->fa_conn_list_tail[sess->link_list_id] == sess_id.session_index)
 232     {
 233       pw->fa_conn_list_tail[sess->link_list_id] = sess->link_prev_idx;
 234     }
 235   return 1;
 236 }
 237
 238 always_inline int
 239 acl_fa_restart_timer_for_session (acl_main_t * am, u64 now,
 240                                   fa_full_session_id_t sess_id)
 241 {
 242   if (acl_fa_conn_list_delete_session (am, sess_id, now))
 243     {
 244       acl_fa_conn_list_add_session (am, sess_id, now);
 245       return 1;
 246     }
 247   else
 248     {
 249       /*
 250        * Our thread does not own this connection, so we can not delete
 251        * The session. To avoid the complicated signaling, we simply
 252        * pick the list waiting time to be the shortest of the timeouts.
 253        * This way we do not have to do anything special, and let
 254        * the regular requeue check take care of everything.
 255        */
 256       return 0;
 257     }
 258 }
 259
 260 always_inline int
 261 is_ip6_5tuple (fa_5tuple_t * p5t)
 262 {
 263   return (p5t->l3_zero_pad[0] | p5t->
 264           l3_zero_pad[1] | p5t->l3_zero_pad[2] | p5t->l3_zero_pad[3] | p5t->
 265           l3_zero_pad[4] | p5t->l3_zero_pad[5]) != 0;
 266 }
 267
 268
 269
 270
 271 always_inline u8
 272 acl_fa_track_session (acl_main_t * am, int is_input, u32 sw_if_index, u64 now,
 273                       fa_session_t * sess, fa_5tuple_t * pkt_5tuple)
 274 {
 275   sess->last_active_time = now;
 276   if (pkt_5tuple->pkt.tcp_flags_valid)
 277     {
 278       sess->tcp_flags_seen.as_u8[is_input] |= pkt_5tuple->pkt.tcp_flags;
 279     }
 280   return 3;
 281 }
 282
 283 always_inline u64
 284 reverse_l4_u64_fastpath (u64 l4, int is_ip6)
 285 {
 286   fa_session_l4_key_t l4i = {.as_u64 = l4 };
 287   fa_session_l4_key_t l4o;
 288
 289   l4o.port[1] = l4i.port[0];
 290   l4o.port[0] = l4i.port[1];
 291
 292   l4o.non_port_l4_data = l4i.non_port_l4_data;
 293   l4o.is_input = 1 - l4i.is_input;
 294   return l4o.as_u64;
 295 }
 296
 297 always_inline u64
 298 reverse_l4_u64_slowpath (u64 l4, int is_ip6)
 299 {
 300   fa_session_l4_key_t l4i = {.as_u64 = l4 };
 301   fa_session_l4_key_t l4o;
 302
 303   if (l4i.proto == icmp_protos[is_ip6])
 304     {
 305       static const u8 *icmp_invmap[] = { icmp4_invmap, icmp6_invmap };
 306       static const u8 *icmp_valid_new[] =
 307         { icmp4_valid_new, icmp6_valid_new };
 308       static const u8 icmp_invmap_size[] = { sizeof (icmp4_invmap),
 309         sizeof (icmp6_invmap)
 310       };
 311       static const u8 icmp_valid_new_size[] = { sizeof (icmp4_valid_new),
 312         sizeof (icmp6_valid_new)
 313       };
 314       int type = is_ip6 ? l4i.port[0] - 128 : l4i.port[0];
 315
 316       l4o.non_port_l4_data = l4i.non_port_l4_data;
 317       l4o.port[0] = l4i.port[0];
 318       l4o.port[1] = l4i.port[1];
 319
 320
 321       /*
 322        * ONLY ICMP messages defined in icmp4_valid_new/icmp6_valid_new table
 323        * are allowed to create stateful ACL.
 324        * The other messages will be forwarded without creating a reverse session.
 325        */
 326
 327       if (type >= 0 && (type <= icmp_valid_new_size[is_ip6])
 328           && (icmp_valid_new[is_ip6][type])
 329           && (type <= icmp_invmap_size[is_ip6]) && icmp_invmap[is_ip6][type])
 330         {
 331           /*
 332            * we set the inverse direction and correct the port,
 333            * if it is okay to add the reverse session.
 334            * If not, then the same session will be added twice
 335            * to bihash, which is the same as adding just one session.
 336            */
 337           l4o.is_input = 1 - l4i.is_input;
 338           l4o.port[0] = icmp_invmap[is_ip6][type] - 1;
 339         }
 340
 341       return l4o.as_u64;
 342     }
 343   else
 344     return reverse_l4_u64_fastpath (l4, is_ip6);
 345 }
 346
 347 always_inline u64
 348 reverse_l4_u64 (u64 l4, int is_ip6)
 349 {
 350   fa_session_l4_key_t l4i = {.as_u64 = l4 };
 351
 352   if (PREDICT_FALSE (l4i.is_slowpath))
 353     {
 354       return reverse_l4_u64_slowpath (l4, is_ip6);
 355     }
 356   else
 357     {
 358       return reverse_l4_u64_fastpath (l4, is_ip6);
 359     }
 360 }
 361
 362 always_inline void
 363 reverse_session_add_del_ip6 (acl_main_t * am,
 364                              clib_bihash_kv_40_8_t * pkv, int is_add)
 365 {
 366   clib_bihash_kv_40_8_t kv2;
 367   kv2.key[0] = pkv->key[2];
 368   kv2.key[1] = pkv->key[3];
 369   kv2.key[2] = pkv->key[0];
 370   kv2.key[3] = pkv->key[1];
 371   /* the last u64 needs special treatment (ports, etc.) */
 372   kv2.key[4] = reverse_l4_u64 (pkv->key[4], 1);
 373   kv2.value = pkv->value;
 374   clib_bihash_add_del_40_8 (&am->fa_ip6_sessions_hash, &kv2, is_add);
 375 }
 376
 377 always_inline void
 378 reverse_session_add_del_ip4 (acl_main_t * am,
 379                              clib_bihash_kv_16_8_t * pkv, int is_add)
 380 {
 381   clib_bihash_kv_16_8_t kv2;
 382   kv2.key[0] =
 383     ((pkv->key[0] & 0xffffffff) << 32) | ((pkv->key[0] >> 32) & 0xffffffff);
 384   /* the last u64 needs special treatment (ports, etc.) */
 385   kv2.key[1] = reverse_l4_u64 (pkv->key[1], 0);
 386   kv2.value = pkv->value;
 387   clib_bihash_add_del_16_8 (&am->fa_ip4_sessions_hash, &kv2, is_add);
 388 }
 389
 390 always_inline void
 391 acl_fa_deactivate_session (acl_main_t * am, u32 sw_if_index,
 392                            fa_full_session_id_t sess_id)
 393 {
 394   fa_session_t *sess =
 395     get_session_ptr (am, sess_id.thread_index, sess_id.session_index);
 396   ASSERT (sess->thread_index == os_get_thread_index ());
 397   if (sess->is_ip6)
 398     {
 399       clib_bihash_add_del_40_8 (&am->fa_ip6_sessions_hash,
 400                                 &sess->info.kv_40_8, 0);
 401       reverse_session_add_del_ip6 (am, &sess->info.kv_40_8, 0);
 402     }
 403   else
 404     {
 405       clib_bihash_add_del_16_8 (&am->fa_ip4_sessions_hash,
 406                                 &sess->info.kv_16_8, 0);
 407       reverse_session_add_del_ip4 (am, &sess->info.kv_16_8, 0);
 408     }
 409
 410   sess->deleted = 1;
 411   clib_smp_atomic_add (&am->fa_session_total_deactivations, 1);
 412 }
 413
 414 always_inline void
 415 acl_fa_put_session (acl_main_t * am, u32 sw_if_index,
 416                     fa_full_session_id_t sess_id)
 417 {
 418   if (sess_id.thread_index != os_get_thread_index ())
 419     {
 420       clib_error
 421         ("Attempting to delete session belonging to thread %d by thread %d",
 422          sess_id.thread_index, os_get_thread_index ());
 423     }
 424   void *oldheap = clib_mem_set_heap (am->acl_mheap);
 425   acl_fa_per_worker_data_t *pw = &am->per_worker_data[sess_id.thread_index];
 426   pool_put_index (pw->fa_sessions_pool, sess_id.session_index);
 427   /* Deleting from timer structures not needed,
 428      as the caller must have dealt with the timers. */
 429   vec_validate (pw->fa_session_dels_by_sw_if_index, sw_if_index);
 430   clib_mem_set_heap (oldheap);
 431   clib_smp_atomic_add (&pw->fa_session_dels_by_sw_if_index[sw_if_index], 1);
 432   clib_smp_atomic_add (&am->fa_session_total_dels, 1);
 433 }
 434
 435 always_inline int
 436 acl_fa_two_stage_delete_session (acl_main_t * am, u32 sw_if_index,
 437                                  fa_full_session_id_t sess_id, u64 now)
 438 {
 439   fa_session_t *sess =
 440     get_session_ptr (am, sess_id.thread_index, sess_id.session_index);
 441   if (sess->deleted)
 442     {
 443       acl_fa_put_session (am, sw_if_index, sess_id);
 444       return 1;
 445     }
 446   else
 447     {
 448       acl_fa_deactivate_session (am, sw_if_index, sess_id);
 449       acl_fa_conn_list_add_session (am, sess_id, now);
 450       return 0;
 451     }
 452 }
 453
 454 always_inline int
 455 acl_fa_can_add_session (acl_main_t * am, int is_input, u32 sw_if_index)
 456 {
 457   u64 curr_sess_count;
 458   curr_sess_count = am->fa_session_total_adds - am->fa_session_total_dels;
 459   return (curr_sess_count + vec_len (vlib_mains) <
 460           am->fa_conn_table_max_entries);
 461 }
 462
 463
 464 always_inline void
 465 acl_fa_try_recycle_session (acl_main_t * am, int is_input, u16 thread_index,
 466                             u32 sw_if_index, u64 now)
 467 {
 468   /* try to recycle a TCP transient session */
 469   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 470   fa_full_session_id_t volatile sess_id;
 471   int n_recycled = 0;
 472
 473   /* clean up sessions from purgatory, if we can */
 474   sess_id.session_index = pw->fa_conn_list_head[ACL_TIMEOUT_PURGATORY];
 475   while ((FA_SESSION_BOGUS_INDEX != sess_id.session_index)
 476          && n_recycled < am->fa_max_deleted_sessions_per_interval)
 477     {
 478       sess_id.thread_index = thread_index;
 479       fa_session_t *sess =
 480         get_session_ptr (am, sess_id.thread_index, sess_id.session_index);
 481       if (sess->link_enqueue_time + fa_session_get_timeout (am, sess) < now)
 482         {
 483           acl_fa_conn_list_delete_session (am, sess_id, now);
 484           /* interface that needs the sessions may not be the interface of the session. */
 485           acl_fa_put_session (am, sess->sw_if_index, sess_id);
 486           n_recycled++;
 487         }
 488       else
 489         break;                  /* too early to try to recycle from here, bail out */
 490       sess_id.session_index = pw->fa_conn_list_head[ACL_TIMEOUT_PURGATORY];
 491     }
 492   sess_id.session_index = pw->fa_conn_list_head[ACL_TIMEOUT_TCP_TRANSIENT];
 493   if (FA_SESSION_BOGUS_INDEX != sess_id.session_index)
 494     {
 495       sess_id.thread_index = thread_index;
 496       acl_fa_conn_list_delete_session (am, sess_id, now);
 497       acl_fa_deactivate_session (am, sw_if_index, sess_id);
 498       /* this goes to purgatory list */
 499       acl_fa_conn_list_add_session (am, sess_id, now);
 500     }
 501 }
 502
 503
 504 always_inline fa_session_t *
 505 acl_fa_add_session (acl_main_t * am, int is_input, int is_ip6,
 506                     u32 sw_if_index, u64 now, fa_5tuple_t * p5tuple,
 507                     u16 current_policy_epoch)
 508 {
 509   fa_full_session_id_t f_sess_id;
 510   uword thread_index = os_get_thread_index ();
 511   void *oldheap = clib_mem_set_heap (am->acl_mheap);
 512   acl_fa_per_worker_data_t *pw = &am->per_worker_data[thread_index];
 513
 514   f_sess_id.thread_index = thread_index;
 515   fa_session_t *sess;
 516
 517   if (f_sess_id.as_u64 == ~0)
 518     {
 519       clib_error ("Adding session with invalid value");
 520     }
 521
 522   pool_get_aligned (pw->fa_sessions_pool, sess, CLIB_CACHE_LINE_BYTES);
 523   f_sess_id.session_index = sess - pw->fa_sessions_pool;
 524   f_sess_id.intf_policy_epoch = current_policy_epoch;
 525
 526   if (is_ip6)
 527     {
 528       sess->info.kv_40_8.key[0] = p5tuple->kv_40_8.key[0];
 529       sess->info.kv_40_8.key[1] = p5tuple->kv_40_8.key[1];
 530       sess->info.kv_40_8.key[2] = p5tuple->kv_40_8.key[2];
 531       sess->info.kv_40_8.key[3] = p5tuple->kv_40_8.key[3];
 532       sess->info.kv_40_8.key[4] = p5tuple->kv_40_8.key[4];
 533       sess->info.kv_40_8.value = f_sess_id.as_u64;
 534     }
 535   else
 536     {
 537       sess->info.kv_16_8.key[0] = p5tuple->kv_16_8.key[0];
 538       sess->info.kv_16_8.key[1] = p5tuple->kv_16_8.key[1];
 539       sess->info.kv_16_8.value = f_sess_id.as_u64;
 540     }
 541
 542   sess->last_active_time = now;
 543   sess->sw_if_index = sw_if_index;
 544   sess->tcp_flags_seen.as_u16 = 0;
 545   sess->thread_index = thread_index;
 546   sess->link_list_id = ACL_TIMEOUT_UNUSED;
 547   sess->link_prev_idx = FA_SESSION_BOGUS_INDEX;
 548   sess->link_next_idx = FA_SESSION_BOGUS_INDEX;
 549   sess->deleted = 0;
 550   sess->is_ip6 = is_ip6;
 551
 552   acl_fa_conn_list_add_session (am, f_sess_id, now);
 553
 554   ASSERT (am->fa_sessions_hash_is_initialized == 1);
 555   if (is_ip6)
 556     {
 557       reverse_session_add_del_ip6 (am, &sess->info.kv_40_8, 1);
 558       clib_bihash_add_del_40_8 (&am->fa_ip6_sessions_hash,
 559                                 &sess->info.kv_40_8, 1);
 560     }
 561   else
 562     {
 563       reverse_session_add_del_ip4 (am, &sess->info.kv_16_8, 1);
 564       clib_bihash_add_del_16_8 (&am->fa_ip4_sessions_hash,
 565                                 &sess->info.kv_16_8, 1);
 566     }
 567
 568   vec_validate (pw->fa_session_adds_by_sw_if_index, sw_if_index);
 569   clib_mem_set_heap (oldheap);
 570   clib_smp_atomic_add (&pw->fa_session_adds_by_sw_if_index[sw_if_index], 1);
 571   clib_smp_atomic_add (&am->fa_session_total_adds, 1);
 572   return sess;
 573 }
 574
 575 always_inline int
 576 acl_fa_find_session (acl_main_t * am, int is_ip6, u32 sw_if_index0,
 577                      fa_5tuple_t * p5tuple, u64 * pvalue_sess)
 578 {
 579   int res = 0;
 580   if (is_ip6)
 581     {
 582       clib_bihash_kv_40_8_t kv_result;
 583       res = (clib_bihash_search_inline_2_40_8
 584              (&am->fa_ip6_sessions_hash, &p5tuple->kv_40_8, &kv_result) == 0);
 585       *pvalue_sess = kv_result.value;
 586     }
 587   else
 588     {
 589       clib_bihash_kv_16_8_t kv_result;
 590       res = (clib_bihash_search_inline_2_16_8
 591              (&am->fa_ip4_sessions_hash, &p5tuple->kv_16_8, &kv_result) == 0);
 592       *pvalue_sess = kv_result.value;
 593     }
 594   return res;
 595 }
 596
 597 /*
 598  * fd.io coding-style-patch-verification: ON
 599  *
 600  * Local Variables:
 601  * eval: (c-set-style "gnu")
 602  * End:
 603  */