Annotation of embedaddon/bird/nest/proto.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- Protocols
! 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: #undef LOCAL_DEBUG
! 10:
! 11: #include "nest/bird.h"
! 12: #include "nest/protocol.h"
! 13: #include "lib/resource.h"
! 14: #include "lib/lists.h"
! 15: #include "lib/event.h"
! 16: #include "lib/string.h"
! 17: #include "conf/conf.h"
! 18: #include "nest/route.h"
! 19: #include "nest/iface.h"
! 20: #include "nest/cli.h"
! 21: #include "filter/filter.h"
! 22:
! 23: pool *proto_pool;
! 24:
! 25: static list protocol_list;
! 26: static list proto_list;
! 27:
! 28: #define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)
! 29:
! 30: list active_proto_list;
! 31: static list inactive_proto_list;
! 32: static list initial_proto_list;
! 33: static list flush_proto_list;
! 34: static struct proto *initial_device_proto;
! 35:
! 36: static event *proto_flush_event;
! 37: static timer *proto_shutdown_timer;
! 38: static timer *gr_wait_timer;
! 39:
! 40: #define GRS_NONE 0
! 41: #define GRS_INIT 1
! 42: #define GRS_ACTIVE 2
! 43: #define GRS_DONE 3
! 44:
! 45: static int graceful_restart_state;
! 46: static u32 graceful_restart_locks;
! 47:
! 48: static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
! 49: static char *c_states[] = { "HUNGRY", "???", "HAPPY", "FLUSHING" };
! 50:
! 51: static void proto_flush_loop(void *);
! 52: static void proto_shutdown_loop(struct timer *);
! 53: static void proto_rethink_goal(struct proto *p);
! 54: static void proto_want_export_up(struct proto *p);
! 55: static void proto_fell_down(struct proto *p);
! 56: static char *proto_state_name(struct proto *p);
! 57:
! 58: static void
! 59: proto_relink(struct proto *p)
! 60: {
! 61: list *l = NULL;
! 62:
! 63: switch (p->core_state)
! 64: {
! 65: case FS_HUNGRY:
! 66: l = &inactive_proto_list;
! 67: break;
! 68: case FS_HAPPY:
! 69: l = &active_proto_list;
! 70: break;
! 71: case FS_FLUSHING:
! 72: l = &flush_proto_list;
! 73: break;
! 74: default:
! 75: ASSERT(0);
! 76: }
! 77:
! 78: rem_node(&p->n);
! 79: add_tail(l, &p->n);
! 80: }
! 81:
! 82: static void
! 83: proto_log_state_change(struct proto *p)
! 84: {
! 85: if (p->debug & D_STATES)
! 86: {
! 87: char *name = proto_state_name(p);
! 88: if (name != p->last_state_name_announced)
! 89: {
! 90: p->last_state_name_announced = name;
! 91: PD(p, "State changed to %s", proto_state_name(p));
! 92: }
! 93: }
! 94: else
! 95: p->last_state_name_announced = NULL;
! 96: }
! 97:
! 98:
! 99: /**
! 100: * proto_new - create a new protocol instance
! 101: * @c: protocol configuration
! 102: * @size: size of protocol data structure (each protocol instance is represented by
! 103: * a structure starting with generic part [struct &proto] and continued
! 104: * with data specific to the protocol)
! 105: *
! 106: * When a new configuration has been read in, the core code starts
! 107: * initializing all the protocol instances configured by calling their
! 108: * init() hooks with the corresponding instance configuration. The initialization
! 109: * code of the protocol is expected to create a new instance according to the
! 110: * configuration by calling this function and then modifying the default settings
! 111: * to values wanted by the protocol.
! 112: */
! 113: void *
! 114: proto_new(struct proto_config *c, unsigned size)
! 115: {
! 116: struct protocol *pr = c->protocol;
! 117: struct proto *p = mb_allocz(proto_pool, size);
! 118:
! 119: p->cf = c;
! 120: p->debug = c->debug;
! 121: p->mrtdump = c->mrtdump;
! 122: p->name = c->name;
! 123: p->preference = c->preference;
! 124: p->disabled = c->disabled;
! 125: p->proto = pr;
! 126: p->table = c->table->table;
! 127: p->hash_key = random_u32();
! 128: c->proto = p;
! 129: return p;
! 130: }
! 131:
! 132: static void
! 133: proto_init_instance(struct proto *p)
! 134: {
! 135: /* Here we cannot use p->cf->name since it won't survive reconfiguration */
! 136: p->pool = rp_new(proto_pool, p->proto->name);
! 137: p->attn = ev_new(p->pool);
! 138: p->attn->data = p;
! 139:
! 140: if (graceful_restart_state == GRS_INIT)
! 141: p->gr_recovery = 1;
! 142:
! 143: if (! p->proto->multitable)
! 144: rt_lock_table(p->table);
! 145: }
! 146:
! 147: extern pool *rt_table_pool;
! 148: /**
! 149: * proto_add_announce_hook - connect protocol to a routing table
! 150: * @p: protocol instance
! 151: * @t: routing table to connect to
! 152: * @stats: per-table protocol statistics
! 153: *
! 154: * This function creates a connection between the protocol instance @p and the
! 155: * routing table @t, making the protocol hear all changes in the table.
! 156: *
! 157: * The announce hook is linked in the protocol ahook list. Announce hooks are
! 158: * allocated from the routing table resource pool and when protocol accepts
! 159: * routes also in the table ahook list. The are linked to the table ahook list
! 160: * and unlinked from it depending on export_state (in proto_want_export_up() and
! 161: * proto_want_export_down()) and they are automatically freed after the protocol
! 162: * is flushed (in proto_fell_down()).
! 163: *
! 164: * Unless you want to listen to multiple routing tables (as the Pipe protocol
! 165: * does), you needn't to worry about this function since the connection to the
! 166: * protocol's primary routing table is initialized automatically by the core
! 167: * code.
! 168: */
! 169: struct announce_hook *
! 170: proto_add_announce_hook(struct proto *p, struct rtable *t, struct proto_stats *stats)
! 171: {
! 172: struct announce_hook *h;
! 173:
! 174: DBG("Connecting protocol %s to table %s\n", p->name, t->name);
! 175: PD(p, "Connected to table %s", t->name);
! 176:
! 177: h = mb_allocz(rt_table_pool, sizeof(struct announce_hook));
! 178: h->table = t;
! 179: h->proto = p;
! 180: h->stats = stats;
! 181:
! 182: h->next = p->ahooks;
! 183: p->ahooks = h;
! 184:
! 185: if (p->rt_notify && (p->export_state != ES_DOWN))
! 186: add_tail(&t->hooks, &h->n);
! 187: return h;
! 188: }
! 189:
! 190: /**
! 191: * proto_find_announce_hook - find announce hooks
! 192: * @p: protocol instance
! 193: * @t: routing table
! 194: *
! 195: * Returns pointer to announce hook or NULL
! 196: */
! 197: struct announce_hook *
! 198: proto_find_announce_hook(struct proto *p, struct rtable *t)
! 199: {
! 200: struct announce_hook *a;
! 201:
! 202: for (a = p->ahooks; a; a = a->next)
! 203: if (a->table == t)
! 204: return a;
! 205:
! 206: return NULL;
! 207: }
! 208:
! 209: static void
! 210: proto_link_ahooks(struct proto *p)
! 211: {
! 212: struct announce_hook *h;
! 213:
! 214: if (p->rt_notify)
! 215: for(h=p->ahooks; h; h=h->next)
! 216: add_tail(&h->table->hooks, &h->n);
! 217: }
! 218:
! 219: static void
! 220: proto_unlink_ahooks(struct proto *p)
! 221: {
! 222: struct announce_hook *h;
! 223:
! 224: if (p->rt_notify)
! 225: for(h=p->ahooks; h; h=h->next)
! 226: rem_node(&h->n);
! 227: }
! 228:
! 229: static void
! 230: proto_free_ahooks(struct proto *p)
! 231: {
! 232: struct announce_hook *h, *hn;
! 233:
! 234: for(h = p->ahooks; h; h = hn)
! 235: {
! 236: hn = h->next;
! 237: mb_free(h);
! 238: }
! 239:
! 240: p->ahooks = NULL;
! 241: p->main_ahook = NULL;
! 242: }
! 243:
! 244:
! 245: /**
! 246: * proto_config_new - create a new protocol configuration
! 247: * @pr: protocol the configuration will belong to
! 248: * @class: SYM_PROTO or SYM_TEMPLATE
! 249: *
! 250: * Whenever the configuration file says that a new instance
! 251: * of a routing protocol should be created, the parser calls
! 252: * proto_config_new() to create a configuration entry for this
! 253: * instance (a structure staring with the &proto_config header
! 254: * containing all the generic items followed by protocol-specific
! 255: * ones). Also, the configuration entry gets added to the list
! 256: * of protocol instances kept in the configuration.
! 257: *
! 258: * The function is also used to create protocol templates (when class
! 259: * SYM_TEMPLATE is specified), the only difference is that templates
! 260: * are not added to the list of protocol instances and therefore not
! 261: * initialized during protos_commit()).
! 262: */
! 263: void *
! 264: proto_config_new(struct protocol *pr, int class)
! 265: {
! 266: struct proto_config *c = cfg_allocz(pr->config_size);
! 267:
! 268: if (class == SYM_PROTO)
! 269: add_tail(&new_config->protos, &c->n);
! 270: c->global = new_config;
! 271: c->protocol = pr;
! 272: c->name = pr->name;
! 273: c->preference = pr->preference;
! 274: c->class = class;
! 275: c->out_filter = FILTER_REJECT;
! 276: c->table = c->global->master_rtc;
! 277: c->debug = new_config->proto_default_debug;
! 278: c->mrtdump = new_config->proto_default_mrtdump;
! 279: return c;
! 280: }
! 281:
! 282: /**
! 283: * proto_copy_config - copy a protocol configuration
! 284: * @dest: destination protocol configuration
! 285: * @src: source protocol configuration
! 286: *
! 287: * Whenever a new instance of a routing protocol is created from the
! 288: * template, proto_copy_config() is called to copy a content of
! 289: * the source protocol configuration to the new protocol configuration.
! 290: * Name, class and a node in protos list of @dest are kept intact.
! 291: * copy_config() protocol hook is used to copy protocol-specific data.
! 292: */
! 293: void
! 294: proto_copy_config(struct proto_config *dest, struct proto_config *src)
! 295: {
! 296: node old_node;
! 297: int old_class;
! 298: char *old_name;
! 299:
! 300: if (dest->protocol != src->protocol)
! 301: cf_error("Can't copy configuration from a different protocol type");
! 302:
! 303: if (dest->protocol->copy_config == NULL)
! 304: cf_error("Inheriting configuration for %s is not supported", src->protocol->name);
! 305:
! 306: DBG("Copying configuration from %s to %s\n", src->name, dest->name);
! 307:
! 308: /*
! 309: * Copy struct proto_config here. Keep original node, class and name.
! 310: * protocol-specific config copy is handled by protocol copy_config() hook
! 311: */
! 312:
! 313: old_node = dest->n;
! 314: old_class = dest->class;
! 315: old_name = dest->name;
! 316:
! 317: memcpy(dest, src, sizeof(struct proto_config));
! 318:
! 319: dest->n = old_node;
! 320: dest->class = old_class;
! 321: dest->name = old_name;
! 322:
! 323: dest->protocol->copy_config(dest, src);
! 324: }
! 325:
! 326: /**
! 327: * protos_preconfig - pre-configuration processing
! 328: * @c: new configuration
! 329: *
! 330: * This function calls the preconfig() hooks of all routing
! 331: * protocols available to prepare them for reading of the new
! 332: * configuration.
! 333: */
! 334: void
! 335: protos_preconfig(struct config *c)
! 336: {
! 337: struct protocol *p;
! 338:
! 339: init_list(&c->protos);
! 340: DBG("Protocol preconfig:");
! 341: WALK_LIST(p, protocol_list)
! 342: {
! 343: DBG(" %s", p->name);
! 344: p->name_counter = 0;
! 345: if (p->preconfig)
! 346: p->preconfig(p, c);
! 347: }
! 348: DBG("\n");
! 349: }
! 350:
! 351: /**
! 352: * protos_postconfig - post-configuration processing
! 353: * @c: new configuration
! 354: *
! 355: * This function calls the postconfig() hooks of all protocol
! 356: * instances specified in configuration @c. The hooks are not
! 357: * called for protocol templates.
! 358: */
! 359: void
! 360: protos_postconfig(struct config *c)
! 361: {
! 362: struct proto_config *x;
! 363: struct protocol *p;
! 364:
! 365: DBG("Protocol postconfig:");
! 366: WALK_LIST(x, c->protos)
! 367: {
! 368: DBG(" %s", x->name);
! 369:
! 370: p = x->protocol;
! 371: if (p->postconfig)
! 372: p->postconfig(x);
! 373: }
! 374: DBG("\n");
! 375: }
! 376:
! 377: extern struct protocol proto_unix_iface;
! 378:
! 379: static struct proto *
! 380: proto_init(struct proto_config *c)
! 381: {
! 382: struct protocol *p = c->protocol;
! 383: struct proto *q = p->init(c);
! 384:
! 385: q->proto_state = PS_DOWN;
! 386: q->core_state = FS_HUNGRY;
! 387: q->export_state = ES_DOWN;
! 388: q->last_state_change = now;
! 389:
! 390: add_tail(&initial_proto_list, &q->n);
! 391:
! 392: if (p == &proto_unix_iface)
! 393: initial_device_proto = q;
! 394:
! 395: add_tail(&proto_list, &q->glob_node);
! 396: PD(q, "Initializing%s", q->disabled ? " [disabled]" : "");
! 397: return q;
! 398: }
! 399:
! 400: int proto_reconfig_type; /* Hack to propagate type info to pipe reconfigure hook */
! 401:
! 402: static int
! 403: proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config *nc, int type)
! 404: {
! 405: /* If the protocol is DOWN, we just restart it */
! 406: if (p->proto_state == PS_DOWN)
! 407: return 0;
! 408:
! 409: /* If there is a too big change in core attributes, ... */
! 410: if ((nc->protocol != oc->protocol) ||
! 411: (nc->disabled != p->disabled) ||
! 412: (nc->table->table != oc->table->table))
! 413: return 0;
! 414:
! 415: p->debug = nc->debug;
! 416: p->mrtdump = nc->mrtdump;
! 417: proto_reconfig_type = type;
! 418:
! 419: /* Execute protocol specific reconfigure hook */
! 420: if (! (p->proto->reconfigure && p->proto->reconfigure(p, nc)))
! 421: return 0;
! 422:
! 423: DBG("\t%s: same\n", oc->name);
! 424: PD(p, "Reconfigured");
! 425: p->cf = nc;
! 426: p->name = nc->name;
! 427: p->preference = nc->preference;
! 428:
! 429:
! 430: /* Multitable protocols handle rest in their reconfigure hooks */
! 431: if (p->proto->multitable)
! 432: return 1;
! 433:
! 434: /* Update filters and limits in the main announce hook
! 435: Note that this also resets limit state */
! 436: if (p->main_ahook)
! 437: {
! 438: struct announce_hook *ah = p->main_ahook;
! 439: ah->in_filter = nc->in_filter;
! 440: ah->out_filter = nc->out_filter;
! 441: ah->rx_limit = nc->rx_limit;
! 442: ah->in_limit = nc->in_limit;
! 443: ah->out_limit = nc->out_limit;
! 444: ah->in_keep_filtered = nc->in_keep_filtered;
! 445: proto_verify_limits(ah);
! 446: }
! 447:
! 448: /* Update routes when filters changed. If the protocol in not UP,
! 449: it has no routes and we can ignore such changes */
! 450: if ((p->proto_state != PS_UP) || (type == RECONFIG_SOFT))
! 451: return 1;
! 452:
! 453: int import_changed = ! filter_same(nc->in_filter, oc->in_filter);
! 454: int export_changed = ! filter_same(nc->out_filter, oc->out_filter);
! 455:
! 456: /* We treat a change in preferences by reimporting routes */
! 457: if (nc->preference != oc->preference)
! 458: import_changed = 1;
! 459:
! 460: if (import_changed || export_changed)
! 461: log(L_INFO "Reloading protocol %s", p->name);
! 462:
! 463: /* If import filter changed, call reload hook */
! 464: if (import_changed && ! (p->reload_routes && p->reload_routes(p)))
! 465: {
! 466: /* Now, the protocol is reconfigured. But route reload failed
! 467: and we have to do regular protocol restart. */
! 468: log(L_INFO "Restarting protocol %s", p->name);
! 469: p->disabled = 1;
! 470: p->down_code = PDC_CF_RESTART;
! 471: proto_rethink_goal(p);
! 472: p->disabled = 0;
! 473: proto_rethink_goal(p);
! 474: return 1;
! 475: }
! 476:
! 477: if (export_changed)
! 478: proto_request_feeding(p);
! 479:
! 480: return 1;
! 481: }
! 482:
! 483: /**
! 484: * protos_commit - commit new protocol configuration
! 485: * @new: new configuration
! 486: * @old: old configuration or %NULL if it's boot time config
! 487: * @force_reconfig: force restart of all protocols (used for example
! 488: * when the router ID changes)
! 489: * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
! 490: *
! 491: * Scan differences between @old and @new configuration and adjust all
! 492: * protocol instances to conform to the new configuration.
! 493: *
! 494: * When a protocol exists in the new configuration, but it doesn't in the
! 495: * original one, it's immediately started. When a collision with the other
! 496: * running protocol would arise, the new protocol will be temporarily stopped
! 497: * by the locking mechanism.
! 498: *
! 499: * When a protocol exists in the old configuration, but it doesn't in the
! 500: * new one, it's shut down and deleted after the shutdown completes.
! 501: *
! 502: * When a protocol exists in both configurations, the core decides
! 503: * whether it's possible to reconfigure it dynamically - it checks all
! 504: * the core properties of the protocol (changes in filters are ignored
! 505: * if type is RECONFIG_SOFT) and if they match, it asks the
! 506: * reconfigure() hook of the protocol to see if the protocol is able
! 507: * to switch to the new configuration. If it isn't possible, the
! 508: * protocol is shut down and a new instance is started with the new
! 509: * configuration after the shutdown is completed.
! 510: */
! 511: void
! 512: protos_commit(struct config *new, struct config *old, int force_reconfig, int type)
! 513: {
! 514: struct proto_config *oc, *nc;
! 515: struct proto *p, *n;
! 516: struct symbol *sym;
! 517:
! 518: DBG("protos_commit:\n");
! 519: if (old)
! 520: {
! 521: WALK_LIST(oc, old->protos)
! 522: {
! 523: p = oc->proto;
! 524: sym = cf_find_symbol(new, oc->name);
! 525: if (sym && sym->class == SYM_PROTO && !new->shutdown)
! 526: {
! 527: /* Found match, let's check if we can smoothly switch to new configuration */
! 528: /* No need to check description */
! 529: nc = sym->def;
! 530: nc->proto = p;
! 531:
! 532: /* We will try to reconfigure protocol p */
! 533: if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
! 534: continue;
! 535:
! 536: /* Unsuccessful, we will restart it */
! 537: if (!p->disabled && !nc->disabled)
! 538: log(L_INFO "Restarting protocol %s", p->name);
! 539: else if (p->disabled && !nc->disabled)
! 540: log(L_INFO "Enabling protocol %s", p->name);
! 541: else if (!p->disabled && nc->disabled)
! 542: log(L_INFO "Disabling protocol %s", p->name);
! 543:
! 544: p->down_code = nc->disabled ? PDC_CF_DISABLE : PDC_CF_RESTART;
! 545: p->cf_new = nc;
! 546: }
! 547: else if (!new->shutdown)
! 548: {
! 549: log(L_INFO "Removing protocol %s", p->name);
! 550: p->down_code = PDC_CF_REMOVE;
! 551: p->cf_new = NULL;
! 552: }
! 553: else /* global shutdown */
! 554: {
! 555: p->down_code = PDC_CMD_SHUTDOWN;
! 556: p->cf_new = NULL;
! 557: }
! 558:
! 559: p->reconfiguring = 1;
! 560: config_add_obstacle(old);
! 561: proto_rethink_goal(p);
! 562: }
! 563: }
! 564:
! 565: WALK_LIST(nc, new->protos)
! 566: if (!nc->proto)
! 567: {
! 568: if (old) /* Not a first-time configuration */
! 569: log(L_INFO "Adding protocol %s", nc->name);
! 570: proto_init(nc);
! 571: }
! 572: DBG("\tdone\n");
! 573:
! 574: DBG("Protocol start\n");
! 575:
! 576: /* Start device protocol first */
! 577: if (initial_device_proto)
! 578: {
! 579: proto_rethink_goal(initial_device_proto);
! 580: initial_device_proto = NULL;
! 581: }
! 582:
! 583: /* Determine router ID for the first time - it has to be here and not in
! 584: global_commit() because it is postponed after start of device protocol */
! 585: if (!config->router_id)
! 586: {
! 587: config->router_id = if_choose_router_id(config->router_id_from, 0);
! 588: if (!config->router_id)
! 589: die("Cannot determine router ID, please configure it manually");
! 590: }
! 591:
! 592: /* Start all other protocols */
! 593: WALK_LIST_DELSAFE(p, n, initial_proto_list)
! 594: proto_rethink_goal(p);
! 595: }
! 596:
! 597: static void
! 598: proto_rethink_goal(struct proto *p)
! 599: {
! 600: struct protocol *q;
! 601: byte goal;
! 602:
! 603: if (p->reconfiguring && p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
! 604: {
! 605: struct proto_config *nc = p->cf_new;
! 606: DBG("%s has shut down for reconfiguration\n", p->name);
! 607: p->cf->proto = NULL;
! 608: config_del_obstacle(p->cf->global);
! 609: rem_node(&p->n);
! 610: rem_node(&p->glob_node);
! 611: mb_free(p);
! 612: if (!nc)
! 613: return;
! 614: p = proto_init(nc);
! 615: }
! 616:
! 617: /* Determine what state we want to reach */
! 618: if (p->disabled || p->reconfiguring)
! 619: goal = PS_DOWN;
! 620: else
! 621: goal = PS_UP;
! 622:
! 623: q = p->proto;
! 624: if (goal == PS_UP) /* Going up */
! 625: {
! 626: if (p->proto_state == PS_DOWN && p->core_state == FS_HUNGRY)
! 627: {
! 628: DBG("Kicking %s up\n", p->name);
! 629: PD(p, "Starting");
! 630: proto_init_instance(p);
! 631: proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
! 632: }
! 633: }
! 634: else /* Going down */
! 635: {
! 636: if (p->proto_state == PS_START || p->proto_state == PS_UP)
! 637: {
! 638: DBG("Kicking %s down\n", p->name);
! 639: PD(p, "Shutting down");
! 640: proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
! 641: }
! 642: }
! 643: }
! 644:
! 645:
! 646: /**
! 647: * DOC: Graceful restart recovery
! 648: *
! 649: * Graceful restart of a router is a process when the routing plane (e.g. BIRD)
! 650: * restarts but both the forwarding plane (e.g kernel routing table) and routing
! 651: * neighbors keep proper routes, and therefore uninterrupted packet forwarding
! 652: * is maintained.
! 653: *
! 654: * BIRD implements graceful restart recovery by deferring export of routes to
! 655: * protocols until routing tables are refilled with the expected content. After
! 656: * start, protocols generate routes as usual, but routes are not propagated to
! 657: * them, until protocols report that they generated all routes. After that,
! 658: * graceful restart recovery is finished and the export (and the initial feed)
! 659: * to protocols is enabled.
! 660: *
! 661: * When graceful restart recovery need is detected during initialization, then
! 662: * enabled protocols are marked with @gr_recovery flag before start. Such
! 663: * protocols then decide how to proceed with graceful restart, participation is
! 664: * voluntary. Protocols could lock the recovery by proto_graceful_restart_lock()
! 665: * (stored in @gr_lock flag), which means that they want to postpone the end of
! 666: * the recovery until they converge and then unlock it. They also could set
! 667: * @gr_wait before advancing to %PS_UP, which means that the core should defer
! 668: * route export to that protocol until the end of the recovery. This should be
! 669: * done by protocols that expect their neigbors to keep the proper routes
! 670: * (kernel table, BGP sessions with BGP graceful restart capability).
! 671: *
! 672: * The graceful restart recovery is finished when either all graceful restart
! 673: * locks are unlocked or when graceful restart wait timer fires.
! 674: *
! 675: */
! 676:
! 677: static void graceful_restart_done(struct timer *t);
! 678:
! 679: /**
! 680: * graceful_restart_recovery - request initial graceful restart recovery
! 681: *
! 682: * Called by the platform initialization code if the need for recovery
! 683: * after graceful restart is detected during boot. Have to be called
! 684: * before protos_commit().
! 685: */
! 686: void
! 687: graceful_restart_recovery(void)
! 688: {
! 689: graceful_restart_state = GRS_INIT;
! 690: }
! 691:
! 692: /**
! 693: * graceful_restart_init - initialize graceful restart
! 694: *
! 695: * When graceful restart recovery was requested, the function starts an active
! 696: * phase of the recovery and initializes graceful restart wait timer. The
! 697: * function have to be called after protos_commit().
! 698: */
! 699: void
! 700: graceful_restart_init(void)
! 701: {
! 702: if (!graceful_restart_state)
! 703: return;
! 704:
! 705: log(L_INFO "Graceful restart started");
! 706:
! 707: if (!graceful_restart_locks)
! 708: {
! 709: graceful_restart_done(NULL);
! 710: return;
! 711: }
! 712:
! 713: graceful_restart_state = GRS_ACTIVE;
! 714: gr_wait_timer = tm_new(proto_pool);
! 715: gr_wait_timer->hook = graceful_restart_done;
! 716: tm_start(gr_wait_timer, config->gr_wait);
! 717: }
! 718:
! 719: /**
! 720: * graceful_restart_done - finalize graceful restart
! 721: * @t: unused
! 722: *
! 723: * When there are no locks on graceful restart, the functions finalizes the
! 724: * graceful restart recovery. Protocols postponing route export until the end of
! 725: * the recovery are awakened and the export to them is enabled. All other
! 726: * related state is cleared. The function is also called when the graceful
! 727: * restart wait timer fires (but there are still some locks).
! 728: */
! 729: static void
! 730: graceful_restart_done(struct timer *t UNUSED)
! 731: {
! 732: struct proto *p;
! 733: node *n;
! 734:
! 735: log(L_INFO "Graceful restart done");
! 736: graceful_restart_state = GRS_DONE;
! 737:
! 738: WALK_LIST2(p, n, proto_list, glob_node)
! 739: {
! 740: if (!p->gr_recovery)
! 741: continue;
! 742:
! 743: /* Resume postponed export of routes */
! 744: if ((p->proto_state == PS_UP) && p->gr_wait)
! 745: {
! 746: proto_want_export_up(p);
! 747: proto_log_state_change(p);
! 748: }
! 749:
! 750: /* Cleanup */
! 751: p->gr_recovery = 0;
! 752: p->gr_wait = 0;
! 753: p->gr_lock = 0;
! 754: }
! 755:
! 756: graceful_restart_locks = 0;
! 757: }
! 758:
! 759: void
! 760: graceful_restart_show_status(void)
! 761: {
! 762: if (graceful_restart_state != GRS_ACTIVE)
! 763: return;
! 764:
! 765: cli_msg(-24, "Graceful restart recovery in progress");
! 766: cli_msg(-24, " Waiting for %d protocols to recover", graceful_restart_locks);
! 767: cli_msg(-24, " Wait timer is %d/%d", tm_remains(gr_wait_timer), config->gr_wait);
! 768: }
! 769:
! 770: /**
! 771: * proto_graceful_restart_lock - lock graceful restart by protocol
! 772: * @p: protocol instance
! 773: *
! 774: * This function allows a protocol to postpone the end of graceful restart
! 775: * recovery until it converges. The lock is removed when the protocol calls
! 776: * proto_graceful_restart_unlock() or when the protocol is stopped.
! 777: *
! 778: * The function have to be called during the initial phase of graceful restart
! 779: * recovery and only for protocols that are part of graceful restart (i.e. their
! 780: * @gr_recovery is set), which means it should be called from protocol start
! 781: * hooks.
! 782: */
! 783: void
! 784: proto_graceful_restart_lock(struct proto *p)
! 785: {
! 786: ASSERT(graceful_restart_state == GRS_INIT);
! 787: ASSERT(p->gr_recovery);
! 788:
! 789: if (p->gr_lock)
! 790: return;
! 791:
! 792: p->gr_lock = 1;
! 793: graceful_restart_locks++;
! 794: }
! 795:
! 796: /**
! 797: * proto_graceful_restart_unlock - unlock graceful restart by protocol
! 798: * @p: protocol instance
! 799: *
! 800: * This function unlocks a lock from proto_graceful_restart_lock(). It is also
! 801: * automatically called when the lock holding protocol went down.
! 802: */
! 803: void
! 804: proto_graceful_restart_unlock(struct proto *p)
! 805: {
! 806: if (!p->gr_lock)
! 807: return;
! 808:
! 809: p->gr_lock = 0;
! 810: graceful_restart_locks--;
! 811:
! 812: if ((graceful_restart_state == GRS_ACTIVE) && !graceful_restart_locks)
! 813: tm_start(gr_wait_timer, 0);
! 814: }
! 815:
! 816:
! 817:
! 818: /**
! 819: * protos_dump_all - dump status of all protocols
! 820: *
! 821: * This function dumps status of all existing protocol instances to the
! 822: * debug output. It involves printing of general status information
! 823: * such as protocol states, its position on the protocol lists
! 824: * and also calling of a dump() hook of the protocol to print
! 825: * the internals.
! 826: */
! 827: void
! 828: protos_dump_all(void)
! 829: {
! 830: struct proto *p;
! 831: struct announce_hook *a;
! 832:
! 833: debug("Protocols:\n");
! 834:
! 835: WALK_LIST(p, active_proto_list)
! 836: {
! 837: debug(" protocol %s state %s/%s\n", p->name,
! 838: p_states[p->proto_state], c_states[p->core_state]);
! 839: for (a = p->ahooks; a; a = a->next)
! 840: {
! 841: debug("\tTABLE %s\n", a->table->name);
! 842: if (a->in_filter)
! 843: debug("\tInput filter: %s\n", filter_name(a->in_filter));
! 844: if (a->out_filter != FILTER_REJECT)
! 845: debug("\tOutput filter: %s\n", filter_name(a->out_filter));
! 846: }
! 847: if (p->disabled)
! 848: debug("\tDISABLED\n");
! 849: else if (p->proto->dump)
! 850: p->proto->dump(p);
! 851: }
! 852: WALK_LIST(p, inactive_proto_list)
! 853: debug(" inactive %s: state %s/%s\n", p->name, p_states[p->proto_state], c_states[p->core_state]);
! 854: WALK_LIST(p, initial_proto_list)
! 855: debug(" initial %s\n", p->name);
! 856: WALK_LIST(p, flush_proto_list)
! 857: debug(" flushing %s\n", p->name);
! 858: }
! 859:
! 860: /**
! 861: * proto_build - make a single protocol available
! 862: * @p: the protocol
! 863: *
! 864: * After the platform specific initialization code uses protos_build()
! 865: * to add all the standard protocols, it should call proto_build() for
! 866: * all platform specific protocols to inform the core that they exist.
! 867: */
! 868: void
! 869: proto_build(struct protocol *p)
! 870: {
! 871: add_tail(&protocol_list, &p->n);
! 872: if (p->attr_class)
! 873: {
! 874: ASSERT(!attr_class_to_protocol[p->attr_class]);
! 875: attr_class_to_protocol[p->attr_class] = p;
! 876: }
! 877: }
! 878:
! 879: /* FIXME: convert this call to some protocol hook */
! 880: extern void bfd_init_all(void);
! 881:
! 882: /**
! 883: * protos_build - build a protocol list
! 884: *
! 885: * This function is called during BIRD startup to insert
! 886: * all standard protocols to the global protocol list. Insertion
! 887: * of platform specific protocols (such as the kernel syncer)
! 888: * is in the domain of competence of the platform dependent
! 889: * startup code.
! 890: */
! 891: void
! 892: protos_build(void)
! 893: {
! 894: init_list(&protocol_list);
! 895: init_list(&proto_list);
! 896: init_list(&active_proto_list);
! 897: init_list(&inactive_proto_list);
! 898: init_list(&initial_proto_list);
! 899: init_list(&flush_proto_list);
! 900: proto_build(&proto_device);
! 901: #ifdef CONFIG_RADV
! 902: proto_build(&proto_radv);
! 903: #endif
! 904: #ifdef CONFIG_RIP
! 905: proto_build(&proto_rip);
! 906: #endif
! 907: #ifdef CONFIG_STATIC
! 908: proto_build(&proto_static);
! 909: #endif
! 910: #ifdef CONFIG_OSPF
! 911: proto_build(&proto_ospf);
! 912: #endif
! 913: #ifdef CONFIG_PIPE
! 914: proto_build(&proto_pipe);
! 915: #endif
! 916: #ifdef CONFIG_BGP
! 917: proto_build(&proto_bgp);
! 918: #endif
! 919: #ifdef CONFIG_BFD
! 920: proto_build(&proto_bfd);
! 921: bfd_init_all();
! 922: #endif
! 923: #ifdef CONFIG_BABEL
! 924: proto_build(&proto_babel);
! 925: #endif
! 926:
! 927: proto_pool = rp_new(&root_pool, "Protocols");
! 928: proto_flush_event = ev_new(proto_pool);
! 929: proto_flush_event->hook = proto_flush_loop;
! 930: proto_shutdown_timer = tm_new(proto_pool);
! 931: proto_shutdown_timer->hook = proto_shutdown_loop;
! 932: }
! 933:
! 934: static void
! 935: proto_feed_more(void *P)
! 936: {
! 937: struct proto *p = P;
! 938:
! 939: if (p->export_state != ES_FEEDING)
! 940: return;
! 941:
! 942: DBG("Feeding protocol %s continued\n", p->name);
! 943: if (rt_feed_baby(p))
! 944: {
! 945: DBG("Feeding protocol %s finished\n", p->name);
! 946: p->export_state = ES_READY;
! 947: proto_log_state_change(p);
! 948:
! 949: if (p->feed_end)
! 950: p->feed_end(p);
! 951: }
! 952: else
! 953: {
! 954: p->attn->hook = proto_feed_more;
! 955: ev_schedule(p->attn); /* Will continue later... */
! 956: }
! 957: }
! 958:
! 959: static void
! 960: proto_feed_initial(void *P)
! 961: {
! 962: struct proto *p = P;
! 963:
! 964: if (p->export_state != ES_FEEDING)
! 965: return;
! 966:
! 967: DBG("Feeding protocol %s\n", p->name);
! 968:
! 969: if_feed_baby(p);
! 970: proto_feed_more(P);
! 971: }
! 972:
! 973: static void
! 974: proto_schedule_feed(struct proto *p, int initial)
! 975: {
! 976: DBG("%s: Scheduling meal\n", p->name);
! 977:
! 978: p->export_state = ES_FEEDING;
! 979: p->refeeding = !initial;
! 980:
! 981: p->attn->hook = initial ? proto_feed_initial : proto_feed_more;
! 982: ev_schedule(p->attn);
! 983:
! 984: if (p->feed_begin)
! 985: p->feed_begin(p, initial);
! 986: }
! 987:
! 988: /*
! 989: * Flushing loop is responsible for flushing routes and protocols
! 990: * after they went down. It runs in proto_flush_event. At the start of
! 991: * one round, protocols waiting to flush are marked in
! 992: * proto_schedule_flush_loop(). At the end of the round (when routing
! 993: * table flush is complete), marked protocols are flushed and a next
! 994: * round may start.
! 995: */
! 996:
! 997: static int flush_loop_state; /* 1 -> running */
! 998:
! 999: static void
! 1000: proto_schedule_flush_loop(void)
! 1001: {
! 1002: struct proto *p;
! 1003: struct announce_hook *h;
! 1004:
! 1005: if (flush_loop_state)
! 1006: return;
! 1007: flush_loop_state = 1;
! 1008:
! 1009: WALK_LIST(p, flush_proto_list)
! 1010: {
! 1011: p->flushing = 1;
! 1012: for (h=p->ahooks; h; h=h->next)
! 1013: rt_mark_for_prune(h->table);
! 1014: }
! 1015:
! 1016: ev_schedule(proto_flush_event);
! 1017: }
! 1018:
! 1019: static void
! 1020: proto_flush_loop(void *unused UNUSED)
! 1021: {
! 1022: struct proto *p;
! 1023:
! 1024: if (! rt_prune_loop())
! 1025: {
! 1026: /* Rtable pruning is not finished */
! 1027: ev_schedule(proto_flush_event);
! 1028: return;
! 1029: }
! 1030:
! 1031: rt_prune_sources();
! 1032:
! 1033: again:
! 1034: WALK_LIST(p, flush_proto_list)
! 1035: if (p->flushing)
! 1036: {
! 1037: /* This will flush interfaces in the same manner
! 1038: like rt_prune_all() flushes routes */
! 1039: if (p->proto == &proto_unix_iface)
! 1040: if_flush_ifaces(p);
! 1041:
! 1042: DBG("Flushing protocol %s\n", p->name);
! 1043: p->flushing = 0;
! 1044: p->core_state = FS_HUNGRY;
! 1045: proto_relink(p);
! 1046: proto_log_state_change(p);
! 1047: if (p->proto_state == PS_DOWN)
! 1048: proto_fell_down(p);
! 1049: goto again;
! 1050: }
! 1051:
! 1052: /* This round finished, perhaps there will be another one */
! 1053: flush_loop_state = 0;
! 1054: if (!EMPTY_LIST(flush_proto_list))
! 1055: proto_schedule_flush_loop();
! 1056: }
! 1057:
! 1058:
! 1059: /* Temporary hack to propagate restart to BGP */
! 1060: int proto_restart;
! 1061:
! 1062: static void
! 1063: proto_shutdown_loop(struct timer *t UNUSED)
! 1064: {
! 1065: struct proto *p, *p_next;
! 1066:
! 1067: WALK_LIST_DELSAFE(p, p_next, active_proto_list)
! 1068: if (p->down_sched)
! 1069: {
! 1070: proto_restart = (p->down_sched == PDS_RESTART);
! 1071:
! 1072: p->disabled = 1;
! 1073: proto_rethink_goal(p);
! 1074: if (proto_restart)
! 1075: {
! 1076: p->disabled = 0;
! 1077: proto_rethink_goal(p);
! 1078: }
! 1079: }
! 1080: }
! 1081:
! 1082: static inline void
! 1083: proto_schedule_down(struct proto *p, byte restart, byte code)
! 1084: {
! 1085: /* Does not work for other states (even PS_START) */
! 1086: ASSERT(p->proto_state == PS_UP);
! 1087:
! 1088: /* Scheduled restart may change to shutdown, but not otherwise */
! 1089: if (p->down_sched == PDS_DISABLE)
! 1090: return;
! 1091:
! 1092: p->down_sched = restart ? PDS_RESTART : PDS_DISABLE;
! 1093: p->down_code = code;
! 1094: tm_start_max(proto_shutdown_timer, restart ? 2 : 0);
! 1095: }
! 1096:
! 1097:
! 1098: /**
! 1099: * proto_request_feeding - request feeding routes to the protocol
! 1100: * @p: given protocol
! 1101: *
! 1102: * Sometimes it is needed to send again all routes to the
! 1103: * protocol. This is called feeding and can be requested by this
! 1104: * function. This would cause protocol export state transition
! 1105: * to ES_FEEDING (during feeding) and when completed, it will
! 1106: * switch back to ES_READY. This function can be called even
! 1107: * when feeding is already running, in that case it is restarted.
! 1108: */
! 1109: void
! 1110: proto_request_feeding(struct proto *p)
! 1111: {
! 1112: ASSERT(p->proto_state == PS_UP);
! 1113:
! 1114: /* Do nothing if we are still waiting for feeding */
! 1115: if (p->export_state == ES_DOWN)
! 1116: return;
! 1117:
! 1118: /* If we are already feeding, we want to restart it */
! 1119: if (p->export_state == ES_FEEDING)
! 1120: {
! 1121: /* Unless feeding is in initial state */
! 1122: if (p->attn->hook == proto_feed_initial)
! 1123: return;
! 1124:
! 1125: rt_feed_baby_abort(p);
! 1126: }
! 1127:
! 1128: /* FIXME: This should be changed for better support of multitable protos */
! 1129: struct announce_hook *ah;
! 1130: for (ah = p->ahooks; ah; ah = ah->next)
! 1131: proto_reset_limit(ah->out_limit);
! 1132:
! 1133: /* Hack: reset exp_routes during refeed, and do not decrease it later */
! 1134: p->stats.exp_routes = 0;
! 1135:
! 1136: proto_schedule_feed(p, 0);
! 1137: proto_log_state_change(p);
! 1138: }
! 1139:
! 1140: static const char *
! 1141: proto_limit_name(struct proto_limit *l)
! 1142: {
! 1143: const char *actions[] = {
! 1144: [PLA_WARN] = "warn",
! 1145: [PLA_BLOCK] = "block",
! 1146: [PLA_RESTART] = "restart",
! 1147: [PLA_DISABLE] = "disable",
! 1148: };
! 1149:
! 1150: return actions[l->action];
! 1151: }
! 1152:
! 1153: /**
! 1154: * proto_notify_limit: notify about limit hit and take appropriate action
! 1155: * @ah: announce hook
! 1156: * @l: limit being hit
! 1157: * @dir: limit direction (PLD_*)
! 1158: * @rt_count: the number of routes
! 1159: *
! 1160: * The function is called by the route processing core when limit @l
! 1161: * is breached. It activates the limit and tooks appropriate action
! 1162: * according to @l->action.
! 1163: */
! 1164: void
! 1165: proto_notify_limit(struct announce_hook *ah, struct proto_limit *l, int dir, u32 rt_count)
! 1166: {
! 1167: const char *dir_name[PLD_MAX] = { "receive", "import" , "export" };
! 1168: const byte dir_down[PLD_MAX] = { PDC_RX_LIMIT_HIT, PDC_IN_LIMIT_HIT, PDC_OUT_LIMIT_HIT };
! 1169: struct proto *p = ah->proto;
! 1170:
! 1171: if (l->state == PLS_BLOCKED)
! 1172: return;
! 1173:
! 1174: /* For warning action, we want the log message every time we hit the limit */
! 1175: if (!l->state || ((l->action == PLA_WARN) && (rt_count == l->limit)))
! 1176: log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
! 1177: p->name, dir_name[dir], l->limit, proto_limit_name(l));
! 1178:
! 1179: switch (l->action)
! 1180: {
! 1181: case PLA_WARN:
! 1182: l->state = PLS_ACTIVE;
! 1183: break;
! 1184:
! 1185: case PLA_BLOCK:
! 1186: l->state = PLS_BLOCKED;
! 1187: break;
! 1188:
! 1189: case PLA_RESTART:
! 1190: case PLA_DISABLE:
! 1191: l->state = PLS_BLOCKED;
! 1192: if (p->proto_state == PS_UP)
! 1193: proto_schedule_down(p, l->action == PLA_RESTART, dir_down[dir]);
! 1194: break;
! 1195: }
! 1196: }
! 1197:
! 1198: void
! 1199: proto_verify_limits(struct announce_hook *ah)
! 1200: {
! 1201: struct proto_limit *l;
! 1202: struct proto_stats *stats = ah->stats;
! 1203: u32 all_routes = stats->imp_routes + stats->filt_routes;
! 1204:
! 1205: l = ah->rx_limit;
! 1206: if (l && (all_routes > l->limit))
! 1207: proto_notify_limit(ah, l, PLD_RX, all_routes);
! 1208:
! 1209: l = ah->in_limit;
! 1210: if (l && (stats->imp_routes > l->limit))
! 1211: proto_notify_limit(ah, l, PLD_IN, stats->imp_routes);
! 1212:
! 1213: l = ah->out_limit;
! 1214: if (l && (stats->exp_routes > l->limit))
! 1215: proto_notify_limit(ah, l, PLD_OUT, stats->exp_routes);
! 1216: }
! 1217:
! 1218:
! 1219: static void
! 1220: proto_want_core_up(struct proto *p)
! 1221: {
! 1222: ASSERT(p->core_state == FS_HUNGRY);
! 1223:
! 1224: if (!p->proto->multitable)
! 1225: {
! 1226: p->main_source = rt_get_source(p, 0);
! 1227: rt_lock_source(p->main_source);
! 1228:
! 1229: /* Connect protocol to routing table */
! 1230: p->main_ahook = proto_add_announce_hook(p, p->table, &p->stats);
! 1231: p->main_ahook->in_filter = p->cf->in_filter;
! 1232: p->main_ahook->out_filter = p->cf->out_filter;
! 1233: p->main_ahook->rx_limit = p->cf->rx_limit;
! 1234: p->main_ahook->in_limit = p->cf->in_limit;
! 1235: p->main_ahook->out_limit = p->cf->out_limit;
! 1236: p->main_ahook->in_keep_filtered = p->cf->in_keep_filtered;
! 1237:
! 1238: proto_reset_limit(p->main_ahook->rx_limit);
! 1239: proto_reset_limit(p->main_ahook->in_limit);
! 1240: proto_reset_limit(p->main_ahook->out_limit);
! 1241: }
! 1242:
! 1243: p->core_state = FS_HAPPY;
! 1244: proto_relink(p);
! 1245: }
! 1246:
! 1247: static void
! 1248: proto_want_export_up(struct proto *p)
! 1249: {
! 1250: ASSERT(p->core_state == FS_HAPPY);
! 1251: ASSERT(p->export_state == ES_DOWN);
! 1252:
! 1253: proto_link_ahooks(p);
! 1254: proto_schedule_feed(p, 1); /* Sets ES_FEEDING */
! 1255: }
! 1256:
! 1257: static void
! 1258: proto_want_export_down(struct proto *p)
! 1259: {
! 1260: ASSERT(p->export_state != ES_DOWN);
! 1261:
! 1262: /* Need to abort feeding */
! 1263: if (p->export_state == ES_FEEDING)
! 1264: rt_feed_baby_abort(p);
! 1265:
! 1266: p->export_state = ES_DOWN;
! 1267: p->stats.exp_routes = 0;
! 1268: proto_unlink_ahooks(p);
! 1269: }
! 1270:
! 1271: static void
! 1272: proto_want_core_down(struct proto *p)
! 1273: {
! 1274: ASSERT(p->core_state == FS_HAPPY);
! 1275: ASSERT(p->export_state == ES_DOWN);
! 1276:
! 1277: p->core_state = FS_FLUSHING;
! 1278: proto_relink(p);
! 1279: proto_schedule_flush_loop();
! 1280:
! 1281: if (!p->proto->multitable)
! 1282: {
! 1283: rt_unlock_source(p->main_source);
! 1284: p->main_source = NULL;
! 1285: }
! 1286: }
! 1287:
! 1288: static void
! 1289: proto_falling_down(struct proto *p)
! 1290: {
! 1291: p->gr_recovery = 0;
! 1292: p->gr_wait = 0;
! 1293: if (p->gr_lock)
! 1294: proto_graceful_restart_unlock(p);
! 1295: }
! 1296:
! 1297: static void
! 1298: proto_fell_down(struct proto *p)
! 1299: {
! 1300: DBG("Protocol %s down\n", p->name);
! 1301:
! 1302: u32 all_routes = p->stats.imp_routes + p->stats.filt_routes;
! 1303: if (all_routes != 0)
! 1304: log(L_ERR "Protocol %s is down but still has %d routes", p->name, all_routes);
! 1305:
! 1306: bzero(&p->stats, sizeof(struct proto_stats));
! 1307: proto_free_ahooks(p);
! 1308:
! 1309: if (! p->proto->multitable)
! 1310: rt_unlock_table(p->table);
! 1311:
! 1312: if (p->proto->cleanup)
! 1313: p->proto->cleanup(p);
! 1314:
! 1315: proto_rethink_goal(p);
! 1316: }
! 1317:
! 1318:
! 1319: /**
! 1320: * proto_notify_state - notify core about protocol state change
! 1321: * @p: protocol the state of which has changed
! 1322: * @ps: the new status
! 1323: *
! 1324: * Whenever a state of a protocol changes due to some event internal
! 1325: * to the protocol (i.e., not inside a start() or shutdown() hook),
! 1326: * it should immediately notify the core about the change by calling
! 1327: * proto_notify_state() which will write the new state to the &proto
! 1328: * structure and take all the actions necessary to adapt to the new
! 1329: * state. State change to PS_DOWN immediately frees resources of protocol
! 1330: * and might execute start callback of protocol; therefore,
! 1331: * it should be used at tail positions of protocol callbacks.
! 1332: */
! 1333: void
! 1334: proto_notify_state(struct proto *p, unsigned ps)
! 1335: {
! 1336: unsigned ops = p->proto_state;
! 1337: unsigned cs = p->core_state;
! 1338: unsigned es = p->export_state;
! 1339:
! 1340: DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
! 1341: if (ops == ps)
! 1342: return;
! 1343:
! 1344: p->proto_state = ps;
! 1345: p->last_state_change = now;
! 1346:
! 1347: switch (ps)
! 1348: {
! 1349: case PS_START:
! 1350: ASSERT(ops == PS_DOWN || ops == PS_UP);
! 1351: ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);
! 1352:
! 1353: if (es != ES_DOWN)
! 1354: proto_want_export_down(p);
! 1355: break;
! 1356:
! 1357: case PS_UP:
! 1358: ASSERT(ops == PS_DOWN || ops == PS_START);
! 1359: ASSERT(cs == FS_HUNGRY || cs == FS_HAPPY);
! 1360: ASSERT(es == ES_DOWN);
! 1361:
! 1362: if (cs == FS_HUNGRY)
! 1363: proto_want_core_up(p);
! 1364: if (!p->gr_wait)
! 1365: proto_want_export_up(p);
! 1366: break;
! 1367:
! 1368: case PS_STOP:
! 1369: ASSERT(ops == PS_START || ops == PS_UP);
! 1370:
! 1371: p->down_sched = 0;
! 1372:
! 1373: if (es != ES_DOWN)
! 1374: proto_want_export_down(p);
! 1375: if (cs == FS_HAPPY)
! 1376: proto_want_core_down(p);
! 1377: proto_falling_down(p);
! 1378: break;
! 1379:
! 1380: case PS_DOWN:
! 1381: p->down_code = 0;
! 1382: p->down_sched = 0;
! 1383:
! 1384: if (es != ES_DOWN)
! 1385: proto_want_export_down(p);
! 1386: if (cs == FS_HAPPY)
! 1387: proto_want_core_down(p);
! 1388: if (ops != PS_STOP)
! 1389: proto_falling_down(p);
! 1390:
! 1391: neigh_prune(); // FIXME convert neighbors to resource?
! 1392: rfree(p->pool);
! 1393: p->pool = NULL;
! 1394:
! 1395: if (cs == FS_HUNGRY) /* Shutdown finished */
! 1396: {
! 1397: proto_log_state_change(p);
! 1398: proto_fell_down(p);
! 1399: return; /* The protocol might have ceased to exist */
! 1400: }
! 1401: break;
! 1402:
! 1403: default:
! 1404: bug("%s: Invalid state %d", p->name, ps);
! 1405: }
! 1406:
! 1407: proto_log_state_change(p);
! 1408: }
! 1409:
! 1410: /*
! 1411: * CLI Commands
! 1412: */
! 1413:
! 1414: static char *
! 1415: proto_state_name(struct proto *p)
! 1416: {
! 1417: #define P(x,y) ((x << 4) | y)
! 1418: switch (P(p->proto_state, p->core_state))
! 1419: {
! 1420: case P(PS_DOWN, FS_HUNGRY): return "down";
! 1421: case P(PS_START, FS_HUNGRY):
! 1422: case P(PS_START, FS_HAPPY): return "start";
! 1423: case P(PS_UP, FS_HAPPY):
! 1424: switch (p->export_state)
! 1425: {
! 1426: case ES_DOWN: return "wait";
! 1427: case ES_FEEDING: return "feed";
! 1428: case ES_READY: return "up";
! 1429: default: return "???";
! 1430: }
! 1431: case P(PS_STOP, FS_HUNGRY):
! 1432: case P(PS_STOP, FS_FLUSHING): return "stop";
! 1433: case P(PS_DOWN, FS_FLUSHING): return "flush";
! 1434: default: return "???";
! 1435: }
! 1436: #undef P
! 1437: }
! 1438:
! 1439: static void
! 1440: proto_show_stats(struct proto_stats *s, int in_keep_filtered)
! 1441: {
! 1442: if (in_keep_filtered)
! 1443: cli_msg(-1006, " Routes: %u imported, %u filtered, %u exported, %u preferred",
! 1444: s->imp_routes, s->filt_routes, s->exp_routes, s->pref_routes);
! 1445: else
! 1446: cli_msg(-1006, " Routes: %u imported, %u exported, %u preferred",
! 1447: s->imp_routes, s->exp_routes, s->pref_routes);
! 1448:
! 1449: cli_msg(-1006, " Route change stats: received rejected filtered ignored accepted");
! 1450: cli_msg(-1006, " Import updates: %10u %10u %10u %10u %10u",
! 1451: s->imp_updates_received, s->imp_updates_invalid,
! 1452: s->imp_updates_filtered, s->imp_updates_ignored,
! 1453: s->imp_updates_accepted);
! 1454: cli_msg(-1006, " Import withdraws: %10u %10u --- %10u %10u",
! 1455: s->imp_withdraws_received, s->imp_withdraws_invalid,
! 1456: s->imp_withdraws_ignored, s->imp_withdraws_accepted);
! 1457: cli_msg(-1006, " Export updates: %10u %10u %10u --- %10u",
! 1458: s->exp_updates_received, s->exp_updates_rejected,
! 1459: s->exp_updates_filtered, s->exp_updates_accepted);
! 1460: cli_msg(-1006, " Export withdraws: %10u --- --- --- %10u",
! 1461: s->exp_withdraws_received, s->exp_withdraws_accepted);
! 1462: }
! 1463:
! 1464: void
! 1465: proto_show_limit(struct proto_limit *l, const char *dsc)
! 1466: {
! 1467: if (!l)
! 1468: return;
! 1469:
! 1470: cli_msg(-1006, " %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
! 1471: cli_msg(-1006, " Action: %s", proto_limit_name(l));
! 1472: }
! 1473:
! 1474: void
! 1475: proto_show_basic_info(struct proto *p)
! 1476: {
! 1477: // cli_msg(-1006, " Table: %s", p->table->name);
! 1478: cli_msg(-1006, " Preference: %d", p->preference);
! 1479: cli_msg(-1006, " Input filter: %s", filter_name(p->cf->in_filter));
! 1480: cli_msg(-1006, " Output filter: %s", filter_name(p->cf->out_filter));
! 1481:
! 1482: if (graceful_restart_state == GRS_ACTIVE)
! 1483: cli_msg(-1006, " GR recovery: %s%s",
! 1484: p->gr_lock ? " pending" : "",
! 1485: p->gr_wait ? " waiting" : "");
! 1486:
! 1487: proto_show_limit(p->cf->rx_limit, "Receive limit:");
! 1488: proto_show_limit(p->cf->in_limit, "Import limit:");
! 1489: proto_show_limit(p->cf->out_limit, "Export limit:");
! 1490:
! 1491: if (p->proto_state != PS_DOWN)
! 1492: proto_show_stats(&p->stats, p->cf->in_keep_filtered);
! 1493: }
! 1494:
! 1495: void
! 1496: proto_cmd_show(struct proto *p, uint verbose, int cnt)
! 1497: {
! 1498: byte buf[256], tbuf[TM_DATETIME_BUFFER_SIZE];
! 1499:
! 1500: /* First protocol - show header */
! 1501: if (!cnt)
! 1502: cli_msg(-2002, "name proto table state since info");
! 1503:
! 1504: buf[0] = 0;
! 1505: if (p->proto->get_status)
! 1506: p->proto->get_status(p, buf);
! 1507: tm_format_datetime(tbuf, &config->tf_proto, p->last_state_change);
! 1508: cli_msg(-1002, "%-8s %-8s %-8s %-5s %-10s %s",
! 1509: p->name,
! 1510: p->proto->name,
! 1511: p->table->name,
! 1512: proto_state_name(p),
! 1513: tbuf,
! 1514: buf);
! 1515: if (verbose)
! 1516: {
! 1517: if (p->cf->dsc)
! 1518: cli_msg(-1006, " Description: %s", p->cf->dsc);
! 1519: if (p->cf->router_id)
! 1520: cli_msg(-1006, " Router ID: %R", p->cf->router_id);
! 1521:
! 1522: if (p->proto->show_proto_info)
! 1523: p->proto->show_proto_info(p);
! 1524: else
! 1525: proto_show_basic_info(p);
! 1526:
! 1527: cli_msg(-1006, "");
! 1528: }
! 1529: }
! 1530:
! 1531: void
! 1532: proto_cmd_disable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
! 1533: {
! 1534: if (p->disabled)
! 1535: {
! 1536: cli_msg(-8, "%s: already disabled", p->name);
! 1537: return;
! 1538: }
! 1539:
! 1540: log(L_INFO "Disabling protocol %s", p->name);
! 1541: p->disabled = 1;
! 1542: p->down_code = PDC_CMD_DISABLE;
! 1543: proto_rethink_goal(p);
! 1544: cli_msg(-9, "%s: disabled", p->name);
! 1545: }
! 1546:
! 1547: void
! 1548: proto_cmd_enable(struct proto *p, uint arg UNUSED, int cnt UNUSED)
! 1549: {
! 1550: if (!p->disabled)
! 1551: {
! 1552: cli_msg(-10, "%s: already enabled", p->name);
! 1553: return;
! 1554: }
! 1555:
! 1556: log(L_INFO "Enabling protocol %s", p->name);
! 1557: p->disabled = 0;
! 1558: proto_rethink_goal(p);
! 1559: cli_msg(-11, "%s: enabled", p->name);
! 1560: }
! 1561:
! 1562: void
! 1563: proto_cmd_restart(struct proto *p, uint arg UNUSED, int cnt UNUSED)
! 1564: {
! 1565: if (p->disabled)
! 1566: {
! 1567: cli_msg(-8, "%s: already disabled", p->name);
! 1568: return;
! 1569: }
! 1570:
! 1571: log(L_INFO "Restarting protocol %s", p->name);
! 1572: p->disabled = 1;
! 1573: p->down_code = PDC_CMD_RESTART;
! 1574: proto_rethink_goal(p);
! 1575: p->disabled = 0;
! 1576: proto_rethink_goal(p);
! 1577: cli_msg(-12, "%s: restarted", p->name);
! 1578: }
! 1579:
! 1580: void
! 1581: proto_cmd_reload(struct proto *p, uint dir, int cnt UNUSED)
! 1582: {
! 1583: if (p->disabled)
! 1584: {
! 1585: cli_msg(-8, "%s: already disabled", p->name);
! 1586: return;
! 1587: }
! 1588:
! 1589: /* If the protocol in not UP, it has no routes */
! 1590: if (p->proto_state != PS_UP)
! 1591: return;
! 1592:
! 1593: log(L_INFO "Reloading protocol %s", p->name);
! 1594:
! 1595: /* re-importing routes */
! 1596: if (dir != CMD_RELOAD_OUT)
! 1597: {
! 1598: if (! (p->reload_routes && p->reload_routes(p)))
! 1599: {
! 1600: cli_msg(-8006, "%s: reload failed", p->name);
! 1601: return;
! 1602: }
! 1603:
! 1604: /*
! 1605: * Should be done before reload_routes() hook?
! 1606: * Perhaps, but these hooks work asynchronously.
! 1607: */
! 1608: if (!p->proto->multitable)
! 1609: {
! 1610: proto_reset_limit(p->main_ahook->rx_limit);
! 1611: proto_reset_limit(p->main_ahook->in_limit);
! 1612: }
! 1613: }
! 1614:
! 1615: /* re-exporting routes */
! 1616: if (dir != CMD_RELOAD_IN)
! 1617: proto_request_feeding(p);
! 1618:
! 1619: cli_msg(-15, "%s: reloading", p->name);
! 1620: }
! 1621:
! 1622: void
! 1623: proto_cmd_debug(struct proto *p, uint mask, int cnt UNUSED)
! 1624: {
! 1625: p->debug = mask;
! 1626: }
! 1627:
! 1628: void
! 1629: proto_cmd_mrtdump(struct proto *p, uint mask, int cnt UNUSED)
! 1630: {
! 1631: p->mrtdump = mask;
! 1632: }
! 1633:
! 1634: static void
! 1635: proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, uint, int), uint arg)
! 1636: {
! 1637: if (s->class != SYM_PROTO)
! 1638: {
! 1639: cli_msg(9002, "%s is not a protocol", s->name);
! 1640: return;
! 1641: }
! 1642:
! 1643: cmd(((struct proto_config *)s->def)->proto, arg, 0);
! 1644: cli_msg(0, "");
! 1645: }
! 1646:
! 1647: static void
! 1648: proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, uint, int), uint arg)
! 1649: {
! 1650: int cnt = 0;
! 1651:
! 1652: node *nn;
! 1653: WALK_LIST(nn, proto_list)
! 1654: {
! 1655: struct proto *p = SKIP_BACK(struct proto, glob_node, nn);
! 1656:
! 1657: if (!patt || patmatch(patt, p->name))
! 1658: cmd(p, arg, cnt++);
! 1659: }
! 1660:
! 1661: if (!cnt)
! 1662: cli_msg(8003, "No protocols match");
! 1663: else
! 1664: cli_msg(0, "");
! 1665: }
! 1666:
! 1667: void
! 1668: proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, uint, int),
! 1669: int restricted, uint arg)
! 1670: {
! 1671: if (restricted && cli_access_restricted())
! 1672: return;
! 1673:
! 1674: if (ps.patt)
! 1675: proto_apply_cmd_patt(ps.ptr, cmd, arg);
! 1676: else
! 1677: proto_apply_cmd_symbol(ps.ptr, cmd, arg);
! 1678: }
! 1679:
! 1680: struct proto *
! 1681: proto_get_named(struct symbol *sym, struct protocol *pr)
! 1682: {
! 1683: struct proto *p, *q;
! 1684:
! 1685: if (sym)
! 1686: {
! 1687: if (sym->class != SYM_PROTO)
! 1688: cf_error("%s: Not a protocol", sym->name);
! 1689: p = ((struct proto_config *)sym->def)->proto;
! 1690: if (!p || p->proto != pr)
! 1691: cf_error("%s: Not a %s protocol", sym->name, pr->name);
! 1692: }
! 1693: else
! 1694: {
! 1695: p = NULL;
! 1696: WALK_LIST(q, active_proto_list)
! 1697: if (q->proto == pr)
! 1698: {
! 1699: if (p)
! 1700: cf_error("There are multiple %s protocols running", pr->name);
! 1701: p = q;
! 1702: }
! 1703: if (!p)
! 1704: cf_error("There is no %s protocol running", pr->name);
! 1705: }
! 1706: return p;
! 1707: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to proto.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