src/vnet/ip/ip_in_out_acl.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 #include <vnet/ip/ip.h>
  16 #include <vnet/classify/vnet_classify.h>
  17 #include <vnet/classify/in_out_acl.h>
  18
  19 typedef struct
  20 {
  21   u32 sw_if_index;
  22   u32 next_index;
  23   u32 table_index;
  24   u32 offset;
  25 } ip_in_out_acl_trace_t;
  26
  27 /* packet trace format function */
  28 static u8 *
  29 format_ip_in_out_acl_trace (u8 * s, u32 is_output, va_list * args)
  30 {
  31   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  32   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  33   ip_in_out_acl_trace_t *t = va_arg (*args, ip_in_out_acl_trace_t *);
  34
  35   s = format (s, "%s: sw_if_index %d, next_index %d, table %d, offset %d",
  36               is_output ? "OUTACL" : "INACL",
  37               t->sw_if_index, t->next_index, t->table_index, t->offset);
  38   return s;
  39 }
  40
  41 static u8 *
  42 format_ip_inacl_trace (u8 * s, va_list * args)
  43 {
  44   return format_ip_in_out_acl_trace (s, 0 /* is_output */ , args);
  45 }
  46
  47 static u8 *
  48 format_ip_outacl_trace (u8 * s, va_list * args)
  49 {
  50   return format_ip_in_out_acl_trace (s, 1 /* is_output */ , args);
  51 }
  52
  53 vlib_node_registration_t ip4_inacl_node;
  54 vlib_node_registration_t ip4_outacl_node;
  55 vlib_node_registration_t ip6_inacl_node;
  56 vlib_node_registration_t ip6_outacl_node;
  57
  58 #define foreach_ip_inacl_error                  \
  59 _(MISS, "input ACL misses")                     \
  60 _(HIT, "input ACL hits")                        \
  61 _(CHAIN_HIT, "input ACL hits after chain walk")
  62
  63 #define foreach_ip_outacl_error                  \
  64 _(MISS, "output ACL misses")                     \
  65 _(HIT, "output ACL hits")                        \
  66 _(CHAIN_HIT, "output ACL hits after chain walk")
  67
  68 typedef enum
  69 {
  70 #define _(sym,str) IP_INACL_ERROR_##sym,
  71   foreach_ip_inacl_error
  72 #undef _
  73     IP_INACL_N_ERROR,
  74 } ip_inacl_error_t;
  75
  76 static char *ip_inacl_error_strings[] = {
  77 #define _(sym,string) string,
  78   foreach_ip_inacl_error
  79 #undef _
  80 };
  81
  82 typedef enum
  83 {
  84 #define _(sym,str) IP_OUTACL_ERROR_##sym,
  85   foreach_ip_outacl_error
  86 #undef _
  87     IP_OUTACL_N_ERROR,
  88 } ip_outacl_error_t;
  89
  90 static char *ip_outacl_error_strings[] = {
  91 #define _(sym,string) string,
  92   foreach_ip_outacl_error
  93 #undef _
  94 };
  95
  96 static inline uword
  97 ip_in_out_acl_inline (vlib_main_t * vm,
  98                       vlib_node_runtime_t * node, vlib_frame_t * frame,
  99                       int is_ip4, int is_output)
 100 {
 101   u32 n_left_from, *from, *to_next;
 102   acl_next_index_t next_index;
 103   in_out_acl_main_t *am = &in_out_acl_main;
 104   vnet_classify_main_t *vcm = am->vnet_classify_main;
 105   f64 now = vlib_time_now (vm);
 106   u32 hits = 0;
 107   u32 misses = 0;
 108   u32 chain_hits = 0;
 109   in_out_acl_table_id_t tid;
 110   vlib_node_runtime_t *error_node;
 111   u32 n_next_nodes;
 112
 113   n_next_nodes = node->n_next_nodes;
 114
 115   if (is_ip4)
 116     {
 117       tid = IN_OUT_ACL_TABLE_IP4;
 118       error_node = vlib_node_get_runtime (vm, ip4_input_node.index);
 119     }
 120   else
 121     {
 122       tid = IN_OUT_ACL_TABLE_IP6;
 123       error_node = vlib_node_get_runtime (vm, ip6_input_node.index);
 124     }
 125
 126   from = vlib_frame_vector_args (frame);
 127   n_left_from = frame->n_vectors;
 128
 129   /* First pass: compute hashes */
 130
 131   while (n_left_from > 2)
 132     {
 133       vlib_buffer_t *b0, *b1;
 134       u32 bi0, bi1;
 135       u8 *h0, *h1;
 136       u32 sw_if_index0, sw_if_index1;
 137       u32 table_index0, table_index1;
 138       vnet_classify_table_t *t0, *t1;
 139
 140       /* prefetch next iteration */
 141       {
 142         vlib_buffer_t *p1, *p2;
 143
 144         p1 = vlib_get_buffer (vm, from[1]);
 145         p2 = vlib_get_buffer (vm, from[2]);
 146
 147         vlib_prefetch_buffer_header (p1, STORE);
 148         CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE);
 149         vlib_prefetch_buffer_header (p2, STORE);
 150         CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
 151       }
 152
 153       bi0 = from[0];
 154       b0 = vlib_get_buffer (vm, bi0);
 155
 156       bi1 = from[1];
 157       b1 = vlib_get_buffer (vm, bi1);
 158
 159       sw_if_index0 =
 160         vnet_buffer (b0)->sw_if_index[is_output ? VLIB_TX : VLIB_RX];
 161       table_index0 =
 162         am->classify_table_index_by_sw_if_index[is_output][tid][sw_if_index0];
 163
 164       sw_if_index1 =
 165         vnet_buffer (b1)->sw_if_index[is_output ? VLIB_TX : VLIB_RX];
 166       table_index1 =
 167         am->classify_table_index_by_sw_if_index[is_output][tid][sw_if_index1];
 168
 169       t0 = pool_elt_at_index (vcm->tables, table_index0);
 170
 171       t1 = pool_elt_at_index (vcm->tables, table_index1);
 172
 173       if (t0->current_data_flag == CLASSIFY_FLAG_USE_CURR_DATA)
 174         h0 = (void *) vlib_buffer_get_current (b0) + t0->current_data_offset;
 175       else
 176         h0 = b0->data;
 177
 178       if (is_output)
 179         {
 180           /* Save the rewrite length, since we are using the l2_classify struct */
 181           vnet_buffer (b0)->l2_classify.pad.l2_len =
 182             vnet_buffer (b0)->ip.save_rewrite_length;
 183           /* advance the match pointer so the matching happens on IP header */
 184           h0 += vnet_buffer (b0)->l2_classify.pad.l2_len;
 185         }
 186
 187       vnet_buffer (b0)->l2_classify.hash =
 188         vnet_classify_hash_packet (t0, (u8 *) h0);
 189
 190       vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash);
 191
 192       if (t1->current_data_flag == CLASSIFY_FLAG_USE_CURR_DATA)
 193         h1 = (void *) vlib_buffer_get_current (b1) + t1->current_data_offset;
 194       else
 195         h1 = b1->data;
 196
 197       if (is_output)
 198         {
 199           /* Save the rewrite length, since we are using the l2_classify struct */
 200           vnet_buffer (b1)->l2_classify.pad.l2_len =
 201             vnet_buffer (b1)->ip.save_rewrite_length;
 202           /* advance the match pointer so the matching happens on IP header */
 203           h1 += vnet_buffer (b1)->l2_classify.pad.l2_len;
 204         }
 205
 206       vnet_buffer (b1)->l2_classify.hash =
 207         vnet_classify_hash_packet (t1, (u8 *) h1);
 208
 209       vnet_classify_prefetch_bucket (t1, vnet_buffer (b1)->l2_classify.hash);
 210
 211       vnet_buffer (b0)->l2_classify.table_index = table_index0;
 212
 213       vnet_buffer (b1)->l2_classify.table_index = table_index1;
 214
 215       from += 2;
 216       n_left_from -= 2;
 217     }
 218
 219   while (n_left_from > 0)
 220     {
 221       vlib_buffer_t *b0;
 222       u32 bi0;
 223       u8 *h0;
 224       u32 sw_if_index0;
 225       u32 table_index0;
 226       vnet_classify_table_t *t0;
 227
 228       bi0 = from[0];
 229       b0 = vlib_get_buffer (vm, bi0);
 230
 231       sw_if_index0 =
 232         vnet_buffer (b0)->sw_if_index[is_output ? VLIB_TX : VLIB_RX];
 233       table_index0 =
 234         am->classify_table_index_by_sw_if_index[is_output][tid][sw_if_index0];
 235
 236       t0 = pool_elt_at_index (vcm->tables, table_index0);
 237
 238       if (t0->current_data_flag == CLASSIFY_FLAG_USE_CURR_DATA)
 239         h0 = (void *) vlib_buffer_get_current (b0) + t0->current_data_offset;
 240       else
 241         h0 = b0->data;
 242
 243       if (is_output)
 244         {
 245           /* Save the rewrite length, since we are using the l2_classify struct */
 246           vnet_buffer (b0)->l2_classify.pad.l2_len =
 247             vnet_buffer (b0)->ip.save_rewrite_length;
 248           /* advance the match pointer so the matching happens on IP header */
 249           h0 += vnet_buffer (b0)->l2_classify.pad.l2_len;
 250         }
 251
 252       vnet_buffer (b0)->l2_classify.hash =
 253         vnet_classify_hash_packet (t0, (u8 *) h0);
 254
 255       vnet_buffer (b0)->l2_classify.table_index = table_index0;
 256       vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash);
 257
 258       from++;
 259       n_left_from--;
 260     }
 261
 262   next_index = node->cached_next_index;
 263   from = vlib_frame_vector_args (frame);
 264   n_left_from = frame->n_vectors;
 265
 266   while (n_left_from > 0)
 267     {
 268       u32 n_left_to_next;
 269
 270       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 271
 272       /* Not enough load/store slots to dual loop... */
 273       while (n_left_from > 0 && n_left_to_next > 0)
 274         {
 275           u32 bi0;
 276           vlib_buffer_t *b0;
 277           u32 next0 = ACL_NEXT_INDEX_DENY;
 278           u32 table_index0;
 279           vnet_classify_table_t *t0;
 280           vnet_classify_entry_t *e0;
 281           u64 hash0;
 282           u8 *h0;
 283           u8 error0;
 284
 285           /* Stride 3 seems to work best */
 286           if (PREDICT_TRUE (n_left_from > 3))
 287             {
 288               vlib_buffer_t *p1 = vlib_get_buffer (vm, from[3]);
 289               vnet_classify_table_t *tp1;
 290               u32 table_index1;
 291               u64 phash1;
 292
 293               table_index1 = vnet_buffer (p1)->l2_classify.table_index;
 294
 295               if (PREDICT_TRUE (table_index1 != ~0))
 296                 {
 297                   tp1 = pool_elt_at_index (vcm->tables, table_index1);
 298                   phash1 = vnet_buffer (p1)->l2_classify.hash;
 299                   vnet_classify_prefetch_entry (tp1, phash1);
 300                 }
 301             }
 302
 303
 304           /* speculatively enqueue b0 to the current next frame */
 305           bi0 = from[0];
 306           to_next[0] = bi0;
 307           from += 1;
 308           to_next += 1;
 309           n_left_from -= 1;
 310           n_left_to_next -= 1;
 311
 312           b0 = vlib_get_buffer (vm, bi0);
 313           table_index0 = vnet_buffer (b0)->l2_classify.table_index;
 314           e0 = 0;
 315           t0 = 0;
 316           vnet_get_config_data (am->vnet_config_main[is_output][tid],
 317                                 &b0->current_config_index, &next0,
 318                                 /* # bytes of config data */ 0);
 319
 320           vnet_buffer (b0)->l2_classify.opaque_index = ~0;
 321
 322           if (PREDICT_TRUE (table_index0 != ~0))
 323             {
 324               hash0 = vnet_buffer (b0)->l2_classify.hash;
 325               t0 = pool_elt_at_index (vcm->tables, table_index0);
 326
 327               if (t0->current_data_flag == CLASSIFY_FLAG_USE_CURR_DATA)
 328                 h0 =
 329                   (void *) vlib_buffer_get_current (b0) +
 330                   t0->current_data_offset;
 331               else
 332                 h0 = b0->data;
 333
 334               /* advance the match pointer so the matching happens on IP header */
 335               if (is_output)
 336                 h0 += vnet_buffer (b0)->l2_classify.pad.l2_len;
 337
 338               e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
 339               if (e0)
 340                 {
 341                   vnet_buffer (b0)->l2_classify.opaque_index
 342                     = e0->opaque_index;
 343                   vlib_buffer_advance (b0, e0->advance);
 344
 345                   next0 = (e0->next_index < n_next_nodes) ?
 346                     e0->next_index : next0;
 347
 348                   hits++;
 349
 350                   if (is_ip4)
 351                     error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 352                       (is_output ? IP4_ERROR_OUTACL_SESSION_DENY :
 353                        IP4_ERROR_INACL_SESSION_DENY) : IP4_ERROR_NONE;
 354                   else
 355                     error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 356                       (is_output ? IP6_ERROR_OUTACL_SESSION_DENY :
 357                        IP6_ERROR_INACL_SESSION_DENY) : IP6_ERROR_NONE;
 358                   b0->error = error_node->errors[error0];
 359
 360                   if (!is_output)
 361                     {
 362                       if (e0->action == CLASSIFY_ACTION_SET_IP4_FIB_INDEX ||
 363                           e0->action == CLASSIFY_ACTION_SET_IP6_FIB_INDEX)
 364                         vnet_buffer (b0)->sw_if_index[VLIB_TX] = e0->metadata;
 365                       else if (e0->action == CLASSIFY_ACTION_SET_METADATA)
 366                         vnet_buffer (b0)->ip.adj_index[VLIB_TX] =
 367                           e0->metadata;
 368                     }
 369                 }
 370               else
 371                 {
 372                   while (1)
 373                     {
 374                       if (PREDICT_TRUE (t0->next_table_index != ~0))
 375                         t0 = pool_elt_at_index (vcm->tables,
 376                                                 t0->next_table_index);
 377                       else
 378                         {
 379                           next0 = (t0->miss_next_index < n_next_nodes) ?
 380                             t0->miss_next_index : next0;
 381
 382                           misses++;
 383
 384                           if (is_ip4)
 385                             error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 386                               (is_output ? IP4_ERROR_OUTACL_TABLE_MISS :
 387                                IP4_ERROR_INACL_TABLE_MISS) : IP4_ERROR_NONE;
 388                           else
 389                             error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 390                               (is_output ? IP6_ERROR_OUTACL_TABLE_MISS :
 391                                IP6_ERROR_INACL_TABLE_MISS) : IP6_ERROR_NONE;
 392                           b0->error = error_node->errors[error0];
 393                           break;
 394                         }
 395
 396                       if (t0->current_data_flag ==
 397                           CLASSIFY_FLAG_USE_CURR_DATA)
 398                         h0 =
 399                           (void *) vlib_buffer_get_current (b0) +
 400                           t0->current_data_offset;
 401                       else
 402                         h0 = b0->data;
 403
 404                       /* advance the match pointer so the matching happens on IP header */
 405                       if (is_output)
 406                         h0 += vnet_buffer (b0)->l2_classify.pad.l2_len;
 407
 408                       hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
 409                       e0 = vnet_classify_find_entry
 410                         (t0, (u8 *) h0, hash0, now);
 411                       if (e0)
 412                         {
 413                           vnet_buffer (b0)->l2_classify.opaque_index
 414                             = e0->opaque_index;
 415                           vlib_buffer_advance (b0, e0->advance);
 416                           next0 = (e0->next_index < n_next_nodes) ?
 417                             e0->next_index : next0;
 418                           hits++;
 419                           chain_hits++;
 420
 421                           if (is_ip4)
 422                             error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 423                               (is_output ? IP4_ERROR_OUTACL_SESSION_DENY :
 424                                IP4_ERROR_INACL_SESSION_DENY) : IP4_ERROR_NONE;
 425                           else
 426                             error0 = (next0 == ACL_NEXT_INDEX_DENY) ?
 427                               (is_output ? IP6_ERROR_OUTACL_SESSION_DENY :
 428                                IP6_ERROR_INACL_SESSION_DENY) : IP6_ERROR_NONE;
 429                           b0->error = error_node->errors[error0];
 430
 431                           if (!is_output)
 432                             {
 433                               if (e0->action ==
 434                                   CLASSIFY_ACTION_SET_IP4_FIB_INDEX
 435                                   || e0->action ==
 436                                   CLASSIFY_ACTION_SET_IP6_FIB_INDEX)
 437                                 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
 438                                   e0->metadata;
 439                               else if (e0->action ==
 440                                        CLASSIFY_ACTION_SET_METADATA)
 441                                 vnet_buffer (b0)->ip.adj_index[VLIB_TX] =
 442                                   e0->metadata;
 443                             }
 444                           break;
 445                         }
 446                     }
 447                 }
 448             }
 449
 450           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
 451                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
 452             {
 453               ip_in_out_acl_trace_t *t =
 454                 vlib_add_trace (vm, node, b0, sizeof (*t));
 455               t->sw_if_index =
 456                 vnet_buffer (b0)->sw_if_index[is_output ? VLIB_TX : VLIB_RX];
 457               t->next_index = next0;
 458               t->table_index = t0 ? t0 - vcm->tables : ~0;
 459               t->offset = (e0 && t0) ? vnet_classify_get_offset (t0, e0) : ~0;
 460             }
 461
 462           if ((next0 == ACL_NEXT_INDEX_DENY) && is_output)
 463             {
 464               /* on output, for the drop node to work properly, go back to ip header */
 465               vlib_buffer_advance (b0, vnet_buffer (b0)->l2.l2_len);
 466             }
 467
 468           /* verify speculative enqueue, maybe switch current next frame */
 469           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 470                                            to_next, n_left_to_next,
 471                                            bi0, next0);
 472         }
 473
 474       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 475     }
 476
 477   vlib_node_increment_counter (vm, node->node_index,
 478                                is_output ? IP_OUTACL_ERROR_MISS :
 479                                IP_INACL_ERROR_MISS, misses);
 480   vlib_node_increment_counter (vm, node->node_index,
 481                                is_output ? IP_OUTACL_ERROR_HIT :
 482                                IP_INACL_ERROR_HIT, hits);
 483   vlib_node_increment_counter (vm, node->node_index,
 484                                is_output ? IP_OUTACL_ERROR_CHAIN_HIT :
 485                                IP_INACL_ERROR_CHAIN_HIT, chain_hits);
 486   return frame->n_vectors;
 487 }
 488
 489 static uword
 490 ip4_inacl (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 491 {
 492   return ip_in_out_acl_inline (vm, node, frame, 1 /* is_ip4 */ ,
 493                                0 /* is_output */ );
 494 }
 495
 496 static uword
 497 ip4_outacl (vlib_main_t * vm, vlib_node_runtime_t * node,
 498             vlib_frame_t * frame)
 499 {
 500   return ip_in_out_acl_inline (vm, node, frame, 1 /* is_ip4 */ ,
 501                                1 /* is_output */ );
 502 }
 503
 504
 505 /* *INDENT-OFF* */
 506 VLIB_REGISTER_NODE (ip4_inacl_node) = {
 507   .function = ip4_inacl,
 508   .name = "ip4-inacl",
 509   .vector_size = sizeof (u32),
 510   .format_trace = format_ip_inacl_trace,
 511   .n_errors = ARRAY_LEN(ip_inacl_error_strings),
 512   .error_strings = ip_inacl_error_strings,
 513
 514   .n_next_nodes = ACL_NEXT_INDEX_N_NEXT,
 515   .next_nodes = {
 516     [ACL_NEXT_INDEX_DENY] = "ip4-drop",
 517   },
 518 };
 519
 520 VLIB_REGISTER_NODE (ip4_outacl_node) = {
 521   .function = ip4_outacl,
 522   .name = "ip4-outacl",
 523   .vector_size = sizeof (u32),
 524   .format_trace = format_ip_outacl_trace,
 525   .n_errors = ARRAY_LEN(ip_outacl_error_strings),
 526   .error_strings = ip_outacl_error_strings,
 527
 528   .n_next_nodes = ACL_NEXT_INDEX_N_NEXT,
 529   .next_nodes = {
 530     [ACL_NEXT_INDEX_DENY] = "ip4-drop",
 531   },
 532 };
 533 /* *INDENT-ON* */
 534
 535 VLIB_NODE_FUNCTION_MULTIARCH (ip4_inacl_node, ip4_inacl);
 536 VLIB_NODE_FUNCTION_MULTIARCH (ip4_outacl_node, ip4_outacl);
 537
 538 static uword
 539 ip6_inacl (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 540 {
 541   return ip_in_out_acl_inline (vm, node, frame, 0 /* is_ip4 */ ,
 542                                0 /* is_output */ );
 543 }
 544
 545 static uword
 546 ip6_outacl (vlib_main_t * vm, vlib_node_runtime_t * node,
 547             vlib_frame_t * frame)
 548 {
 549   return ip_in_out_acl_inline (vm, node, frame, 0 /* is_ip4 */ ,
 550                                1 /* is_output */ );
 551 }
 552
 553 /* *INDENT-OFF* */
 554 VLIB_REGISTER_NODE (ip6_inacl_node) = {
 555   .function = ip6_inacl,
 556   .name = "ip6-inacl",
 557   .vector_size = sizeof (u32),
 558   .format_trace = format_ip_inacl_trace,
 559   .n_errors = ARRAY_LEN(ip_inacl_error_strings),
 560   .error_strings = ip_inacl_error_strings,
 561
 562   .n_next_nodes = ACL_NEXT_INDEX_N_NEXT,
 563   .next_nodes = {
 564     [ACL_NEXT_INDEX_DENY] = "ip6-drop",
 565   },
 566 };
 567
 568 VLIB_REGISTER_NODE (ip6_outacl_node) = {
 569   .function = ip6_outacl,
 570   .name = "ip6-outacl",
 571   .vector_size = sizeof (u32),
 572   .format_trace = format_ip_outacl_trace,
 573   .n_errors = ARRAY_LEN(ip_outacl_error_strings),
 574   .error_strings = ip_outacl_error_strings,
 575
 576   .n_next_nodes = ACL_NEXT_INDEX_N_NEXT,
 577   .next_nodes = {
 578     [ACL_NEXT_INDEX_DENY] = "ip6-drop",
 579   },
 580 };
 581 /* *INDENT-ON* */
 582
 583 VLIB_NODE_FUNCTION_MULTIARCH (ip6_inacl_node, ip6_inacl);
 584 VLIB_NODE_FUNCTION_MULTIARCH (ip6_outacl_node, ip6_outacl);
 585
 586 static clib_error_t *
 587 ip_in_out_acl_init (vlib_main_t * vm)
 588 {
 589   return 0;
 590 }
 591
 592 VLIB_INIT_FUNCTION (ip_in_out_acl_init);
 593
 594
 595 /*
 596  * fd.io coding-style-patch-verification: ON
 597  *
 598  * Local Variables:
 599  * eval: (c-set-style "gnu")
 600  * End:
 601  */