src/vnet/gre/gre.h

   1 /*
   2  * gre.h: types/functions for gre.
   3  *
   4  * Copyright (c) 2012 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #ifndef included_gre_h
  19 #define included_gre_h
  20
  21 #include <vnet/vnet.h>
  22 #include <vnet/gre/packet.h>
  23 #include <vnet/ip/ip.h>
  24 #include <vnet/pg/pg.h>
  25 #include <vnet/ip/format.h>
  26 #include <vnet/adj/adj_types.h>
  27 #include <vnet/tunnel/tunnel.h>
  28 #include <vnet/nhrp/nhrp.h>
  29
  30 extern vnet_hw_interface_class_t gre_hw_interface_class;
  31 extern vnet_hw_interface_class_t mgre_hw_interface_class;
  32
  33 typedef enum
  34 {
  35 #define gre_error(n,s) GRE_ERROR_##n,
  36 #include <vnet/gre/error.def>
  37 #undef gre_error
  38   GRE_N_ERROR,
  39 } gre_error_t;
  40
  41 /**
  42  * L3: GRE (i.e. this tunnel is in L3 mode)
  43  * TEB: Transparent Ethernet Bridging - the tunnel is in L2 mode
  44  * ERSPAN: type 2 - the tunnel is for port mirror SPAN output. Each tunnel is
  45  *         associated with a session ID and expected to be used for encap
  46  *         and output of mirrored packet from a L2 network only. There is
  47  *         no support for receiving ERSPAN packets from a GRE ERSPAN tunnel
  48  */
  49 #define foreach_gre_tunnel_type \
  50   _(L3, "L3")                   \
  51   _(TEB, "TEB")                 \
  52   _(ERSPAN, "ERSPAN")           \
  53
  54 /**
  55  * @brief The GRE tunnel type
  56  */
  57 typedef enum gre_tunnel_type_t_
  58 {
  59 #define _(n, s) GRE_TUNNEL_TYPE_##n,
  60   foreach_gre_tunnel_type
  61 #undef _
  62 } __clib_packed gre_tunnel_type_t;
  63
  64 extern u8 *format_gre_tunnel_type (u8 * s, va_list * args);
  65
  66
  67 /**
  68  * A GRE payload protocol registration
  69  */
  70 typedef struct
  71 {
  72   /** Name (a c string). */
  73   char *name;
  74
  75   /** GRE protocol type in host byte order. */
  76   gre_protocol_t protocol;
  77
  78   /** GRE tunnel type */
  79   gre_tunnel_type_t tunnel_type;
  80
  81   /** Node which handles this type. */
  82   u32 node_index;
  83
  84   /** Next index for this type. */
  85   u32 next_index;
  86 } gre_protocol_info_t;
  87
  88 /**
  89  * Elements of the GRE key that are common for v6 and v6 addresses
  90  */
  91 typedef struct gre_tunnel_key_common_t_
  92 {
  93   union
  94   {
  95     struct
  96     {
  97       u32 fib_index;
  98       u16 session_id;
  99       gre_tunnel_type_t type;
 100       tunnel_mode_t mode;
 101     };
 102     u64 as_u64;
 103   };
 104 } gre_tunnel_key_common_t;
 105
 106 STATIC_ASSERT_SIZEOF (gre_tunnel_key_common_t, sizeof (u64));
 107
 108 /**
 109  * @brief Key for a IPv4 GRE Tunnel
 110  */
 111 typedef struct gre_tunnel_key4_t_
 112 {
 113   /**
 114    * Source and destination IP addresses
 115    */
 116   union
 117   {
 118     struct
 119     {
 120       ip4_address_t gtk_src;
 121       ip4_address_t gtk_dst;
 122     };
 123     u64 gtk_as_u64;
 124   };
 125
 126   /** address independent attributes */
 127   gre_tunnel_key_common_t gtk_common;
 128 } __attribute__ ((packed)) gre_tunnel_key4_t;
 129
 130 STATIC_ASSERT_SIZEOF (gre_tunnel_key4_t, 2 * sizeof (u64));
 131
 132 /**
 133  * @brief Key for a IPv6 GRE Tunnel
 134  * We use a different type so that the V4 key hash is as small as possible
 135  */
 136 typedef struct gre_tunnel_key6_t_
 137 {
 138   /**
 139    * Source and destination IP addresses
 140    */
 141   ip6_address_t gtk_src;
 142   ip6_address_t gtk_dst;
 143
 144   /** address independent attributes */
 145   gre_tunnel_key_common_t gtk_common;
 146 } __attribute__ ((packed)) gre_tunnel_key6_t;
 147
 148 STATIC_ASSERT_SIZEOF (gre_tunnel_key6_t, 5 * sizeof (u64));
 149
 150 /**
 151  * Union of the two possible key types
 152  */
 153 typedef union gre_tunnel_key_t_
 154 {
 155   gre_tunnel_key4_t gtk_v4;
 156   gre_tunnel_key6_t gtk_v6;
 157 } gre_tunnel_key_t;
 158
 159 /**
 160  * The session ID is only a 10 bit value
 161  */
 162 #define GTK_SESSION_ID_MAX (0x3ff)
 163
 164 /**
 165  * Used for GRE header seq number generation for ERSPAN encap
 166  */
 167 typedef struct
 168 {
 169   u32 seq_num;
 170   u32 ref_count;
 171 } gre_sn_t;
 172
 173 /**
 174  * Hash key for GRE header seq number generation for ERSPAN encap
 175  */
 176 typedef struct
 177 {
 178   ip46_address_t src;
 179   ip46_address_t dst;
 180   u32 fib_index;
 181 } gre_sn_key_t;
 182
 183 /**
 184  * @brief A representation of a GRE tunnel
 185  */
 186 typedef struct
 187 {
 188   /**
 189    * Required for pool_get_aligned
 190    */
 191   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 192
 193   /**
 194    * The tunnel's source/local address
 195    */
 196   ip46_address_t tunnel_src;
 197   /**
 198    * The tunnel's destination/remote address
 199    */
 200   fib_prefix_t tunnel_dst;
 201   /**
 202    * The FIB in which the src.dst address are present
 203    */
 204   u32 outer_fib_index;
 205   u32 hw_if_index;
 206   u32 sw_if_index;
 207   gre_tunnel_type_t type;
 208   tunnel_mode_t mode;
 209   tunnel_encap_decap_flags_t flags;
 210
 211   /**
 212    * an L2 tunnel always rquires an L2 midchain. cache here for DP.
 213    */
 214   adj_index_t l2_adj_index;
 215
 216   /**
 217    * ERSPAN type 2 session ID, least significant 10 bits of u16
 218    */
 219   u16 session_id;
 220
 221   /**
 222    * GRE header sequence number (SN) used for ERSPAN type 2 header, must be
 223    * bumped automically to be thread safe. As multiple GRE tunnels are created
 224    * for the same fib-idx/DIP/SIP with different ERSPAN session number, they all
 225    * share the same SN which is kept per FIB/DIP/SIP, as specified by RFC2890.
 226    */
 227   gre_sn_t *gre_sn;
 228
 229
 230   u32 dev_instance;             /* Real device instance in tunnel vector */
 231   u32 user_instance;            /* Instance name being shown to user */
 232 } gre_tunnel_t;
 233
 234 typedef struct
 235 {
 236   u8 next_index;
 237   u8 tunnel_type;
 238 } next_info_t;
 239
 240 /**
 241  * @brief GRE related global data
 242  */
 243 typedef struct
 244 {
 245   /**
 246    * pool of tunnel instances
 247    */
 248   gre_tunnel_t *tunnels;
 249
 250   /**
 251    * GRE payload protocol registrations
 252    */
 253   gre_protocol_info_t *protocol_infos;
 254
 255   /**
 256    *  Hash tables mapping name/protocol to protocol info index.
 257    */
 258   uword *protocol_info_by_name, *protocol_info_by_protocol;
 259
 260   /**
 261    * Hash mapping to tunnels with ipv4 src/dst addr
 262    */
 263   uword *tunnel_by_key4;
 264
 265   /**
 266    * Hash mapping to tunnels with ipv6 src/dst addr
 267    */
 268   uword *tunnel_by_key6;
 269
 270   /**
 271    * Hash mapping tunnel src/dst addr and fib-idx to sequence number
 272    */
 273   uword *seq_num_by_key;
 274
 275   /**
 276    * Mapping from sw_if_index to tunnel index
 277    */
 278   u32 *tunnel_index_by_sw_if_index;
 279
 280   /* Sparse vector mapping gre protocol in network byte order
 281      to next index. */
 282   next_info_t *next_by_protocol;
 283
 284   /* convenience */
 285   vlib_main_t *vlib_main;
 286   vnet_main_t *vnet_main;
 287
 288   /* Record used instances */
 289   uword *instance_used;
 290 } gre_main_t;
 291
 292 /**
 293  * @brief IPv4 and GRE header.
 294  */
 295 /* *INDENT-OFF* */
 296 typedef CLIB_PACKED (struct {
 297   ip4_header_t ip4;
 298   gre_header_t gre;
 299 }) ip4_and_gre_header_t;
 300 /* *INDENT-ON* */
 301
 302 /**
 303  * @brief IPv6 and GRE header.
 304  */
 305 /* *INDENT-OFF* */
 306 typedef CLIB_PACKED (struct {
 307   ip6_header_t ip6;
 308   gre_header_t gre;
 309 }) ip6_and_gre_header_t;
 310 /* *INDENT-ON* */
 311
 312 always_inline gre_protocol_info_t *
 313 gre_get_protocol_info (gre_main_t * em, gre_protocol_t protocol)
 314 {
 315   uword *p = hash_get (em->protocol_info_by_protocol, protocol);
 316   return p ? vec_elt_at_index (em->protocol_infos, p[0]) : 0;
 317 }
 318
 319 extern gre_main_t gre_main;
 320
 321 extern clib_error_t *gre_interface_admin_up_down (vnet_main_t * vnm,
 322                                                   u32 hw_if_index, u32 flags);
 323
 324 extern void gre_tunnel_stack (adj_index_t ai);
 325 extern void gre_update_adj (vnet_main_t * vnm,
 326                             u32 sw_if_index, adj_index_t ai);
 327
 328 typedef struct mgre_walk_ctx_t_
 329 {
 330   const gre_tunnel_t *t;
 331   const nhrp_entry_t *ne;
 332 } mgre_walk_ctx_t;
 333
 334 adj_walk_rc_t mgre_mk_complete_walk (adj_index_t ai, void *data);
 335 adj_walk_rc_t mgre_mk_incomplete_walk (adj_index_t ai, void *data);
 336
 337 format_function_t format_gre_protocol;
 338 format_function_t format_gre_header;
 339 format_function_t format_gre_header_with_length;
 340
 341 extern vlib_node_registration_t gre4_input_node;
 342 extern vlib_node_registration_t gre6_input_node;
 343 extern vlib_node_registration_t gre_encap_node;
 344 extern vnet_device_class_t gre_device_class;
 345
 346 /* Parse gre protocol as 0xXXXX or protocol name.
 347    In either host or network byte order. */
 348 unformat_function_t unformat_gre_protocol_host_byte_order;
 349 unformat_function_t unformat_gre_protocol_net_byte_order;
 350
 351 /* Parse gre header. */
 352 unformat_function_t unformat_gre_header;
 353 unformat_function_t unformat_pg_gre_header;
 354
 355 void
 356 gre_register_input_protocol (vlib_main_t * vm, gre_protocol_t protocol,
 357                              u32 node_index, gre_tunnel_type_t tunnel_type);
 358
 359 /* manually added to the interface output node in gre.c */
 360 #define GRE_OUTPUT_NEXT_LOOKUP  1
 361
 362 typedef struct
 363 {
 364   u8 is_add;
 365   gre_tunnel_type_t type;
 366   tunnel_mode_t mode;
 367   u8 is_ipv6;
 368   u32 instance;
 369   ip46_address_t src, dst;
 370   u32 outer_table_id;
 371   u16 session_id;
 372   tunnel_encap_decap_flags_t flags;
 373 } vnet_gre_tunnel_add_del_args_t;
 374
 375 extern int vnet_gre_tunnel_add_del (vnet_gre_tunnel_add_del_args_t * a,
 376                                     u32 * sw_if_indexp);
 377
 378 static inline void
 379 gre_mk_key4 (ip4_address_t src,
 380              ip4_address_t dst,
 381              u32 fib_index,
 382              gre_tunnel_type_t ttype,
 383              tunnel_mode_t tmode, u16 session_id, gre_tunnel_key4_t * key)
 384 {
 385   key->gtk_src = src;
 386   key->gtk_dst = dst;
 387   key->gtk_common.type = ttype;
 388   key->gtk_common.mode = tmode;
 389   key->gtk_common.fib_index = fib_index;
 390   key->gtk_common.session_id = session_id;
 391 }
 392
 393 static inline int
 394 gre_match_key4 (const gre_tunnel_key4_t * key1,
 395                 const gre_tunnel_key4_t * key2)
 396 {
 397   return ((key1->gtk_as_u64 == key2->gtk_as_u64) &&
 398           (key1->gtk_common.as_u64 == key2->gtk_common.as_u64));
 399 }
 400
 401 static inline void
 402 gre_mk_key6 (const ip6_address_t * src,
 403              const ip6_address_t * dst,
 404              u32 fib_index,
 405              gre_tunnel_type_t ttype,
 406              tunnel_mode_t tmode, u16 session_id, gre_tunnel_key6_t * key)
 407 {
 408   key->gtk_src = *src;
 409   key->gtk_dst = *dst;
 410   key->gtk_common.type = ttype;
 411   key->gtk_common.mode = tmode;
 412   key->gtk_common.fib_index = fib_index;
 413   key->gtk_common.session_id = session_id;
 414 }
 415
 416 static inline int
 417 gre_match_key6 (const gre_tunnel_key6_t * key1,
 418                 const gre_tunnel_key6_t * key2)
 419 {
 420   return (ip6_address_is_equal (&key1->gtk_src, &key2->gtk_src) &&
 421           ip6_address_is_equal (&key1->gtk_dst, &key2->gtk_dst) &&
 422           (key1->gtk_common.as_u64 == key2->gtk_common.as_u64));
 423 }
 424
 425 static inline void
 426 gre_mk_sn_key (const gre_tunnel_t * gt, gre_sn_key_t * key)
 427 {
 428   key->src = gt->tunnel_src;
 429   key->dst = gt->tunnel_dst.fp_addr;
 430   key->fib_index = gt->outer_fib_index;
 431 }
 432
 433 #endif /* included_gre_h */
 434
 435 /*
 436  * fd.io coding-style-patch-verification: ON
 437  *
 438  * Local Variables:
 439  * eval: (c-set-style "gnu")
 440  * End:
 441  */