lib/table.h

   1 /*
   2  * Routing Table
   3  * Copyright (C) 1998 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #ifndef _ZEBRA_TABLE_H
  23 #define _ZEBRA_TABLE_H
  24
  25 #include "memory.h"
  26 #include "hash.h"
  27 #include "prefix.h"
  28 #include "typesafe.h"
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 DECLARE_MTYPE(ROUTE_TABLE)
  35 DECLARE_MTYPE(ROUTE_NODE)
  36
  37 /*
  38  * Forward declarations.
  39  */
  40 struct route_node;
  41 struct route_table;
  42
  43 /*
  44  * route_table_delegate_t
  45  *
  46  * Function vector that can be used by a client to customize the
  47  * behavior of one or more route tables.
  48  */
  49 typedef struct route_table_delegate_t_ route_table_delegate_t;
  50
  51 typedef struct route_node *(*route_table_create_node_func_t)(
  52         route_table_delegate_t *, struct route_table *);
  53
  54 typedef void (*route_table_destroy_node_func_t)(route_table_delegate_t *,
  55                                                 struct route_table *,
  56                                                 struct route_node *);
  57
  58 struct route_table_delegate_t_ {
  59         route_table_create_node_func_t create_node;
  60         route_table_destroy_node_func_t destroy_node;
  61 };
  62
  63 PREDECL_HASH(rn_hash_node)
  64
  65 /* Routing table top structure. */
  66 struct route_table {
  67         struct route_node *top;
  68         struct rn_hash_node_head hash;
  69
  70         /*
  71          * Delegate that performs certain functions for this table.
  72          */
  73         route_table_delegate_t *delegate;
  74         void (*cleanup)(struct route_table *, struct route_node *);
  75
  76         unsigned long count;
  77
  78         /*
  79          * User data.
  80          */
  81         void *info;
  82 };
  83
  84 /*
  85  * node->link is really internal to the table code and should not be
  86  * accessed by outside code.  We don't have any writers (yay), though some
  87  * readers are left to be fixed.
  88  *
  89  * rationale: we need to add a hash table in parallel, to speed up
  90  * exact-match lookups.
  91  *
  92  * same really applies for node->parent, though that's less of an issue.
  93  * table->link should be - and is - NEVER written by outside code
  94  */
  95 #ifdef FRR_COMPILING_TABLE_C
  96 #define table_rdonly(x)         x
  97 #define table_internal(x)       x
  98 #else
  99 #define table_rdonly(x)         const x
 100 #define table_internal(x)                                                      \
 101         const x __attribute__(                                                 \
 102                 (deprecated("this should only be accessed by lib/table.c")))
 103 /* table_internal is for node->link and node->lock, once we have done
 104  * something about remaining accesses */
 105 #endif
 106
 107 /* so... the problem with this is that "const" doesn't mean "readonly".
 108  * It in fact may allow the compiler to optimize based on the assumption
 109  * that the value doesn't change.  Hence, since the only purpose of this
 110  * is to aid in development, don't put the "const" in release builds.
 111  *
 112  * (I haven't seen this actually break, but GCC and LLVM are getting ever
 113  * more aggressive in optimizing...)
 114  */
 115 #ifndef DEV_BUILD
 116 #undef table_rdonly
 117 #define table_rdonly(x) x
 118 #endif
 119
 120 /*
 121  * Macro that defines all fields in a route node.
 122  */
 123 #define ROUTE_NODE_FIELDS                                                      \
 124         /* Actual prefix of this radix. */                                     \
 125         struct prefix p;                                                       \
 126                                                                                \
 127         /* Tree link. */                                                       \
 128         struct route_table *table_rdonly(table);                               \
 129         struct route_node *table_rdonly(parent);                               \
 130         struct route_node *table_rdonly(link[2]);                              \
 131                                                                                \
 132         /* Lock of this radix */                                               \
 133         unsigned int table_rdonly(lock);                                       \
 134                                                                                \
 135         struct rn_hash_node_item nodehash;                                     \
 136         /* Each node of route. */                                              \
 137         void *info;                                                            \
 138
 139
 140 /* Each routing entry. */
 141 struct route_node {
 142         ROUTE_NODE_FIELDS
 143
 144 #define l_left   link[0]
 145 #define l_right  link[1]
 146 };
 147
 148 typedef struct route_table_iter_t_ route_table_iter_t;
 149
 150 typedef enum {
 151         RT_ITER_STATE_INIT,
 152         RT_ITER_STATE_ITERATING,
 153         RT_ITER_STATE_PAUSED,
 154         RT_ITER_STATE_DONE
 155 } route_table_iter_state_t;
 156
 157 /*
 158  * route_table_iter_t
 159  *
 160  * Structure that holds state for iterating over a route table.
 161  */
 162 struct route_table_iter_t_ {
 163
 164         route_table_iter_state_t state;
 165
 166         /*
 167          * Routing table that we are iterating over. The caller must ensure
 168          * that that table outlives the iterator.
 169          */
 170         struct route_table *table;
 171
 172         /*
 173          * The node that the iterator is currently on.
 174          */
 175         struct route_node *current;
 176
 177         /*
 178          * The last prefix that the iterator processed before it was paused.
 179          */
 180         struct prefix pause_prefix;
 181 };
 182
 183 /* Prototypes. */
 184 extern struct route_table *route_table_init(void);
 185
 186 extern struct route_table *
 187 route_table_init_with_delegate(route_table_delegate_t *delegate);
 188
 189 extern route_table_delegate_t *route_table_get_default_delegate(void);
 190
 191 static inline void *route_table_get_info(struct route_table *table)
 192 {
 193         return table->info;
 194 }
 195
 196 static inline void route_table_set_info(struct route_table *table, void *d)
 197 {
 198         table->info = d;
 199 }
 200
 201 extern void route_table_finish(struct route_table *table);
 202 extern struct route_node *route_top(struct route_table *table);
 203 extern struct route_node *route_next(struct route_node *node);
 204 extern struct route_node *route_next_until(struct route_node *node,
 205                                            const struct route_node *limit);
 206 extern struct route_node *route_node_get(struct route_table *const table,
 207                                          union prefixconstptr pu);
 208 extern struct route_node *route_node_lookup(const struct route_table *table,
 209                                             union prefixconstptr pu);
 210 extern struct route_node *
 211 route_node_lookup_maynull(const struct route_table *table,
 212                           union prefixconstptr pu);
 213 extern struct route_node *route_node_match(const struct route_table *table,
 214                                            union prefixconstptr pu);
 215 extern struct route_node *route_node_match_ipv4(const struct route_table *table,
 216                                                 const struct in_addr *addr);
 217 extern struct route_node *route_node_match_ipv6(const struct route_table *table,
 218                                                 const struct in6_addr *addr);
 219
 220 extern unsigned long route_table_count(const struct route_table *table);
 221
 222 extern struct route_node *route_node_create(route_table_delegate_t *delegate,
 223                                             struct route_table *table);
 224 extern void route_node_delete(struct route_node *node);
 225 extern void route_node_destroy(route_table_delegate_t *delegate,
 226                                struct route_table *table,
 227                                struct route_node *node);
 228
 229 extern struct route_node *route_table_get_next(const struct route_table *table,
 230                                                union prefixconstptr pu);
 231 extern int route_table_prefix_iter_cmp(const struct prefix *p1,
 232                                        const struct prefix *p2);
 233
 234 /*
 235  * Iterator functions.
 236  */
 237 extern void route_table_iter_init(route_table_iter_t *iter,
 238                                   struct route_table *table);
 239 extern void route_table_iter_pause(route_table_iter_t *iter);
 240 extern void route_table_iter_cleanup(route_table_iter_t *iter);
 241
 242 /*
 243  * Inline functions.
 244  */
 245
 246 /* Lock node. */
 247 static inline struct route_node *route_lock_node(struct route_node *node)
 248 {
 249         (*(unsigned *)&node->lock)++;
 250         return node;
 251 }
 252
 253 /* Unlock node. */
 254 static inline void route_unlock_node(struct route_node *node)
 255 {
 256         assert(node->lock > 0);
 257         (*(unsigned *)&node->lock)--;
 258
 259         if (node->lock == 0)
 260                 route_node_delete(node);
 261 }
 262
 263 /*
 264  * route_table_iter_next
 265  *
 266  * Get the next node in the tree.
 267  */
 268 static inline struct route_node *route_table_iter_next(route_table_iter_t *iter)
 269 {
 270         struct route_node *node;
 271
 272         switch (iter->state) {
 273
 274         case RT_ITER_STATE_INIT:
 275
 276                 /*
 277                  * We're just starting the iteration.
 278                  */
 279                 node = route_top(iter->table);
 280                 break;
 281
 282         case RT_ITER_STATE_ITERATING:
 283                 node = route_next(iter->current);
 284                 break;
 285
 286         case RT_ITER_STATE_PAUSED:
 287
 288                 /*
 289                  * Start with the node following pause_prefix.
 290                  */
 291                 node = route_table_get_next(iter->table, &iter->pause_prefix);
 292                 break;
 293
 294         case RT_ITER_STATE_DONE:
 295                 return NULL;
 296
 297         default:
 298                 assert(0);
 299         }
 300
 301         iter->current = node;
 302         if (node)
 303                 iter->state = RT_ITER_STATE_ITERATING;
 304         else
 305                 iter->state = RT_ITER_STATE_DONE;
 306
 307         return node;
 308 }
 309
 310 /*
 311  * route_table_iter_is_done
 312  *
 313  * Returns TRUE if the iteration is complete.
 314  */
 315 static inline int route_table_iter_is_done(route_table_iter_t *iter)
 316 {
 317         return iter->state == RT_ITER_STATE_DONE;
 318 }
 319
 320 /*
 321  * route_table_iter_started
 322  *
 323  * Returns TRUE if this iterator has started iterating over the tree.
 324  */
 325 static inline int route_table_iter_started(route_table_iter_t *iter)
 326 {
 327         return iter->state != RT_ITER_STATE_INIT;
 328 }
 329
 330 #ifdef __cplusplus
 331 }
 332 #endif
 333
 334 #endif /* _ZEBRA_TABLE_H */