src/vnet/adj/adj_glean.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 <vnet/adj/adj.h>
  17 #include <vnet/adj/adj_internal.h>
  18 #include <vnet/fib/fib_walk.h>
  19
  20 /*
  21  * The 'DB' of all glean adjs.
  22  * There is only one glean per-interface per-protocol, so this is a per-interface
  23  * vector
  24  */
  25 static adj_index_t *adj_gleans[FIB_PROTOCOL_MAX];
  26
  27 static inline u32
  28 adj_get_glean_node (fib_protocol_t proto)
  29 {
  30     switch (proto) {
  31     case FIB_PROTOCOL_IP4:
  32         return (ip4_glean_node.index);
  33     case FIB_PROTOCOL_IP6:
  34         return (ip6_glean_node.index);
  35     case FIB_PROTOCOL_MPLS:
  36         break;
  37     }
  38     ASSERT(0);
  39     return (~0);
  40 }
  41
  42 /*
  43  * adj_glean_add_or_lock
  44  *
  45  * The next_hop address here is used for source address selection in the DP.
  46  * The glean adj is added to an interface's connected prefix, the next-hop
  47  * passed here is the local prefix on the same interface.
  48  */
  49 adj_index_t
  50 adj_glean_add_or_lock (fib_protocol_t proto,
  51                        vnet_link_t linkt,
  52                        u32 sw_if_index,
  53                        const ip46_address_t *nh_addr)
  54 {
  55     ip_adjacency_t * adj;
  56
  57     vec_validate_init_empty(adj_gleans[proto], sw_if_index, ADJ_INDEX_INVALID);
  58
  59     if (ADJ_INDEX_INVALID == adj_gleans[proto][sw_if_index])
  60     {
  61         adj = adj_alloc(proto);
  62
  63         adj->lookup_next_index = IP_LOOKUP_NEXT_GLEAN;
  64         adj->ia_nh_proto = proto;
  65         adj->ia_link = linkt;
  66         adj->ia_node_index = adj_get_glean_node(proto);
  67         adj_gleans[proto][sw_if_index] = adj_get_index(adj);
  68
  69         if (NULL != nh_addr)
  70         {
  71             adj->sub_type.glean.receive_addr = *nh_addr;
  72         }
  73         else
  74         {
  75             adj->sub_type.glean.receive_addr = zero_addr;
  76         }
  77
  78         adj->rewrite_header.sw_if_index = sw_if_index;
  79         adj->rewrite_header.data_bytes = 0;
  80         adj->rewrite_header.max_l3_packet_bytes =
  81           vnet_sw_interface_get_mtu(vnet_get_main(), sw_if_index,
  82                                     vnet_link_to_mtu(linkt));
  83         adj_lock(adj_get_index(adj));
  84
  85         vnet_update_adjacency_for_sw_interface(vnet_get_main(),
  86                                                sw_if_index,
  87                                                adj_get_index(adj));
  88     }
  89     else
  90     {
  91         adj = adj_get(adj_gleans[proto][sw_if_index]);
  92         adj_lock(adj_get_index(adj));
  93     }
  94
  95     adj_delegate_adj_created(adj);
  96
  97     return (adj_get_index(adj));
  98 }
  99
 100 /**
 101  * adj_glean_update_rewrite
 102  */
 103 void
 104 adj_glean_update_rewrite (adj_index_t adj_index)
 105 {
 106     ip_adjacency_t *adj;
 107
 108     ASSERT(ADJ_INDEX_INVALID != adj_index);
 109
 110     adj = adj_get(adj_index);
 111
 112     vnet_rewrite_for_sw_interface(vnet_get_main(),
 113                                   adj_fib_proto_2_nd(adj->ia_nh_proto),
 114                                   adj->rewrite_header.sw_if_index,
 115                                   adj->ia_node_index,
 116                                   VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST,
 117                                   &adj->rewrite_header,
 118                                   sizeof (adj->rewrite_data));
 119 }
 120
 121 adj_index_t
 122 adj_glean_get (fib_protocol_t proto,
 123                u32 sw_if_index)
 124 {
 125     if (sw_if_index < vec_len(adj_gleans[proto]))
 126     {
 127         return (adj_gleans[proto][sw_if_index]);
 128     }
 129     return (ADJ_INDEX_INVALID);
 130 }
 131
 132 void
 133 adj_glean_remove (fib_protocol_t proto,
 134                   u32 sw_if_index)
 135 {
 136     ASSERT(sw_if_index < vec_len(adj_gleans[proto]));
 137
 138     adj_gleans[proto][sw_if_index] = ADJ_INDEX_INVALID;
 139 }
 140
 141 static clib_error_t *
 142 adj_glean_interface_state_change (vnet_main_t * vnm,
 143                                   u32 sw_if_index,
 144                                   u32 flags)
 145 {
 146     /*
 147      * for each glean on the interface trigger a walk back to the children
 148      */
 149     fib_protocol_t proto;
 150     ip_adjacency_t *adj;
 151
 152
 153     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 154     {
 155         if (sw_if_index >= vec_len(adj_gleans[proto]) ||
 156             ADJ_INDEX_INVALID == adj_gleans[proto][sw_if_index])
 157             continue;
 158
 159         adj = adj_get(adj_gleans[proto][sw_if_index]);
 160
 161         fib_node_back_walk_ctx_t bw_ctx = {
 162             .fnbw_reason = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP ?
 163                             FIB_NODE_BW_REASON_FLAG_INTERFACE_UP :
 164                             FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN),
 165         };
 166
 167         fib_walk_sync(FIB_NODE_TYPE_ADJ, adj_get_index(adj), &bw_ctx);
 168     }
 169
 170     return (NULL);
 171 }
 172
 173 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(adj_glean_interface_state_change);
 174
 175 /**
 176  * @brief Invoked on each SW interface of a HW interface when the
 177  * HW interface state changes
 178  */
 179 static walk_rc_t
 180 adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
 181                                       u32 sw_if_index,
 182                                       void *arg)
 183 {
 184     adj_glean_interface_state_change(vnm, sw_if_index, (uword) arg);
 185
 186     return (WALK_CONTINUE);
 187 }
 188
 189 /**
 190  * @brief Registered callback for HW interface state changes
 191  */
 192 static clib_error_t *
 193 adj_glean_hw_interface_state_change (vnet_main_t * vnm,
 194                                      u32 hw_if_index,
 195                                      u32 flags)
 196 {
 197     /*
 198      * walk SW interfaces on the HW
 199      */
 200     uword sw_flags;
 201
 202     sw_flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
 203                 VNET_SW_INTERFACE_FLAG_ADMIN_UP :
 204                 0);
 205
 206     vnet_hw_interface_walk_sw(vnm, hw_if_index,
 207                               adj_nbr_hw_sw_interface_state_change,
 208                               (void*) sw_flags);
 209
 210     return (NULL);
 211 }
 212
 213 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(
 214     adj_glean_hw_interface_state_change);
 215
 216 static clib_error_t *
 217 adj_glean_interface_delete (vnet_main_t * vnm,
 218                             u32 sw_if_index,
 219                             u32 is_add)
 220 {
 221     /*
 222      * for each glean on the interface trigger a walk back to the children
 223      */
 224     fib_protocol_t proto;
 225     ip_adjacency_t *adj;
 226
 227     if (is_add)
 228     {
 229         /*
 230          * not interested in interface additions. we will not back walk
 231          * to resolve paths through newly added interfaces. Why? The control
 232          * plane should have the brains to add interfaces first, then routes.
 233          * So the case where there are paths with a interface that matches
 234          * one just created is the case where the path resolved through an
 235          * interface that was deleted, and still has not been removed. The
 236          * new interface added, is NO GUARANTEE that the interface being
 237          * added now, even though it may have the same sw_if_index, is the
 238          * same interface that the path needs. So tough!
 239          * If the control plane wants these routes to resolve it needs to
 240          * remove and add them again.
 241          */
 242         return (NULL);
 243     }
 244
 245     for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
 246     {
 247         if (sw_if_index >= vec_len(adj_gleans[proto]) ||
 248             ADJ_INDEX_INVALID == adj_gleans[proto][sw_if_index])
 249             continue;
 250
 251         adj = adj_get(adj_gleans[proto][sw_if_index]);
 252
 253         fib_node_back_walk_ctx_t bw_ctx = {
 254             .fnbw_reason =  FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
 255         };
 256
 257         fib_walk_sync(FIB_NODE_TYPE_ADJ, adj_get_index(adj), &bw_ctx);
 258     }
 259
 260     return (NULL);
 261 }
 262
 263 VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_glean_interface_delete);
 264
 265 u8*
 266 format_adj_glean (u8* s, va_list *ap)
 267 {
 268     index_t index = va_arg(*ap, index_t);
 269     CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
 270     ip_adjacency_t * adj = adj_get(index);
 271
 272     s = format(s, "%U-glean: %U",
 273                format_fib_protocol, adj->ia_nh_proto,
 274                 format_vnet_rewrite,
 275                 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
 276
 277     return (s);
 278 }
 279
 280
 281 static void
 282 adj_dpo_lock (dpo_id_t *dpo)
 283 {
 284     adj_lock(dpo->dpoi_index);
 285 }
 286 static void
 287 adj_dpo_unlock (dpo_id_t *dpo)
 288 {
 289     adj_unlock(dpo->dpoi_index);
 290 }
 291
 292 const static dpo_vft_t adj_glean_dpo_vft = {
 293     .dv_lock = adj_dpo_lock,
 294     .dv_unlock = adj_dpo_unlock,
 295     .dv_format = format_adj_glean,
 296     .dv_get_urpf = adj_dpo_get_urpf,
 297 };
 298
 299 /**
 300  * @brief The per-protocol VLIB graph nodes that are assigned to a glean
 301  *        object.
 302  *
 303  * this means that these graph nodes are ones from which a glean is the
 304  * parent object in the DPO-graph.
 305  */
 306 const static char* const glean_ip4_nodes[] =
 307 {
 308     "ip4-glean",
 309     NULL,
 310 };
 311 const static char* const glean_ip6_nodes[] =
 312 {
 313     "ip6-glean",
 314     NULL,
 315 };
 316
 317 const static char* const * const glean_nodes[DPO_PROTO_NUM] =
 318 {
 319     [DPO_PROTO_IP4]  = glean_ip4_nodes,
 320     [DPO_PROTO_IP6]  = glean_ip6_nodes,
 321     [DPO_PROTO_MPLS] = NULL,
 322 };
 323
 324 void
 325 adj_glean_module_init (void)
 326 {
 327     dpo_register(DPO_ADJACENCY_GLEAN, &adj_glean_dpo_vft, glean_nodes);
 328 }