Statistics
| Branch: | Revision:

iof-bird-daemon / nest / rt-attr.c @ 84cac51a

History | View | Annotate | Download (27.8 KB)

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
  int 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
  int 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
/**
832
 * ea_show - print an &eattr to CLI
833
 * @c: destination CLI
834
 * @e: attribute to be printed
835
 *
836
 * This function takes an extended attribute represented by its &eattr
837
 * structure and prints it to the CLI according to the type information.
838
 *
839
 * If the protocol defining the attribute provides its own
840
 * get_attr() hook, it's consulted first.
841
 */
842
void
843
ea_show(struct cli *c, eattr *e)
844
{
845
  struct protocol *p;
846
  int status = GA_UNKNOWN;
847
  struct adata *ad = (e->type & EAF_EMBEDDED) ? NULL : e->u.ptr;
848
  byte buf[CLI_MSG_SIZE];
849
  byte *pos = buf, *end = buf + sizeof(buf);
850

    
851
  if (p = attr_class_to_protocol[EA_PROTO(e->id)])
852
    {
853
      pos += bsprintf(pos, "%s.", p->name);
854
      if (p->get_attr)
855
        status = p->get_attr(e, pos, end - pos);
856
      pos += strlen(pos);
857
    }
858
  else if (EA_PROTO(e->id))
859
    pos += bsprintf(pos, "%02x.", EA_PROTO(e->id));
860
  else
861
    status = get_generic_attr(e, &pos, end - pos);
862

    
863
  if (status < GA_NAME)
864
    pos += bsprintf(pos, "%02x", EA_ID(e->id));
865
  if (status < GA_FULL)
866
    {
867
      *pos++ = ':';
868
      *pos++ = ' ';
869
      switch (e->type & EAF_TYPE_MASK)
870
        {
871
        case EAF_TYPE_INT:
872
          bsprintf(pos, "%u", e->u.data);
873
          break;
874
        case EAF_TYPE_OPAQUE:
875
          opaque_format(ad, pos, end - pos);
876
          break;
877
        case EAF_TYPE_IP_ADDRESS:
878
          bsprintf(pos, "%I", *(ip_addr *) ad->data);
879
          break;
880
        case EAF_TYPE_ROUTER_ID:
881
          bsprintf(pos, "%R", e->u.data);
882
          break;
883
        case EAF_TYPE_AS_PATH:
884
          as_path_format(ad, pos, end - pos);
885
          break;
886
        case EAF_TYPE_BITFIELD:
887
          bsprintf(pos, "%08x", e->u.data);
888
          break;
889
        case EAF_TYPE_INT_SET:
890
          ea_show_int_set(c, ad, 1, pos, buf, end);
891
          return;
892
        case EAF_TYPE_EC_SET:
893
          ea_show_ec_set(c, ad, pos, buf, end);
894
          return;
895
        case EAF_TYPE_UNDEF:
896
        default:
897
          bsprintf(pos, "<type %02x>", e->type);
898
        }
899
    }
900
  cli_printf(c, -1012, "\t%s", buf);
901
}
902

    
903
/**
904
 * ea_dump - dump an extended attribute
905
 * @e: attribute to be dumped
906
 *
907
 * ea_dump() dumps contents of the extended attribute given to
908
 * the debug output.
909
 */
910
void
911
ea_dump(ea_list *e)
912
{
913
  int i;
914

    
915
  if (!e)
916
    {
917
      debug("NONE");
918
      return;
919
    }
920
  while (e)
921
    {
922
      debug("[%c%c%c]",
923
            (e->flags & EALF_SORTED) ? 'S' : 's',
924
            (e->flags & EALF_BISECT) ? 'B' : 'b',
925
            (e->flags & EALF_CACHED) ? 'C' : 'c');
926
      for(i=0; i<e->count; i++)
927
        {
928
          eattr *a = &e->attrs[i];
929
          debug(" %02x:%02x.%02x", EA_PROTO(a->id), EA_ID(a->id), a->flags);
930
          if (a->type & EAF_TEMP)
931
            debug("T");
932
          debug("=%c", "?iO?I?P???S?????" [a->type & EAF_TYPE_MASK]);
933
          if (a->type & EAF_ORIGINATED)
934
            debug("o");
935
          if (a->type & EAF_EMBEDDED)
936
            debug(":%08x", a->u.data);
937
          else
938
            {
939
              int j, len = a->u.ptr->length;
940
              debug("[%d]:", len);
941
              for(j=0; j<len; j++)
942
                debug("%02x", a->u.ptr->data[j]);
943
            }
944
        }
945
      if (e = e->next)
946
        debug(" | ");
947
    }
948
}
949

    
950
/**
951
 * ea_hash - calculate an &ea_list hash key
952
 * @e: attribute list
953
 *
954
 * ea_hash() takes an extended attribute list and calculated a hopefully
955
 * uniformly distributed hash value from its contents.
956
 */
