bgpd/bgp_table.h

   1 /* BGP routing table
   2  * Copyright (C) 1998, 2001 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #ifndef _QUAGGA_BGP_TABLE_H
  22 #define _QUAGGA_BGP_TABLE_H
  23
  24 /* XXX BEGIN TEMPORARY COMPAT */
  25 #define bgp_dest bgp_node
  26 /* XXX END TEMPORARY COMPAT */
  27
  28 #include "mpls.h"
  29 #include "table.h"
  30 #include "queue.h"
  31 #include "linklist.h"
  32 #include "bgpd.h"
  33 #include "bgp_advertise.h"
  34
  35 struct bgp_table {
  36         /* table belongs to this instance */
  37         struct bgp *bgp;
  38
  39         /* afi/safi of this table */
  40         afi_t afi;
  41         safi_t safi;
  42
  43         int lock;
  44
  45         /* soft_reconfig_table in progress */
  46         bool soft_reconfig_init;
  47         struct thread *soft_reconfig_thread;
  48
  49         /* list of peers on which soft_reconfig_table has to run */
  50         struct list *soft_reconfig_peers;
  51
  52         struct route_table *route_table;
  53         uint64_t version;
  54 };
  55
  56 enum bgp_path_selection_reason {
  57         bgp_path_selection_none,
  58         bgp_path_selection_first,
  59         bgp_path_selection_evpn_sticky_mac,
  60         bgp_path_selection_evpn_seq,
  61         bgp_path_selection_evpn_local_path,
  62         bgp_path_selection_evpn_non_proxy,
  63         bgp_path_selection_evpn_lower_ip,
  64         bgp_path_selection_weight,
  65         bgp_path_selection_local_pref,
  66         bgp_path_selection_local_route,
  67         bgp_path_selection_confed_as_path,
  68         bgp_path_selection_as_path,
  69         bgp_path_selection_origin,
  70         bgp_path_selection_med,
  71         bgp_path_selection_peer,
  72         bgp_path_selection_confed,
  73         bgp_path_selection_igp_metric,
  74         bgp_path_selection_older,
  75         bgp_path_selection_router_id,
  76         bgp_path_selection_cluster_length,
  77         bgp_path_selection_stale,
  78         bgp_path_selection_local_configured,
  79         bgp_path_selection_neighbor_ip,
  80         bgp_path_selection_default,
  81 };
  82
  83 struct bgp_node {
  84         /*
  85          * CAUTION
  86          *
  87          * These fields must be the very first fields in this structure.
  88          *
  89          * @see bgp_node_to_rnode
  90          * @see bgp_node_from_rnode
  91          */
  92         ROUTE_NODE_FIELDS
  93
  94         struct bgp_adj_out_rb adj_out;
  95
  96         struct bgp_adj_in *adj_in;
  97
  98         struct bgp_dest *pdest;
  99
 100         STAILQ_ENTRY(bgp_dest) pq;
 101
 102         uint64_t version;
 103
 104         mpls_label_t local_label;
 105
 106         uint16_t flags;
 107 #define BGP_NODE_PROCESS_SCHEDULED      (1 << 0)
 108 #define BGP_NODE_USER_CLEAR             (1 << 1)
 109 #define BGP_NODE_LABEL_CHANGED          (1 << 2)
 110 #define BGP_NODE_REGISTERED_FOR_LABEL   (1 << 3)
 111 #define BGP_NODE_SELECT_DEFER           (1 << 4)
 112 #define BGP_NODE_FIB_INSTALL_PENDING    (1 << 5)
 113 #define BGP_NODE_FIB_INSTALLED          (1 << 6)
 114 #define BGP_NODE_LABEL_REQUESTED        (1 << 7)
 115 #define BGP_NODE_SOFT_RECONFIG (1 << 8)
 116
 117         struct bgp_addpath_node_data tx_addpath;
 118
 119         enum bgp_path_selection_reason reason;
 120 };
 121
 122 extern void bgp_delete_listnode(struct bgp_dest *dest);
 123 /*
 124  * bgp_table_iter_t
 125  *
 126  * Structure that holds state for iterating over a bgp table.
 127  */
 128 typedef struct bgp_table_iter_t_ {
 129         struct bgp_table *table;
 130         route_table_iter_t rt_iter;
 131 } bgp_table_iter_t;
 132
 133 extern struct bgp_table *bgp_table_init(struct bgp *bgp, afi_t, safi_t);
 134 extern void bgp_table_lock(struct bgp_table *);
 135 extern void bgp_table_unlock(struct bgp_table *);
 136 extern void bgp_table_finish(struct bgp_table **);
 137 extern void bgp_dest_unlock_node(struct bgp_dest *dest);
 138 extern struct bgp_dest *bgp_dest_lock_node(struct bgp_dest *dest);
 139 extern const char *bgp_dest_get_prefix_str(struct bgp_dest *dest);
 140
 141
 142 /*
 143  * bgp_dest_from_rnode
 144  *
 145  * Returns the bgp_dest structure corresponding to a route_node.
 146  */
 147 static inline struct bgp_dest *bgp_dest_from_rnode(struct route_node *rnode)
 148 {
 149         return (struct bgp_dest *)rnode;
 150 }
 151
 152 /*
 153  * bgp_dest_to_rnode
 154  *
 155  * Returns the route_node structure corresponding to a bgp_dest.
 156  */
 157 static inline struct route_node *bgp_dest_to_rnode(const struct bgp_dest *dest)
 158 {
 159         return (struct route_node *)dest;
 160 }
 161
 162 /*
 163  * bgp_dest_table
 164  *
 165  * Returns the bgp_table that the given dest is in.
 166  */
 167 static inline struct bgp_table *bgp_dest_table(struct bgp_dest *dest)
 168 {
 169         return route_table_get_info(bgp_dest_to_rnode(dest)->table);
 170 }
 171
 172 /*
 173  * bgp_dest_parent_nolock
 174  *
 175  * Gets the parent dest of the given node without locking it.
 176  */
 177 static inline struct bgp_dest *bgp_dest_parent_nolock(struct bgp_dest *dest)
 178 {
 179         struct route_node *rn = bgp_dest_to_rnode(dest)->parent;
 180
 181         return bgp_dest_from_rnode(rn);
 182 }
 183
 184 /*
 185  * bgp_table_top_nolock
 186  *
 187  * Gets the top dest in the table without locking it.
 188  *
 189  * @see bgp_table_top
 190  */
 191 static inline struct bgp_dest *
 192 bgp_table_top_nolock(const struct bgp_table *const table)
 193 {
 194         return bgp_dest_from_rnode(table->route_table->top);
 195 }
 196
 197 /*
 198  * bgp_table_top
 199  */
 200 static inline struct bgp_dest *
 201 bgp_table_top(const struct bgp_table *const table)
 202 {
 203         return bgp_dest_from_rnode(route_top(table->route_table));
 204 }
 205
 206 /*
 207  * bgp_route_next
 208  */
 209 static inline struct bgp_dest *bgp_route_next(struct bgp_dest *dest)
 210 {
 211         return bgp_dest_from_rnode(route_next(bgp_dest_to_rnode(dest)));
 212 }
 213
 214 /*
 215  * bgp_route_next_until
 216  */
 217 static inline struct bgp_dest *bgp_route_next_until(struct bgp_dest *dest,
 218                                                     struct bgp_dest *limit)
 219 {
 220         struct route_node *rnode;
 221
 222         rnode = route_next_until(bgp_dest_to_rnode(dest),
 223                         bgp_dest_to_rnode(limit));
 224
 225         return bgp_dest_from_rnode(rnode);
 226 }
 227
 228 /*
 229  * bgp_node_get
 230  */
 231 static inline struct bgp_dest *bgp_node_get(struct bgp_table *const table,
 232                                             const struct prefix *p)
 233 {
 234         return bgp_dest_from_rnode(route_node_get(table->route_table, p));
 235 }
 236
 237 /*
 238  * bgp_node_lookup
 239  */
 240 static inline struct bgp_dest *
 241 bgp_node_lookup(const struct bgp_table *const table, const struct prefix *p)
 242 {
 243         struct route_node *rn = route_node_lookup(table->route_table, p);
 244
 245         return bgp_dest_from_rnode(rn);
 246 }
 247
 248 /*
 249  * bgp_node_match
 250  */
 251 static inline struct bgp_dest *bgp_node_match(const struct bgp_table *table,
 252                                               const struct prefix *p)
 253 {
 254         struct route_node *rn = route_node_match(table->route_table, p);
 255
 256         return bgp_dest_from_rnode(rn);
 257 }
 258
 259 /*
 260  * bgp_node_match_ipv4
 261  */
 262 static inline struct bgp_dest *
 263 bgp_node_match_ipv4(const struct bgp_table *table, struct in_addr *addr)
 264 {
 265         struct route_node *rn = route_node_match_ipv4(table->route_table, addr);
 266
 267         return bgp_dest_from_rnode(rn);
 268 }
 269
 270 /*
 271  * bgp_node_match_ipv6
 272  */
 273 static inline struct bgp_dest *
 274 bgp_node_match_ipv6(const struct bgp_table *table, struct in6_addr *addr)
 275 {
 276         struct route_node *rn = route_node_match_ipv6(table->route_table, addr);
 277
 278         return bgp_dest_from_rnode(rn);
 279 }
 280
 281 static inline unsigned long bgp_table_count(const struct bgp_table *const table)
 282 {
 283         return route_table_count(table->route_table);
 284 }
 285
 286 /*
 287  * bgp_table_get_next
 288  */
 289 static inline struct bgp_dest *bgp_table_get_next(const struct bgp_table *table,
 290                                                   const struct prefix *p)
 291 {
 292         return bgp_dest_from_rnode(route_table_get_next(table->route_table, p));
 293 }
 294
 295 /*
 296  * bgp_table_iter_init
 297  */
 298 static inline void bgp_table_iter_init(bgp_table_iter_t *iter,
 299                                        struct bgp_table *table)
 300 {
 301         bgp_table_lock(table);
 302         iter->table = table;
 303         route_table_iter_init(&iter->rt_iter, table->route_table);
 304 }
 305
 306 /*
 307  * bgp_table_iter_next
 308  */
 309 static inline struct bgp_dest *bgp_table_iter_next(bgp_table_iter_t *iter)
 310 {
 311         return bgp_dest_from_rnode(route_table_iter_next(&iter->rt_iter));
 312 }
 313
 314 /*
 315  * bgp_table_iter_cleanup
 316  */
 317 static inline void bgp_table_iter_cleanup(bgp_table_iter_t *iter)
 318 {
 319         route_table_iter_cleanup(&iter->rt_iter);
 320         bgp_table_unlock(iter->table);
 321         iter->table = NULL;
 322 }
 323
 324 /*
 325  * bgp_table_iter_pause
 326  */
 327 static inline void bgp_table_iter_pause(bgp_table_iter_t *iter)
 328 {
 329         route_table_iter_pause(&iter->rt_iter);
 330 }
 331
 332 /*
 333  * bgp_table_iter_is_done
 334  */
 335 static inline int bgp_table_iter_is_done(bgp_table_iter_t *iter)
 336 {
 337         return route_table_iter_is_done(&iter->rt_iter);
 338 }
 339
 340 /*
 341  * bgp_table_iter_started
 342  */
 343 static inline int bgp_table_iter_started(bgp_table_iter_t *iter)
 344 {
 345         return route_table_iter_started(&iter->rt_iter);
 346 }
 347
 348 /* This would benefit from a real atomic operation...
 349  * until then. */
 350 static inline uint64_t bgp_table_next_version(struct bgp_table *table)
 351 {
 352         return ++table->version;
 353 }
 354
 355 static inline uint64_t bgp_table_version(struct bgp_table *table)
 356 {
 357         return table->version;
 358 }
 359
 360 /* Find the subtree of the prefix p
 361  *
 362  * This will return the first node that belongs the the subtree of p. Including
 363  * p itself, if it is in the tree.
 364  *
 365  * If the subtree is not present in the table, NULL is returned.
 366  */
 367 struct bgp_dest *bgp_table_subtree_lookup(const struct bgp_table *table,
 368                                           const struct prefix *p);
 369
 370 static inline struct bgp_aggregate *
 371 bgp_dest_get_bgp_aggregate_info(struct bgp_dest *dest)
 372 {
 373         return dest ? dest->info : NULL;
 374 }
 375
 376 static inline void
 377 bgp_dest_set_bgp_aggregate_info(struct bgp_dest *dest,
 378                                 struct bgp_aggregate *aggregate)
 379 {
 380         dest->info = aggregate;
 381 }
 382
 383 static inline struct bgp_distance *
 384 bgp_dest_get_bgp_distance_info(struct bgp_dest *dest)
 385 {
 386         return dest ? dest->info : NULL;
 387 }
 388
 389 static inline void bgp_dest_set_bgp_distance_info(struct bgp_dest *dest,
 390                                                   struct bgp_distance *distance)
 391 {
 392         dest->info = distance;
 393 }
 394
 395 static inline struct bgp_static *
 396 bgp_dest_get_bgp_static_info(struct bgp_dest *dest)
 397 {
 398         return dest ? dest->info : NULL;
 399 }
 400
 401 static inline void bgp_dest_set_bgp_static_info(struct bgp_dest *dest,
 402                                                 struct bgp_static *bgp_static)
 403 {
 404         dest->info = bgp_static;
 405 }
 406
 407 static inline struct bgp_connected_ref *
 408 bgp_dest_get_bgp_connected_ref_info(struct bgp_dest *dest)
 409 {
 410         return dest ? dest->info : NULL;
 411 }
 412
 413 static inline void
 414 bgp_dest_set_bgp_connected_ref_info(struct bgp_dest *dest,
 415                                     struct bgp_connected_ref *bc)
 416 {
 417         dest->info = bc;
 418 }
 419
 420 static inline struct bgp_nexthop_cache *
 421 bgp_dest_get_bgp_nexthop_info(struct bgp_dest *dest)
 422 {
 423         return dest ? dest->info : NULL;
 424 }
 425
 426 static inline void bgp_dest_set_bgp_nexthop_info(struct bgp_dest *dest,
 427                                                  struct bgp_nexthop_cache *bnc)
 428 {
 429         dest->info = bnc;
 430 }
 431
 432 static inline struct bgp_path_info *
 433 bgp_dest_get_bgp_path_info(struct bgp_dest *dest)
 434 {
 435         return dest ? dest->info : NULL;
 436 }
 437
 438 static inline void bgp_dest_set_bgp_path_info(struct bgp_dest *dest,
 439                                               struct bgp_path_info *bi)
 440 {
 441         dest->info = bi;
 442 }
 443
 444 static inline struct bgp_table *
 445 bgp_dest_get_bgp_table_info(struct bgp_dest *dest)
 446 {
 447         return dest->info;
 448 }
 449
 450 static inline void bgp_dest_set_bgp_table_info(struct bgp_dest *dest,
 451                                                struct bgp_table *table)
 452 {
 453         dest->info = table;
 454 }
 455
 456 static inline bool bgp_dest_has_bgp_path_info_data(struct bgp_dest *dest)
 457 {
 458         return !!dest->info;
 459 }
 460
 461 static inline const struct prefix *bgp_dest_get_prefix(const struct bgp_dest *dest)
 462 {
 463         return &dest->p;
 464 }
 465
 466 static inline unsigned int bgp_dest_get_lock_count(const struct bgp_dest *dest)
 467 {
 468         return dest->lock;
 469 }
 470
 471 #ifdef _FRR_ATTRIBUTE_PRINTFRR
 472 #pragma FRR printfrr_ext "%pRN"  (struct bgp_node *)
 473 #pragma FRR printfrr_ext "%pBD"  (struct bgp_dest *)
 474 #endif
 475
 476 #endif /* _QUAGGA_BGP_TABLE_H */