src/vnet/teib/teib.c

   1 /*
   2  * teib.h: Tunnel Endpoint Information Base
   3  *
   4  * Copyright (c) 2020 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
  19 #include <vnet/teib/teib.h>
  20 #include <vnet/fib/fib_table.h>
  21 #include <vnet/adj/adj_midchain.h>
  22 #include <vnet/ip/ip6_ll_table.h>
  23
  24 typedef struct teib_key_t_
  25 {
  26   ip_address_t tk_peer;
  27   u8 __pad[3];
  28   u32 tk_sw_if_index;
  29 } __clib_packed teib_key_t;
  30
  31 STATIC_ASSERT_SIZEOF (teib_key_t, 24);
  32
  33 struct teib_entry_t_
  34 {
  35   teib_key_t *te_key;
  36   fib_prefix_t te_nh;
  37   u32 te_fib_index;
  38 };
  39
  40 typedef struct teib_db_t_
  41 {
  42   u32 td_n_entries[N_AF];
  43   uword *td_db;
  44 } teib_db_t;
  45
  46 static teib_db_t teib_db;
  47 static teib_entry_t *teib_pool;
  48 static teib_vft_t *teib_vfts;
  49 static vlib_log_class_t teib_logger;
  50
  51 #define TEIB_NOTIFY(_te, _fn) {                  \
  52   teib_vft_t *_vft;                              \
  53   vec_foreach(_vft, teib_vfts) {                 \
  54     if (_vft->_fn) {                             \
  55       _vft->_fn(_te);                            \
  56     }                                            \
  57   }                                              \
  58 }
  59
  60 #define TEIB_DBG(...)                           \
  61     vlib_log_debug (teib_logger, __VA_ARGS__);
  62
  63 #define TEIB_INFO(...)                          \
  64     vlib_log_notice (teib_logger, __VA_ARGS__);
  65
  66 #define TEIB_TE_DBG(_te, _fmt, _args...)                      \
  67   vlib_log_debug (teib_logger, "[%U]: " _fmt, format_teib_entry, _te - teib_pool, ##_args)
  68 #define TEIB_TE_INFO(_te, _fmt, _args...)                      \
  69   vlib_log_notice (teib_logger, "[%U]: " _fmt, format_teib_entry, _te - teib_pool, ##_args)
  70
  71 u32
  72 teib_entry_get_sw_if_index (const teib_entry_t * te)
  73 {
  74   return (te->te_key->tk_sw_if_index);
  75 }
  76
  77 static ip_address_family_t
  78 teib_entry_get_af (const teib_entry_t * te)
  79 {
  80   return (ip_addr_version (&te->te_key->tk_peer));
  81 }
  82
  83 u32
  84 teib_entry_get_fib_index (const teib_entry_t * te)
  85 {
  86   return (te->te_fib_index);
  87 }
  88
  89 const ip_address_t *
  90 teib_entry_get_peer (const teib_entry_t * te)
  91 {
  92   return (&te->te_key->tk_peer);
  93 }
  94
  95 const fib_prefix_t *
  96 teib_entry_get_nh (const teib_entry_t * te)
  97 {
  98   return (&te->te_nh);
  99 }
 100
 101 void
 102 teib_entry_adj_stack (const teib_entry_t * te, adj_index_t ai)
 103 {
 104   adj_midchain_delegate_stack (ai, te->te_fib_index, &te->te_nh);
 105 }
 106
 107 teib_entry_t *
 108 teib_entry_get (index_t tei)
 109 {
 110   return pool_elt_at_index (teib_pool, tei);
 111 }
 112
 113 teib_entry_t *
 114 teib_entry_find (u32 sw_if_index, const ip_address_t * peer)
 115 {
 116   teib_key_t nk = {
 117     .tk_peer = *peer,
 118     .tk_sw_if_index = sw_if_index,
 119   };
 120   uword *p;
 121
 122   p = hash_get_mem (teib_db.td_db, &nk);
 123
 124   if (NULL != p)
 125     return teib_entry_get (p[0]);
 126
 127   return (NULL);
 128 }
 129
 130 teib_entry_t *
 131 teib_entry_find_46 (u32 sw_if_index,
 132                     fib_protocol_t fproto, const ip46_address_t * peer)
 133 {
 134   ip_address_t ip;
 135
 136   ip_address_from_46 (peer, fproto, &ip);
 137
 138   return (teib_entry_find (sw_if_index, &ip));
 139 }
 140
 141 static void
 142 teib_adj_fib_add (const ip_address_t * ip, u32 sw_if_index, u32 fib_index)
 143 {
 144   if (AF_IP6 == ip_addr_version (ip) &&
 145       ip6_address_is_link_local_unicast (&ip_addr_v6 (ip)))
 146     {
 147       ip6_ll_prefix_t pfx = {
 148         .ilp_addr = ip_addr_v6 (ip),
 149         .ilp_sw_if_index = sw_if_index,
 150       };
 151       ip6_ll_table_entry_update (&pfx, FIB_ROUTE_PATH_FLAG_NONE);
 152     }
 153   else
 154     {
 155       fib_prefix_t pfx;
 156
 157       ip_address_to_fib_prefix (ip, &pfx);
 158       fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
 159                                 FIB_ENTRY_FLAG_ATTACHED,
 160                                 fib_proto_to_dpo (pfx.fp_proto),
 161                                 &pfx.fp_addr,
 162                                 sw_if_index,
 163                                 ~0, 1, NULL, FIB_ROUTE_PATH_FLAG_NONE);
 164
 165
 166       if (0 == teib_db.td_n_entries[ip_addr_version (ip)]++)
 167         fib_table_lock (fib_index, pfx.fp_proto, FIB_SOURCE_ADJ);
 168     }
 169 }
 170
 171 static void
 172 teib_adj_fib_remove (ip_address_t * ip, u32 sw_if_index, u32 fib_index)
 173 {
 174   if (AF_IP6 == ip_addr_version (ip) &&
 175       ip6_address_is_link_local_unicast (&ip_addr_v6 (ip)))
 176     {
 177       ip6_ll_prefix_t pfx = {
 178         .ilp_addr = ip_addr_v6 (ip),
 179         .ilp_sw_if_index = sw_if_index,
 180       };
 181       ip6_ll_table_entry_delete (&pfx);
 182     }
 183   else
 184     {
 185       fib_prefix_t pfx;
 186
 187       ip_address_to_fib_prefix (ip, &pfx);
 188       fib_table_entry_path_remove (fib_index, &pfx, FIB_SOURCE_ADJ,
 189                                    fib_proto_to_dpo (pfx.fp_proto),
 190                                    &pfx.fp_addr,
 191                                    sw_if_index,
 192                                    ~0, 1, FIB_ROUTE_PATH_FLAG_NONE);
 193
 194       if (0 == --teib_db.td_n_entries[ip_addr_version (ip)])
 195         fib_table_unlock (fib_index, pfx.fp_proto, FIB_SOURCE_ADJ);
 196     }
 197 }
 198
 199 int
 200 teib_entry_add (u32 sw_if_index,
 201                 const ip_address_t * peer,
 202                 u32 nh_table_id, const ip_address_t * nh)
 203 {
 204   fib_protocol_t nh_proto;
 205   teib_entry_t *te;
 206   u32 fib_index;
 207   index_t tei;
 208
 209   nh_proto = (AF_IP4 == ip_addr_version (nh) ?
 210               FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6);
 211
 212   fib_index = fib_table_find (nh_proto, nh_table_id);
 213
 214   if (~0 == fib_index)
 215     {
 216       return (VNET_API_ERROR_NO_SUCH_FIB);
 217     }
 218
 219   te = teib_entry_find (sw_if_index, peer);
 220
 221   if (NULL == te)
 222     {
 223       teib_key_t nk = {
 224         .tk_peer = *peer,
 225         .tk_sw_if_index = sw_if_index,
 226       };
 227       teib_entry_t *te;
 228
 229       pool_get_zero (teib_pool, te);
 230
 231       tei = te - teib_pool;
 232       te->te_key = clib_mem_alloc (sizeof (*te->te_key));
 233       clib_memcpy (te->te_key, &nk, sizeof (*te->te_key));
 234
 235       ip_address_to_fib_prefix (nh, &te->te_nh);
 236       te->te_fib_index = fib_index;
 237
 238       hash_set_mem (teib_db.td_db, te->te_key, tei);
 239
 240       /* we how have a /32 in the overlay, add an adj-fib */
 241       teib_adj_fib_add (&te->te_key->tk_peer, sw_if_index, fib_index);
 242
 243       TEIB_NOTIFY (te, nv_added);
 244       TEIB_TE_INFO (te, "created");
 245     }
 246   else
 247     {
 248       TEIB_TE_INFO (te, "exists");
 249       return (VNET_API_ERROR_ENTRY_ALREADY_EXISTS);
 250     }
 251   return 0;
 252 }
 253
 254 int
 255 teib_entry_del (u32 sw_if_index, const ip_address_t * peer)
 256 {
 257   teib_entry_t *te;
 258
 259   te = teib_entry_find (sw_if_index, peer);
 260
 261   if (te != NULL)
 262     {
 263       TEIB_TE_INFO (te, "removed");
 264
 265       u32 fib_index;
 266
 267       fib_index = fib_table_get_index_for_sw_if_index
 268         (ip_address_family_to_fib_proto (ip_addr_version (peer)),
 269          sw_if_index);
 270
 271       teib_adj_fib_remove (&te->te_key->tk_peer, sw_if_index, fib_index);
 272
 273       hash_unset_mem (teib_db.td_db, te->te_key);
 274
 275       TEIB_NOTIFY (te, nv_deleted);
 276
 277       clib_mem_free (te->te_key);
 278       pool_put (teib_pool, te);
 279     }
 280   else
 281     {
 282       TEIB_INFO ("no such entry: %U, %U, %U",
 283                  format_vnet_sw_if_index_name,
 284                  vnet_get_main (), sw_if_index, format_ip_address, peer);
 285       return (VNET_API_ERROR_NO_SUCH_ENTRY);
 286     }
 287   return 0;
 288 }
 289
 290 u8 *
 291 format_teib_entry (u8 * s, va_list * args)
 292 {
 293   index_t tei = va_arg (*args, index_t);
 294   vnet_main_t *vnm = vnet_get_main ();
 295   teib_entry_t *te;
 296
 297   te = teib_entry_get (tei);
 298
 299   s = format (s, "[%d] ", tei);
 300   s = format (s, "%U:", format_vnet_sw_if_index_name,
 301               vnm, te->te_key->tk_sw_if_index);
 302   s = format (s, "%U", format_ip_address,
 303               &te->te_key->tk_peer, IP46_TYPE_ANY);
 304   s = format (s, " via [%d]:%U",
 305               fib_table_get_table_id (te->te_fib_index, te->te_nh.fp_proto),
 306               format_fib_prefix, &te->te_nh);
 307
 308   return (s);
 309 }
 310
 311 void
 312 teib_walk (teib_walk_cb_t fn, void *ctx)
 313 {
 314   index_t tei;
 315
 316   /* *INDENT-OFF* */
 317   pool_foreach_index (tei, teib_pool)
 318    {
 319     fn(tei, ctx);
 320   }
 321   /* *INDENT-ON* */
 322 }
 323
 324 void
 325 teib_walk_itf (u32 sw_if_index, teib_walk_cb_t fn, void *ctx)
 326 {
 327   index_t tei;
 328
 329   /* *INDENT-OFF* */
 330   pool_foreach_index (tei, teib_pool)
 331    {
 332     if (sw_if_index == teib_entry_get_sw_if_index(teib_entry_get(tei)))
 333       fn(tei, ctx);
 334   }
 335   /* *INDENT-ON* */
 336 }
 337
 338 static void
 339 teib_walk_itf_proto (u32 sw_if_index,
 340                      ip_address_family_t af, teib_walk_cb_t fn, void *ctx)
 341 {
 342   index_t tei;
 343
 344   /* *INDENT-OFF* */
 345   pool_foreach_index (tei, teib_pool)
 346    {
 347     if (sw_if_index == teib_entry_get_sw_if_index(teib_entry_get(tei)) &&
 348         af == teib_entry_get_af(teib_entry_get(tei)))
 349       fn(tei, ctx);
 350   }
 351   /* *INDENT-ON* */
 352 }
 353
 354 typedef struct teib_table_bind_ctx_t_
 355 {
 356   u32 new_fib_index;
 357   u32 old_fib_index;
 358 } teib_table_bind_ctx_t;
 359
 360 static walk_rc_t
 361 teib_walk_table_bind (index_t tei, void *arg)
 362 {
 363   teib_table_bind_ctx_t *ctx = arg;
 364   teib_entry_t *te;
 365
 366   te = teib_entry_get (tei);
 367
 368   TEIB_TE_INFO (te, "bind: %d -> %d", ctx->old_fib_index, ctx->new_fib_index);
 369
 370   teib_adj_fib_remove (&te->te_key->tk_peer,
 371                        te->te_key->tk_sw_if_index, ctx->old_fib_index);
 372   teib_adj_fib_add (&te->te_key->tk_peer,
 373                     te->te_key->tk_sw_if_index, ctx->new_fib_index);
 374
 375   return (WALK_CONTINUE);
 376 }
 377
 378 static void
 379 teib_table_bind_v4 (ip4_main_t * im,
 380                     uword opaque,
 381                     u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
 382 {
 383   teib_table_bind_ctx_t ctx = {
 384     .old_fib_index = old_fib_index,
 385     .new_fib_index = new_fib_index,
 386   };
 387
 388   teib_walk_itf_proto (sw_if_index, AF_IP4, teib_walk_table_bind, &ctx);
 389 }
 390
 391 static void
 392 teib_table_bind_v6 (ip6_main_t * im,
 393                     uword opaque,
 394                     u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
 395 {
 396   teib_table_bind_ctx_t ctx = {
 397     .old_fib_index = old_fib_index,
 398     .new_fib_index = new_fib_index,
 399   };
 400
 401   teib_walk_itf_proto (sw_if_index, AF_IP6, teib_walk_table_bind, &ctx);
 402 }
 403
 404 void
 405 teib_register (const teib_vft_t * vft)
 406 {
 407   vec_add1 (teib_vfts, *vft);
 408 }
 409
 410 static clib_error_t *
 411 teib_init (vlib_main_t * vm)
 412 {
 413   teib_db.td_db = hash_create_mem (0, sizeof (teib_key_t), sizeof (u32));
 414
 415   ip4_table_bind_callback_t cb4 = {
 416     .function = teib_table_bind_v4,
 417   };
 418   vec_add1 (ip4_main.table_bind_callbacks, cb4);
 419
 420   ip6_table_bind_callback_t cb6 = {
 421     .function = teib_table_bind_v6,
 422   };
 423   vec_add1 (ip6_main.table_bind_callbacks, cb6);
 424
 425   teib_logger = vlib_log_register_class ("teib", "teib");
 426
 427   return (NULL);
 428 }
 429
 430 VLIB_INIT_FUNCTION (teib_init);
 431
 432 /*
 433  * fd.io coding-style-patch-verification: ON
 434  *
 435  * Local Variables:
 436  * eval: (c-set-style "gnu")
 437  * End:
 438  */