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