957
inline uint
958
ea_hash(ea_list *e)
959
{
960
  u32 h = 0;
961
  int i;
962

    
963
  if (e)                        /* Assuming chain of length 1 */
964
    {
965
      for(i=0; i<e->count; i++)
966
        {
967
          struct eattr *a = &e->attrs[i];
968
          h ^= a->id;
969
          if (a->type & EAF_EMBEDDED)
970
            h ^= a->u.data;
971
          else
972
            {
973
              struct adata *d = a->u.ptr;
974
              int size = d->length;
975
              byte *z = d->data;
976
              while (size >= 4)
977
                {
978
                  h ^= *(u32 *)z;
979
                  z += 4;
980
                  size -= 4;
981
                }
982
              while (size--)
983
                h = (h >> 24) ^ (h << 8) ^ *z++;
984
            }
985
        }
986
      h ^= h >> 16;
987
      h ^= h >> 6;
988
      h &= 0xffff;
989
    }
990
  return h;
991
}
992

    
993
/**
994
 * ea_append - concatenate &ea_list's
995
 * @to: destination list (can be %NULL)
996
 * @what: list to be appended (can be %NULL)
997
 *
998
 * This function appends the &ea_list @what at the end of
999
 * &ea_list @to and returns a pointer to the resulting list.
1000
 */
1001
ea_list *
1002
ea_append(ea_list *to, ea_list *what)
1003
{
1004
  ea_list *res;
1005

    
1006
  if (!to)
1007
    return what;
1008
  res = to;
1009
  while (to->next)
1010
    to = to->next;
1011
  to->next = what;
1012
  return res;
1013
}
1014

    
1015
/*
1016
 *        rta's
1017
 */
1018

    
1019
static uint rta_cache_count;
1020
static uint rta_cache_size = 32;
1021
static uint rta_cache_limit;
1022
static uint rta_cache_mask;
1023
static rta **rta_hash_table;
1024

    
1025
static void
1026
rta_alloc_hash(void)
1027
{
1028
  rta_hash_table = mb_allocz(rta_pool, sizeof(rta *) * rta_cache_size);
1029
  if (rta_cache_size < 32768)
1030
    rta_cache_limit = rta_cache_size * 2;
1031
  else
1032
    rta_cache_limit = ~0;
1033
  rta_cache_mask = rta_cache_size - 1;
1034
}
1035

    
1036
static inline uint
1037
rta_hash(rta *a)
1038
{
1039
  return (((uint) (uintptr_t) a->src) ^ ipa_hash(a->gw) ^
1040
          mpnh_hash(a->nexthops) ^ ea_hash(a->eattrs)) & 0xffff;
1041
}
1042

    
1043
static inline int
1044
rta_same(rta *x, rta *y)
1045
{
1046
  return (x->src == y->src &&
1047
          x->source == y->source &&
1048
          x->scope == y->scope &&
1049
          x->cast == y->cast &&
1050
          x->dest == y->dest &&
1051
          x->flags == y->flags &&
1052
          x->igp_metric == y->igp_metric &&
1053
          ipa_equal(x->gw, y->gw) &&
1054
          ipa_equal(x->from, y->from) &&
1055
          x->iface == y->iface &&
1056
          x->hostentry == y->hostentry &&
1057
          mpnh_same(x->nexthops, y->nexthops) &&
1058
          ea_same(x->eattrs, y->eattrs));
1059
}
1060

    
1061
static rta *
1062
rta_copy(rta *o)
1063
{
1064
  rta *r = sl_alloc(rta_slab);
1065

    
1066
  memcpy(r, o, sizeof(rta));
1067
  r->uc = 1;
1068
  r->nexthops = mpnh_copy(o->nexthops);
1069
  r->eattrs = ea_list_copy(o->eattrs);
1070
  return r;
1071
}
1072

    
1073
static inline void
1074
rta_insert(rta *r)
1075
{
1076
  uint h = r->hash_key & rta_cache_mask;
1077
  r->next = rta_hash_table[h];
1078
  if (r->next)
1079
    r->next->pprev = &r->next;
1080
  r->pprev = &rta_hash_table[h];
1081
  rta_hash_table[h] = r;
1082
}
1083

    
1084
static void
1085
rta_rehash(void)
1086
{
1087
  uint ohs = rta_cache_size;
1088
  uint h;
1089
  rta *r, *n;
1090
  rta **oht = rta_hash_table;
1091

    
1092
  rta_cache_size = 2*rta_cache_size;
1093
  DBG("Rehashing rta cache from %d to %d entries.\n", ohs, rta_cache_size);
1094
  rta_alloc_hash();
1095
  for(h=0; h<ohs; h++)
1096
    for(r=oht[h]; r; r=n)
1097
      {
1098
        n = r->next;
1099
        rta_insert(r);
1100
      }
1101
  mb_free(oht);
1102
}
1103

    
1104
/**
1105
 * rta_lookup - look up a &rta in attribute cache
1106
 * @o: a un-cached &rta
1107
 *
1108
 * rta_lookup() gets an un-cached &rta structure and returns its cached
1109
 * counterpart. It starts with examining the attribute cache to see whether
1110
 * there exists a matching entry. If such an entry exists, it's returned and
1111
 * its use count is incremented, else a new entry is created with use count
1112
 * set to 1.
1113
 *
1114
 * The extended attribute lists attached to the &rta are automatically
1115
 * converted to the normalized form.
1116
 */
