1: /*
2: * BIRD -- UNIX Kernel Synchronization
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: Kernel synchronization
11: *
12: * This system dependent module implements the Kernel and Device protocol,
13: * that is synchronization of interface lists and routing tables with the
14: * OS kernel.
15: *
16: * The whole kernel synchronization is a bit messy and touches some internals
17: * of the routing table engine, because routing table maintenance is a typical
18: * example of the proverbial compatibility between different Unices and we want
19: * to keep the overhead of our KRT business as low as possible and avoid maintaining
20: * a local routing table copy.
21: *
22: * The kernel syncer can work in three different modes (according to system config header):
23: * Either with a single routing table and single KRT protocol [traditional UNIX]
24: * or with many routing tables and separate KRT protocols for all of them
25: * or with many routing tables, but every scan including all tables, so we start
26: * separate KRT protocols which cooperate with each other [Linux].
27: * In this case, we keep only a single scan timer.
28: *
29: * We use FIB node flags in the routing table to keep track of route
30: * synchronization status. We also attach temporary &rte's to the routing table,
31: * but it cannot do any harm to the rest of BIRD since table synchronization is
32: * an atomic process.
33: *
34: * When starting up, we cheat by looking if there is another
35: * KRT instance to be initialized later and performing table scan
36: * only once for all the instances.
37: *
38: * The code uses OS-dependent parts for kernel updates and scans. These parts are
39: * in more specific sysdep directories (e.g. sysdep/linux) in functions krt_sys_*
40: * and kif_sys_* (and some others like krt_replace_rte()) and krt-sys.h header file.
41: * This is also used for platform specific protocol options and route attributes.
42: *
43: * There was also an old code that used traditional UNIX ioctls for these tasks.
44: * It was unmaintained and later removed. For reference, see sysdep/krt-* files
45: * in commit 396dfa9042305f62da1f56589c4b98fac57fc2f6
46: */
47:
48: /*
49: * If you are brave enough, continue now. You cannot say you haven't been warned.
50: */
51:
52: #undef LOCAL_DEBUG
53:
54: #include "nest/bird.h"
55: #include "nest/iface.h"
56: #include "nest/route.h"
57: #include "nest/protocol.h"
58: #include "filter/filter.h"
59: #include "conf/conf.h"
60: #include "lib/string.h"
61: #include "lib/timer.h"
62:
63: #include "unix.h"
64: #include "krt.h"
65:
66: /*
67: * Global resources
68: */
69:
70: pool *krt_pool;
71: static linpool *krt_filter_lp;
72: static list krt_proto_list;
73:
74: void
75: krt_io_init(void)
76: {
77: krt_pool = rp_new(&root_pool, "Kernel Syncer");
78: krt_filter_lp = lp_new_default(krt_pool);
79: init_list(&krt_proto_list);
80: krt_sys_io_init();
81: }
82:
83: /*
84: * Interfaces
85: */
86:
87: struct kif_proto *kif_proto;
88: static struct kif_config *kif_cf;
89: static timer *kif_scan_timer;
90: static btime kif_last_shot;
91:
92: static struct kif_iface_config kif_default_iface = {};
93:
94: struct kif_iface_config *
95: kif_get_iface_config(struct iface *iface)
96: {
97: struct kif_config *cf = (void *) (kif_proto->p.cf);
98: struct kif_iface_config *ic = (void *) iface_patt_find(&cf->iface_list, iface, NULL);
99: return ic ?: &kif_default_iface;
100: }
101:
102: static void
103: kif_scan(timer *t)
104: {
105: struct kif_proto *p = t->data;
106:
107: KRT_TRACE(p, D_EVENTS, "Scanning interfaces");
108: kif_last_shot = current_time();
109: kif_do_scan(p);
110: }
111:
112: static void
113: kif_force_scan(void)
114: {
115: if (kif_proto && ((kif_last_shot + 2 S) < current_time()))
116: {
117: kif_scan(kif_scan_timer);
118: tm_start(kif_scan_timer, ((struct kif_config *) kif_proto->p.cf)->scan_time);
119: }
120: }
121:
122: void
123: kif_request_scan(void)
124: {
125: if (kif_proto && (kif_scan_timer->expires > (current_time() + 1 S)))
126: tm_start(kif_scan_timer, 1 S);
127: }
128:
129: static struct proto *
130: kif_init(struct proto_config *c)
131: {
132: struct kif_proto *p = proto_new(c);
133:
134: kif_sys_init(p);
135: return &p->p;
136: }
137:
138: static int
139: kif_start(struct proto *P)
140: {
141: struct kif_proto *p = (struct kif_proto *) P;
142:
143: kif_proto = p;
144: kif_sys_start(p);
145:
146: /* Start periodic interface scanning */
147: kif_scan_timer = tm_new_init(P->pool, kif_scan, p, KIF_CF->scan_time, 0);
148: kif_scan(kif_scan_timer);
149: tm_start(kif_scan_timer, KIF_CF->scan_time);
150:
151: return PS_UP;
152: }
153:
154: static int
155: kif_shutdown(struct proto *P)
156: {
157: struct kif_proto *p = (struct kif_proto *) P;
158:
159: tm_stop(kif_scan_timer);
160: kif_sys_shutdown(p);
161: kif_proto = NULL;
162:
163: return PS_DOWN;
164: }
165:
166: static int
167: kif_reconfigure(struct proto *p, struct proto_config *new)
168: {
169: struct kif_config *o = (struct kif_config *) p->cf;
170: struct kif_config *n = (struct kif_config *) new;
171:
172: if (!kif_sys_reconfigure((struct kif_proto *) p, n, o))
173: return 0;
174:
175: if (o->scan_time != n->scan_time)
176: {
177: tm_stop(kif_scan_timer);
178: kif_scan_timer->recurrent = n->scan_time;
179: kif_scan(kif_scan_timer);
180: tm_start(kif_scan_timer, n->scan_time);
181: }
182:
183: if (!EMPTY_LIST(o->iface_list) || !EMPTY_LIST(n->iface_list))
184: {
185: /* This is hack, we have to update a configuration
186: * to the new value just now, because it is used
187: * for recalculation of preferred addresses.
188: */
189: p->cf = new;
190:
191: if_recalc_all_preferred_addresses();
192: }
193:
194: return 1;
195: }
196:
197:
198: static void
199: kif_preconfig(struct protocol *P UNUSED, struct config *c)
200: {
201: kif_cf = NULL;
202: kif_sys_preconfig(c);
203: }
204:
205: struct proto_config *
206: kif_init_config(int class)
207: {
208: if (kif_cf)
209: cf_error("Kernel device protocol already defined");
210:
211: kif_cf = (struct kif_config *) proto_config_new(&proto_unix_iface, class);
212: kif_cf->scan_time = 60 S;
213: init_list(&kif_cf->iface_list);
214:
215: kif_sys_init_config(kif_cf);
216: return (struct proto_config *) kif_cf;
217: }
218:
219: static void
220: kif_copy_config(struct proto_config *dest, struct proto_config *src)
221: {
222: struct kif_config *d = (struct kif_config *) dest;
223: struct kif_config *s = (struct kif_config *) src;
224:
225: /* Copy interface config list */
226: cfg_copy_list(&d->iface_list, &s->iface_list, sizeof(struct kif_iface_config));
227:
228: /* Fix sysdep parts */
229: kif_sys_copy_config(d, s);
230: }
231:
232: struct protocol proto_unix_iface = {
233: .name = "Device",
234: .template = "device%d",
235: .class = PROTOCOL_DEVICE,
236: .proto_size = sizeof(struct kif_proto),
237: .config_size = sizeof(struct kif_config),
238: .preconfig = kif_preconfig,
239: .init = kif_init,
240: .start = kif_start,
241: .shutdown = kif_shutdown,
242: .reconfigure = kif_reconfigure,
243: .copy_config = kif_copy_config
244: };
245:
246: /*
247: * Tracing of routes
248: */
249:
250: static inline void
251: krt_trace_in(struct krt_proto *p, rte *e, char *msg)
252: {
253: if (p->p.debug & D_PACKETS)
254: log(L_TRACE "%s: %N: %s", p->p.name, e->net->n.addr, msg);
255: }
256:
257: static inline void
258: krt_trace_in_rl(struct tbf *f, struct krt_proto *p, rte *e, char *msg)
259: {
260: if (p->p.debug & D_PACKETS)
261: log_rl(f, L_TRACE "%s: %N: %s", p->p.name, e->net->n.addr, msg);
262: }
263:
264: /*
265: * Inherited Routes
266: */
267:
268: #ifdef KRT_ALLOW_LEARN
269:
270: static struct tbf rl_alien = TBF_DEFAULT_LOG_LIMITS;
271:
272: /*
273: * krt_same_key() specifies what (aside from the net) is the key in
274: * kernel routing tables. It should be OS-dependent, this is for
275: * Linux. It is important for asynchronous alien updates, because a
276: * positive update is implicitly a negative one for any old route with
277: * the same key.
278: */
279:
280: static inline int
281: krt_same_key(rte *a, rte *b)
282: {
283: return a->u.krt.metric == b->u.krt.metric;
284: }
285:
286: static inline int
287: krt_uptodate(rte *a, rte *b)
288: {
289: if (a->attrs != b->attrs)
290: return 0;
291:
292: if (a->u.krt.proto != b->u.krt.proto)
293: return 0;
294:
295: return 1;
296: }
297:
298: static void
299: krt_learn_announce_update(struct krt_proto *p, rte *e)
300: {
301: net *n = e->net;
302: rta *aa = rta_clone(e->attrs);
303: rte *ee = rte_get_temp(aa);
304: ee->pflags = EA_ID_FLAG(EA_KRT_SOURCE) | EA_ID_FLAG(EA_KRT_METRIC);
305: ee->u.krt = e->u.krt;
306: rte_update(&p->p, n->n.addr, ee);
307: }
308:
309: static void
310: krt_learn_announce_delete(struct krt_proto *p, net *n)
311: {
312: rte_update(&p->p, n->n.addr, NULL);
313: }
314:
315: /* Called when alien route is discovered during scan */
316: static void
317: krt_learn_scan(struct krt_proto *p, rte *e)
318: {
319: net *n0 = e->net;
320: net *n = net_get(&p->krt_table, n0->n.addr);
321: rte *m, **mm;
322:
323: e->attrs = rta_lookup(e->attrs);
324:
325: for(mm=&n->routes; m = *mm; mm=&m->next)
326: if (krt_same_key(m, e))
327: break;
328: if (m)
329: {
330: if (krt_uptodate(m, e))
331: {
332: krt_trace_in_rl(&rl_alien, p, e, "[alien] seen");
333: rte_free(e);
334: m->u.krt.seen = 1;
335: }
336: else
337: {
338: krt_trace_in(p, e, "[alien] updated");
339: *mm = m->next;
340: rte_free(m);
341: m = NULL;
342: }
343: }
344: else
345: krt_trace_in(p, e, "[alien] created");
346: if (!m)
347: {
348: e->next = n->routes;
349: n->routes = e;
350: e->u.krt.seen = 1;
351: }
352: }
353:
354: static void
355: krt_learn_prune(struct krt_proto *p)
356: {
357: struct fib *fib = &p->krt_table.fib;
358: struct fib_iterator fit;
359:
360: KRT_TRACE(p, D_EVENTS, "Pruning inherited routes");
361:
362: FIB_ITERATE_INIT(&fit, fib);
363: again:
364: FIB_ITERATE_START(fib, &fit, net, n)
365: {
366: rte *e, **ee, *best, **pbest, *old_best;
367:
368: /*
369: * Note that old_best may be NULL even if there was an old best route in
370: * the previous step, because it might be replaced in krt_learn_scan().
371: * But in that case there is a new valid best route.
372: */
373:
374: old_best = NULL;
375: best = NULL;
376: pbest = NULL;
377: ee = &n->routes;
378: while (e = *ee)
379: {
380: if (e->u.krt.best)
381: old_best = e;
382:
383: if (!e->u.krt.seen)
384: {
385: *ee = e->next;
386: rte_free(e);
387: continue;
388: }
389:
390: if (!best || best->u.krt.metric > e->u.krt.metric)
391: {
392: best = e;
393: pbest = ee;
394: }
395:
396: e->u.krt.seen = 0;
397: e->u.krt.best = 0;
398: ee = &e->next;
399: }
400: if (!n->routes)
401: {
402: DBG("%I/%d: deleting\n", n->n.prefix, n->n.pxlen);
403: if (old_best)
404: krt_learn_announce_delete(p, n);
405:
406: FIB_ITERATE_PUT(&fit);
407: fib_delete(fib, n);
408: goto again;
409: }
410:
411: best->u.krt.best = 1;
412: *pbest = best->next;
413: best->next = n->routes;
414: n->routes = best;
415:
416: if ((best != old_best) || p->reload)
417: {
418: DBG("%I/%d: announcing (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
419: krt_learn_announce_update(p, best);
420: }
421: else
422: DBG("%I/%d: uptodate (metric=%d)\n", n->n.prefix, n->n.pxlen, best->u.krt.metric);
423: }
424: FIB_ITERATE_END;
425:
426: p->reload = 0;
427: }
428:
429: static void
430: krt_learn_async(struct krt_proto *p, rte *e, int new)
431: {
432: net *n0 = e->net;
433: net *n = net_get(&p->krt_table, n0->n.addr);
434: rte *g, **gg, *best, **bestp, *old_best;
435:
436: e->attrs = rta_lookup(e->attrs);
437:
438: old_best = n->routes;
439: for(gg=&n->routes; g = *gg; gg = &g->next)
440: if (krt_same_key(g, e))
441: break;
442: if (new)
443: {
444: if (g)
445: {
446: if (krt_uptodate(g, e))
447: {
448: krt_trace_in(p, e, "[alien async] same");
449: rte_free(e);
450: return;
451: }
452: krt_trace_in(p, e, "[alien async] updated");
453: *gg = g->next;
454: rte_free(g);
455: }
456: else
457: krt_trace_in(p, e, "[alien async] created");
458:
459: e->next = n->routes;
460: n->routes = e;
461: }
462: else if (!g)
463: {
464: krt_trace_in(p, e, "[alien async] delete failed");
465: rte_free(e);
466: return;
467: }
468: else
469: {
470: krt_trace_in(p, e, "[alien async] removed");
471: *gg = g->next;
472: rte_free(e);
473: rte_free(g);
474: }
475: best = n->routes;
476: bestp = &n->routes;
477: for(gg=&n->routes; g=*gg; gg=&g->next)
478: {
479: if (best->u.krt.metric > g->u.krt.metric)
480: {
481: best = g;
482: bestp = gg;
483: }
484:
485: g->u.krt.best = 0;
486: }
487:
488: if (best)
489: {
490: best->u.krt.best = 1;
491: *bestp = best->next;
492: best->next = n->routes;
493: n->routes = best;
494: }
495:
496: if (best != old_best)
497: {
498: DBG("krt_learn_async: distributing change\n");
499: if (best)
500: krt_learn_announce_update(p, best);
501: else
502: krt_learn_announce_delete(p, n);
503: }
504: }
505:
506: static void
507: krt_learn_init(struct krt_proto *p)
508: {
509: if (KRT_CF->learn)
510: {
511: struct rtable_config *cf = mb_allocz(p->p.pool, sizeof(struct rtable_config));
512: cf->name = "Inherited";
513: cf->addr_type = p->p.net_type;
514:
515: rt_setup(p->p.pool, &p->krt_table, cf);
516: }
517: }
518:
519: static void
520: krt_dump(struct proto *P)
521: {
522: struct krt_proto *p = (struct krt_proto *) P;
523:
524: if (!KRT_CF->learn)
525: return;
526: debug("KRT: Table of inheritable routes\n");
527: rt_dump(&p->krt_table);
528: }
529:
530: static void
531: krt_dump_attrs(rte *e)
532: {
533: debug(" [m=%d,p=%d]", e->u.krt.metric, e->u.krt.proto);
534: }
535:
536: #endif
537:
538: /*
539: * Routes
540: */
541:
542: static void
543: krt_flush_routes(struct krt_proto *p)
544: {
545: struct rtable *t = p->p.main_channel->table;
546:
547: KRT_TRACE(p, D_EVENTS, "Flushing kernel routes");
548: FIB_WALK(&t->fib, net, n)
549: {
550: rte *e = n->routes;
551: if (rte_is_valid(e) && (n->n.flags & KRF_INSTALLED))
552: {
553: /* FIXME: this does not work if gw is changed in export filter */
554: krt_replace_rte(p, e->net, NULL, e);
555: n->n.flags &= ~KRF_INSTALLED;
556: }
557: }
558: FIB_WALK_END;
559: }
560:
561: static struct rte *
562: krt_export_net(struct krt_proto *p, net *net, rte **rt_free)
563: {
564: struct channel *c = p->p.main_channel;
565: const struct filter *filter = c->out_filter;
566: rte *rt;
567:
568: if (c->ra_mode == RA_MERGED)
569: return rt_export_merged(c, net, rt_free, krt_filter_lp, 1);
570:
571: rt = net->routes;
572: *rt_free = NULL;
573:
574: if (!rte_is_valid(rt))
575: return NULL;
576:
577: if (filter == FILTER_REJECT)
578: return NULL;
579:
580: rte_make_tmp_attrs(&rt, krt_filter_lp, NULL);
581:
582: /* We could run krt_preexport() here, but it is already handled by KRF_INSTALLED */
583:
584: if (filter == FILTER_ACCEPT)
585: goto accept;
586:
587: if (f_run(filter, &rt, krt_filter_lp, FF_SILENT) > F_ACCEPT)
588: goto reject;
589:
590:
591: accept:
592: if (rt != net->routes)
593: *rt_free = rt;
594: return rt;
595:
596: reject:
597: if (rt != net->routes)
598: rte_free(rt);
599: return NULL;
600: }
601:
602: static int
603: krt_same_dest(rte *k, rte *e)
604: {
605: rta *ka = k->attrs, *ea = e->attrs;
606:
607: if (ka->dest != ea->dest)
608: return 0;
609:
610: if (ka->dest == RTD_UNICAST)
611: return nexthop_same(&(ka->nh), &(ea->nh));
612:
613: return 1;
614: }
615:
616: /*
617: * This gets called back when the low-level scanning code discovers a route.
618: * We expect that the route is a temporary rte and its attributes are uncached.
619: */
620:
621: void
622: krt_got_route(struct krt_proto *p, rte *e)
623: {
624: net *net = e->net;
625: int verdict;
626:
627: #ifdef KRT_ALLOW_LEARN
628: switch (e->u.krt.src)
629: {
630: case KRT_SRC_KERNEL:
631: verdict = KRF_IGNORE;
632: goto sentenced;
633:
634: case KRT_SRC_REDIRECT:
635: verdict = KRF_DELETE;
636: goto sentenced;
637:
638: case KRT_SRC_ALIEN:
639: if (KRT_CF->learn)
640: krt_learn_scan(p, e);
641: else
642: {
643: krt_trace_in_rl(&rl_alien, p, e, "[alien] ignored");
644: rte_free(e);
645: }
646: return;
647: }
648: #endif
649: /* The rest is for KRT_SRC_BIRD (or KRT_SRC_UNKNOWN) */
650:
651: if (net->n.flags & KRF_VERDICT_MASK)
652: {
653: /* Route to this destination was already seen. Strange, but it happens... */
654: krt_trace_in(p, e, "already seen");
655: rte_free(e);
656: return;
657: }
658:
659: if (!p->ready)
660: {
661: /* We wait for the initial feed to have correct KRF_INSTALLED flag */
662: verdict = KRF_IGNORE;
663: goto sentenced;
664: }
665:
666: if (net->n.flags & KRF_INSTALLED)
667: {
668: rte *new, *rt_free;
669:
670: new = krt_export_net(p, net, &rt_free);
671:
672: /* TODO: There also may be changes in route eattrs, we ignore that for now. */
673:
674: if (!new)
675: verdict = KRF_DELETE;
676: else if ((net->n.flags & KRF_SYNC_ERROR) || !krt_same_dest(e, new))
677: verdict = KRF_UPDATE;
678: else
679: verdict = KRF_SEEN;
680:
681: if (rt_free)
682: rte_free(rt_free);
683:
684: lp_flush(krt_filter_lp);
685: }
686: else
687: verdict = KRF_DELETE;
688:
689: sentenced:
690: krt_trace_in(p, e, ((char *[]) { "?", "seen", "will be updated", "will be removed", "ignored" }) [verdict]);
691: net->n.flags = (net->n.flags & ~KRF_VERDICT_MASK) | verdict;
692: if (verdict == KRF_UPDATE || verdict == KRF_DELETE)
693: {
694: /* Get a cached copy of attributes and temporarily link the route */
695: rta *a = e->attrs;
696: a->source = RTS_DUMMY;
697: e->attrs = rta_lookup(a);
698: e->next = net->routes;
699: net->routes = e;
700: }
701: else
702: rte_free(e);
703: }
704:
705: static void
706: krt_prune(struct krt_proto *p)
707: {
708: struct rtable *t = p->p.main_channel->table;
709:
710: KRT_TRACE(p, D_EVENTS, "Pruning table %s", t->name);
711: FIB_WALK(&t->fib, net, n)
712: {
713: int verdict = n->n.flags & KRF_VERDICT_MASK;
714: rte *new, *old, *rt_free = NULL;
715:
716: if (verdict == KRF_UPDATE || verdict == KRF_DELETE)
717: {
718: /* Get a dummy route from krt_got_route() */
719: old = n->routes;
720: n->routes = old->next;
721: }
722: else
723: old = NULL;
724:
725: if (verdict == KRF_CREATE || verdict == KRF_UPDATE)
726: {
727: /* We have to run export filter to get proper 'new' route */
728: new = krt_export_net(p, n, &rt_free);
729:
730: if (!new)
731: verdict = (verdict == KRF_CREATE) ? KRF_IGNORE : KRF_DELETE;
732: }
733: else
734: new = NULL;
735:
736: switch (verdict)
737: {
738: case KRF_CREATE:
739: if (new && (n->n.flags & KRF_INSTALLED))
740: {
741: krt_trace_in(p, new, "reinstalling");
742: krt_replace_rte(p, n, new, NULL);
743: }
744: break;
745: case KRF_SEEN:
746: case KRF_IGNORE:
747: /* Nothing happens */
748: break;
749: case KRF_UPDATE:
750: krt_trace_in(p, new, "updating");
751: krt_replace_rte(p, n, new, old);
752: break;
753: case KRF_DELETE:
754: krt_trace_in(p, old, "deleting");
755: krt_replace_rte(p, n, NULL, old);
756: break;
757: default:
758: bug("krt_prune: invalid route status");
759: }
760:
761: if (old)
762: rte_free(old);
763: if (rt_free)
764: rte_free(rt_free);
765: lp_flush(krt_filter_lp);
766: n->n.flags &= ~KRF_VERDICT_MASK;
767: }
768: FIB_WALK_END;
769:
770: #ifdef KRT_ALLOW_LEARN
771: if (KRT_CF->learn)
772: krt_learn_prune(p);
773: #endif
774:
775: if (p->ready)
776: p->initialized = 1;
777: }
778:
779: void
780: krt_got_route_async(struct krt_proto *p, rte *e, int new)
781: {
782: net *net = e->net;
783:
784: switch (e->u.krt.src)
785: {
786: case KRT_SRC_BIRD:
787: /* Should be filtered by the back end */
788: bug("BIRD originated routes should not get here.");
789:
790: case KRT_SRC_REDIRECT:
791: if (new)
792: {
793: krt_trace_in(p, e, "[redirect] deleting");
794: krt_replace_rte(p, net, NULL, e);
795: }
796: /* If !new, it is probably echo of our deletion */
797: break;
798:
799: #ifdef KRT_ALLOW_LEARN
800: case KRT_SRC_ALIEN:
801: if (KRT_CF->learn)
802: {
803: krt_learn_async(p, e, new);
804: return;
805: }
806: #endif
807: }
808: rte_free(e);
809: }
810:
811: /*
812: * Periodic scanning
813: */
814:
815:
816: #ifdef CONFIG_ALL_TABLES_AT_ONCE
817:
818: static timer *krt_scan_timer;
819: static int krt_scan_count;
820:
821: static void
822: krt_scan(timer *t UNUSED)
823: {
824: struct krt_proto *p;
825:
826: kif_force_scan();
827:
828: /* We need some node to decide whether to print the debug messages or not */
829: p = SKIP_BACK(struct krt_proto, krt_node, HEAD(krt_proto_list));
830: KRT_TRACE(p, D_EVENTS, "Scanning routing table");
831:
832: krt_do_scan(NULL);
833:
834: void *q;
835: WALK_LIST(q, krt_proto_list)
836: {
837: p = SKIP_BACK(struct krt_proto, krt_node, q);
838: krt_prune(p);
839: }
840: }
841:
842: static void
843: krt_scan_timer_start(struct krt_proto *p)
844: {
845: if (!krt_scan_count)
846: krt_scan_timer = tm_new_init(krt_pool, krt_scan, NULL, KRT_CF->scan_time, 0);
847:
848: krt_scan_count++;
849:
850: tm_start(krt_scan_timer, 1 S);
851: }
852:
853: static void
854: krt_scan_timer_stop(struct krt_proto *p UNUSED)
855: {
856: krt_scan_count--;
857:
858: if (!krt_scan_count)
859: {
860: rfree(krt_scan_timer);
861: krt_scan_timer = NULL;
862: }
863: }
864:
865: static void
866: krt_scan_timer_kick(struct krt_proto *p UNUSED)
867: {
868: tm_start(krt_scan_timer, 0);
869: }
870:
871: #else
872:
873: static void
874: krt_scan(timer *t)
875: {
876: struct krt_proto *p = t->data;
877:
878: kif_force_scan();
879:
880: KRT_TRACE(p, D_EVENTS, "Scanning routing table");
881: krt_do_scan(p);
882: krt_prune(p);
883: }
884:
885: static void
886: krt_scan_timer_start(struct krt_proto *p)
887: {
888: p->scan_timer = tm_new_init(p->p.pool, krt_scan, p, KRT_CF->scan_time, 0);
889: tm_start(p->scan_timer, 1 S);
890: }
891:
892: static void
893: krt_scan_timer_stop(struct krt_proto *p)
894: {
895: tm_stop(p->scan_timer);
896: }
897:
898: static void
899: krt_scan_timer_kick(struct krt_proto *p)
900: {
901: tm_start(p->scan_timer, 0);
902: }
903:
904: #endif
905:
906:
907:
908:
909: /*
910: * Updates
911: */
912:
913: static void
914: krt_make_tmp_attrs(struct rte *rt, struct linpool *pool)
915: {
916: rte_init_tmp_attrs(rt, pool, 2);
917: rte_make_tmp_attr(rt, EA_KRT_SOURCE, EAF_TYPE_INT, rt->u.krt.proto);
918: rte_make_tmp_attr(rt, EA_KRT_METRIC, EAF_TYPE_INT, rt->u.krt.metric);
919: }
920:
921: static void
922: krt_store_tmp_attrs(struct rte *rt, struct linpool *pool)
923: {
924: rte_init_tmp_attrs(rt, pool, 2);
925: rt->u.krt.proto = rte_store_tmp_attr(rt, EA_KRT_SOURCE);
926: rt->u.krt.metric = rte_store_tmp_attr(rt, EA_KRT_METRIC);
927: }
928:
929: static int
930: krt_preexport(struct proto *P, rte **new, struct linpool *pool UNUSED)
931: {
932: // struct krt_proto *p = (struct krt_proto *) P;
933: rte *e = *new;
934:
935: if (e->attrs->src->proto == P)
936: {
937: #ifdef CONFIG_SINGLE_ROUTE
938: /*
939: * Implicit withdraw - when the imported kernel route becomes the best one,
940: * we know that the previous one exported to the kernel was already removed,
941: * but if we processed the update as usual, we would send withdraw to the
942: * kernel, which would remove the new imported route instead.
943: *
944: * We will remove KRT_INSTALLED flag, which stops such withdraw to be
945: * processed in krt_rt_notify() and krt_replace_rte().
946: */
947: if (e == e->net->routes)
948: e->net->n.flags &= ~KRF_INSTALLED;
949: #endif
950: return -1;
951: }
952:
953: if (!krt_capable(e))
954: return -1;
955:
956: return 0;
957: }
958:
959: static void
960: krt_rt_notify(struct proto *P, struct channel *ch UNUSED, net *net,
961: rte *new, rte *old)
962: {
963: struct krt_proto *p = (struct krt_proto *) P;
964:
965: if (config->shutdown)
966: return;
967: if (!(net->n.flags & KRF_INSTALLED))
968: old = NULL;
969: if (new)
970: net->n.flags |= KRF_INSTALLED;
971: else
972: net->n.flags &= ~KRF_INSTALLED;
973: if (p->initialized) /* Before first scan we don't touch the routes */
974: krt_replace_rte(p, net, new, old);
975: }
976:
977: static void
978: krt_if_notify(struct proto *P, uint flags, struct iface *iface UNUSED)
979: {
980: struct krt_proto *p = (struct krt_proto *) P;
981:
982: /*
983: * When interface went down, we should remove routes to it. In the ideal world,
984: * OS kernel would send us route removal notifications in such cases, but we
985: * cannot rely on it as it is often not true. E.g. Linux kernel removes related
986: * routes when an interface went down, but it does not notify userspace about
987: * that. To be sure, we just schedule a scan to ensure synchronization.
988: */
989:
990: if ((flags & IF_CHANGE_DOWN) && KRT_CF->learn)
991: krt_scan_timer_kick(p);
992: }
993:
994: static void
995: krt_reload_routes(struct channel *C)
996: {
997: struct krt_proto *p = (void *) C->proto;
998:
999: /* Although we keep learned routes in krt_table, we rather schedule a scan */
1000:
1001: if (KRT_CF->learn)
1002: {
1003: p->reload = 1;
1004: krt_scan_timer_kick(p);
1005: }
1006: }
1007:
1008: static void
1009: krt_feed_end(struct channel *C)
1010: {
1011: struct krt_proto *p = (void *) C->proto;
1012:
1013: p->ready = 1;
1014: krt_scan_timer_kick(p);
1015: }
1016:
1017:
1018: static int
1019: krt_rte_same(rte *a, rte *b)
1020: {
1021: /* src is always KRT_SRC_ALIEN and type is irrelevant */
1022: return (a->u.krt.proto == b->u.krt.proto) && (a->u.krt.metric == b->u.krt.metric);
1023: }
1024:
1025:
1026: /*
1027: * Protocol glue
1028: */
1029:
1030: struct krt_config *krt_cf;
1031:
1032: static void
1033: krt_preconfig(struct protocol *P UNUSED, struct config *c)
1034: {
1035: krt_cf = NULL;
1036: krt_sys_preconfig(c);
1037: }
1038:
1039: static void
1040: krt_postconfig(struct proto_config *CF)
1041: {
1042: struct krt_config *cf = (void *) CF;
1043:
1044: if (EMPTY_LIST(CF->channels))
1045: cf_error("Channel not specified");
1046:
1047: #ifdef CONFIG_ALL_TABLES_AT_ONCE
1048: if (krt_cf->scan_time != cf->scan_time)
1049: cf_error("All kernel syncers must use the same table scan interval");
1050: #endif
1051:
1052: struct channel_config *cc = proto_cf_main_channel(CF);
1053: struct rtable_config *tab = cc->table;
1054: if (tab->krt_attached)
1055: cf_error("Kernel syncer (%s) already attached to table %s", tab->krt_attached->name, tab->name);
1056: tab->krt_attached = CF;
1057:
1058: if (cf->merge_paths)
1059: {
1060: cc->ra_mode = RA_MERGED;
1061: cc->merge_limit = cf->merge_paths;
1062: }
1063:
1064: krt_sys_postconfig(cf);
1065: }
1066:
1067: static struct proto *
1068: krt_init(struct proto_config *CF)
1069: {
1070: struct krt_proto *p = proto_new(CF);
1071: // struct krt_config *cf = (void *) CF;
1072:
1073: p->p.main_channel = proto_add_channel(&p->p, proto_cf_main_channel(CF));
1074:
1075: p->p.preexport = krt_preexport;
1076: p->p.rt_notify = krt_rt_notify;
1077: p->p.if_notify = krt_if_notify;
1078: p->p.reload_routes = krt_reload_routes;
1079: p->p.feed_end = krt_feed_end;
1080: p->p.make_tmp_attrs = krt_make_tmp_attrs;
1081: p->p.store_tmp_attrs = krt_store_tmp_attrs;
1082: p->p.rte_same = krt_rte_same;
1083:
1084: krt_sys_init(p);
1085: return &p->p;
1086: }
1087:
1088: static int
1089: krt_start(struct proto *P)
1090: {
1091: struct krt_proto *p = (struct krt_proto *) P;
1092:
1093: switch (p->p.net_type)
1094: {
1095: case NET_IP4: p->af = AF_INET; break;
1096: case NET_IP6: p->af = AF_INET6; break;
1097: case NET_IP6_SADR: p->af = AF_INET6; break;
1098: #ifdef AF_MPLS
1099: case NET_MPLS: p->af = AF_MPLS; break;
1100: #endif
1101: default: log(L_ERR "KRT: Tried to start with strange net type: %d", p->p.net_type); return PS_START; break;
1102: }
1103:
1104: add_tail(&krt_proto_list, &p->krt_node);
1105:
1106: #ifdef KRT_ALLOW_LEARN
1107: krt_learn_init(p);
1108: #endif
1109:
1110: if (!krt_sys_start(p))
1111: {
1112: rem_node(&p->krt_node);
1113: return PS_START;
1114: }
1115:
1116: krt_scan_timer_start(p);
1117:
1118: if (p->p.gr_recovery && KRT_CF->graceful_restart)
1119: p->p.main_channel->gr_wait = 1;
1120:
1121: return PS_UP;
1122: }
1123:
1124: static int
1125: krt_shutdown(struct proto *P)
1126: {
1127: struct krt_proto *p = (struct krt_proto *) P;
1128:
1129: krt_scan_timer_stop(p);
1130:
1131: /* FIXME we should flush routes even when persist during reconfiguration */
1132: if (p->initialized && !KRT_CF->persist && (P->down_code != PDC_CMD_GR_DOWN))
1133: krt_flush_routes(p);
1134:
1135: p->ready = 0;
1136: p->initialized = 0;
1137:
1138: if (p->p.proto_state == PS_START)
1139: return PS_DOWN;
1140:
1141: krt_sys_shutdown(p);
1142: rem_node(&p->krt_node);
1143:
1144: return PS_DOWN;
1145: }
1146:
1147: static int
1148: krt_reconfigure(struct proto *p, struct proto_config *CF)
1149: {
1150: struct krt_config *o = (void *) p->cf;
1151: struct krt_config *n = (void *) CF;
1152:
1153: if (!proto_configure_channel(p, &p->main_channel, proto_cf_main_channel(CF)))
1154: return 0;
1155:
1156: if (!krt_sys_reconfigure((struct krt_proto *) p, n, o))
1157: return 0;
1158:
1159: /* persist, graceful restart need not be the same */
1160: return o->scan_time == n->scan_time && o->learn == n->learn;
1161: }
1162:
1163: struct proto_config *
1164: krt_init_config(int class)
1165: {
1166: #ifndef CONFIG_MULTIPLE_TABLES
1167: if (krt_cf)
1168: cf_error("Kernel protocol already defined");
1169: #endif
1170:
1171: krt_cf = (struct krt_config *) proto_config_new(&proto_unix_kernel, class);
1172: krt_cf->scan_time = 60 S;
1173:
1174: krt_sys_init_config(krt_cf);
1175: return (struct proto_config *) krt_cf;
1176: }
1177:
1178: static void
1179: krt_copy_config(struct proto_config *dest, struct proto_config *src)
1180: {
1181: struct krt_config *d = (struct krt_config *) dest;
1182: struct krt_config *s = (struct krt_config *) src;
1183:
1184: /* Fix sysdep parts */
1185: krt_sys_copy_config(d, s);
1186: }
1187:
1188: static int
1189: krt_get_attr(eattr *a, byte *buf, int buflen)
1190: {
1191: switch (a->id)
1192: {
1193: case EA_KRT_SOURCE:
1194: bsprintf(buf, "source");
1195: return GA_NAME;
1196:
1197: case EA_KRT_METRIC:
1198: bsprintf(buf, "metric");
1199: return GA_NAME;
1200:
1201: default:
1202: return krt_sys_get_attr(a, buf, buflen);
1203: }
1204: }
1205:
1206:
1207: #ifdef CONFIG_IP6_SADR_KERNEL
1208: #define MAYBE_IP6_SADR NB_IP6_SADR
1209: #else
1210: #define MAYBE_IP6_SADR 0
1211: #endif
1212:
1213: #ifdef HAVE_MPLS_KERNEL
1214: #define MAYBE_MPLS NB_MPLS
1215: #else
1216: #define MAYBE_MPLS 0
1217: #endif
1218:
1219: struct protocol proto_unix_kernel = {
1220: .name = "Kernel",
1221: .template = "kernel%d",
1222: .class = PROTOCOL_KERNEL,
1223: .preference = DEF_PREF_INHERITED,
1224: .channel_mask = NB_IP | MAYBE_IP6_SADR | MAYBE_MPLS,
1225: .proto_size = sizeof(struct krt_proto),
1226: .config_size = sizeof(struct krt_config),
1227: .preconfig = krt_preconfig,
1228: .postconfig = krt_postconfig,
1229: .init = krt_init,
1230: .start = krt_start,
1231: .shutdown = krt_shutdown,
1232: .reconfigure = krt_reconfigure,
1233: .copy_config = krt_copy_config,
1234: .get_attr = krt_get_attr,
1235: #ifdef KRT_ALLOW_LEARN
1236: .dump = krt_dump,
1237: .dump_attrs = krt_dump_attrs,
1238: #endif
1239: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to krt.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 / sysdep / unix