src/vnet/ip/ip4_forward.h

   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  * ip/ip4_forward.h: IP v4 forwarding
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #ifndef __included_ip4_forward_h__
  41 #define __included_ip4_forward_h__
  42
  43 #include <vnet/fib/ip4_fib.h>
  44 #include <vnet/dpo/load_balance_map.h>
  45
  46 /**
  47  * @file
  48  * @brief IPv4 Forwarding.
  49  *
  50  * This file contains the source code for IPv4 forwarding.
  51  */
  52
  53 always_inline uword
  54 ip4_lookup_inline (vlib_main_t * vm,
  55                    vlib_node_runtime_t * node,
  56                    vlib_frame_t * frame,
  57                    int lookup_for_responses_to_locally_received_packets)
  58 {
  59   ip4_main_t *im = &ip4_main;
  60   vlib_combined_counter_main_t *cm = &load_balance_main.lbm_to_counters;
  61   u32 n_left_from, n_left_to_next, *from, *to_next;
  62   ip_lookup_next_t next;
  63   u32 thread_index = vlib_get_thread_index ();
  64
  65   from = vlib_frame_vector_args (frame);
  66   n_left_from = frame->n_vectors;
  67   next = node->cached_next_index;
  68
  69   while (n_left_from > 0)
  70     {
  71       vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
  72
  73       while (n_left_from >= 8 && n_left_to_next >= 4)
  74         {
  75           vlib_buffer_t *p0, *p1, *p2, *p3;
  76           ip4_header_t *ip0, *ip1, *ip2, *ip3;
  77           ip_lookup_next_t next0, next1, next2, next3;
  78           const load_balance_t *lb0, *lb1, *lb2, *lb3;
  79           ip4_fib_mtrie_t *mtrie0, *mtrie1, *mtrie2, *mtrie3;
  80           ip4_fib_mtrie_leaf_t leaf0, leaf1, leaf2, leaf3;
  81           ip4_address_t *dst_addr0, *dst_addr1, *dst_addr2, *dst_addr3;
  82           u32 pi0, fib_index0, lb_index0;
  83           u32 pi1, fib_index1, lb_index1;
  84           u32 pi2, fib_index2, lb_index2;
  85           u32 pi3, fib_index3, lb_index3;
  86           flow_hash_config_t flow_hash_config0, flow_hash_config1;
  87           flow_hash_config_t flow_hash_config2, flow_hash_config3;
  88           u32 hash_c0, hash_c1, hash_c2, hash_c3;
  89           const dpo_id_t *dpo0, *dpo1, *dpo2, *dpo3;
  90
  91           /* Prefetch next iteration. */
  92           {
  93             vlib_buffer_t *p4, *p5, *p6, *p7;
  94
  95             p4 = vlib_get_buffer (vm, from[4]);
  96             p5 = vlib_get_buffer (vm, from[5]);
  97             p6 = vlib_get_buffer (vm, from[6]);
  98             p7 = vlib_get_buffer (vm, from[7]);
  99
 100             vlib_prefetch_buffer_header (p4, LOAD);
 101             vlib_prefetch_buffer_header (p5, LOAD);
 102             vlib_prefetch_buffer_header (p6, LOAD);
 103             vlib_prefetch_buffer_header (p7, LOAD);
 104
 105             CLIB_PREFETCH (p4->data, sizeof (ip0[0]), LOAD);
 106             CLIB_PREFETCH (p5->data, sizeof (ip0[0]), LOAD);
 107             CLIB_PREFETCH (p6->data, sizeof (ip0[0]), LOAD);
 108             CLIB_PREFETCH (p7->data, sizeof (ip0[0]), LOAD);
 109           }
 110
 111           pi0 = to_next[0] = from[0];
 112           pi1 = to_next[1] = from[1];
 113           pi2 = to_next[2] = from[2];
 114           pi3 = to_next[3] = from[3];
 115
 116           from += 4;
 117           to_next += 4;
 118           n_left_to_next -= 4;
 119           n_left_from -= 4;
 120
 121           p0 = vlib_get_buffer (vm, pi0);
 122           p1 = vlib_get_buffer (vm, pi1);
 123           p2 = vlib_get_buffer (vm, pi2);
 124           p3 = vlib_get_buffer (vm, pi3);
 125
 126           ip0 = vlib_buffer_get_current (p0);
 127           ip1 = vlib_buffer_get_current (p1);
 128           ip2 = vlib_buffer_get_current (p2);
 129           ip3 = vlib_buffer_get_current (p3);
 130
 131           dst_addr0 = &ip0->dst_address;
 132           dst_addr1 = &ip1->dst_address;
 133           dst_addr2 = &ip2->dst_address;
 134           dst_addr3 = &ip3->dst_address;
 135
 136           fib_index0 =
 137             vec_elt (im->fib_index_by_sw_if_index,
 138                      vnet_buffer (p0)->sw_if_index[VLIB_RX]);
 139           fib_index1 =
 140             vec_elt (im->fib_index_by_sw_if_index,
 141                      vnet_buffer (p1)->sw_if_index[VLIB_RX]);
 142           fib_index2 =
 143             vec_elt (im->fib_index_by_sw_if_index,
 144                      vnet_buffer (p2)->sw_if_index[VLIB_RX]);
 145           fib_index3 =
 146             vec_elt (im->fib_index_by_sw_if_index,
 147                      vnet_buffer (p3)->sw_if_index[VLIB_RX]);
 148           fib_index0 =
 149             (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
 150              (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
 151           fib_index1 =
 152             (vnet_buffer (p1)->sw_if_index[VLIB_TX] ==
 153              (u32) ~ 0) ? fib_index1 : vnet_buffer (p1)->sw_if_index[VLIB_TX];
 154           fib_index2 =
 155             (vnet_buffer (p2)->sw_if_index[VLIB_TX] ==
 156              (u32) ~ 0) ? fib_index2 : vnet_buffer (p2)->sw_if_index[VLIB_TX];
 157           fib_index3 =
 158             (vnet_buffer (p3)->sw_if_index[VLIB_TX] ==
 159              (u32) ~ 0) ? fib_index3 : vnet_buffer (p3)->sw_if_index[VLIB_TX];
 160
 161
 162           if (!lookup_for_responses_to_locally_received_packets)
 163             {
 164               mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
 165               mtrie1 = &ip4_fib_get (fib_index1)->mtrie;
 166               mtrie2 = &ip4_fib_get (fib_index2)->mtrie;
 167               mtrie3 = &ip4_fib_get (fib_index3)->mtrie;
 168
 169               leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, dst_addr0);
 170               leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, dst_addr1);
 171               leaf2 = ip4_fib_mtrie_lookup_step_one (mtrie2, dst_addr2);
 172               leaf3 = ip4_fib_mtrie_lookup_step_one (mtrie3, dst_addr3);
 173             }
 174
 175           if (!lookup_for_responses_to_locally_received_packets)
 176             {
 177               leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
 178               leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 2);
 179               leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, dst_addr2, 2);
 180               leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, dst_addr3, 2);
 181             }
 182
 183           if (!lookup_for_responses_to_locally_received_packets)
 184             {
 185               leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
 186               leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 3);
 187               leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, dst_addr2, 3);
 188               leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, dst_addr3, 3);
 189             }
 190
 191           if (lookup_for_responses_to_locally_received_packets)
 192             {
 193               lb_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_RX];
 194               lb_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_RX];
 195               lb_index2 = vnet_buffer (p2)->ip.adj_index[VLIB_RX];
 196               lb_index3 = vnet_buffer (p3)->ip.adj_index[VLIB_RX];
 197             }
 198           else
 199             {
 200               lb_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
 201               lb_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1);
 202               lb_index2 = ip4_fib_mtrie_leaf_get_adj_index (leaf2);
 203               lb_index3 = ip4_fib_mtrie_leaf_get_adj_index (leaf3);
 204             }
 205
 206           ASSERT (lb_index0 && lb_index1 && lb_index2 && lb_index3);
 207           lb0 = load_balance_get (lb_index0);
 208           lb1 = load_balance_get (lb_index1);
 209           lb2 = load_balance_get (lb_index2);
 210           lb3 = load_balance_get (lb_index3);
 211
 212           ASSERT (lb0->lb_n_buckets > 0);
 213           ASSERT (is_pow2 (lb0->lb_n_buckets));
 214           ASSERT (lb1->lb_n_buckets > 0);
 215           ASSERT (is_pow2 (lb1->lb_n_buckets));
 216           ASSERT (lb2->lb_n_buckets > 0);
 217           ASSERT (is_pow2 (lb2->lb_n_buckets));
 218           ASSERT (lb3->lb_n_buckets > 0);
 219           ASSERT (is_pow2 (lb3->lb_n_buckets));
 220
 221           /* Use flow hash to compute multipath adjacency. */
 222           hash_c0 = vnet_buffer (p0)->ip.flow_hash = 0;
 223           hash_c1 = vnet_buffer (p1)->ip.flow_hash = 0;
 224           hash_c2 = vnet_buffer (p2)->ip.flow_hash = 0;
 225           hash_c3 = vnet_buffer (p3)->ip.flow_hash = 0;
 226           if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
 227             {
 228               flow_hash_config0 = lb0->lb_hash_config;
 229               hash_c0 = vnet_buffer (p0)->ip.flow_hash =
 230                 ip4_compute_flow_hash (ip0, flow_hash_config0);
 231               dpo0 =
 232                 load_balance_get_fwd_bucket (lb0,
 233                                              (hash_c0 &
 234                                               (lb0->lb_n_buckets_minus_1)));
 235             }
 236           else
 237             {
 238               dpo0 = load_balance_get_bucket_i (lb0, 0);
 239             }
 240           if (PREDICT_FALSE (lb1->lb_n_buckets > 1))
 241             {
 242               flow_hash_config1 = lb1->lb_hash_config;
 243               hash_c1 = vnet_buffer (p1)->ip.flow_hash =
 244                 ip4_compute_flow_hash (ip1, flow_hash_config1);
 245               dpo1 =
 246                 load_balance_get_fwd_bucket (lb1,
 247                                              (hash_c1 &
 248                                               (lb1->lb_n_buckets_minus_1)));
 249             }
 250           else
 251             {
 252               dpo1 = load_balance_get_bucket_i (lb1, 0);
 253             }
 254           if (PREDICT_FALSE (lb2->lb_n_buckets > 1))
 255             {
 256               flow_hash_config2 = lb2->lb_hash_config;
 257               hash_c2 = vnet_buffer (p2)->ip.flow_hash =
 258                 ip4_compute_flow_hash (ip2, flow_hash_config2);
 259               dpo2 =
 260                 load_balance_get_fwd_bucket (lb2,
 261                                              (hash_c2 &
 262                                               (lb2->lb_n_buckets_minus_1)));
 263             }
 264           else
 265             {
 266               dpo2 = load_balance_get_bucket_i (lb2, 0);
 267             }
 268           if (PREDICT_FALSE (lb3->lb_n_buckets > 1))
 269             {
 270               flow_hash_config3 = lb3->lb_hash_config;
 271               hash_c3 = vnet_buffer (p3)->ip.flow_hash =
 272                 ip4_compute_flow_hash (ip3, flow_hash_config3);
 273               dpo3 =
 274                 load_balance_get_fwd_bucket (lb3,
 275                                              (hash_c3 &
 276                                               (lb3->lb_n_buckets_minus_1)));
 277             }
 278           else
 279             {
 280               dpo3 = load_balance_get_bucket_i (lb3, 0);
 281             }
 282
 283           next0 = dpo0->dpoi_next_node;
 284           vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 285           next1 = dpo1->dpoi_next_node;
 286           vnet_buffer (p1)->ip.adj_index[VLIB_TX] = dpo1->dpoi_index;
 287           next2 = dpo2->dpoi_next_node;
 288           vnet_buffer (p2)->ip.adj_index[VLIB_TX] = dpo2->dpoi_index;
 289           next3 = dpo3->dpoi_next_node;
 290           vnet_buffer (p3)->ip.adj_index[VLIB_TX] = dpo3->dpoi_index;
 291
 292           vlib_increment_combined_counter
 293             (cm, thread_index, lb_index0, 1,
 294              vlib_buffer_length_in_chain (vm, p0));
 295           vlib_increment_combined_counter
 296             (cm, thread_index, lb_index1, 1,
 297              vlib_buffer_length_in_chain (vm, p1));
 298           vlib_increment_combined_counter
 299             (cm, thread_index, lb_index2, 1,
 300              vlib_buffer_length_in_chain (vm, p2));
 301           vlib_increment_combined_counter
 302             (cm, thread_index, lb_index3, 1,
 303              vlib_buffer_length_in_chain (vm, p3));
 304
 305           vlib_validate_buffer_enqueue_x4 (vm, node, next,
 306                                            to_next, n_left_to_next,
 307                                            pi0, pi1, pi2, pi3,
 308                                            next0, next1, next2, next3);
 309         }
 310
 311       while (n_left_from > 0 && n_left_to_next > 0)
 312         {
 313           vlib_buffer_t *p0;
 314           ip4_header_t *ip0;
 315           ip_lookup_next_t next0;
 316           const load_balance_t *lb0;
 317           ip4_fib_mtrie_t *mtrie0;
 318           ip4_fib_mtrie_leaf_t leaf0;
 319           ip4_address_t *dst_addr0;
 320           u32 pi0, fib_index0, lbi0;
 321           flow_hash_config_t flow_hash_config0;
 322           const dpo_id_t *dpo0;
 323           u32 hash_c0;
 324
 325           pi0 = from[0];
 326           to_next[0] = pi0;
 327
 328           p0 = vlib_get_buffer (vm, pi0);
 329
 330           ip0 = vlib_buffer_get_current (p0);
 331
 332           dst_addr0 = &ip0->dst_address;
 333
 334           fib_index0 =
 335             vec_elt (im->fib_index_by_sw_if_index,
 336                      vnet_buffer (p0)->sw_if_index[VLIB_RX]);
 337           fib_index0 =
 338             (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
 339              (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
 340
 341           if (!lookup_for_responses_to_locally_received_packets)
 342             {
 343               mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
 344
 345               leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, dst_addr0);
 346             }
 347
 348           if (!lookup_for_responses_to_locally_received_packets)
 349             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
 350
 351           if (!lookup_for_responses_to_locally_received_packets)
 352             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
 353
 354           if (lookup_for_responses_to_locally_received_packets)
 355             lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_RX];
 356           else
 357             {
 358               /* Handle default route. */
 359               lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
 360             }
 361
 362           ASSERT (lbi0);
 363           lb0 = load_balance_get (lbi0);
 364
 365           ASSERT (lb0->lb_n_buckets > 0);
 366           ASSERT (is_pow2 (lb0->lb_n_buckets));
 367
 368           /* Use flow hash to compute multipath adjacency. */
 369           hash_c0 = vnet_buffer (p0)->ip.flow_hash = 0;
 370           if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
 371             {
 372               flow_hash_config0 = lb0->lb_hash_config;
 373
 374               hash_c0 = vnet_buffer (p0)->ip.flow_hash =
 375                 ip4_compute_flow_hash (ip0, flow_hash_config0);
 376               dpo0 =
 377                 load_balance_get_fwd_bucket (lb0,
 378                                              (hash_c0 &
 379                                               (lb0->lb_n_buckets_minus_1)));
 380             }
 381           else
 382             {
 383               dpo0 = load_balance_get_bucket_i (lb0, 0);
 384             }
 385
 386           next0 = dpo0->dpoi_next_node;
 387           vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 388
 389           vlib_increment_combined_counter (cm, thread_index, lbi0, 1,
 390                                            vlib_buffer_length_in_chain (vm,
 391                                                                         p0));
 392
 393           from += 1;
 394           to_next += 1;
 395           n_left_to_next -= 1;
 396           n_left_from -= 1;
 397
 398           if (PREDICT_FALSE (next0 != next))
 399             {
 400               n_left_to_next += 1;
 401               vlib_put_next_frame (vm, node, next, n_left_to_next);
 402               next = next0;
 403               vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
 404               to_next[0] = pi0;
 405               to_next += 1;
 406               n_left_to_next -= 1;
 407             }
 408         }
 409
 410       vlib_put_next_frame (vm, node, next, n_left_to_next);
 411     }
 412
 413   if (node->flags & VLIB_NODE_FLAG_TRACE)
 414     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 415
 416   return frame->n_vectors;
 417 }
 418
 419 #endif /* __included_ip4_forward_h__ */
 420
 421 /*
 422  * fd.io coding-style-patch-verification: ON
 423  *
 424  * Local Variables:
 425  * eval: (c-set-style "gnu")
 426  * End:
 427  */