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