1: /*
2: * BIRD -- Route Attribute Cache
3: *
4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: /**
10: * DOC: Route attribute cache
11: *
12: * Each route entry carries a set of route attributes. Several of them
13: * vary from route to route, but most attributes are usually common
14: * for a large number of routes. To conserve memory, we've decided to
15: * store only the varying ones directly in the &rte and hold the rest
16: * in a special structure called &rta which is shared among all the
17: * &rte's with these attributes.
18: *
19: * Each &rta contains all the static attributes of the route (i.e.,
20: * those which are always present) as structure members and a list of
21: * dynamic attributes represented by a linked list of &ea_list
22: * structures, each of them consisting of an array of &eattr's containing
23: * the individual attributes. An attribute can be specified more than once
24: * in the &ea_list chain and in such case the first occurrence overrides
25: * the others. This semantics is used especially when someone (for example
26: * a filter) wishes to alter values of several dynamic attributes, but
27: * it wants to preserve the original attribute lists maintained by
28: * another module.
29: *
30: * Each &eattr contains an attribute identifier (split to protocol ID and
31: * per-protocol attribute ID), protocol dependent flags, a type code (consisting
32: * of several bit fields describing attribute characteristics) and either an
33: * embedded 32-bit value or a pointer to a &adata structure holding attribute
34: * contents.
35: *
36: * There exist two variants of &rta's -- cached and un-cached ones. Un-cached
37: * &rta's can have arbitrarily complex structure of &ea_list's and they
38: * can be modified by any module in the route processing chain. Cached
39: * &rta's have their attribute lists normalized (that means at most one
40: * &ea_list is present and its values are sorted in order to speed up
41: * searching), they are stored in a hash table to make fast lookup possible
42: * and they are provided with a use count to allow sharing.
43: *
44: * Routing tables always contain only cached &rta's.
45: */
46:
47: #include "nest/bird.h"
48: #include "nest/route.h"
49: #include "nest/protocol.h"
50: #include "nest/iface.h"
51: #include "nest/cli.h"
52: #include "nest/attrs.h"
53: #include "lib/alloca.h"
54: #include "lib/hash.h"
55: #include "lib/idm.h"
56: #include "lib/resource.h"
57: #include "lib/string.h"
58:
59: #include <stddef.h>
60:
61: const adata null_adata; /* adata of length 0 */
62:
63: const char * const rta_src_names[RTS_MAX] = {
64: [RTS_DUMMY] = "",
65: [RTS_STATIC] = "static",
66: [RTS_INHERIT] = "inherit",
67: [RTS_DEVICE] = "device",
68: [RTS_STATIC_DEVICE] = "static-device",
69: [RTS_REDIRECT] = "redirect",
70: [RTS_RIP] = "RIP",
71: [RTS_OSPF] = "OSPF",
72: [RTS_OSPF_IA] = "OSPF-IA",
73: [RTS_OSPF_EXT1] = "OSPF-E1",
74: [RTS_OSPF_EXT2] = "OSPF-E2",
75: [RTS_BGP] = "BGP",
76: [RTS_PIPE] = "pipe",
77: [RTS_BABEL] = "Babel",
78: [RTS_RPKI] = "RPKI",
79: };
80:
81: const char * rta_dest_names[RTD_MAX] = {
82: [RTD_NONE] = "",
83: [RTD_UNICAST] = "unicast",
84: [RTD_BLACKHOLE] = "blackhole",
85: [RTD_UNREACHABLE] = "unreachable",
86: [RTD_PROHIBIT] = "prohibited",
87: };
88:
89: pool *rta_pool;
90:
91: static slab *rta_slab_[4];
92: static slab *nexthop_slab_[4];
93: static slab *rte_src_slab;
94:
95: static struct idm src_ids;
96: #define SRC_ID_INIT_SIZE 4
97:
98: /* rte source hash */
99:
100: #define RSH_KEY(n) n->proto, n->private_id
101: #define RSH_NEXT(n) n->next
102: #define RSH_EQ(p1,n1,p2,n2) p1 == p2 && n1 == n2
103: #define RSH_FN(p,n) p->hash_key ^ u32_hash(n)
104:
105: #define RSH_REHASH rte_src_rehash
106: #define RSH_PARAMS /2, *2, 1, 1, 8, 20
107: #define RSH_INIT_ORDER 6
108:
109: static HASH(struct rte_src) src_hash;
110:
111: static void
112: rte_src_init(void)
113: {
114: rte_src_slab = sl_new(rta_pool, sizeof(struct rte_src));
115:
116: idm_init(&src_ids, rta_pool, SRC_ID_INIT_SIZE);
117:
118: HASH_INIT(src_hash, rta_pool, RSH_INIT_ORDER);
119: }
120:
121:
122: HASH_DEFINE_REHASH_FN(RSH, struct rte_src)
123:
124: struct rte_src *
125: rt_find_source(struct proto *p, u32 id)
126: {
127: return HASH_FIND(src_hash, RSH, p, id);
128: }
129:
130: struct rte_src *
131: rt_get_source(struct proto *p, u32 id)
132: {
133: struct rte_src *src = rt_find_source(p, id);
134:
135: if (src)
136: return src;
137:
138: src = sl_alloc(rte_src_slab);
139: src->proto = p;
140: src->private_id = id;
141: src->global_id = idm_alloc(&src_ids);
142: src->uc = 0;
143:
144: HASH_INSERT2(src_hash, RSH, rta_pool, src);
145:
146: return src;
147: }
148:
149: void
150: rt_prune_sources(void)
151: {
152: HASH_WALK_FILTER(src_hash, next, src, sp)
153: {
154: if (src->uc == 0)
155: {
156: HASH_DO_REMOVE(src_hash, RSH, sp);
157: idm_free(&src_ids, src->global_id);
158: sl_free(rte_src_slab, src);
159: }
160: }
161: HASH_WALK_FILTER_END;
162:
163: HASH_MAY_RESIZE_DOWN(src_hash, RSH, rta_pool);
164: }
165:
166:
167: /*
168: * Multipath Next Hop
169: */
170:
171: static inline u32
172: nexthop_hash(struct nexthop *x)
173: {
174: u32 h = 0;
175: for (; x; x = x->next)
176: {
177: h ^= ipa_hash(x->gw) ^ (h << 5) ^ (h >> 9);
178:
179: for (int i = 0; i < x->labels; i++)
180: h ^= x->label[i] ^ (h << 6) ^ (h >> 7);
181: }
182:
183: return h;
184: }
185:
186: int
187: nexthop__same(struct nexthop *x, struct nexthop *y)
188: {
189: for (; x && y; x = x->next, y = y->next)
190: {
191: if (!ipa_equal(x->gw, y->gw) || (x->iface != y->iface) ||
192: (x->flags != y->flags) || (x->weight != y->weight) ||
193: (x->labels_orig != y->labels_orig) || (x->labels != y->labels))
194: return 0;
195:
196: for (int i = 0; i < x->labels; i++)
197: if (x->label[i] != y->label[i])
198: return 0;
199: }
200:
201: return x == y;
202: }
203:
204: static int
205: nexthop_compare_node(const struct nexthop *x, const struct nexthop *y)
206: {
207: int r;
208:
209: if (!x)
210: return 1;
211:
212: if (!y)
213: return -1;
214:
215: /* Should we also compare flags ? */
216:
217: r = ((int) y->weight) - ((int) x->weight);
218: if (r)
219: return r;
220:
221: r = ipa_compare(x->gw, y->gw);
222: if (r)
223: return r;
224:
225: r = ((int) y->labels) - ((int) x->labels);
226: if (r)
227: return r;
228:
229: for (int i = 0; i < y->labels; i++)
230: {
231: r = ((int) y->label[i]) - ((int) x->label[i]);
232: if (r)
233: return r;
234: }
235:
236: return ((int) x->iface->index) - ((int) y->iface->index);
237: }
238:
239: static inline struct nexthop *
240: nexthop_copy_node(const struct nexthop *src, linpool *lp)
241: {
242: struct nexthop *n = lp_alloc(lp, nexthop_size(src));
243:
244: memcpy(n, src, nexthop_size(src));
245: n->next = NULL;
246:
247: return n;
248: }
249:
250: /**
251: * nexthop_merge - merge nexthop lists
252: * @x: list 1
253: * @y: list 2
254: * @rx: reusability of list @x
255: * @ry: reusability of list @y
256: * @max: max number of nexthops
257: * @lp: linpool for allocating nexthops
258: *
259: * The nexthop_merge() function takes two nexthop lists @x and @y and merges them,
260: * eliminating possible duplicates. The input lists must be sorted and the
261: * result is sorted too. The number of nexthops in result is limited by @max.
262: * New nodes are allocated from linpool @lp.
263: *
264: * The arguments @rx and @ry specify whether corresponding input lists may be
265: * consumed by the function (i.e. their nodes reused in the resulting list), in
266: * that case the caller should not access these lists after that. To eliminate
267: * issues with deallocation of these lists, the caller should use some form of
268: * bulk deallocation (e.g. stack or linpool) to free these nodes when the
269: * resulting list is no longer needed. When reusability is not set, the
270: * corresponding lists are not modified nor linked from the resulting list.
271: */
272: struct nexthop *
273: nexthop_merge(struct nexthop *x, struct nexthop *y, int rx, int ry, int max, linpool *lp)
274: {
275: struct nexthop *root = NULL;
276: struct nexthop **n = &root;
277:
278: while ((x || y) && max--)
279: {
280: int cmp = nexthop_compare_node(x, y);
281: if (cmp < 0)
282: {
283: *n = rx ? x : nexthop_copy_node(x, lp);
284: x = x->next;
285: }
286: else if (cmp > 0)
287: {
288: *n = ry ? y : nexthop_copy_node(y, lp);
289: y = y->next;
290: }
291: else
292: {
293: *n = rx ? x : (ry ? y : nexthop_copy_node(x, lp));
294: x = x->next;
295: y = y->next;
296: }
297: n = &((*n)->next);
298: }
299: *n = NULL;
300:
301: return root;
302: }
303:
304: void
305: nexthop_insert(struct nexthop **n, struct nexthop *x)
306: {
307: for (; *n; n = &((*n)->next))
308: {
309: int cmp = nexthop_compare_node(*n, x);
310:
311: if (cmp < 0)
312: continue;
313: else if (cmp > 0)
314: break;
315: else
316: return;
317: }
318:
319: x->next = *n;
320: *n = x;
321: }
322:
323: struct nexthop *
324: nexthop_sort(struct nexthop *x)
325: {
326: struct nexthop *s = NULL;
327:
328: /* Simple insert-sort */
329: while (x)
330: {
331: struct nexthop *n = x;
332: x = n->next;
333: n->next = NULL;
334:
335: nexthop_insert(&s, n);
336: }
337:
338: return s;
339: }
340:
341: int
342: nexthop_is_sorted(struct nexthop *x)
343: {
344: for (; x && x->next; x = x->next)
345: if (nexthop_compare_node(x, x->next) >= 0)
346: return 0;
347:
348: return 1;
349: }
350:
351: static inline slab *
352: nexthop_slab(struct nexthop *nh)
353: {
354: return nexthop_slab_[MIN(nh->labels, 3)];
355: }
356:
357: static struct nexthop *
358: nexthop_copy(struct nexthop *o)
359: {
360: struct nexthop *first = NULL;
361: struct nexthop **last = &first;
362:
363: for (; o; o = o->next)
364: {
365: struct nexthop *n = sl_alloc(nexthop_slab(o));
366: n->gw = o->gw;
367: n->iface = o->iface;
368: n->next = NULL;
369: n->flags = o->flags;
370: n->weight = o->weight;
371: n->labels_orig = o->labels_orig;
372: n->labels = o->labels;
373: for (int i=0; i<o->labels; i++)
374: n->label[i] = o->label[i];
375:
376: *last = n;
377: last = &(n->next);
378: }
379:
380: return first;
381: }
382:
383: static void
384: nexthop_free(struct nexthop *o)
385: {
386: struct nexthop *n;
387:
388: while (o)
389: {
390: n = o->next;
391: sl_free(nexthop_slab(o), o);
392: o = n;
393: }
394: }
395:
396:
397: /*
398: * Extended Attributes
399: */
400:
401: static inline eattr *
402: ea__find(ea_list *e, unsigned id)
403: {
404: eattr *a;
405: int l, r, m;
406:
407: while (e)
408: {
409: if (e->flags & EALF_BISECT)
410: {
411: l = 0;
412: r = e->count - 1;
413: while (l <= r)
414: {
415: m = (l+r) / 2;
416: a = &e->attrs[m];
417: if (a->id == id)
418: return a;
419: else if (a->id < id)
420: l = m+1;
421: else
422: r = m-1;
423: }
424: }
425: else
426: for(m=0; m<e->count; m++)
427: if (e->attrs[m].id == id)
428: return &e->attrs[m];
429: e = e->next;
430: }
431: return NULL;
432: }
433:
434: /**
435: * ea_find - find an extended attribute
436: * @e: attribute list to search in
437: * @id: attribute ID to search for
438: *
439: * Given an extended attribute list, ea_find() searches for a first
440: * occurrence of an attribute with specified ID, returning either a pointer
441: * to its &eattr structure or %NULL if no such attribute exists.
442: */
443: eattr *
444: ea_find(ea_list *e, unsigned id)
445: {
446: eattr *a = ea__find(e, id & EA_CODE_MASK);
447:
448: if (a && (a->type & EAF_TYPE_MASK) == EAF_TYPE_UNDEF &&
449: !(id & EA_ALLOW_UNDEF))
450: return NULL;
451: return a;
452: }
453:
454: /**
455: * ea_walk - walk through extended attributes
456: * @s: walk state structure
457: * @id: start of attribute ID interval
458: * @max: length of attribute ID interval
459: *
460: * Given an extended attribute list, ea_walk() walks through the list looking
461: * for first occurrences of attributes with ID in specified interval from @id to
462: * (@id + @max - 1), returning pointers to found &eattr structures, storing its
463: * walk state in @s for subsequent calls.
464: *
465: * The function ea_walk() is supposed to be called in a loop, with initially
466: * zeroed walk state structure @s with filled the initial extended attribute
467: * list, returning one found attribute in each call or %NULL when no other
468: * attribute exists. The extended attribute list or the arguments should not be
469: * modified between calls. The maximum value of @max is 128.
470: */
471: eattr *
472: ea_walk(struct ea_walk_state *s, uint id, uint max)
473: {
474: ea_list *e = s->eattrs;
475: eattr *a = s->ea;
476: eattr *a_max;
477:
478: max = id + max;
479:
480: if (a)
481: goto step;
482:
483: for (; e; e = e->next)
484: {
485: if (e->flags & EALF_BISECT)
486: {
487: int l, r, m;
488:
489: l = 0;
490: r = e->count - 1;
491: while (l < r)
492: {
493: m = (l+r) / 2;
494: if (e->attrs[m].id < id)
495: l = m + 1;
496: else
497: r = m;
498: }
499: a = e->attrs + l;
500: }
501: else
502: a = e->attrs;
503:
504: step:
505: a_max = e->attrs + e->count;
506: for (; a < a_max; a++)
507: if ((a->id >= id) && (a->id < max))
508: {
509: int n = a->id - id;
510:
511: if (BIT32_TEST(s->visited, n))
512: continue;
513:
514: BIT32_SET(s->visited, n);
515:
516: if ((a->type & EAF_TYPE_MASK) == EAF_TYPE_UNDEF)
517: continue;
518:
519: s->eattrs = e;
520: s->ea = a;
521: return a;
522: }
523: else if (e->flags & EALF_BISECT)
524: break;
525: }
526:
527: return NULL;
528: }
529:
530: /**
531: * ea_get_int - fetch an integer attribute
532: * @e: attribute list
533: * @id: attribute ID
534: * @def: default value
535: *
536: * This function is a shortcut for retrieving a value of an integer attribute
537: * by calling ea_find() to find the attribute, extracting its value or returning
538: * a provided default if no such attribute is present.
539: */
540: int
541: ea_get_int(ea_list *e, unsigned id, int def)
542: {
543: eattr *a = ea_find(e, id);
544: if (!a)
545: return def;
546: return a->u.data;
547: }
548:
549: static inline void
550: ea_do_sort(ea_list *e)
551: {
552: unsigned n = e->count;
553: eattr *a = e->attrs;
554: eattr *b = alloca(n * sizeof(eattr));
555: unsigned s, ss;
556:
557: /* We need to use a stable sorting algorithm, hence mergesort */
558: do
559: {
560: s = ss = 0;
561: while (s < n)
562: {
563: eattr *p, *q, *lo, *hi;
564: p = b;
565: ss = s;
566: *p++ = a[s++];
567: while (s < n && p[-1].id <= a[s].id)
568: *p++ = a[s++];
569: if (s < n)
570: {
571: q = p;
572: *p++ = a[s++];
573: while (s < n && p[-1].id <= a[s].id)
574: *p++ = a[s++];
575: lo = b;
576: hi = q;
577: s = ss;
578: while (lo < q && hi < p)
579: if (lo->id <= hi->id)
580: a[s++] = *lo++;
581: else
582: a[s++] = *hi++;
583: while (lo < q)
584: a[s++] = *lo++;
585: while (hi < p)
586: a[s++] = *hi++;
587: }
588: }
589: }
590: while (ss);
591: }
592:
593: /**
594: * In place discard duplicates and undefs in sorted ea_list. We use stable sort
595: * for this reason.
596: **/
597: static inline void
598: ea_do_prune(ea_list *e)
599: {
600: eattr *s, *d, *l, *s0;
601: int i = 0;
602:
603: s = d = e->attrs; /* Beginning of the list. @s is source, @d is destination. */
604: l = e->attrs + e->count; /* End of the list */
605:
606: /* Walk from begin to end. */
607: while (s < l)
608: {
609: s0 = s++;
610: /* Find a consecutive block of the same attribute */
611: while (s < l && s->id == s[-1].id)
612: s++;
613:
614: /* Now s0 is the most recent version, s[-1] the oldest one */
615: /* Drop undefs */
616: if ((s0->type & EAF_TYPE_MASK) == EAF_TYPE_UNDEF)
617: continue;
618:
619: /* Copy the newest version to destination */
620: *d = *s0;
621:
622: /* Preserve info whether it originated locally */
623: d->type = (d->type & ~(EAF_ORIGINATED|EAF_FRESH)) | (s[-1].type & EAF_ORIGINATED);
624:
625: /* Next destination */
626: d++;
627: i++;
628: }
629:
630: e->count = i;
631: }
632:
633: /**
634: * ea_sort - sort an attribute list
635: * @e: list to be sorted
636: *
637: * This function takes a &ea_list chain and sorts the attributes
638: * within each of its entries.
639: *
640: * If an attribute occurs multiple times in a single &ea_list,
641: * ea_sort() leaves only the first (the only significant) occurrence.
642: */
643: void
644: ea_sort(ea_list *e)
645: {
646: while (e)
647: {
648: if (!(e->flags & EALF_SORTED))
649: {
650: ea_do_sort(e);
651: ea_do_prune(e);
652: e->flags |= EALF_SORTED;
653: }
654: if (e->count > 5)
655: e->flags |= EALF_BISECT;
656: e = e->next;
657: }
658: }
659:
660: /**
661: * ea_scan - estimate attribute list size
662: * @e: attribute list
663: *
664: * This function calculates an upper bound of the size of
665: * a given &ea_list after merging with ea_merge().
666: */
667: unsigned
668: ea_scan(ea_list *e)
669: {
670: unsigned cnt = 0;
671:
672: while (e)
673: {
674: cnt += e->count;
675: e = e->next;
676: }
677: return sizeof(ea_list) + sizeof(eattr)*cnt;
678: }
679:
680: /**
681: * ea_merge - merge segments of an attribute list
682: * @e: attribute list
683: * @t: buffer to store the result to
684: *
685: * This function takes a possibly multi-segment attribute list
686: * and merges all of its segments to one.
687: *
688: * The primary use of this function is for &ea_list normalization:
689: * first call ea_scan() to determine how much memory will the result
690: * take, then allocate a buffer (usually using alloca()), merge the
691: * segments with ea_merge() and finally sort and prune the result
692: * by calling ea_sort().
693: */
694: void
695: ea_merge(ea_list *e, ea_list *t)
696: {
697: eattr *d = t->attrs;
698:
699: t->flags = 0;
700: t->count = 0;
701: t->next = NULL;
702: while (e)
703: {
704: memcpy(d, e->attrs, sizeof(eattr)*e->count);
705: t->count += e->count;
706: d += e->count;
707: e = e->next;
708: }
709: }
710:
711: /**
712: * ea_same - compare two &ea_list's
713: * @x: attribute list
714: * @y: attribute list
715: *
716: * ea_same() compares two normalized attribute lists @x and @y and returns
717: * 1 if they contain the same attributes, 0 otherwise.
718: */
719: int
720: ea_same(ea_list *x, ea_list *y)
721: {
722: int c;
723:
724: if (!x || !y)
725: return x == y;
726: ASSERT(!x->next && !y->next);
727: if (x->count != y->count)
728: return 0;
729: for(c=0; c<x->count; c++)
730: {
731: eattr *a = &x->attrs[c];
732: eattr *b = &y->attrs[c];
733:
734: if (a->id != b->id ||
735: a->flags != b->flags ||
736: a->type != b->type ||
737: ((a->type & EAF_EMBEDDED) ? a->u.data != b->u.data : !adata_same(a->u.ptr, b->u.ptr)))
738: return 0;
739: }
740: return 1;
741: }
742:
743: static inline ea_list *
744: ea_list_copy(ea_list *o)
745: {
746: ea_list *n;
747: unsigned i, len;
748:
749: if (!o)
750: return NULL;
751: ASSERT(!o->next);
752: len = sizeof(ea_list) + sizeof(eattr) * o->count;
753: n = mb_alloc(rta_pool, len);
754: memcpy(n, o, len);
755: n->flags |= EALF_CACHED;
756: for(i=0; i<o->count; i++)
757: {
758: eattr *a = &n->attrs[i];
759: if (!(a->type & EAF_EMBEDDED))
760: {
761: unsigned size = sizeof(struct adata) + a->u.ptr->length;
762: struct adata *d = mb_alloc(rta_pool, size);
763: memcpy(d, a->u.ptr, size);
764: a->u.ptr = d;
765: }
766: }
767: return n;
768: }
769:
770: static inline void
771: ea_free(ea_list *o)
772: {
773: int i;
774:
775: if (o)
776: {
777: ASSERT(!o->next);
778: for(i=0; i<o->count; i++)
779: {
780: eattr *a = &o->attrs[i];
781: if (!(a->type & EAF_EMBEDDED))
782: mb_free((void *) a->u.ptr);
783: }
784: mb_free(o);
785: }
786: }
787:
788: static int
789: get_generic_attr(eattr *a, byte **buf, int buflen UNUSED)
790: {
791: if (a->id == EA_GEN_IGP_METRIC)
792: {
793: *buf += bsprintf(*buf, "igp_metric");
794: return GA_NAME;
795: }
796:
797: return GA_UNKNOWN;
798: }
799:
800: void
801: ea_format_bitfield(struct eattr *a, byte *buf, int bufsize, const char **names, int min, int max)
802: {
803: byte *bound = buf + bufsize - 32;
804: u32 data = a->u.data;
805: int i;
806:
807: for (i = min; i < max; i++)
808: if ((data & (1u << i)) && names[i])
809: {
810: if (buf > bound)
811: {
812: strcpy(buf, " ...");
813: return;
814: }
815:
816: buf += bsprintf(buf, " %s", names[i]);
817: data &= ~(1u << i);
818: }
819:
820: if (data)
821: bsprintf(buf, " %08x", data);
822:
823: return;
824: }
825:
826: static inline void
827: opaque_format(const struct adata *ad, byte *buf, uint size)
828: {
829: byte *bound = buf + size - 10;
830: uint i;
831:
832: for(i = 0; i < ad->length; i++)
833: {
834: if (buf > bound)
835: {
836: strcpy(buf, " ...");
837: return;
838: }
839: if (i)
840: *buf++ = ' ';
841:
842: buf += bsprintf(buf, "%02x", ad->data[i]);
843: }
844:
845: *buf = 0;
846: return;
847: }
848:
849: static inline void
850: ea_show_int_set(struct cli *c, const struct adata *ad, int way, byte *pos, byte *buf, byte *end)
851: {
852: int i = int_set_format(ad, way, 0, pos, end - pos);
853: cli_printf(c, -1012, "\t%s", buf);
854: while (i)
855: {
856: i = int_set_format(ad, way, i, buf, end - buf - 1);
857: cli_printf(c, -1012, "\t\t%s", buf);
858: }
859: }
860:
861: static inline void
862: ea_show_ec_set(struct cli *c, const struct adata *ad, byte *pos, byte *buf, byte *end)
863: {
864: int i = ec_set_format(ad, 0, pos, end - pos);
865: cli_printf(c, -1012, "\t%s", buf);
866: while (i)
867: {
868: i = ec_set_format(ad, i, buf, end - buf - 1);
869: cli_printf(c, -1012, "\t\t%s", buf);
870: }
871: }
872:
873: static inline void
874: ea_show_lc_set(struct cli *c, const struct adata *ad, byte *pos, byte *buf, byte *end)
875: {
876: int i = lc_set_format(ad, 0, pos, end - pos);
877: cli_printf(c, -1012, "\t%s", buf);
878: while (i)
879: {
880: i = lc_set_format(ad, i, buf, end - buf - 1);
881: cli_printf(c, -1012, "\t\t%s", buf);
882: }
883: }
884:
885: /**
886: * ea_show - print an &eattr to CLI
887: * @c: destination CLI
888: * @e: attribute to be printed
889: *
890: * This function takes an extended attribute represented by its &eattr
891: * structure and prints it to the CLI according to the type information.
892: *
893: * If the protocol defining the attribute provides its own
894: * get_attr() hook, it's consulted first.
895: */
896: void
897: ea_show(struct cli *c, eattr *e)
898: {
899: struct protocol *p;
900: int status = GA_UNKNOWN;
901: const struct adata *ad = (e->type & EAF_EMBEDDED) ? NULL : e->u.ptr;
902: byte buf[CLI_MSG_SIZE];
903: byte *pos = buf, *end = buf + sizeof(buf);
904:
905: if (EA_IS_CUSTOM(e->id))
906: {
907: const char *name = ea_custom_name(e->id);
908: if (name)
909: {
910: pos += bsprintf(pos, "%s", name);
911: status = GA_NAME;
912: }
913: else
914: pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
915: }
916: else if (p = class_to_protocol[EA_PROTO(e->id)])
917: {
918: pos += bsprintf(pos, "%s.", p->name);
919: if (p->get_attr)
920: status = p->get_attr(e, pos, end - pos);
921: pos += strlen(pos);
922: }
923: else if (EA_PROTO(e->id))
924: pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
925: else
926: status = get_generic_attr(e, &pos, end - pos);
927:
928: if (status < GA_NAME)
929: pos += bsprintf(pos, "%02x", EA_ID(e->id));
930: if (status < GA_FULL)
931: {
932: *pos++ = ':';
933: *pos++ = ' ';
934: switch (e->type & EAF_TYPE_MASK)
935: {
936: case EAF_TYPE_INT:
937: bsprintf(pos, "%u", e->u.data);
938: break;
939: case EAF_TYPE_OPAQUE:
940: opaque_format(ad, pos, end - pos);
941: break;
942: case EAF_TYPE_IP_ADDRESS:
943: bsprintf(pos, "%I", *(ip_addr *) ad->data);
944: break;
945: case EAF_TYPE_ROUTER_ID:
946: bsprintf(pos, "%R", e->u.data);
947: break;
948: case EAF_TYPE_AS_PATH:
949: as_path_format(ad, pos, end - pos);
950: break;
951: case EAF_TYPE_BITFIELD:
952: bsprintf(pos, "%08x", e->u.data);
953: break;
954: case EAF_TYPE_INT_SET:
955: ea_show_int_set(c, ad, 1, pos, buf, end);
956: return;
957: case EAF_TYPE_EC_SET:
958: ea_show_ec_set(c, ad, pos, buf, end);
959: return;
960: case EAF_TYPE_LC_SET:
961: ea_show_lc_set(c, ad, pos, buf, end);
962: return;
963: case EAF_TYPE_UNDEF:
964: default:
965: bsprintf(pos, "<type %02x>", e->type);
966: }
967: }
968: cli_printf(c, -1012, "\t%s", buf);
969: }
970:
971: /**
972: * ea_dump - dump an extended attribute
973: * @e: attribute to be dumped
974: *
975: * ea_dump() dumps contents of the extended attribute given to
976: * the debug output.
977: */
978: void
979: ea_dump(ea_list *e)
980: {
981: int i;
982:
983: if (!e)
984: {
985: debug("NONE");
986: return;
987: }
988: while (e)
989: {
990: debug("[%c%c%c]",
991: (e->flags & EALF_SORTED) ? 'S' : 's',
992: (e->flags & EALF_BISECT) ? 'B' : 'b',
993: (e->flags & EALF_CACHED) ? 'C' : 'c');
994: for(i=0; i<e->count; i++)
995: {
996: eattr *a = &e->attrs[i];
997: debug(" %02x:%02x.%02x", EA_PROTO(a->id), EA_ID(a->id), a->flags);
998: debug("=%c", "?iO?I?P???S?????" [a->type & EAF_TYPE_MASK]);
999: if (a->type & EAF_ORIGINATED)
1000: debug("o");
1001: if (a->type & EAF_EMBEDDED)
1002: debug(":%08x", a->u.data);
1003: else
1004: {
1005: int j, len = a->u.ptr->length;
1006: debug("[%d]:", len);
1007: for(j=0; j<len; j++)
1008: debug("%02x", a->u.ptr->data[j]);
1009: }
1010: }
1011: if (e = e->next)
1012: debug(" | ");
1013: }
1014: }
1015:
1016: /**
1017: * ea_hash - calculate an &ea_list hash key
1018: * @e: attribute list
1019: *
1020: * ea_hash() takes an extended attribute list and calculated a hopefully
1021: * uniformly distributed hash value from its contents.
1022: */
1023: inline uint
1024: ea_hash(ea_list *e)
1025: {
1026: const u64 mul = 0x68576150f3d6847;
1027: u64 h = 0xafcef24eda8b29;
1028: int i;
1029:
1030: if (e) /* Assuming chain of length 1 */
1031: {
1032: for(i=0; i<e->count; i++)
1033: {
1034: struct eattr *a = &e->attrs[i];
1035: h ^= a->id; h *= mul;
1036: if (a->type & EAF_EMBEDDED)
1037: h ^= a->u.data;
1038: else
1039: {
1040: const struct adata *d = a->u.ptr;
1041: h ^= mem_hash(d->data, d->length);
1042: }
1043: h *= mul;
1044: }
1045: }
1046: return (h >> 32) ^ (h & 0xffffffff);
1047: }
1048:
1049: /**
1050: * ea_append - concatenate &ea_list's
1051: * @to: destination list (can be %NULL)
1052: * @what: list to be appended (can be %NULL)
1053: *
1054: * This function appends the &ea_list @what at the end of
1055: * &ea_list @to and returns a pointer to the resulting list.
1056: */
1057: ea_list *
1058: ea_append(ea_list *to, ea_list *what)
1059: {
1060: ea_list *res;
1061:
1062: if (!to)
1063: return what;
1064: res = to;
1065: while (to->next)
1066: to = to->next;
1067: to->next = what;
1068: return res;
1069: }
1070:
1071: /*
1072: * rta's
1073: */
1074:
1075: static uint rta_cache_count;
1076: static uint rta_cache_size = 32;
1077: static uint rta_cache_limit;
1078: static uint rta_cache_mask;
1079: static rta **rta_hash_table;
1080:
1081: static void
1082: rta_alloc_hash(void)
1083: {
1084: rta_hash_table = mb_allocz(rta_pool, sizeof(rta *) * rta_cache_size);
1085: if (rta_cache_size < 32768)
1086: rta_cache_limit = rta_cache_size * 2;
1087: else
1088: rta_cache_limit = ~0;
1089: rta_cache_mask = rta_cache_size - 1;
1090: }
1091:
1092: static inline uint
1093: rta_hash(rta *a)
1094: {
1095: u64 h;
1096: mem_hash_init(&h);
1097: #define MIX(f) mem_hash_mix(&h, &(a->f), sizeof(a->f));
1098: MIX(src);
1099: MIX(hostentry);
1100: MIX(from);
1101: MIX(igp_metric);
1102: MIX(source);
1103: MIX(scope);
1104: MIX(dest);
1105: #undef MIX
1106:
1107: return mem_hash_value(&h) ^ nexthop_hash(&(a->nh)) ^ ea_hash(a->eattrs);
1108: }
1109:
1110: static inline int
1111: rta_same(rta *x, rta *y)
1112: {
1113: return (x->src == y->src &&
1114: x->source == y->source &&
1115: x->scope == y->scope &&
1116: x->dest == y->dest &&
1117: x->igp_metric == y->igp_metric &&
1118: ipa_equal(x->from, y->from) &&
1119: x->hostentry == y->hostentry &&
1120: nexthop_same(&(x->nh), &(y->nh)) &&
1121: ea_same(x->eattrs, y->eattrs));
1122: }
1123:
1124: static inline slab *
1125: rta_slab(rta *a)
1126: {
1127: return rta_slab_[a->nh.labels > 2 ? 3 : a->nh.labels];
1128: }
1129:
1130: static rta *
1131: rta_copy(rta *o)
1132: {
1133: rta *r = sl_alloc(rta_slab(o));
1134:
1135: memcpy(r, o, rta_size(o));
1136: r->uc = 1;
1137: r->nh.next = nexthop_copy(o->nh.next);
1138: r->eattrs = ea_list_copy(o->eattrs);
1139: return r;
1140: }
1141:
1142: static inline void
1143: rta_insert(rta *r)
1144: {
1145: uint h = r->hash_key & rta_cache_mask;
1146: r->next = rta_hash_table[h];
1147: if (r->next)
1148: r->next->pprev = &r->next;
1149: r->pprev = &rta_hash_table[h];
1150: rta_hash_table[h] = r;
1151: }
1152:
1153: static void
1154: rta_rehash(void)
1155: {
1156: uint ohs = rta_cache_size;
1157: uint h;
1158: rta *r, *n;
1159: rta **oht = rta_hash_table;
1160:
1161: rta_cache_size = 2*rta_cache_size;
1162: DBG("Rehashing rta cache from %d to %d entries.\n", ohs, rta_cache_size);
1163: rta_alloc_hash();
1164: for(h=0; h<ohs; h++)
1165: for(r=oht[h]; r; r=n)
1166: {
1167: n = r->next;
1168: rta_insert(r);
1169: }
1170: mb_free(oht);
1171: }
1172:
1173: /**
1174: * rta_lookup - look up a &rta in attribute cache
1175: * @o: a un-cached &rta
1176: *
1177: * rta_lookup() gets an un-cached &rta structure and returns its cached
1178: * counterpart. It starts with examining the attribute cache to see whether
1179: * there exists a matching entry. If such an entry exists, it's returned and
1180: * its use count is incremented, else a new entry is created with use count
1181: * set to 1.
1182: *
1183: * The extended attribute lists attached to the &rta are automatically
1184: * converted to the normalized form.
1185: */
1186: rta *
1187: rta_lookup(rta *o)
1188: {
1189: rta *r;
1190: uint h;
1191:
1192: ASSERT(!(o->aflags & RTAF_CACHED));
1193: if (o->eattrs)
1194: ea_normalize(o->eattrs);
1195:
1196: h = rta_hash(o);
1197: for(r=rta_hash_table[h & rta_cache_mask]; r; r=r->next)
1198: if (r->hash_key == h && rta_same(r, o))
1199: return rta_clone(r);
1200:
1201: r = rta_copy(o);
1202: r->hash_key = h;
1203: r->aflags = RTAF_CACHED;
1204: rt_lock_source(r->src);
1205: rt_lock_hostentry(r->hostentry);
1206: rta_insert(r);
1207:
1208: if (++rta_cache_count > rta_cache_limit)
1209: rta_rehash();
1210:
1211: return r;
1212: }
1213:
1214: void
1215: rta__free(rta *a)
1216: {
1217: ASSERT(rta_cache_count && (a->aflags & RTAF_CACHED));
1218: rta_cache_count--;
1219: *a->pprev = a->next;
1220: if (a->next)
1221: a->next->pprev = a->pprev;
1222: rt_unlock_hostentry(a->hostentry);
1223: rt_unlock_source(a->src);
1224: if (a->nh.next)
1225: nexthop_free(a->nh.next);
1226: ea_free(a->eattrs);
1227: a->aflags = 0; /* Poison the entry */
1228: sl_free(rta_slab(a), a);
1229: }
1230:
1231: rta *
1232: rta_do_cow(rta *o, linpool *lp)
1233: {
1234: rta *r = lp_alloc(lp, rta_size(o));
1235: memcpy(r, o, rta_size(o));
1236: for (struct nexthop **nhn = &(r->nh.next), *nho = o->nh.next; nho; nho = nho->next)
1237: {
1238: *nhn = lp_alloc(lp, nexthop_size(nho));
1239: memcpy(*nhn, nho, nexthop_size(nho));
1240: nhn = &((*nhn)->next);
1241: }
1242: r->aflags = 0;
1243: r->uc = 0;
1244: return r;
1245: }
1246:
1247: /**
1248: * rta_dump - dump route attributes
1249: * @a: attribute structure to dump
1250: *
1251: * This function takes a &rta and dumps its contents to the debug output.
1252: */
1253: void
1254: rta_dump(rta *a)
1255: {
1256: static char *rts[] = { "RTS_DUMMY", "RTS_STATIC", "RTS_INHERIT", "RTS_DEVICE",
1257: "RTS_STAT_DEV", "RTS_REDIR", "RTS_RIP",
1258: "RTS_OSPF", "RTS_OSPF_IA", "RTS_OSPF_EXT1",
1259: "RTS_OSPF_EXT2", "RTS_BGP", "RTS_PIPE", "RTS_BABEL" };
1260: static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
1261:
1262: debug("p=%s uc=%d %s %s%s h=%04x",
1263: a->src->proto->name, a->uc, rts[a->source], ip_scope_text(a->scope),
1264: rtd[a->dest], a->hash_key);
1265: if (!(a->aflags & RTAF_CACHED))
1266: debug(" !CACHED");
1267: debug(" <-%I", a->from);
1268: if (a->dest == RTD_UNICAST)
1269: for (struct nexthop *nh = &(a->nh); nh; nh = nh->next)
1270: {
1271: if (ipa_nonzero(nh->gw)) debug(" ->%I", nh->gw);
1272: if (nh->labels) debug(" L %d", nh->label[0]);
1273: for (int i=1; i<nh->labels; i++)
1274: debug("/%d", nh->label[i]);
1275: debug(" [%s]", nh->iface ? nh->iface->name : "???");
1276: }
1277: if (a->eattrs)
1278: {
1279: debug(" EA: ");
1280: ea_dump(a->eattrs);
1281: }
1282: }
1283:
1284: /**
1285: * rta_dump_all - dump attribute cache
1286: *
1287: * This function dumps the whole contents of route attribute cache
1288: * to the debug output.
1289: */
1290: void
1291: rta_dump_all(void)
1292: {
1293: rta *a;
1294: uint h;
1295:
1296: debug("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
1297: for(h=0; h<rta_cache_size; h++)
1298: for(a=rta_hash_table[h]; a; a=a->next)
1299: {
1300: debug("%p ", a);
1301: rta_dump(a);
1302: debug("\n");
1303: }
1304: debug("\n");
1305: }
1306:
1307: void
1308: rta_show(struct cli *c, rta *a)
1309: {
1310: cli_printf(c, -1008, "\tType: %s %s", rta_src_names[a->source], ip_scope_text(a->scope));
1311:
1312: for(ea_list *eal = a->eattrs; eal; eal=eal->next)
1313: for(int i=0; i<eal->count; i++)
1314: ea_show(c, &eal->attrs[i]);
1315: }
1316:
1317: /**
1318: * rta_init - initialize route attribute cache
1319: *
1320: * This function is called during initialization of the routing
1321: * table module to set up the internals of the attribute cache.
1322: */
1323: void
1324: rta_init(void)
1325: {
1326: rta_pool = rp_new(&root_pool, "Attributes");
1327:
1328: rta_slab_[0] = sl_new(rta_pool, sizeof(rta));
1329: rta_slab_[1] = sl_new(rta_pool, sizeof(rta) + sizeof(u32));
1330: rta_slab_[2] = sl_new(rta_pool, sizeof(rta) + sizeof(u32)*2);
1331: rta_slab_[3] = sl_new(rta_pool, sizeof(rta) + sizeof(u32)*MPLS_MAX_LABEL_STACK);
1332:
1333: nexthop_slab_[0] = sl_new(rta_pool, sizeof(struct nexthop));
1334: nexthop_slab_[1] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32));
1335: nexthop_slab_[2] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32)*2);
1336: nexthop_slab_[3] = sl_new(rta_pool, sizeof(struct nexthop) + sizeof(u32)*MPLS_MAX_LABEL_STACK);
1337:
1338: rta_alloc_hash();
1339: rte_src_init();
1340: }
1341:
1342: /*
1343: * Documentation for functions declared inline in route.h
1344: */
1345: #if 0
1346:
1347: /**
1348: * rta_clone - clone route attributes
1349: * @r: a &rta to be cloned
1350: *
1351: * rta_clone() takes a cached &rta and returns its identical cached
1352: * copy. Currently it works by just returning the original &rta with
1353: * its use count incremented.
1354: */
1355: static inline rta *rta_clone(rta *r)
1356: { DUMMY; }
1357:
1358: /**
1359: * rta_free - free route attributes
1360: * @r: a &rta to be freed
1361: *
1362: * If you stop using a &rta (for example when deleting a route which uses
1363: * it), you need to call rta_free() to notify the attribute cache the
1364: * attribute is no longer in use and can be freed if you were the last
1365: * user (which rta_free() tests by inspecting the use count).
1366: */
1367: static inline void rta_free(rta *r)
1368: { DUMMY; }
1369:
1370: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rt-attr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / nest