1117
rta *
1118
rta_lookup(rta *o)
1119
{
1120
  rta *r;
1121
  uint h;
1122

    
1123
  ASSERT(!(o->aflags & RTAF_CACHED));
1124
  if (o->eattrs)
1125
    {
1126
      if (o->eattrs->next)        /* Multiple ea_list's, need to merge them */
1127
        {
1128
          ea_list *ml = alloca(ea_scan(o->eattrs));
1129
          ea_merge(o->eattrs, ml);
1130
          o->eattrs = ml;
1131
        }
1132
      ea_sort(o->eattrs);
1133
    }
1134

    
1135
  h = rta_hash(o);
1136
  for(r=rta_hash_table[h & rta_cache_mask]; r; r=r->next)
1137
    if (r->hash_key == h && rta_same(r, o))
1138
      return rta_clone(r);
1139

    
1140
  r = rta_copy(o);
1141
  r->hash_key = h;
1142
  r->aflags = RTAF_CACHED;
1143
  rt_lock_source(r->src);
1144
  rt_lock_hostentry(r->hostentry);
1145
  rta_insert(r);
1146

    
1147
  if (++rta_cache_count > rta_cache_limit)
1148
    rta_rehash();
1149

    
1150
  return r;
1151
}
1152

    
1153
void
1154
rta__free(rta *a)
1155
{
1156
  ASSERT(rta_cache_count && (a->aflags & RTAF_CACHED));
1157
  rta_cache_count--;
1158
  *a->pprev = a->next;
1159
  if (a->next)
1160
    a->next->pprev = a->pprev;
1161
  a->aflags = 0;                /* Poison the entry */
1162
  rt_unlock_hostentry(a->hostentry);
1163
  rt_unlock_source(a->src);
1164
  mpnh_free(a->nexthops);
1165
  ea_free(a->eattrs);
1166
  sl_free(rta_slab, a);
1167
}
1168

    
1169
rta *
1170
rta_do_cow(rta *o, linpool *lp)
1171
{
1172
  rta *r = lp_alloc(lp, sizeof(rta));
1173
  memcpy(r, o, sizeof(rta));
1174
  r->aflags = 0;
1175
  r->uc = 0;
1176
  return r;
1177
}
1178

    
1179
/**
1180
 * rta_dump - dump route attributes
1181
 * @a: attribute structure to dump
1182
 *
1183
 * This function takes a &rta and dumps its contents to the debug output.
1184
 */
