src/plugins/lb/lb.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  * lb-plugin implements a MagLev-like load balancer.
  18  * http://research.google.com/pubs/pub44824.html
  19  *
  20  * It hasn't been tested for interoperability with the original MagLev
  21  * but intends to provide similar functionality.
  22  * The load-balancer receives traffic destined to VIP (Virtual IP)
  23  * addresses from one or multiple(ECMP) routers.
  24  * The load-balancer tunnels the traffic toward many application servers
  25  * ensuring session stickyness (i.e. that a single sessions is tunneled
  26  * towards a single application server).
  27  *
  28  */
  29
  30 #ifndef LB_PLUGIN_LB_LB_H_
  31 #define LB_PLUGIN_LB_LB_H_
  32
  33 #include <lb/util.h>
  34 #include <vnet/util/refcount.h>
  35
  36 #include <vnet/vnet.h>
  37 #include <vnet/ip/ip.h>
  38 #include <vnet/dpo/dpo.h>
  39 #include <vnet/fib/fib_table.h>
  40 #include <vppinfra/hash.h>
  41 #include <vppinfra/bihash_8_8.h>
  42 #include <vppinfra/bihash_24_8.h>
  43 #include <lb/lbhash.h>
  44
  45 #define LB_DEFAULT_PER_CPU_STICKY_BUCKETS 1 << 10
  46 #define LB_DEFAULT_FLOW_TIMEOUT 40
  47 #define LB_MAPPING_BUCKETS  1024
  48 #define LB_MAPPING_MEMORY_SIZE  64<<20
  49
  50 #define LB_VIP_PER_PORT_BUCKETS  1024
  51 #define LB_VIP_PER_PORT_MEMORY_SIZE  64<<20
  52
  53 typedef enum {
  54   LB_NEXT_DROP,
  55   LB_N_NEXT,
  56 } lb_next_t;
  57
  58 typedef enum {
  59   LB_NAT4_IN2OUT_NEXT_DROP,
  60   LB_NAT4_IN2OUT_NEXT_LOOKUP,
  61   LB_NAT4_IN2OUT_N_NEXT,
  62 } LB_nat4_in2out_next_t;
  63
  64 typedef enum {
  65   LB_NAT6_IN2OUT_NEXT_DROP,
  66   LB_NAT6_IN2OUT_NEXT_LOOKUP,
  67   LB_NAT6_IN2OUT_N_NEXT,
  68 } LB_nat6_in2out_next_t;
  69
  70 #define foreach_lb_nat_in2out_error                       \
  71 _(UNSUPPORTED_PROTOCOL, "Unsupported protocol")         \
  72 _(IN2OUT_PACKETS, "Good in2out packets processed")      \
  73 _(NO_TRANSLATION, "No translation")
  74
  75 typedef enum {
  76 #define _(sym,str) LB_NAT_IN2OUT_ERROR_##sym,
  77   foreach_lb_nat_in2out_error
  78 #undef _
  79   LB_NAT_IN2OUT_N_ERROR,
  80 } lb_nat_in2out_error_t;
  81
  82 /**
  83  * lb for kube-proxy supports three types of service
  84  */
  85 typedef enum {
  86   LB_SRV_TYPE_CLUSTERIP,
  87   LB_SRV_TYPE_NODEPORT,
  88   LB_SRV_N_TYPES,
  89 } lb_svr_type_t;
  90
  91 typedef enum {
  92   LB4_NODEPORT_NEXT_IP4_NAT4,
  93   LB4_NODEPORT_NEXT_DROP,
  94   LB4_NODEPORT_N_NEXT,
  95 } lb4_nodeport_next_t;
  96
  97 typedef enum {
  98   LB6_NODEPORT_NEXT_IP6_NAT6,
  99   LB6_NODEPORT_NEXT_DROP,
 100   LB6_NODEPORT_N_NEXT,
 101 } lb6_nodeport_next_t;
 102
 103 /**
 104  * Each VIP is configured with a set of
 105  * application server.
 106  */
 107 typedef struct {
 108   /**
 109    * Registration to FIB event.
 110    */
 111   fib_node_t fib_node;
 112
 113   /**
 114    * Destination address used to tunnel traffic towards
 115    * that application server.
 116    * The address is also used as ID and pseudo-random
 117    * seed for the load-balancing process.
 118    */
 119   ip46_address_t address;
 120
 121   /**
 122    * ASs are indexed by address and VIP Index.
 123    * Which means there will be duplicated if the same server
 124    * address is used for multiple VIPs.
 125    */
 126   u32 vip_index;
 127
 128   /**
 129    * Some per-AS flags.
 130    * For now only LB_AS_FLAGS_USED is defined.
 131    */
 132   u8 flags;
 133
 134 #define LB_AS_FLAGS_USED 0x1
 135
 136   /**
 137    * Rotating timestamp of when LB_AS_FLAGS_USED flag was last set.
 138    *
 139    * AS removal is based on garbage collection and reference counting.
 140    * When an AS is removed, there is a race between configuration core
 141    * and worker cores which may still add a reference while it should not
 142    * be used. This timestamp is used to not remove the AS while a race condition
 143    * may happen.
 144    */
 145   u32 last_used;
 146
 147   /**
 148    * The FIB entry index for the next-hop
 149    */
 150   fib_node_index_t next_hop_fib_entry_index;
 151
 152   /**
 153    * The child index on the FIB entry
 154    */
 155   u32 next_hop_child_index;
 156
 157   /**
 158    * The next DPO in the graph to follow.
 159    */
 160   dpo_id_t dpo;
 161
 162 } lb_as_t;
 163
 164 format_function_t format_lb_as;
 165
 166 typedef struct {
 167   u32 as_index;
 168 } lb_new_flow_entry_t;
 169
 170 #define lb_foreach_vip_counter \
 171  _(NEXT_PACKET, "packet from existing sessions", 0) \
 172  _(FIRST_PACKET, "first session packet", 1) \
 173  _(UNTRACKED_PACKET, "untracked packet", 2) \
 174  _(NO_SERVER, "no server configured", 3)
 175
 176 typedef enum {
 177 #define _(a,b,c) LB_VIP_COUNTER_##a = c,
 178   lb_foreach_vip_counter
 179 #undef _
 180   LB_N_VIP_COUNTERS
 181 } lb_vip_counter_t;
 182
 183 typedef enum {
 184   LB_ENCAP_TYPE_GRE4,
 185   LB_ENCAP_TYPE_GRE6,
 186   LB_ENCAP_TYPE_L3DSR,
 187   LB_ENCAP_TYPE_NAT4,
 188   LB_ENCAP_TYPE_NAT6,
 189   LB_ENCAP_N_TYPES,
 190 } lb_encap_type_t;
 191
 192 /**
 193  * Lookup type
 194  */
 195
 196 typedef enum {
 197   LB_LKP_SAME_IP_PORT,
 198   LB_LKP_DIFF_IP_PORT,
 199   LB_LKP_ALL_PORT_IP,
 200   LB_LKP_N_TYPES,
 201 } lb_lkp_type_t;
 202
 203 /**
 204  * The load balancer supports IPv4 and IPv6 traffic
 205  * and GRE4, GRE6, L3DSR and NAT4, NAT6 encap.
 206  */
 207 typedef enum {
 208   LB_VIP_TYPE_IP6_GRE6,
 209   LB_VIP_TYPE_IP6_GRE4,
 210   LB_VIP_TYPE_IP4_GRE6,
 211   LB_VIP_TYPE_IP4_GRE4,
 212   LB_VIP_TYPE_IP4_L3DSR,
 213   LB_VIP_TYPE_IP4_NAT4,
 214   LB_VIP_TYPE_IP6_NAT6,
 215   LB_VIP_N_TYPES,
 216 } lb_vip_type_t;
 217
 218 format_function_t format_lb_vip_type;
 219 unformat_function_t unformat_lb_vip_type;
 220
 221
 222 /* args for different vip encap types */
 223 typedef struct {
 224   union
 225   {
 226     struct
 227     {
 228       /* Service type. clusterip or nodeport */
 229       u8 srv_type;
 230
 231       /* Pod's port corresponding to specific service. network byte order */
 232       u16 target_port;
 233     };
 234     /* DSCP bits for L3DSR */
 235     u8 dscp;
 236     u64 as_u64;
 237   };
 238 } lb_vip_encap_args_t;
 239
 240 typedef struct {
 241   /* all fields in NET byte order */
 242   union {
 243     struct {
 244       u32 vip_prefix_index;
 245       u16 port;
 246       u8  protocol;
 247       u8 rsv;
 248     };
 249     u64 as_u64;
 250   };
 251 } vip_port_key_t;
 252
 253 /**
 254  * Load balancing service is provided per VIP+protocol+port.
 255  * In this data model, a VIP can be a whole prefix.
 256  * But load balancing only
 257  * occurs on a per-source-address/port basis. Meaning that if a given source
 258  * reuses the same port for multiple destinations within the same VIP,
 259  * they will be considered as a single flow.
 260  */
 261 typedef struct {
 262
 263   //Runtime
 264
 265   /**
 266    * Vector mapping (flow-hash & new_connect_table_mask) to AS index.
 267    * This is used for new flows.
 268    */
 269   lb_new_flow_entry_t *new_flow_table;
 270
 271   /**
 272    * New flows table length - 1
 273    * (length MUST be a power of 2)
 274    */
 275   u32 new_flow_table_mask;
 276
 277   /**
 278    * Last time garbage collection was run to free the ASs.
 279    */
 280   u32 last_garbage_collection;
 281
 282   //Not runtime
 283
 284   /**
 285    * A Virtual IP represents a given service delivered
 286    * by a set of application servers. It can be a single
 287    * address or a prefix.
 288    * IPv4 prefixes are encoded using IPv4-in-IPv6 embedded address
 289    * (i.e. ::/96 prefix).
 290    */
 291   ip46_address_t prefix;
 292
 293   /**
 294    * The VIP prefix length.
 295    * In case of IPv4, plen = 96 + ip4_plen.
 296    */
 297   u8 plen;
 298
 299   /* tcp or udp. If not per-port vip, set to ~0 */
 300   u8 protocol;
 301
 302   /* tcp port or udp port. If not per-port vip, set to ~0 */
 303   u16 port;
 304
 305   /* Valid for per-port vip */
 306   u32 vip_prefix_index;
 307
 308   /**
 309    * The type of traffic for this.
 310    * LB_TYPE_UNDEFINED if unknown.
 311    */
 312   lb_vip_type_t type;
 313
 314   /* args for different vip encap types */
 315   lb_vip_encap_args_t encap_args;
 316
 317   /**
 318    * Flags related to this VIP.
 319    * LB_VIP_FLAGS_USED means the VIP is active.
 320    * When it is not set, the VIP in the process of being removed.
 321    * We cannot immediately remove a VIP because the VIP index still may be stored
 322    * in the adjacency index.
 323    */
 324   u8 flags;
 325 #define LB_VIP_FLAGS_USED 0x1
 326
 327   /**
 328    * Pool of AS indexes used for this VIP.
 329    * This also includes ASs that have been removed (but are still referenced).
 330    */
 331   u32 *as_indexes;
 332 } lb_vip_t;
 333
 334 #define lb_vip_is_ip4(type) (type == LB_VIP_TYPE_IP4_GRE6 \
 335                             || type == LB_VIP_TYPE_IP4_GRE4 \
 336                             || type == LB_VIP_TYPE_IP4_L3DSR \
 337                             || type == LB_VIP_TYPE_IP4_NAT4 )
 338
 339 #define lb_vip_is_ip6(type) (type == LB_VIP_TYPE_IP6_GRE6 \
 340                             || type == LB_VIP_TYPE_IP6_GRE4 \
 341                             || type == LB_VIP_TYPE_IP6_NAT6 )
 342
 343 #define lb_encap_is_ip4(vip) ((vip)->type == LB_VIP_TYPE_IP6_GRE4 \
 344                              || (vip)->type == LB_VIP_TYPE_IP4_GRE4 \
 345                              || (vip)->type == LB_VIP_TYPE_IP4_L3DSR \
 346                              || (vip)->type == LB_VIP_TYPE_IP4_NAT4 )
 347
 348 #define lb_vip_is_gre4(vip) (((vip)->type == LB_VIP_TYPE_IP6_GRE4 \
 349                             || (vip)->type == LB_VIP_TYPE_IP4_GRE4) \
 350                             && ((vip)->port == 0))
 351
 352
 353 #define lb_vip_is_gre6(vip) (((vip)->type == LB_VIP_TYPE_IP6_GRE6 \
 354                             || (vip)->type == LB_VIP_TYPE_IP4_GRE6) \
 355                             && ((vip)->port == 0))
 356
 357 #define lb_vip_is_gre4_port(vip) (((vip)->type == LB_VIP_TYPE_IP6_GRE4 \
 358                                  || (vip)->type == LB_VIP_TYPE_IP4_GRE4) \
 359                                  && ((vip)->port != 0))
 360
 361 #define lb_vip_is_gre6_port(vip) (((vip)->type == LB_VIP_TYPE_IP6_GRE6 \
 362                                  || (vip)->type == LB_VIP_TYPE_IP4_GRE6) \
 363                                  && ((vip)->port != 0))
 364
 365 always_inline bool
 366 lb_vip_is_l3dsr(const lb_vip_t *vip)
 367 {
 368   return (vip->type == LB_VIP_TYPE_IP4_L3DSR && vip->port ==0);
 369 }
 370
 371 always_inline bool
 372 lb_vip_is_l3dsr_port(const lb_vip_t *vip)
 373 {
 374   return (vip->type == LB_VIP_TYPE_IP4_L3DSR && vip->port !=0);
 375 }
 376 always_inline bool
 377 lb_vip_is_nat4_port(const lb_vip_t *vip)
 378 {
 379   return (vip->type == LB_VIP_TYPE_IP4_NAT4 && vip->port !=0);
 380 }
 381 always_inline bool
 382 lb_vip_is_nat6_port(const lb_vip_t *vip)
 383 {
 384   return (vip->type == LB_VIP_TYPE_IP6_NAT6 && vip->port !=0);
 385 }
 386
 387 format_function_t format_lb_vip;
 388 format_function_t format_lb_vip_detailed;
 389
 390 #define foreach_lb_nat_protocol \
 391   _(UDP, 0, udp, "udp")       \
 392   _(TCP, 1, tcp, "tcp")
 393
 394 typedef enum {
 395 #define _(N, i, n, s) LB_NAT_PROTOCOL_##N = i,
 396   foreach_lb_nat_protocol
 397 #undef _
 398 } lb_nat_protocol_t;
 399
 400 always_inline u32
 401 lb_ip_proto_to_nat_proto (u8 ip_proto)
 402 {
 403   u32 nat_proto = ~0;
 404
 405   nat_proto = (ip_proto == IP_PROTOCOL_UDP) ? LB_NAT_PROTOCOL_UDP : nat_proto;
 406   nat_proto = (ip_proto == IP_PROTOCOL_TCP) ? LB_NAT_PROTOCOL_TCP : nat_proto;
 407
 408   return nat_proto;
 409 }
 410
 411 /* Key for Pod's egress SNAT */
 412 typedef struct {
 413   union
 414   {
 415     struct
 416     {
 417       ip4_address_t addr;
 418       u16 port;
 419       u16 protocol:3,
 420           fib_index:13;
 421     };
 422     u64 as_u64;
 423   };
 424 } lb_snat4_key_t;
 425
 426 typedef struct
 427 {
 428   union
 429   {
 430     struct
 431     {
 432       ip6_address_t addr;
 433       u16 port;
 434       u16 protocol;
 435       u32 fib_index;
 436     };
 437     u64 as_u64[3];
 438   };
 439 } lb_snat6_key_t;
 440
 441 typedef struct {
 442   /**
 443    * for vip + port case, src_ip = vip;
 444    * for node ip + node_port, src_ip = node_ip
 445    */
 446   ip46_address_t src_ip;
 447   ip46_address_t as_ip;
 448   u8 src_ip_is_ipv6;
 449   u8 as_ip_is_ipv6;
 450   /**
 451    * Network byte order
 452    * for vip + port case, src_port = port;
 453    * for node ip + node_port, src_port = node_port
 454    */
 455   u16 src_port;
 456   u16 target_port; /* Network byte order */
 457   u32 vrf_id;
 458   u32 fib_index;
 459 } lb_snat_mapping_t;
 460
 461 typedef struct {
 462   /**
 463    * Each CPU has its own sticky flow hash table.
 464    * One single table is used for all VIPs.
 465    */
 466   lb_hash_t *sticky_ht;
 467 } lb_per_cpu_t;
 468
 469 typedef struct {
 470   /**
 471    * Pool of all Virtual IPs
 472    */
 473   lb_vip_t *vips;
 474
 475   /**
 476    * bitmap for vip prefix to support per-port vip
 477    */
 478   uword *vip_prefix_indexes;
 479
 480   /**
 481    * Pool of ASs.
 482    * ASs are referenced by address and vip index.
 483    * The first element (index 0) is special and used only to fill
 484    * new_flow_tables when no AS has been configured.
 485    */
 486   lb_as_t *ass;
 487
 488   /**
 489    * Each AS has an associated reference counter.
 490    * As ass[0] has a special meaning, its associated counter
 491    * starts at 0 and is decremented instead. i.e. do not use it.
 492    */
 493   vlib_refcount_t as_refcount;
 494
 495   /* hash lookup vip_index by key: {u16: nodeport} */
 496   uword * vip_index_by_nodeport;
 497
 498   /**
 499    * Some global data is per-cpu
 500    */
 501   lb_per_cpu_t *per_cpu;
 502
 503   /**
 504    * Node next index for IP adjacencies, for each of the traffic types.
 505    */
 506   u32 ip_lookup_next_index[LB_VIP_N_TYPES];
 507
 508   /**
 509    * Source address used in IPv6 encapsulated traffic
 510    */
 511   ip6_address_t ip6_src_address;
 512
 513   /**
 514    * Source address used for IPv4 encapsulated traffic
 515    */
 516   ip4_address_t ip4_src_address;
 517
 518   /**
 519    * Number of buckets in the per-cpu sticky hash table.
 520    */
 521   u32 per_cpu_sticky_buckets;
 522
 523   /**
 524    * Flow timeout in seconds.
 525    */
 526   u32 flow_timeout;
 527
 528   /**
 529    * Per VIP counter
 530    */
 531   vlib_simple_counter_main_t vip_counters[LB_N_VIP_COUNTERS];
 532
 533   /**
 534    * DPO used to send packet from IP4/6 lookup to LB node.
 535    */
 536   dpo_type_t dpo_gre4_type;
 537   dpo_type_t dpo_gre6_type;
 538   dpo_type_t dpo_gre4_port_type;
 539   dpo_type_t dpo_gre6_port_type;
 540   dpo_type_t dpo_l3dsr_type;
 541   dpo_type_t dpo_l3dsr_port_type;
 542   dpo_type_t dpo_nat4_port_type;
 543   dpo_type_t dpo_nat6_port_type;
 544   /**
 545    * Node type for registering to fib changes.
 546    */
 547   fib_node_type_t fib_node_type;
 548
 549   /* lookup per_port vip by key */
 550   clib_bihash_8_8_t vip_index_per_port;
 551
 552   /* Find a static mapping by AS IP : target_port */
 553   clib_bihash_8_8_t mapping_by_as4;
 554   clib_bihash_24_8_t mapping_by_as6;
 555
 556   /* Static mapping pool */
 557   lb_snat_mapping_t * snat_mappings;
 558
 559   /**
 560    * API dynamically registered base ID.
 561    */
 562   u16 msg_id_base;
 563
 564   volatile u32 *writer_lock;
 565
 566   /* convenience */
 567   vlib_main_t *vlib_main;
 568   vnet_main_t *vnet_main;
 569 } lb_main_t;
 570
 571 /* args for different vip encap types */
 572 typedef struct {
 573   ip46_address_t prefix;
 574   u8 plen;
 575   u8 protocol;
 576   u16 port;
 577   lb_vip_type_t type;
 578   u32 new_length;
 579   lb_vip_encap_args_t encap_args;
 580 } lb_vip_add_args_t;
 581
 582 extern lb_main_t lb_main;
 583 extern vlib_node_registration_t lb4_node;
 584 extern vlib_node_registration_t lb6_node;
 585 extern vlib_node_registration_t lb4_nodeport_node;
 586 extern vlib_node_registration_t lb6_nodeport_node;
 587 extern vlib_node_registration_t lb_nat4_in2out_node;
 588 extern vlib_node_registration_t lb_nat6_in2out_node;
 589
 590 /**
 591  * Fix global load-balancer parameters.
 592  * @param ip4_address IPv4 source address used for encapsulated traffic
 593  * @param ip6_address IPv6 source address used for encapsulated traffic
 594  * @return 0 on success. VNET_LB_ERR_XXX on error
 595  */
 596 int lb_conf(ip4_address_t *ip4_address, ip6_address_t *ip6_address,
 597             u32 sticky_buckets, u32 flow_timeout);
 598
 599 int lb_vip_add(lb_vip_add_args_t args, u32 *vip_index);
 600
 601 int lb_vip_del(u32 vip_index);
 602
 603 int lb_vip_find_index(ip46_address_t *prefix, u8 plen, u8 protocol,
 604                       u16 port, u32 *vip_index);
 605
 606 #define lb_vip_get_by_index(index) (pool_is_free_index(lb_main.vips, index)?NULL:pool_elt_at_index(lb_main.vips, index))
 607
 608 int lb_vip_add_ass(u32 vip_index, ip46_address_t *addresses, u32 n);
 609 int lb_vip_del_ass(u32 vip_index, ip46_address_t *addresses, u32 n, u8 flush);
 610 int lb_flush_vip_as (u32 vip_index, u32 as_index);
 611
 612 u32 lb_hash_time_now(vlib_main_t * vm);
 613
 614 void lb_garbage_collection();
 615
 616 int lb_nat4_interface_add_del (u32 sw_if_index, int is_del);
 617 int lb_nat6_interface_add_del (u32 sw_if_index, int is_del);
 618
 619 format_function_t format_lb_main;
 620
 621 #endif /* LB_PLUGIN_LB_LB_H_ */