sys/net/route/route_helpers.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2020 Alexander V. Chernikov
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30 #include "opt_inet.h"
  31 #include "opt_inet6.h"
  32 #include "opt_route.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/jail.h>
  36 #include <sys/systm.h>
  37 #include <sys/malloc.h>
  38 #include <sys/mbuf.h>
  39 #include <sys/socket.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/syslog.h>
  42 #include <sys/sysproto.h>
  43 #include <sys/proc.h>
  44 #include <sys/domain.h>
  45 #include <sys/kernel.h>
  46 #include <sys/lock.h>
  47 #include <sys/rmlock.h>
  48
  49 #include <net/if.h>
  50 #include <net/if_var.h>
  51 #include <net/if_dl.h>
  52 #include <net/route.h>
  53 #include <net/route/route_ctl.h>
  54 #include <net/route/route_var.h>
  55 #include <net/route/nhop_utils.h>
  56 #include <net/route/nhop.h>
  57 #include <net/route/nhop_var.h>
  58 #ifdef INET
  59 #include <netinet/in_fib.h>
  60 #endif
  61 #ifdef INET6
  62 #include <netinet6/in6_fib.h>
  63 #endif
  64 #include <net/vnet.h>
  65
  66 /*
  67  * RIB helper functions.
  68  */
  69
  70 /*
  71  * Calls @wa_f with @arg for each entry in the table specified by
  72  * @af and @fibnum.
  73  *
  74  * @ss_t callback is called before and after the tree traversal
  75  *  while holding table lock.
  76  *
  77  * Table is traversed under read lock unless @wlock is set.
  78  */
  79 void
  80 rib_walk_ext_internal(struct rib_head *rnh, bool wlock, rib_walktree_f_t *wa_f,
  81     rib_walk_hook_f_t *hook_f, void *arg)
  82 {
  83         RIB_RLOCK_TRACKER;
  84
  85         if (wlock)
  86                 RIB_WLOCK(rnh);
  87         else
  88                 RIB_RLOCK(rnh);
  89         if (hook_f != NULL)
  90                 hook_f(rnh, RIB_WALK_HOOK_PRE, arg);
  91         rnh->rnh_walktree(&rnh->head, (walktree_f_t *)wa_f, arg);
  92         if (hook_f != NULL)
  93                 hook_f(rnh, RIB_WALK_HOOK_POST, arg);
  94         if (wlock)
  95                 RIB_WUNLOCK(rnh);
  96         else
  97                 RIB_RUNLOCK(rnh);
  98 }
  99
 100 void
 101 rib_walk_ext(uint32_t fibnum, int family, bool wlock, rib_walktree_f_t *wa_f,
 102     rib_walk_hook_f_t *hook_f, void *arg)
 103 {
 104         struct rib_head *rnh;
 105
 106         if ((rnh = rt_tables_get_rnh(fibnum, family)) != NULL)
 107                 rib_walk_ext_internal(rnh, wlock, wa_f, hook_f, arg);
 108 }
 109
 110 /*
 111  * Calls @wa_f with @arg for each entry in the table specified by
 112  * @af and @fibnum.
 113  *
 114  * Table is traversed under read lock unless @wlock is set.
 115  */
 116 void
 117 rib_walk(uint32_t fibnum, int family, bool wlock, rib_walktree_f_t *wa_f,
 118     void *arg)
 119 {
 120
 121         rib_walk_ext(fibnum, family, wlock, wa_f, NULL, arg);
 122 }
 123
 124 /*
 125  * Iterates over all existing fibs in system calling
 126  *  @hook_f function before/after traversing each fib.
 127  *  Calls @wa_f function for each element in current fib.
 128  * If af is not AF_UNSPEC, iterates over fibs in particular
 129  * address family.
 130  */
 131 void
 132 rib_foreach_table_walk(int family, bool wlock, rib_walktree_f_t *wa_f,
 133     rib_walk_hook_f_t *hook_f, void *arg)
 134 {
 135
 136         for (uint32_t fibnum = 0; fibnum < rt_numfibs; fibnum++) {
 137                 /* Do we want some specific family? */
 138                 if (family != AF_UNSPEC) {
 139                         rib_walk_ext(fibnum, family, wlock, wa_f, hook_f, arg);
 140                         continue;
 141                 }
 142
 143                 for (int i = 1; i <= AF_MAX; i++)
 144                         rib_walk_ext(fibnum, i, wlock, wa_f, hook_f, arg);
 145         }
 146 }
 147
 148 /*
 149  * Iterates over all existing fibs in system and deletes each element
 150  *  for which @filter_f function returns non-zero value.
 151  * If @family is not AF_UNSPEC, iterates over fibs in particular
 152  * address family.
 153  */
 154 void
 155 rib_foreach_table_walk_del(int family, rib_filter_f_t *filter_f, void *arg)
 156 {
 157
 158         for (uint32_t fibnum = 0; fibnum < rt_numfibs; fibnum++) {
 159                 /* Do we want some specific family? */
 160                 if (family != AF_UNSPEC) {
 161                         rib_walk_del(fibnum, family, filter_f, arg, 0);
 162                         continue;
 163                 }
 164
 165                 for (int i = 1; i <= AF_MAX; i++)
 166                         rib_walk_del(fibnum, i, filter_f, arg, 0);
 167         }
 168 }
 169
 170
 171 /*
 172  * Wrapper for the control plane functions for performing af-agnostic
 173  *  lookups.
 174  * @fibnum: fib to perform the lookup.
 175  * @dst: sockaddr with family and addr filled in. IPv6 addresses needs to be in
 176  *  deembedded from.
 177  * @flags: fib(9) flags.
 178  * @flowid: flow id for path selection in multipath use case.
 179  *
 180  * Returns nhop_object or NULL.
 181  *
 182  * Requires NET_EPOCH.
 183  *
 184  */
 185 struct nhop_object *
 186 rib_lookup(uint32_t fibnum, const struct sockaddr *dst, uint32_t flags,
 187     uint32_t flowid)
 188 {
 189         struct nhop_object *nh;
 190
 191         nh = NULL;
 192
 193         switch (dst->sa_family) {
 194 #ifdef INET
 195         case AF_INET:
 196         {
 197                 const struct sockaddr_in *a = (const struct sockaddr_in *)dst;
 198                 nh = fib4_lookup(fibnum, a->sin_addr, 0, flags, flowid);
 199                 break;
 200         }
 201 #endif
 202 #ifdef INET6
 203         case AF_INET6:
 204         {
 205                 const struct sockaddr_in6 *a = (const struct sockaddr_in6*)dst;
 206                 nh = fib6_lookup(fibnum, &a->sin6_addr, a->sin6_scope_id,
 207                     flags, flowid);
 208                 break;
 209         }
 210 #endif
 211         }
 212
 213         return (nh);
 214 }
 215
 216 #ifdef ROUTE_MPATH
 217 static void
 218 decompose_change_notification(struct rib_cmd_info *rc, route_notification_t *cb,
 219     void *cbdata)
 220 {
 221         uint32_t num_old, num_new;
 222         uint32_t nh_idx_old, nh_idx_new;
 223         struct weightened_nhop *wn_old, *wn_new;
 224         struct weightened_nhop tmp = { NULL, 0 };
 225         uint32_t idx_old = 0, idx_new = 0;
 226
 227         struct rib_cmd_info rc_del = { .rc_cmd = RTM_DELETE, .rc_rt = rc->rc_rt };
 228         struct rib_cmd_info rc_add = { .rc_cmd = RTM_ADD, .rc_rt = rc->rc_rt };
 229
 230         if (NH_IS_NHGRP(rc->rc_nh_old)) {
 231                 wn_old = nhgrp_get_nhops((struct nhgrp_object *)rc->rc_nh_old, &num_old);
 232         } else {
 233                 tmp.nh = rc->rc_nh_old;
 234                 tmp.weight = rc->rc_nh_weight;
 235                 wn_old = &tmp;
 236                 num_old = 1;
 237         }
 238         if (NH_IS_NHGRP(rc->rc_nh_new)) {
 239                 wn_new = nhgrp_get_nhops((struct nhgrp_object *)rc->rc_nh_new, &num_new);
 240         } else {
 241                 tmp.nh = rc->rc_nh_new;
 242                 tmp.weight = rc->rc_nh_weight;
 243                 wn_new = &tmp;
 244                 num_new = 1;
 245         }
 246
 247         /* Use the fact that each @wn array is sorted */
 248         /*
 249          * Want to convert into set of add and delete operations
 250          * [1] -> [1, 2] = A{2}
 251          * [2] -> [1, 2] = A{1}
 252          * [1, 2, 4]->[1, 3, 4] = A{2}, D{3}
 253          * [1, 2, 4]->[1, 4] = D{2}
 254          * [1, 2, 4] -> [3, 4] = D{1}, C{2,3} OR C{1,3}, D{2} OR D{1},D{2},A{3}
 255          * [1, 2] -> [3, 4] =
 256          *
 257          */
 258         idx_old = 0;
 259         while ((idx_old < num_old) && (idx_new < num_new)) {
 260                 nh_idx_old = wn_old[idx_old].nh->nh_priv->nh_idx;
 261                 nh_idx_new = wn_new[idx_new].nh->nh_priv->nh_idx;
 262
 263                 if (nh_idx_old == nh_idx_new) {
 264                         if (wn_old[idx_old].weight != wn_new[idx_new].weight) {
 265                                 /* Update weight by providing del/add notifications */
 266                                 rc_del.rc_nh_old = wn_old[idx_old].nh;
 267                                 rc_del.rc_nh_weight = wn_old[idx_old].weight;
 268                                 cb(&rc_del, cbdata);
 269
 270                                 rc_add.rc_nh_new = wn_new[idx_new].nh;
 271                                 rc_add.rc_nh_weight = wn_new[idx_new].weight;
 272                                 cb(&rc_add, cbdata);
 273                         }
 274                         idx_old++;
 275                         idx_new++;
 276                 } else if (nh_idx_old < nh_idx_new) {
 277                         /*
 278                          * [1, ~2~, 4], [1, ~3~, 4]
 279                          * [1, ~2~, 5], [1, ~3~, 4]
 280                          * [1, ~2~], [1, ~3~, 4]
 281                          */
 282                         if ((idx_old + 1 >= num_old) ||
 283                             (wn_old[idx_old + 1].nh->nh_priv->nh_idx > nh_idx_new)) {
 284                                 /* Add new unless the next old item is still <= new */
 285                                 rc_add.rc_nh_new = wn_new[idx_new].nh;
 286                                 rc_add.rc_nh_weight = wn_new[idx_new].weight;
 287                                 cb(&rc_add, cbdata);
 288                                 idx_new++;
 289                         }
 290                         /* In any case, delete current old */
 291                         rc_del.rc_nh_old = wn_old[idx_old].nh;
 292                         rc_del.rc_nh_weight = wn_old[idx_old].weight;
 293                         cb(&rc_del, cbdata);
 294                         idx_old++;
 295                 } else {
 296                         /*
 297                          * nh_idx_old > nh_idx_new
 298                          *
 299                          * [1, ~3~, 4], [1, ~2~, 4]
 300                          * [1, ~3~, 5], [1, ~2~, 4]
 301                          * [1, ~3~, 4], [1, ~2~]
 302                          */
 303                         if ((idx_new + 1 >= num_new) ||
 304                             (wn_new[idx_new + 1].nh->nh_priv->nh_idx > nh_idx_old)) {
 305                                 /* No next item or next item is > current one */
 306                                 rc_add.rc_nh_new = wn_new[idx_new].nh;
 307                                 rc_add.rc_nh_weight = wn_new[idx_new].weight;
 308                                 cb(&rc_add, cbdata);
 309                                 idx_new++;
 310                         }
 311                         /* In any case, delete current old */
 312                         rc_del.rc_nh_old = wn_old[idx_old].nh;
 313                         rc_del.rc_nh_weight = wn_old[idx_old].weight;
 314                         cb(&rc_del, cbdata);
 315                         idx_old++;
 316                 }
 317         }
 318
 319         while (idx_old < num_old) {
 320                 rc_del.rc_nh_old = wn_old[idx_old].nh;
 321                 rc_del.rc_nh_weight = wn_old[idx_old].weight;
 322                 cb(&rc_del, cbdata);
 323                 idx_old++;
 324         }
 325
 326         while (idx_new < num_new) {
 327                 rc_add.rc_nh_new = wn_new[idx_new].nh;
 328                 rc_add.rc_nh_weight = wn_new[idx_new].weight;
 329                 cb(&rc_add, cbdata);
 330                 idx_new++;
 331         }
 332 }
 333
 334 /*
 335  * Decompose multipath cmd info @rc into a list of add/del/change
 336  *  single-path operations, calling @cb callback for each operation.
 337  * Assumes at least one of the nexthops in @rc is multipath.
 338  */
 339 void
 340 rib_decompose_notification(struct rib_cmd_info *rc, route_notification_t *cb,
 341     void *cbdata)
 342 {
 343         struct weightened_nhop *wn;
 344         uint32_t num_nhops;
 345         struct rib_cmd_info rc_new;
 346
 347         rc_new = *rc;
 348         DPRINTF("cb=%p cmd=%d nh_old=%p nh_new=%p",
 349             cb, rc->cmd, rc->nh_old, rc->nh_new);
 350         switch (rc->rc_cmd) {
 351         case RTM_ADD:
 352                 if (!NH_IS_NHGRP(rc->rc_nh_new))
 353                         return;
 354                 wn = nhgrp_get_nhops((struct nhgrp_object *)rc->rc_nh_new, &num_nhops);
 355                 for (uint32_t i = 0; i < num_nhops; i++) {
 356                         rc_new.rc_nh_new = wn[i].nh;
 357                         rc_new.rc_nh_weight = wn[i].weight;
 358                         cb(&rc_new, cbdata);
 359                 }
 360                 break;
 361         case RTM_DELETE:
 362                 if (!NH_IS_NHGRP(rc->rc_nh_old))
 363                         return;
 364                 wn = nhgrp_get_nhops((struct nhgrp_object *)rc->rc_nh_old, &num_nhops);
 365                 for (uint32_t i = 0; i < num_nhops; i++) {
 366                         rc_new.rc_nh_old = wn[i].nh;
 367                         rc_new.rc_nh_weight = wn[i].weight;
 368                         cb(&rc_new, cbdata);
 369                 }
 370                 break;
 371         case RTM_CHANGE:
 372                 if (!NH_IS_NHGRP(rc->rc_nh_old) && !NH_IS_NHGRP(rc->rc_nh_new))
 373                         return;
 374                 decompose_change_notification(rc, cb, cbdata);
 375                 break;
 376         }
 377 }
 378 #endif