1185
void
1186
rta_dump(rta *a)
1187
{
1188
  static char *rts[] = { "RTS_DUMMY", "RTS_STATIC", "RTS_INHERIT", "RTS_DEVICE",
1189
                         "RTS_STAT_DEV", "RTS_REDIR", "RTS_RIP",
1190
                         "RTS_OSPF", "RTS_OSPF_IA", "RTS_OSPF_EXT1",
1191
                         "RTS_OSPF_EXT2", "RTS_BGP", "RTS_PIPE", "RTS_BABEL" };
1192
  static char *rtc[] = { "", " BC", " MC", " AC" };
1193
  static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
1194

    
1195
  debug("p=%s uc=%d %s %s%s%s h=%04x",
1196
        a->src->proto->name, a->uc, rts[a->source], ip_scope_text(a->scope), rtc[a->cast],
1197
        rtd[a->dest], a->hash_key);
1198
  if (!(a->aflags & RTAF_CACHED))
1199
    debug(" !CACHED");
1200
  debug(" <-%I", a->from);
1201
  if (a->dest == RTD_ROUTER)
1202
    debug(" ->%I", a->gw);
1203
  if (a->dest == RTD_DEVICE || a->dest == RTD_ROUTER)
1204
    debug(" [%s]", a->iface ? a->iface->name : "???" );
1205
  if (a->eattrs)
1206
    {
1207
      debug(" EA: ");
1208
      ea_dump(a->eattrs);
1209
    }
1210
}
1211

    
1212
/**
1213
 * rta_dump_all - dump attribute cache
1214
 *
1215
 * This function dumps the whole contents of route attribute cache
1216
 * to the debug output.
1217
 */
1218
void
1219
rta_dump_all(void)
1220
{
1221
  rta *a;
1222
  uint h;
1223

    
1224
  debug("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
1225
  for(h=0; h<rta_cache_size; h++)
1226
    for(a=rta_hash_table[h]; a; a=a->next)
1227
      {
1228
        debug("%p ", a);
1229
        rta_dump(a);
1230
        debug("\n");
1231
      }
1232
  debug("\n");
1233
}
1234

    
1235
void
1236
rta_show(struct cli *c, rta *a, ea_list *eal)
1237
{
1238
  static char *src_names[] = { "dummy", "static", "inherit", "device", "static-device", "redirect",
1239
                               "RIP", "OSPF", "OSPF-IA", "OSPF-E1", "OSPF-E2", "BGP", "pipe" };
1240
  static char *cast_names[] = { "unicast", "broadcast", "multicast", "anycast" };
1241
  int i;
1242

    
1243
  cli_printf(c, -1008, "\tType: %s %s %s", src_names[a->source], cast_names[a->cast], ip_scope_text(a->scope));
1244
  if (!eal)
1245
    eal = a->eattrs;
1246
  for(; eal; eal=eal->next)
1247
    for(i=0; i<eal->count; i++)
1248
      ea_show(c, &eal->attrs[i]);
1249
}
1250

    
1251
/**
1252
 * rta_init - initialize route attribute cache
1253
 *
1254
 * This function is called during initialization of the routing
1255
 * table module to set up the internals of the attribute cache.
1256
 */
1257
void
1258
rta_init(void)
1259
{
1260
  rta_pool = rp_new(&root_pool, "Attributes");
1261
  rta_slab = sl_new(rta_pool, sizeof(rta));
1262
  mpnh_slab = sl_new(rta_pool, sizeof(struct mpnh));
1263
  rta_alloc_hash();
1264
  rte_src_init();
1265
}
1266

    
1267
/*
1268
 *  Documentation for functions declared inline in route.h
1269
 */
1270
#if 0
1271

1272
/**
1273
 * rta_clone - clone route attributes
1274
 * @r: a &rta to be cloned
1275
 *
1276
 * rta_clone() takes a cached &rta and returns its identical cached
1277
 * copy. Currently it works by just returning the original &rta with
1278
 * its use count incremented.
1279
 */
1280
static inline rta *rta_clone(rta *r)
1281
{ DUMMY; }
1282

1283
/**
1284
 * rta_free - free route attributes
1285
 * @r: a &rta to be freed
1286
 *
1287
 * If you stop using a &rta (for example when deleting a route which uses
1288
 * it), you need to call rta_free() to notify the attribute cache the
1289
 * attribute is no longer in use and can be freed if you were the last
1290
 * user (which rta_free() tests by inspecting the use count).
1291
 */
1292
static inline void rta_free(rta *r)
1293
{ DUMMY; }
1294

1295
#endif