src/plugins/lb/node.c

   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 #include <lb/lb.h>
  17
  18 #include <vnet/gre/packet.h>
  19 #include <lb/lbhash.h>
  20
  21 #define foreach_lb_error \
  22  _(NONE, "no error") \
  23  _(PROTO_NOT_SUPPORTED, "protocol not supported")
  24
  25 typedef enum {
  26 #define _(sym,str) LB_ERROR_##sym,
  27   foreach_lb_error
  28 #undef _
  29     LB_N_ERROR,
  30 } lb_error_t;
  31
  32 static char *lb_error_strings[] = {
  33 #define _(sym,string) string,
  34     foreach_lb_error
  35 #undef _
  36 };
  37
  38 typedef struct {
  39   u32 vip_index;
  40   u32 as_index;
  41 } lb_trace_t;
  42
  43 u8 *
  44 format_lb_trace (u8 * s, va_list * args)
  45 {
  46   lb_main_t *lbm = &lb_main;
  47   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  48   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  49   lb_trace_t *t = va_arg (*args, lb_trace_t *);
  50   if (pool_is_free_index(lbm->vips, t->vip_index)) {
  51       s = format(s, "lb vip[%d]: This VIP was freed since capture\n");
  52   } else {
  53       s = format(s, "lb vip[%d]: %U\n", t->vip_index, format_lb_vip, &lbm->vips[t->vip_index]);
  54   }
  55   if (pool_is_free_index(lbm->ass, t->as_index)) {
  56       s = format(s, "lb as[%d]: This AS was freed since capture\n");
  57   } else {
  58       s = format(s, "lb as[%d]: %U\n", t->as_index, format_lb_as, &lbm->ass[t->as_index]);
  59   }
  60   return s;
  61 }
  62
  63 lb_hash_t *lb_get_sticky_table(u32 thread_index)
  64 {
  65   lb_main_t *lbm = &lb_main;
  66   lb_hash_t *sticky_ht = lbm->per_cpu[thread_index].sticky_ht;
  67   //Check if size changed
  68   if (PREDICT_FALSE(sticky_ht && (lbm->per_cpu_sticky_buckets != lb_hash_nbuckets(sticky_ht))))
  69     {
  70       //Dereference everything in there
  71       lb_hash_bucket_t *b;
  72       u32 i;
  73       lb_hash_foreach_entry(sticky_ht, b, i) {
  74         vlib_refcount_add(&lbm->as_refcount, thread_index, b->value[i], -1);
  75         vlib_refcount_add(&lbm->as_refcount, thread_index, 0, 1);
  76       }
  77
  78       lb_hash_free(sticky_ht);
  79       sticky_ht = NULL;
  80     }
  81
  82   //Create if necessary
  83   if (PREDICT_FALSE(sticky_ht == NULL)) {
  84     lbm->per_cpu[thread_index].sticky_ht = lb_hash_alloc(lbm->per_cpu_sticky_buckets, lbm->flow_timeout);
  85     sticky_ht = lbm->per_cpu[thread_index].sticky_ht;
  86     clib_warning("Regenerated sticky table %p", sticky_ht);
  87   }
  88
  89   ASSERT(sticky_ht);
  90
  91   //Update timeout
  92   sticky_ht->timeout = lbm->flow_timeout;
  93   return sticky_ht;
  94 }
  95
  96 u64
  97 lb_node_get_other_ports4(ip4_header_t *ip40)
  98 {
  99   return 0;
 100 }
 101
 102 u64
 103 lb_node_get_other_ports6(ip6_header_t *ip60)
 104 {
 105   return 0;
 106 }
 107
 108 static_always_inline u32
 109 lb_node_get_hash(vlib_buffer_t *p, u8 is_input_v4)
 110 {
 111   u32 hash;
 112   if (is_input_v4)
 113     {
 114       ip4_header_t *ip40;
 115       u64 ports;
 116       ip40 = vlib_buffer_get_current (p);
 117       if (PREDICT_TRUE (ip40->protocol == IP_PROTOCOL_TCP ||
 118                        ip40->protocol == IP_PROTOCOL_UDP))
 119         ports = ((u64)((udp_header_t *)(ip40 + 1))->src_port << 16) |
 120           ((u64)((udp_header_t *)(ip40 + 1))->dst_port);
 121       else
 122         ports = lb_node_get_other_ports4(ip40);
 123
 124       hash = lb_hash_hash(*((u64 *)&ip40->address_pair), ports,
 125                           0, 0, 0);
 126     }
 127   else
 128     {
 129       ip6_header_t *ip60;
 130       ip60 = vlib_buffer_get_current (p);
 131       u64 ports;
 132       if (PREDICT_TRUE (ip60->protocol == IP_PROTOCOL_TCP ||
 133                         ip60->protocol == IP_PROTOCOL_UDP))
 134         ports = ((u64)((udp_header_t *)(ip60 + 1))->src_port << 16) |
 135         ((u64)((udp_header_t *)(ip60 + 1))->dst_port);
 136       else
 137         ports = lb_node_get_other_ports6(ip60);
 138
 139       hash = lb_hash_hash(ip60->src_address.as_u64[0],
 140                           ip60->src_address.as_u64[1],
 141                           ip60->dst_address.as_u64[0],
 142                           ip60->dst_address.as_u64[1],
 143                           ports);
 144     }
 145   return hash;
 146 }
 147
 148 static_always_inline uword
 149 lb_node_fn (vlib_main_t * vm,
 150          vlib_node_runtime_t * node, vlib_frame_t * frame,
 151          u8 is_input_v4, //Compile-time parameter stating that is input is v4 (or v6)
 152          lb_encap_type_t encap_type) //Compile-time parameter stating that is GRE4 or GRE6 or L3DSR
 153 {
 154   lb_main_t *lbm = &lb_main;
 155   u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
 156   u32 thread_index = vlib_get_thread_index();
 157   u32 lb_time = lb_hash_time_now(vm);
 158
 159   lb_hash_t *sticky_ht = lb_get_sticky_table(thread_index);
 160   from = vlib_frame_vector_args (frame);
 161   n_left_from = frame->n_vectors;
 162   next_index = node->cached_next_index;
 163
 164   u32 nexthash0 = 0;
 165   if (PREDICT_TRUE(n_left_from > 0))
 166     nexthash0 = lb_node_get_hash(vlib_get_buffer (vm, from[0]), is_input_v4);
 167
 168   while (n_left_from > 0)
 169   {
 170     vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 171     while (n_left_from > 0 && n_left_to_next > 0)
 172     {
 173       u32 pi0;
 174       vlib_buffer_t *p0;
 175       lb_vip_t *vip0;
 176       u32 asindex0;
 177       u16 len0;
 178       u32 available_index0;
 179       u8 counter = 0;
 180       u32 hash0 = nexthash0;
 181
 182       if (PREDICT_TRUE(n_left_from > 1))
 183         {
 184           vlib_buffer_t *p1 = vlib_get_buffer (vm, from[1]);
 185           //Compute next hash and prefetch bucket
 186           nexthash0 = lb_node_get_hash(p1, is_input_v4);
 187           lb_hash_prefetch_bucket(sticky_ht, nexthash0);
 188           //Prefetch for encap, next
 189           CLIB_PREFETCH (vlib_buffer_get_current(p1) - 64, 64, STORE);
 190         }
 191
 192       if (PREDICT_TRUE(n_left_from > 2))
 193         {
 194           vlib_buffer_t *p2;
 195           p2 = vlib_get_buffer(vm, from[2]);
 196           /* prefetch packet header and data */
 197           vlib_prefetch_buffer_header(p2, STORE);
 198           CLIB_PREFETCH (vlib_buffer_get_current(p2), 64, STORE);
 199         }
 200
 201       pi0 = to_next[0] = from[0];
 202       from += 1;
 203       n_left_from -= 1;
 204       to_next += 1;
 205       n_left_to_next -= 1;
 206
 207       p0 = vlib_get_buffer (vm, pi0);
 208       vip0 = pool_elt_at_index (lbm->vips,
 209                                 vnet_buffer (p0)->ip.adj_index[VLIB_TX]);
 210
 211       if (is_input_v4)
 212         {
 213           ip4_header_t *ip40;
 214           ip40 = vlib_buffer_get_current (p0);
 215           len0 = clib_net_to_host_u16(ip40->length);
 216         }
 217       else
 218         {
 219           ip6_header_t *ip60;
 220           ip60 = vlib_buffer_get_current (p0);
 221           len0 = clib_net_to_host_u16(ip60->payload_length) + sizeof(ip6_header_t);
 222         }
 223
 224       lb_hash_get(sticky_ht, hash0, vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 225                   lb_time, &available_index0, &asindex0);
 226
 227       if (PREDICT_TRUE(asindex0 != ~0))
 228         {
 229           //Found an existing entry
 230           counter = LB_VIP_COUNTER_NEXT_PACKET;
 231         }
 232       else if (PREDICT_TRUE(available_index0 != ~0))
 233         {
 234           //There is an available slot for a new flow
 235           asindex0 = vip0->new_flow_table[hash0 & vip0->new_flow_table_mask].as_index;
 236           counter = LB_VIP_COUNTER_FIRST_PACKET;
 237           counter = (asindex0 == 0)?LB_VIP_COUNTER_NO_SERVER:counter;
 238
 239           //TODO: There are race conditions with as0 and vip0 manipulation.
 240           //Configuration may be changed, vectors resized, etc...
 241
 242           //Dereference previously used
 243           vlib_refcount_add(&lbm->as_refcount, thread_index,
 244                             lb_hash_available_value(sticky_ht, hash0, available_index0), -1);
 245           vlib_refcount_add(&lbm->as_refcount, thread_index,
 246                             asindex0, 1);
 247
 248           //Add sticky entry
 249           //Note that when there is no AS configured, an entry is configured anyway.
 250           //But no configured AS is not something that should happen
 251           lb_hash_put(sticky_ht, hash0, asindex0,
 252                       vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 253                       available_index0, lb_time);
 254         }
 255       else
 256         {
 257           //Could not store new entry in the table
 258           asindex0 = vip0->new_flow_table[hash0 & vip0->new_flow_table_mask].as_index;
 259           counter = LB_VIP_COUNTER_UNTRACKED_PACKET;
 260         }
 261
 262       vlib_increment_simple_counter(&lbm->vip_counters[counter],
 263                                     thread_index,
 264                                     vnet_buffer (p0)->ip.adj_index[VLIB_TX],
 265                                     1);
 266
 267       //Now let's encap
 268       if ( (encap_type == LB_ENCAP_TYPE_GRE4)
 269            || (encap_type == LB_ENCAP_TYPE_GRE6) )
 270         {
 271           gre_header_t *gre0;
 272           if (encap_type == LB_ENCAP_TYPE_GRE4) /* encap GRE4*/
 273             {
 274               ip4_header_t *ip40;
 275               vlib_buffer_advance(p0, - sizeof(ip4_header_t) - sizeof(gre_header_t));
 276               ip40 = vlib_buffer_get_current(p0);
 277               gre0 = (gre_header_t *)(ip40 + 1);
 278               ip40->src_address = lbm->ip4_src_address;
 279               ip40->dst_address = lbm->ass[asindex0].address.ip4;
 280               ip40->ip_version_and_header_length = 0x45;
 281               ip40->ttl = 128;
 282               ip40->fragment_id = 0;
 283               ip40->flags_and_fragment_offset = 0;
 284               ip40->length = clib_host_to_net_u16(len0 + sizeof(gre_header_t) + sizeof(ip4_header_t));
 285               ip40->protocol = IP_PROTOCOL_GRE;
 286               ip40->checksum = ip4_header_checksum (ip40);
 287             }
 288           else /* encap GRE6*/
 289             {
 290               ip6_header_t *ip60;
 291               vlib_buffer_advance(p0, - sizeof(ip6_header_t) - sizeof(gre_header_t));
 292               ip60 = vlib_buffer_get_current(p0);
 293               gre0 = (gre_header_t *)(ip60 + 1);
 294               ip60->dst_address = lbm->ass[asindex0].address.ip6;
 295               ip60->src_address = lbm->ip6_src_address;
 296               ip60->hop_limit = 128;
 297               ip60->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (0x6<<28);
 298               ip60->payload_length = clib_host_to_net_u16(len0 + sizeof(gre_header_t));
 299               ip60->protocol = IP_PROTOCOL_GRE;
 300             }
 301
 302           gre0->flags_and_version = 0;
 303           gre0->protocol = (is_input_v4)?
 304               clib_host_to_net_u16(0x0800):
 305               clib_host_to_net_u16(0x86DD);
 306       } else if (encap_type == LB_ENCAP_TYPE_L3DSR) /* encap L3DSR*/
 307         {
 308           ip4_header_t *ip40;
 309
 310           ip40 = vlib_buffer_get_current(p0);
 311           ip40->dst_address = lbm->ass[asindex0].address.ip4;
 312           /* Get and rewrite DSCP bit */
 313           ip40->tos = (u8)((vip0->dscp & 0x3F)<<2);
 314           ip40->checksum = ip4_header_checksum (ip40);
 315         }
 316
 317       if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
 318         {
 319           lb_trace_t *tr = vlib_add_trace (vm, node, p0, sizeof (*tr));
 320           tr->as_index = asindex0;
 321           tr->vip_index = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
 322         }
 323
 324       //Enqueue to next
 325       //Note that this is going to error if asindex0 == 0
 326       vnet_buffer (p0)->ip.adj_index[VLIB_TX] = lbm->ass[asindex0].dpo.dpoi_index;
 327       vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 328                                        n_left_to_next, pi0,
 329                                        lbm->ass[asindex0].dpo.dpoi_next_node);
 330     }
 331     vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 332   }
 333
 334   return frame->n_vectors;
 335 }
 336
 337 static uword
 338 lb6_gre6_node_fn (vlib_main_t * vm,
 339          vlib_node_runtime_t * node, vlib_frame_t * frame)
 340 {
 341   return lb_node_fn(vm, node, frame, 0, LB_ENCAP_TYPE_GRE6);
 342 }
 343
 344 static uword
 345 lb6_gre4_node_fn (vlib_main_t * vm,
 346          vlib_node_runtime_t * node, vlib_frame_t * frame)
 347 {
 348   return lb_node_fn(vm, node, frame, 0, LB_ENCAP_TYPE_GRE4);
 349 }
 350
 351 static uword
 352 lb4_gre6_node_fn (vlib_main_t * vm,
 353          vlib_node_runtime_t * node, vlib_frame_t * frame)
 354 {
 355   return lb_node_fn(vm, node, frame, 1, LB_ENCAP_TYPE_GRE6);
 356 }
 357
 358 static uword
 359 lb4_gre4_node_fn (vlib_main_t * vm,
 360          vlib_node_runtime_t * node, vlib_frame_t * frame)
 361 {
 362   return lb_node_fn(vm, node, frame, 1, LB_ENCAP_TYPE_GRE4);
 363 }
 364
 365 static uword
 366 lb4_l3dsr_node_fn (vlib_main_t * vm,
 367          vlib_node_runtime_t * node, vlib_frame_t * frame)
 368 {
 369   return lb_node_fn(vm, node, frame, 1, LB_ENCAP_TYPE_L3DSR);
 370 }
 371
 372 VLIB_REGISTER_NODE (lb6_gre6_node) =
 373 {
 374   .function = lb6_gre6_node_fn,
 375   .name = "lb6-gre6",
 376   .vector_size = sizeof (u32),
 377   .format_trace = format_lb_trace,
 378
 379   .n_errors = LB_N_ERROR,
 380   .error_strings = lb_error_strings,
 381
 382   .n_next_nodes = LB_N_NEXT,
 383   .next_nodes =
 384   {
 385       [LB_NEXT_DROP] = "error-drop"
 386   },
 387 };
 388
 389 VLIB_REGISTER_NODE (lb6_gre4_node) =
 390 {
 391   .function = lb6_gre4_node_fn,
 392   .name = "lb6-gre4",
 393   .vector_size = sizeof (u32),
 394   .format_trace = format_lb_trace,
 395
 396   .n_errors = LB_N_ERROR,
 397   .error_strings = lb_error_strings,
 398
 399   .n_next_nodes = LB_N_NEXT,
 400   .next_nodes =
 401   {
 402       [LB_NEXT_DROP] = "error-drop"
 403   },
 404 };
 405
 406 VLIB_REGISTER_NODE (lb4_gre6_node) =
 407 {
 408   .function = lb4_gre6_node_fn,
 409   .name = "lb4-gre6",
 410   .vector_size = sizeof (u32),
 411   .format_trace = format_lb_trace,
 412
 413   .n_errors = LB_N_ERROR,
 414   .error_strings = lb_error_strings,
 415
 416   .n_next_nodes = LB_N_NEXT,
 417   .next_nodes =
 418   {
 419       [LB_NEXT_DROP] = "error-drop"
 420   },
 421 };
 422
 423 VLIB_REGISTER_NODE (lb4_gre4_node) =
 424 {
 425   .function = lb4_gre4_node_fn,
 426   .name = "lb4-gre4",
 427   .vector_size = sizeof (u32),
 428   .format_trace = format_lb_trace,
 429
 430   .n_errors = LB_N_ERROR,
 431   .error_strings = lb_error_strings,
 432
 433   .n_next_nodes = LB_N_NEXT,
 434   .next_nodes =
 435   {
 436       [LB_NEXT_DROP] = "error-drop"
 437   },
 438 };
 439
 440 VLIB_REGISTER_NODE (lb4_l3dsr_node) =
 441 {
 442   .function = lb4_l3dsr_node_fn,
 443   .name = "lb4-l3dsr",
 444   .vector_size = sizeof (u32),
 445   .format_trace = format_lb_trace,
 446
 447   .n_errors = LB_N_ERROR,
 448   .error_strings = lb_error_strings,
 449
 450   .n_next_nodes = LB_N_NEXT,
 451   .next_nodes =
 452   {
 453       [LB_NEXT_DROP] = "error-drop"
 454   },
 455 };