Annotation of embedaddon/bird2/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/timer.h"
! 17: #include "lib/string.h"
! 18: #include "conf/conf.h"
! 19: #include "nest/route.h"
! 20: #include "nest/iface.h"
! 21: #include "nest/cli.h"
! 22: #include "filter/filter.h"
! 23:
! 24: pool *proto_pool;
! 25: list proto_list;
! 26:
! 27: static list protocol_list;
! 28: struct protocol *class_to_protocol[PROTOCOL__MAX];
! 29:
! 30: #define PD(pr, msg, args...) do { if (pr->debug & D_STATES) { log(L_TRACE "%s: " msg, pr->name , ## args); } } while(0)
! 31:
! 32: static timer *proto_shutdown_timer;
! 33: static timer *gr_wait_timer;
! 34:
! 35: #define GRS_NONE 0
! 36: #define GRS_INIT 1
! 37: #define GRS_ACTIVE 2
! 38: #define GRS_DONE 3
! 39:
! 40: static int graceful_restart_state;
! 41: static u32 graceful_restart_locks;
! 42:
! 43: static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
! 44: static char *c_states[] = { "DOWN", "START", "UP", "FLUSHING" };
! 45:
! 46: extern struct protocol proto_unix_iface;
! 47:
! 48: static void proto_shutdown_loop(timer *);
! 49: static void proto_rethink_goal(struct proto *p);
! 50: static char *proto_state_name(struct proto *p);
! 51: static void channel_verify_limits(struct channel *c);
! 52: static inline void channel_reset_limit(struct channel_limit *l);
! 53:
! 54:
! 55: static inline int proto_is_done(struct proto *p)
! 56: { return (p->proto_state == PS_DOWN) && (p->active_channels == 0); }
! 57:
! 58: static inline int channel_is_active(struct channel *c)
! 59: { return (c->channel_state == CS_START) || (c->channel_state == CS_UP); }
! 60:
! 61: static void
! 62: proto_log_state_change(struct proto *p)
! 63: {
! 64: if (p->debug & D_STATES)
! 65: {
! 66: char *name = proto_state_name(p);
! 67: if (name != p->last_state_name_announced)
! 68: {
! 69: p->last_state_name_announced = name;
! 70: PD(p, "State changed to %s", proto_state_name(p));
! 71: }
! 72: }
! 73: else
! 74: p->last_state_name_announced = NULL;
! 75: }
! 76:
! 77:
! 78: struct channel_config *
! 79: proto_cf_find_channel(struct proto_config *pc, uint net_type)
! 80: {
! 81: struct channel_config *cc;
! 82:
! 83: WALK_LIST(cc, pc->channels)
! 84: if (cc->net_type == net_type)
! 85: return cc;
! 86:
! 87: return NULL;
! 88: }
! 89:
! 90: /**
! 91: * proto_find_channel_by_table - find channel connected to a routing table
! 92: * @p: protocol instance
! 93: * @t: routing table
! 94: *
! 95: * Returns pointer to channel or NULL
! 96: */
! 97: struct channel *
! 98: proto_find_channel_by_table(struct proto *p, struct rtable *t)
! 99: {
! 100: struct channel *c;
! 101:
! 102: WALK_LIST(c, p->channels)
! 103: if (c->table == t)
! 104: return c;
! 105:
! 106: return NULL;
! 107: }
! 108:
! 109: /**
! 110: * proto_find_channel_by_name - find channel by its name
! 111: * @p: protocol instance
! 112: * @n: channel name
! 113: *
! 114: * Returns pointer to channel or NULL
! 115: */
! 116: struct channel *
! 117: proto_find_channel_by_name(struct proto *p, const char *n)
! 118: {
! 119: struct channel *c;
! 120:
! 121: WALK_LIST(c, p->channels)
! 122: if (!strcmp(c->name, n))
! 123: return c;
! 124:
! 125: return NULL;
! 126: }
! 127:
! 128: /**
! 129: * proto_add_channel - connect protocol to a routing table
! 130: * @p: protocol instance
! 131: * @cf: channel configuration
! 132: *
! 133: * This function creates a channel between the protocol instance @p and the
! 134: * routing table specified in the configuration @cf, making the protocol hear
! 135: * all changes in the table and allowing the protocol to update routes in the
! 136: * table.
! 137: *
! 138: * The channel is linked in the protocol channel list and when active also in
! 139: * the table channel list. Channels are allocated from the global resource pool
! 140: * (@proto_pool) and they are automatically freed when the protocol is removed.
! 141: */
! 142:
! 143: struct channel *
! 144: proto_add_channel(struct proto *p, struct channel_config *cf)
! 145: {
! 146: struct channel *c = mb_allocz(proto_pool, cf->channel->channel_size);
! 147:
! 148: c->name = cf->name;
! 149: c->channel = cf->channel;
! 150: c->proto = p;
! 151: c->table = cf->table->table;
! 152:
! 153: c->in_filter = cf->in_filter;
! 154: c->out_filter = cf->out_filter;
! 155: c->rx_limit = cf->rx_limit;
! 156: c->in_limit = cf->in_limit;
! 157: c->out_limit = cf->out_limit;
! 158:
! 159: c->net_type = cf->net_type;
! 160: c->ra_mode = cf->ra_mode;
! 161: c->preference = cf->preference;
! 162: c->merge_limit = cf->merge_limit;
! 163: c->in_keep_filtered = cf->in_keep_filtered;
! 164:
! 165: c->channel_state = CS_DOWN;
! 166: c->export_state = ES_DOWN;
! 167: c->last_state_change = current_time();
! 168: c->last_tx_filter_change = current_time();
! 169: c->reloadable = 1;
! 170:
! 171: CALL(c->channel->init, c, cf);
! 172:
! 173: add_tail(&p->channels, &c->n);
! 174:
! 175: PD(p, "Channel %s connected to table %s", c->name, c->table->name);
! 176:
! 177: return c;
! 178: }
! 179:
! 180: void
! 181: proto_remove_channel(struct proto *p, struct channel *c)
! 182: {
! 183: ASSERT(c->channel_state == CS_DOWN);
! 184:
! 185: PD(p, "Channel %s removed", c->name);
! 186:
! 187: rem_node(&c->n);
! 188: mb_free(c);
! 189: }
! 190:
! 191:
! 192: static void
! 193: proto_start_channels(struct proto *p)
! 194: {
! 195: struct channel *c;
! 196: WALK_LIST(c, p->channels)
! 197: if (!c->disabled)
! 198: channel_set_state(c, CS_UP);
! 199: }
! 200:
! 201: static void
! 202: proto_pause_channels(struct proto *p)
! 203: {
! 204: struct channel *c;
! 205: WALK_LIST(c, p->channels)
! 206: if (!c->disabled && channel_is_active(c))
! 207: channel_set_state(c, CS_START);
! 208: }
! 209:
! 210: static void
! 211: proto_stop_channels(struct proto *p)
! 212: {
! 213: struct channel *c;
! 214: WALK_LIST(c, p->channels)
! 215: if (!c->disabled && channel_is_active(c))
! 216: channel_set_state(c, CS_FLUSHING);
! 217: }
! 218:
! 219: static void
! 220: proto_remove_channels(struct proto *p)
! 221: {
! 222: struct channel *c;
! 223: WALK_LIST_FIRST(c, p->channels)
! 224: proto_remove_channel(p, c);
! 225: }
! 226:
! 227: static void
! 228: channel_schedule_feed(struct channel *c, int initial)
! 229: {
! 230: // DBG("%s: Scheduling meal\n", p->name);
! 231: ASSERT(c->channel_state == CS_UP);
! 232:
! 233: c->export_state = ES_FEEDING;
! 234: c->refeeding = !initial;
! 235:
! 236: ev_schedule(c->feed_event);
! 237: }
! 238:
! 239: static void
! 240: channel_feed_loop(void *ptr)
! 241: {
! 242: struct channel *c = ptr;
! 243:
! 244: if (c->export_state != ES_FEEDING)
! 245: return;
! 246:
! 247: if (!c->feed_active)
! 248: if (c->proto->feed_begin)
! 249: c->proto->feed_begin(c, !c->refeeding);
! 250:
! 251: // DBG("Feeding protocol %s continued\n", p->name);
! 252: if (!rt_feed_channel(c))
! 253: {
! 254: ev_schedule(c->feed_event);
! 255: return;
! 256: }
! 257:
! 258: // DBG("Feeding protocol %s finished\n", p->name);
! 259: c->export_state = ES_READY;
! 260: // proto_log_state_change(p);
! 261:
! 262: if (c->proto->feed_end)
! 263: c->proto->feed_end(c);
! 264: }
! 265:
! 266:
! 267: static void
! 268: channel_start_export(struct channel *c)
! 269: {
! 270: ASSERT(c->channel_state == CS_UP);
! 271: ASSERT(c->export_state == ES_DOWN);
! 272:
! 273: channel_schedule_feed(c, 1); /* Sets ES_FEEDING */
! 274: }
! 275:
! 276: static void
! 277: channel_stop_export(struct channel *c)
! 278: {
! 279: /* Need to abort feeding */
! 280: if (c->export_state == ES_FEEDING)
! 281: rt_feed_channel_abort(c);
! 282:
! 283: c->export_state = ES_DOWN;
! 284: c->stats.exp_routes = 0;
! 285: }
! 286:
! 287:
! 288: /* Called by protocol for reload from in_table */
! 289: void
! 290: channel_schedule_reload(struct channel *c)
! 291: {
! 292: ASSERT(c->channel_state == CS_UP);
! 293:
! 294: rt_reload_channel_abort(c);
! 295: ev_schedule(c->reload_event);
! 296: }
! 297:
! 298: static void
! 299: channel_reload_loop(void *ptr)
! 300: {
! 301: struct channel *c = ptr;
! 302:
! 303: if (!rt_reload_channel(c))
! 304: {
! 305: ev_schedule(c->reload_event);
! 306: return;
! 307: }
! 308: }
! 309:
! 310: static void
! 311: channel_reset_import(struct channel *c)
! 312: {
! 313: /* Need to abort feeding */
! 314: ev_postpone(c->reload_event);
! 315: rt_reload_channel_abort(c);
! 316:
! 317: rt_prune_sync(c->in_table, 1);
! 318: }
! 319:
! 320: static void
! 321: channel_reset_export(struct channel *c)
! 322: {
! 323: /* Just free the routes */
! 324: rt_prune_sync(c->out_table, 1);
! 325: }
! 326:
! 327: /* Called by protocol to activate in_table */
! 328: void
! 329: channel_setup_in_table(struct channel *c)
! 330: {
! 331: struct rtable_config *cf = mb_allocz(c->proto->pool, sizeof(struct rtable_config));
! 332: cf->name = "import";
! 333: cf->addr_type = c->net_type;
! 334:
! 335: c->in_table = mb_allocz(c->proto->pool, sizeof(struct rtable));
! 336: rt_setup(c->proto->pool, c->in_table, cf);
! 337:
! 338: c->reload_event = ev_new_init(c->proto->pool, channel_reload_loop, c);
! 339: }
! 340:
! 341: /* Called by protocol to activate out_table */
! 342: void
! 343: channel_setup_out_table(struct channel *c)
! 344: {
! 345: struct rtable_config *cf = mb_allocz(c->proto->pool, sizeof(struct rtable_config));
! 346: cf->name = "export";
! 347: cf->addr_type = c->net_type;
! 348:
! 349: c->out_table = mb_allocz(c->proto->pool, sizeof(struct rtable));
! 350: rt_setup(c->proto->pool, c->out_table, cf);
! 351: }
! 352:
! 353:
! 354: static void
! 355: channel_do_start(struct channel *c)
! 356: {
! 357: rt_lock_table(c->table);
! 358: add_tail(&c->table->channels, &c->table_node);
! 359: c->proto->active_channels++;
! 360:
! 361: c->feed_event = ev_new_init(c->proto->pool, channel_feed_loop, c);
! 362:
! 363: channel_reset_limit(&c->rx_limit);
! 364: channel_reset_limit(&c->in_limit);
! 365: channel_reset_limit(&c->out_limit);
! 366:
! 367: CALL(c->channel->start, c);
! 368: }
! 369:
! 370: static void
! 371: channel_do_flush(struct channel *c)
! 372: {
! 373: rt_schedule_prune(c->table);
! 374:
! 375: c->gr_wait = 0;
! 376: if (c->gr_lock)
! 377: channel_graceful_restart_unlock(c);
! 378:
! 379: CALL(c->channel->shutdown, c);
! 380: }
! 381:
! 382: static void
! 383: channel_do_down(struct channel *c)
! 384: {
! 385: ASSERT(!c->feed_active && !c->reload_active);
! 386:
! 387: rem_node(&c->table_node);
! 388: rt_unlock_table(c->table);
! 389: c->proto->active_channels--;
! 390:
! 391: if ((c->stats.imp_routes + c->stats.filt_routes) != 0)
! 392: log(L_ERR "%s: Channel %s is down but still has some routes", c->proto->name, c->name);
! 393:
! 394: memset(&c->stats, 0, sizeof(struct proto_stats));
! 395:
! 396: c->in_table = NULL;
! 397: c->reload_event = NULL;
! 398: c->out_table = NULL;
! 399:
! 400: CALL(c->channel->cleanup, c);
! 401:
! 402: /* Schedule protocol shutddown */
! 403: if (proto_is_done(c->proto))
! 404: ev_schedule(c->proto->event);
! 405: }
! 406:
! 407: void
! 408: channel_set_state(struct channel *c, uint state)
! 409: {
! 410: uint cs = c->channel_state;
! 411: uint es = c->export_state;
! 412:
! 413: DBG("%s reporting channel %s state transition %s -> %s\n", c->proto->name, c->name, c_states[cs], c_states[state]);
! 414: if (state == cs)
! 415: return;
! 416:
! 417: c->channel_state = state;
! 418: c->last_state_change = current_time();
! 419:
! 420: switch (state)
! 421: {
! 422: case CS_START:
! 423: ASSERT(cs == CS_DOWN || cs == CS_UP);
! 424:
! 425: if (cs == CS_DOWN)
! 426: channel_do_start(c);
! 427:
! 428: if (es != ES_DOWN)
! 429: channel_stop_export(c);
! 430:
! 431: if (c->in_table && (cs == CS_UP))
! 432: channel_reset_import(c);
! 433:
! 434: if (c->out_table && (cs == CS_UP))
! 435: channel_reset_export(c);
! 436:
! 437: break;
! 438:
! 439: case CS_UP:
! 440: ASSERT(cs == CS_DOWN || cs == CS_START);
! 441:
! 442: if (cs == CS_DOWN)
! 443: channel_do_start(c);
! 444:
! 445: if (!c->gr_wait && c->proto->rt_notify)
! 446: channel_start_export(c);
! 447:
! 448: break;
! 449:
! 450: case CS_FLUSHING:
! 451: ASSERT(cs == CS_START || cs == CS_UP);
! 452:
! 453: if (es != ES_DOWN)
! 454: channel_stop_export(c);
! 455:
! 456: if (c->in_table && (cs == CS_UP))
! 457: channel_reset_import(c);
! 458:
! 459: if (c->out_table && (cs == CS_UP))
! 460: channel_reset_export(c);
! 461:
! 462: channel_do_flush(c);
! 463: break;
! 464:
! 465: case CS_DOWN:
! 466: ASSERT(cs == CS_FLUSHING);
! 467:
! 468: channel_do_down(c);
! 469: break;
! 470:
! 471: default:
! 472: ASSERT(0);
! 473: }
! 474: // XXXX proto_log_state_change(c);
! 475: }
! 476:
! 477: /**
! 478: * channel_request_feeding - request feeding routes to the channel
! 479: * @c: given channel
! 480: *
! 481: * Sometimes it is needed to send again all routes to the channel. This is
! 482: * called feeding and can be requested by this function. This would cause
! 483: * channel export state transition to ES_FEEDING (during feeding) and when
! 484: * completed, it will switch back to ES_READY. This function can be called
! 485: * even when feeding is already running, in that case it is restarted.
! 486: */
! 487: void
! 488: channel_request_feeding(struct channel *c)
! 489: {
! 490: ASSERT(c->channel_state == CS_UP);
! 491:
! 492: /* Do nothing if we are still waiting for feeding */
! 493: if (c->export_state == ES_DOWN)
! 494: return;
! 495:
! 496: /* If we are already feeding, we want to restart it */
! 497: if (c->export_state == ES_FEEDING)
! 498: {
! 499: /* Unless feeding is in initial state */
! 500: if (!c->feed_active)
! 501: return;
! 502:
! 503: rt_feed_channel_abort(c);
! 504: }
! 505:
! 506: channel_reset_limit(&c->out_limit);
! 507:
! 508: /* Hack: reset exp_routes during refeed, and do not decrease it later */
! 509: c->stats.exp_routes = 0;
! 510:
! 511: channel_schedule_feed(c, 0); /* Sets ES_FEEDING */
! 512: // proto_log_state_change(c);
! 513: }
! 514:
! 515: static inline int
! 516: channel_reloadable(struct channel *c)
! 517: {
! 518: return c->proto->reload_routes && c->reloadable;
! 519: }
! 520:
! 521: static void
! 522: channel_request_reload(struct channel *c)
! 523: {
! 524: ASSERT(c->channel_state == CS_UP);
! 525: ASSERT(channel_reloadable(c));
! 526:
! 527: c->proto->reload_routes(c);
! 528:
! 529: /*
! 530: * Should this be done before reload_routes() hook?
! 531: * Perhaps, but routes are updated asynchronously.
! 532: */
! 533: channel_reset_limit(&c->rx_limit);
! 534: channel_reset_limit(&c->in_limit);
! 535: }
! 536:
! 537: const struct channel_class channel_basic = {
! 538: .channel_size = sizeof(struct channel),
! 539: .config_size = sizeof(struct channel_config)
! 540: };
! 541:
! 542: void *
! 543: channel_config_new(const struct channel_class *cc, const char *name, uint net_type, struct proto_config *proto)
! 544: {
! 545: struct channel_config *cf = NULL;
! 546: struct rtable_config *tab = NULL;
! 547:
! 548: if (net_type)
! 549: {
! 550: if (!net_val_match(net_type, proto->protocol->channel_mask))
! 551: cf_error("Unsupported channel type");
! 552:
! 553: if (proto->net_type && (net_type != proto->net_type))
! 554: cf_error("Different channel type");
! 555:
! 556: tab = new_config->def_tables[net_type];
! 557: }
! 558:
! 559: if (!cc)
! 560: cc = &channel_basic;
! 561:
! 562: cf = cfg_allocz(cc->config_size);
! 563: cf->name = name;
! 564: cf->channel = cc;
! 565: cf->parent = proto;
! 566: cf->table = tab;
! 567: cf->out_filter = FILTER_REJECT;
! 568:
! 569: cf->net_type = net_type;
! 570: cf->ra_mode = RA_OPTIMAL;
! 571: cf->preference = proto->protocol->preference;
! 572:
! 573: add_tail(&proto->channels, &cf->n);
! 574:
! 575: return cf;
! 576: }
! 577:
! 578: void *
! 579: channel_config_get(const struct channel_class *cc, const char *name, uint net_type, struct proto_config *proto)
! 580: {
! 581: struct channel_config *cf;
! 582:
! 583: /* We are using name as token, so no strcmp() */
! 584: WALK_LIST(cf, proto->channels)
! 585: if (cf->name == name)
! 586: {
! 587: /* Allow to redefine channel only if inherited from template */
! 588: if (cf->parent == proto)
! 589: cf_error("Multiple %s channels", name);
! 590:
! 591: cf->parent = proto;
! 592: return cf;
! 593: }
! 594:
! 595: return channel_config_new(cc, name, net_type, proto);
! 596: }
! 597:
! 598: struct channel_config *
! 599: channel_copy_config(struct channel_config *src, struct proto_config *proto)
! 600: {
! 601: struct channel_config *dst = cfg_alloc(src->channel->config_size);
! 602:
! 603: memcpy(dst, src, src->channel->config_size);
! 604: add_tail(&proto->channels, &dst->n);
! 605: CALL(src->channel->copy_config, dst, src);
! 606:
! 607: return dst;
! 608: }
! 609:
! 610:
! 611: static int reconfigure_type; /* Hack to propagate type info to channel_reconfigure() */
! 612:
! 613: int
! 614: channel_reconfigure(struct channel *c, struct channel_config *cf)
! 615: {
! 616: /* FIXME: better handle these changes, also handle in_keep_filtered */
! 617: if ((c->table != cf->table->table) || (cf->ra_mode && (c->ra_mode != cf->ra_mode)))
! 618: return 0;
! 619:
! 620: /* Note that filter_same() requires arguments in (new, old) order */
! 621: int import_changed = !filter_same(cf->in_filter, c->in_filter);
! 622: int export_changed = !filter_same(cf->out_filter, c->out_filter);
! 623:
! 624: if (c->preference != cf->preference)
! 625: import_changed = 1;
! 626:
! 627: if (c->merge_limit != cf->merge_limit)
! 628: export_changed = 1;
! 629:
! 630: /* Reconfigure channel fields */
! 631: c->in_filter = cf->in_filter;
! 632: c->out_filter = cf->out_filter;
! 633: c->rx_limit = cf->rx_limit;
! 634: c->in_limit = cf->in_limit;
! 635: c->out_limit = cf->out_limit;
! 636:
! 637: // c->ra_mode = cf->ra_mode;
! 638: c->merge_limit = cf->merge_limit;
! 639: c->preference = cf->preference;
! 640: c->in_keep_filtered = cf->in_keep_filtered;
! 641:
! 642: channel_verify_limits(c);
! 643:
! 644: if (export_changed)
! 645: c->last_tx_filter_change = current_time();
! 646:
! 647: /* Execute channel-specific reconfigure hook */
! 648: if (c->channel->reconfigure && !c->channel->reconfigure(c, cf, &import_changed, &export_changed))
! 649: return 0;
! 650:
! 651: /* If the channel is not open, it has no routes and we cannot reload it anyways */
! 652: if (c->channel_state != CS_UP)
! 653: return 1;
! 654:
! 655: if (reconfigure_type == RECONFIG_SOFT)
! 656: {
! 657: if (import_changed)
! 658: log(L_INFO "Channel %s.%s changed import", c->proto->name, c->name);
! 659:
! 660: if (export_changed)
! 661: log(L_INFO "Channel %s.%s changed export", c->proto->name, c->name);
! 662:
! 663: return 1;
! 664: }
! 665:
! 666: /* Route reload may be not supported */
! 667: if (import_changed && !channel_reloadable(c))
! 668: return 0;
! 669:
! 670: if (import_changed || export_changed)
! 671: log(L_INFO "Reloading channel %s.%s", c->proto->name, c->name);
! 672:
! 673: if (import_changed)
! 674: channel_request_reload(c);
! 675:
! 676: if (export_changed)
! 677: channel_request_feeding(c);
! 678:
! 679: return 1;
! 680: }
! 681:
! 682:
! 683: int
! 684: proto_configure_channel(struct proto *p, struct channel **pc, struct channel_config *cf)
! 685: {
! 686: struct channel *c = *pc;
! 687:
! 688: if (!c && cf)
! 689: {
! 690: /* We could add the channel, but currently it would just stay in down state
! 691: until protocol is restarted, so it is better to force restart anyways. */
! 692: if (p->proto_state != PS_DOWN)
! 693: {
! 694: log(L_INFO "Cannot add channel %s.%s", p->name, cf->name);
! 695: return 0;
! 696: }
! 697:
! 698: *pc = proto_add_channel(p, cf);
! 699: }
! 700: else if (c && !cf)
! 701: {
! 702: if (c->channel_state != CS_DOWN)
! 703: {
! 704: log(L_INFO "Cannot remove channel %s.%s", c->proto->name, c->name);
! 705: return 0;
! 706: }
! 707:
! 708: proto_remove_channel(p, c);
! 709: *pc = NULL;
! 710: }
! 711: else if (c && cf)
! 712: {
! 713: if (!channel_reconfigure(c, cf))
! 714: {
! 715: log(L_INFO "Cannot reconfigure channel %s.%s", c->proto->name, c->name);
! 716: return 0;
! 717: }
! 718: }
! 719:
! 720: return 1;
! 721: }
! 722:
! 723:
! 724: static void
! 725: proto_event(void *ptr)
! 726: {
! 727: struct proto *p = ptr;
! 728:
! 729: if (p->do_start)
! 730: {
! 731: if_feed_baby(p);
! 732: p->do_start = 0;
! 733: }
! 734:
! 735: if (p->do_stop)
! 736: {
! 737: if (p->proto == &proto_unix_iface)
! 738: if_flush_ifaces(p);
! 739: p->do_stop = 0;
! 740: }
! 741:
! 742: if (proto_is_done(p))
! 743: {
! 744: if (p->proto->cleanup)
! 745: p->proto->cleanup(p);
! 746:
! 747: p->active = 0;
! 748: proto_log_state_change(p);
! 749: proto_rethink_goal(p);
! 750: }
! 751: }
! 752:
! 753:
! 754: /**
! 755: * proto_new - create a new protocol instance
! 756: * @c: protocol configuration
! 757: *
! 758: * When a new configuration has been read in, the core code starts
! 759: * initializing all the protocol instances configured by calling their
! 760: * init() hooks with the corresponding instance configuration. The initialization
! 761: * code of the protocol is expected to create a new instance according to the
! 762: * configuration by calling this function and then modifying the default settings
! 763: * to values wanted by the protocol.
! 764: */
! 765: void *
! 766: proto_new(struct proto_config *cf)
! 767: {
! 768: struct proto *p = mb_allocz(proto_pool, cf->protocol->proto_size);
! 769:
! 770: p->cf = cf;
! 771: p->debug = cf->debug;
! 772: p->mrtdump = cf->mrtdump;
! 773: p->name = cf->name;
! 774: p->proto = cf->protocol;
! 775: p->net_type = cf->net_type;
! 776: p->disabled = cf->disabled;
! 777: p->hash_key = random_u32();
! 778: cf->proto = p;
! 779:
! 780: init_list(&p->channels);
! 781:
! 782: return p;
! 783: }
! 784:
! 785: static struct proto *
! 786: proto_init(struct proto_config *c, node *n)
! 787: {
! 788: struct protocol *pr = c->protocol;
! 789: struct proto *p = pr->init(c);
! 790:
! 791: p->proto_state = PS_DOWN;
! 792: p->last_state_change = current_time();
! 793: p->vrf = c->vrf;
! 794: p->vrf_set = c->vrf_set;
! 795: insert_node(&p->n, n);
! 796:
! 797: p->event = ev_new_init(proto_pool, proto_event, p);
! 798:
! 799: PD(p, "Initializing%s", p->disabled ? " [disabled]" : "");
! 800:
! 801: return p;
! 802: }
! 803:
! 804: static void
! 805: proto_start(struct proto *p)
! 806: {
! 807: /* Here we cannot use p->cf->name since it won't survive reconfiguration */
! 808: p->pool = rp_new(proto_pool, p->proto->name);
! 809:
! 810: if (graceful_restart_state == GRS_INIT)
! 811: p->gr_recovery = 1;
! 812: }
! 813:
! 814:
! 815: /**
! 816: * proto_config_new - create a new protocol configuration
! 817: * @pr: protocol the configuration will belong to
! 818: * @class: SYM_PROTO or SYM_TEMPLATE
! 819: *
! 820: * Whenever the configuration file says that a new instance
! 821: * of a routing protocol should be created, the parser calls
! 822: * proto_config_new() to create a configuration entry for this
! 823: * instance (a structure staring with the &proto_config header
! 824: * containing all the generic items followed by protocol-specific
! 825: * ones). Also, the configuration entry gets added to the list
! 826: * of protocol instances kept in the configuration.
! 827: *
! 828: * The function is also used to create protocol templates (when class
! 829: * SYM_TEMPLATE is specified), the only difference is that templates
! 830: * are not added to the list of protocol instances and therefore not
! 831: * initialized during protos_commit()).
! 832: */
! 833: void *
! 834: proto_config_new(struct protocol *pr, int class)
! 835: {
! 836: struct proto_config *cf = cfg_allocz(pr->config_size);
! 837:
! 838: if (class == SYM_PROTO)
! 839: add_tail(&new_config->protos, &cf->n);
! 840:
! 841: cf->global = new_config;
! 842: cf->protocol = pr;
! 843: cf->name = pr->name;
! 844: cf->class = class;
! 845: cf->debug = new_config->proto_default_debug;
! 846: cf->mrtdump = new_config->proto_default_mrtdump;
! 847:
! 848: init_list(&cf->channels);
! 849:
! 850: return cf;
! 851: }
! 852:
! 853:
! 854: /**
! 855: * proto_copy_config - copy a protocol configuration
! 856: * @dest: destination protocol configuration
! 857: * @src: source protocol configuration
! 858: *
! 859: * Whenever a new instance of a routing protocol is created from the
! 860: * template, proto_copy_config() is called to copy a content of
! 861: * the source protocol configuration to the new protocol configuration.
! 862: * Name, class and a node in protos list of @dest are kept intact.
! 863: * copy_config() protocol hook is used to copy protocol-specific data.
! 864: */
! 865: void
! 866: proto_copy_config(struct proto_config *dest, struct proto_config *src)
! 867: {
! 868: struct channel_config *cc;
! 869: node old_node;
! 870: int old_class;
! 871: char *old_name;
! 872:
! 873: if (dest->protocol != src->protocol)
! 874: cf_error("Can't copy configuration from a different protocol type");
! 875:
! 876: if (dest->protocol->copy_config == NULL)
! 877: cf_error("Inheriting configuration for %s is not supported", src->protocol->name);
! 878:
! 879: DBG("Copying configuration from %s to %s\n", src->name, dest->name);
! 880:
! 881: /*
! 882: * Copy struct proto_config here. Keep original node, class and name.
! 883: * protocol-specific config copy is handled by protocol copy_config() hook
! 884: */
! 885:
! 886: old_node = dest->n;
! 887: old_class = dest->class;
! 888: old_name = dest->name;
! 889:
! 890: memcpy(dest, src, src->protocol->config_size);
! 891:
! 892: dest->n = old_node;
! 893: dest->class = old_class;
! 894: dest->name = old_name;
! 895: init_list(&dest->channels);
! 896:
! 897: WALK_LIST(cc, src->channels)
! 898: channel_copy_config(cc, dest);
! 899:
! 900: /* FIXME: allow for undefined copy_config */
! 901: dest->protocol->copy_config(dest, src);
! 902: }
! 903:
! 904: void
! 905: proto_clone_config(struct symbol *sym, struct proto_config *parent)
! 906: {
! 907: struct proto_config *cf = proto_config_new(parent->protocol, SYM_PROTO);
! 908: proto_copy_config(cf, parent);
! 909: cf->name = sym->name;
! 910: cf->proto = NULL;
! 911: cf->parent = parent;
! 912:
! 913: sym->class = cf->class;
! 914: sym->proto = cf;
! 915: }
! 916:
! 917: static void
! 918: proto_undef_clone(struct symbol *sym, struct proto_config *cf)
! 919: {
! 920: rem_node(&cf->n);
! 921:
! 922: sym->class = SYM_VOID;
! 923: sym->proto = NULL;
! 924: }
! 925:
! 926: /**
! 927: * protos_preconfig - pre-configuration processing
! 928: * @c: new configuration
! 929: *
! 930: * This function calls the preconfig() hooks of all routing
! 931: * protocols available to prepare them for reading of the new
! 932: * configuration.
! 933: */
! 934: void
! 935: protos_preconfig(struct config *c)
! 936: {
! 937: struct protocol *p;
! 938:
! 939: init_list(&c->protos);
! 940: DBG("Protocol preconfig:");
! 941: WALK_LIST(p, protocol_list)
! 942: {
! 943: DBG(" %s", p->name);
! 944: p->name_counter = 0;
! 945: if (p->preconfig)
! 946: p->preconfig(p, c);
! 947: }
! 948: DBG("\n");
! 949: }
! 950:
! 951: static int
! 952: proto_reconfigure(struct proto *p, struct proto_config *oc, struct proto_config *nc, int type)
! 953: {
! 954: /* If the protocol is DOWN, we just restart it */
! 955: if (p->proto_state == PS_DOWN)
! 956: return 0;
! 957:
! 958: /* If there is a too big change in core attributes, ... */
! 959: if ((nc->protocol != oc->protocol) ||
! 960: (nc->net_type != oc->net_type) ||
! 961: (nc->disabled != p->disabled) ||
! 962: (nc->vrf != oc->vrf) ||
! 963: (nc->vrf_set != oc->vrf_set))
! 964: return 0;
! 965:
! 966: p->name = nc->name;
! 967: p->debug = nc->debug;
! 968: p->mrtdump = nc->mrtdump;
! 969: reconfigure_type = type;
! 970:
! 971: /* Execute protocol specific reconfigure hook */
! 972: if (!p->proto->reconfigure || !p->proto->reconfigure(p, nc))
! 973: return 0;
! 974:
! 975: DBG("\t%s: same\n", oc->name);
! 976: PD(p, "Reconfigured");
! 977: p->cf = nc;
! 978:
! 979: return 1;
! 980: }
! 981:
! 982: /**
! 983: * protos_commit - commit new protocol configuration
! 984: * @new: new configuration
! 985: * @old: old configuration or %NULL if it's boot time config
! 986: * @force_reconfig: force restart of all protocols (used for example
! 987: * when the router ID changes)
! 988: * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
! 989: *
! 990: * Scan differences between @old and @new configuration and adjust all
! 991: * protocol instances to conform to the new configuration.
! 992: *
! 993: * When a protocol exists in the new configuration, but it doesn't in the
! 994: * original one, it's immediately started. When a collision with the other
! 995: * running protocol would arise, the new protocol will be temporarily stopped
! 996: * by the locking mechanism.
! 997: *
! 998: * When a protocol exists in the old configuration, but it doesn't in the
! 999: * new one, it's shut down and deleted after the shutdown completes.
! 1000: *
! 1001: * When a protocol exists in both configurations, the core decides
! 1002: * whether it's possible to reconfigure it dynamically - it checks all
! 1003: * the core properties of the protocol (changes in filters are ignored
! 1004: * if type is RECONFIG_SOFT) and if they match, it asks the
! 1005: * reconfigure() hook of the protocol to see if the protocol is able
! 1006: * to switch to the new configuration. If it isn't possible, the
! 1007: * protocol is shut down and a new instance is started with the new
! 1008: * configuration after the shutdown is completed.
! 1009: */
! 1010: void
! 1011: protos_commit(struct config *new, struct config *old, int force_reconfig, int type)
! 1012: {
! 1013: struct proto_config *oc, *nc;
! 1014: struct symbol *sym;
! 1015: struct proto *p;
! 1016: node *n;
! 1017:
! 1018:
! 1019: DBG("protos_commit:\n");
! 1020: if (old)
! 1021: {
! 1022: WALK_LIST(oc, old->protos)
! 1023: {
! 1024: p = oc->proto;
! 1025: sym = cf_find_symbol(new, oc->name);
! 1026:
! 1027: /* Handle dynamic protocols */
! 1028: if (!sym && oc->parent && !new->shutdown)
! 1029: {
! 1030: struct symbol *parsym = cf_find_symbol(new, oc->parent->name);
! 1031: if (parsym && parsym->class == SYM_PROTO)
! 1032: {
! 1033: /* This is hack, we would like to share config, but we need to copy it now */
! 1034: new_config = new;
! 1035: cfg_mem = new->mem;
! 1036: conf_this_scope = new->root_scope;
! 1037: sym = cf_get_symbol(oc->name);
! 1038: proto_clone_config(sym, parsym->proto);
! 1039: new_config = NULL;
! 1040: cfg_mem = NULL;
! 1041: }
! 1042: }
! 1043:
! 1044: if (sym && sym->class == SYM_PROTO && !new->shutdown)
! 1045: {
! 1046: /* Found match, let's check if we can smoothly switch to new configuration */
! 1047: /* No need to check description */
! 1048: nc = sym->proto;
! 1049: nc->proto = p;
! 1050:
! 1051: /* We will try to reconfigure protocol p */
! 1052: if (! force_reconfig && proto_reconfigure(p, oc, nc, type))
! 1053: continue;
! 1054:
! 1055: if (nc->parent)
! 1056: {
! 1057: proto_undef_clone(sym, nc);
! 1058: goto remove;
! 1059: }
! 1060:
! 1061: /* Unsuccessful, we will restart it */
! 1062: if (!p->disabled && !nc->disabled)
! 1063: log(L_INFO "Restarting protocol %s", p->name);
! 1064: else if (p->disabled && !nc->disabled)
! 1065: log(L_INFO "Enabling protocol %s", p->name);
! 1066: else if (!p->disabled && nc->disabled)
! 1067: log(L_INFO "Disabling protocol %s", p->name);
! 1068:
! 1069: p->down_code = nc->disabled ? PDC_CF_DISABLE : PDC_CF_RESTART;
! 1070: p->cf_new = nc;
! 1071: }
! 1072: else if (!new->shutdown)
! 1073: {
! 1074: remove:
! 1075: log(L_INFO "Removing protocol %s", p->name);
! 1076: p->down_code = PDC_CF_REMOVE;
! 1077: p->cf_new = NULL;
! 1078: }
! 1079: else if (new->gr_down)
! 1080: {
! 1081: p->down_code = PDC_CMD_GR_DOWN;
! 1082: p->cf_new = NULL;
! 1083: }
! 1084: else /* global shutdown */
! 1085: {
! 1086: p->down_code = PDC_CMD_SHUTDOWN;
! 1087: p->cf_new = NULL;
! 1088: }
! 1089:
! 1090: p->reconfiguring = 1;
! 1091: config_add_obstacle(old);
! 1092: proto_rethink_goal(p);
! 1093: }
! 1094: }
! 1095:
! 1096: struct proto *first_dev_proto = NULL;
! 1097:
! 1098: n = NODE &(proto_list.head);
! 1099: WALK_LIST(nc, new->protos)
! 1100: if (!nc->proto)
! 1101: {
! 1102: /* Not a first-time configuration */
! 1103: if (old)
! 1104: log(L_INFO "Adding protocol %s", nc->name);
! 1105:
! 1106: p = proto_init(nc, n);
! 1107: n = NODE p;
! 1108:
! 1109: if (p->proto == &proto_unix_iface)
! 1110: first_dev_proto = p;
! 1111: }
! 1112: else
! 1113: n = NODE nc->proto;
! 1114:
! 1115: DBG("Protocol start\n");
! 1116:
! 1117: /* Start device protocol first */
! 1118: if (first_dev_proto)
! 1119: proto_rethink_goal(first_dev_proto);
! 1120:
! 1121: /* Determine router ID for the first time - it has to be here and not in
! 1122: global_commit() because it is postponed after start of device protocol */
! 1123: if (!config->router_id)
! 1124: {
! 1125: config->router_id = if_choose_router_id(config->router_id_from, 0);
! 1126: if (!config->router_id)
! 1127: die("Cannot determine router ID, please configure it manually");
! 1128: }
! 1129:
! 1130: /* Start all new protocols */
! 1131: WALK_LIST_DELSAFE(p, n, proto_list)
! 1132: proto_rethink_goal(p);
! 1133: }
! 1134:
! 1135: static void
! 1136: proto_rethink_goal(struct proto *p)
! 1137: {
! 1138: struct protocol *q;
! 1139: byte goal;
! 1140:
! 1141: if (p->reconfiguring && !p->active)
! 1142: {
! 1143: struct proto_config *nc = p->cf_new;
! 1144: node *n = p->n.prev;
! 1145: DBG("%s has shut down for reconfiguration\n", p->name);
! 1146: p->cf->proto = NULL;
! 1147: config_del_obstacle(p->cf->global);
! 1148: proto_remove_channels(p);
! 1149: rem_node(&p->n);
! 1150: rfree(p->event);
! 1151: mb_free(p->message);
! 1152: mb_free(p);
! 1153: if (!nc)
! 1154: return;
! 1155: p = proto_init(nc, n);
! 1156: }
! 1157:
! 1158: /* Determine what state we want to reach */
! 1159: if (p->disabled || p->reconfiguring)
! 1160: goal = PS_DOWN;
! 1161: else
! 1162: goal = PS_UP;
! 1163:
! 1164: q = p->proto;
! 1165: if (goal == PS_UP)
! 1166: {
! 1167: if (!p->active)
! 1168: {
! 1169: /* Going up */
! 1170: DBG("Kicking %s up\n", p->name);
! 1171: PD(p, "Starting");
! 1172: proto_start(p);
! 1173: proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
! 1174: }
! 1175: }
! 1176: else
! 1177: {
! 1178: if (p->proto_state == PS_START || p->proto_state == PS_UP)
! 1179: {
! 1180: /* Going down */
! 1181: DBG("Kicking %s down\n", p->name);
! 1182: PD(p, "Shutting down");
! 1183: proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
! 1184: }
! 1185: }
! 1186: }
! 1187:
! 1188: struct proto *
! 1189: proto_spawn(struct proto_config *cf, uint disabled)
! 1190: {
! 1191: struct proto *p = proto_init(cf, TAIL(proto_list));
! 1192: p->disabled = disabled;
! 1193: proto_rethink_goal(p);
! 1194: return p;
! 1195: }
! 1196:
! 1197:
! 1198: /**
! 1199: * DOC: Graceful restart recovery
! 1200: *
! 1201: * Graceful restart of a router is a process when the routing plane (e.g. BIRD)
! 1202: * restarts but both the forwarding plane (e.g kernel routing table) and routing
! 1203: * neighbors keep proper routes, and therefore uninterrupted packet forwarding
! 1204: * is maintained.
! 1205: *
! 1206: * BIRD implements graceful restart recovery by deferring export of routes to
! 1207: * protocols until routing tables are refilled with the expected content. After
! 1208: * start, protocols generate routes as usual, but routes are not propagated to
! 1209: * them, until protocols report that they generated all routes. After that,
! 1210: * graceful restart recovery is finished and the export (and the initial feed)
! 1211: * to protocols is enabled.
! 1212: *
! 1213: * When graceful restart recovery need is detected during initialization, then
! 1214: * enabled protocols are marked with @gr_recovery flag before start. Such
! 1215: * protocols then decide how to proceed with graceful restart, participation is
! 1216: * voluntary. Protocols could lock the recovery for each channel by function
! 1217: * channel_graceful_restart_lock() (state stored in @gr_lock flag), which means
! 1218: * that they want to postpone the end of the recovery until they converge and
! 1219: * then unlock it. They also could set @gr_wait before advancing to %PS_UP,
! 1220: * which means that the core should defer route export to that channel until
! 1221: * the end of the recovery. This should be done by protocols that expect their
! 1222: * neigbors to keep the proper routes (kernel table, BGP sessions with BGP
! 1223: * graceful restart capability).
! 1224: *
! 1225: * The graceful restart recovery is finished when either all graceful restart
! 1226: * locks are unlocked or when graceful restart wait timer fires.
! 1227: *
! 1228: */
! 1229:
! 1230: static void graceful_restart_done(timer *t);
! 1231:
! 1232: /**
! 1233: * graceful_restart_recovery - request initial graceful restart recovery
! 1234: *
! 1235: * Called by the platform initialization code if the need for recovery
! 1236: * after graceful restart is detected during boot. Have to be called
! 1237: * before protos_commit().
! 1238: */
! 1239: void
! 1240: graceful_restart_recovery(void)
! 1241: {
! 1242: graceful_restart_state = GRS_INIT;
! 1243: }
! 1244:
! 1245: /**
! 1246: * graceful_restart_init - initialize graceful restart
! 1247: *
! 1248: * When graceful restart recovery was requested, the function starts an active
! 1249: * phase of the recovery and initializes graceful restart wait timer. The
! 1250: * function have to be called after protos_commit().
! 1251: */
! 1252: void
! 1253: graceful_restart_init(void)
! 1254: {
! 1255: if (!graceful_restart_state)
! 1256: return;
! 1257:
! 1258: log(L_INFO "Graceful restart started");
! 1259:
! 1260: if (!graceful_restart_locks)
! 1261: {
! 1262: graceful_restart_done(NULL);
! 1263: return;
! 1264: }
! 1265:
! 1266: graceful_restart_state = GRS_ACTIVE;
! 1267: gr_wait_timer = tm_new_init(proto_pool, graceful_restart_done, NULL, 0, 0);
! 1268: tm_start(gr_wait_timer, config->gr_wait S);
! 1269: }
! 1270:
! 1271: /**
! 1272: * graceful_restart_done - finalize graceful restart
! 1273: * @t: unused
! 1274: *
! 1275: * When there are no locks on graceful restart, the functions finalizes the
! 1276: * graceful restart recovery. Protocols postponing route export until the end of
! 1277: * the recovery are awakened and the export to them is enabled. All other
! 1278: * related state is cleared. The function is also called when the graceful
! 1279: * restart wait timer fires (but there are still some locks).
! 1280: */
! 1281: static void
! 1282: graceful_restart_done(timer *t UNUSED)
! 1283: {
! 1284: log(L_INFO "Graceful restart done");
! 1285: graceful_restart_state = GRS_DONE;
! 1286:
! 1287: struct proto *p;
! 1288: WALK_LIST(p, proto_list)
! 1289: {
! 1290: if (!p->gr_recovery)
! 1291: continue;
! 1292:
! 1293: struct channel *c;
! 1294: WALK_LIST(c, p->channels)
! 1295: {
! 1296: /* Resume postponed export of routes */
! 1297: if ((c->channel_state == CS_UP) && c->gr_wait && c->proto->rt_notify)
! 1298: channel_start_export(c);
! 1299:
! 1300: /* Cleanup */
! 1301: c->gr_wait = 0;
! 1302: c->gr_lock = 0;
! 1303: }
! 1304:
! 1305: p->gr_recovery = 0;
! 1306: }
! 1307:
! 1308: graceful_restart_locks = 0;
! 1309: }
! 1310:
! 1311: void
! 1312: graceful_restart_show_status(void)
! 1313: {
! 1314: if (graceful_restart_state != GRS_ACTIVE)
! 1315: return;
! 1316:
! 1317: cli_msg(-24, "Graceful restart recovery in progress");
! 1318: cli_msg(-24, " Waiting for %d channels to recover", graceful_restart_locks);
! 1319: cli_msg(-24, " Wait timer is %t/%u", tm_remains(gr_wait_timer), config->gr_wait);
! 1320: }
! 1321:
! 1322: /**
! 1323: * channel_graceful_restart_lock - lock graceful restart by channel
! 1324: * @p: channel instance
! 1325: *
! 1326: * This function allows a protocol to postpone the end of graceful restart
! 1327: * recovery until it converges. The lock is removed when the protocol calls
! 1328: * channel_graceful_restart_unlock() or when the channel is closed.
! 1329: *
! 1330: * The function have to be called during the initial phase of graceful restart
! 1331: * recovery and only for protocols that are part of graceful restart (i.e. their
! 1332: * @gr_recovery is set), which means it should be called from protocol start
! 1333: * hooks.
! 1334: */
! 1335: void
! 1336: channel_graceful_restart_lock(struct channel *c)
! 1337: {
! 1338: ASSERT(graceful_restart_state == GRS_INIT);
! 1339: ASSERT(c->proto->gr_recovery);
! 1340:
! 1341: if (c->gr_lock)
! 1342: return;
! 1343:
! 1344: c->gr_lock = 1;
! 1345: graceful_restart_locks++;
! 1346: }
! 1347:
! 1348: /**
! 1349: * channel_graceful_restart_unlock - unlock graceful restart by channel
! 1350: * @p: channel instance
! 1351: *
! 1352: * This function unlocks a lock from channel_graceful_restart_lock(). It is also
! 1353: * automatically called when the lock holding protocol went down.
! 1354: */
! 1355: void
! 1356: channel_graceful_restart_unlock(struct channel *c)
! 1357: {
! 1358: if (!c->gr_lock)
! 1359: return;
! 1360:
! 1361: c->gr_lock = 0;
! 1362: graceful_restart_locks--;
! 1363:
! 1364: if ((graceful_restart_state == GRS_ACTIVE) && !graceful_restart_locks)
! 1365: tm_start(gr_wait_timer, 0);
! 1366: }
! 1367:
! 1368:
! 1369:
! 1370: /**
! 1371: * protos_dump_all - dump status of all protocols
! 1372: *
! 1373: * This function dumps status of all existing protocol instances to the
! 1374: * debug output. It involves printing of general status information
! 1375: * such as protocol states, its position on the protocol lists
! 1376: * and also calling of a dump() hook of the protocol to print
! 1377: * the internals.
! 1378: */
! 1379: void
! 1380: protos_dump_all(void)
! 1381: {
! 1382: debug("Protocols:\n");
! 1383:
! 1384: struct proto *p;
! 1385: WALK_LIST(p, proto_list)
! 1386: {
! 1387: debug(" protocol %s state %s\n", p->name, p_states[p->proto_state]);
! 1388:
! 1389: struct channel *c;
! 1390: WALK_LIST(c, p->channels)
! 1391: {
! 1392: debug("\tTABLE %s\n", c->table->name);
! 1393: if (c->in_filter)
! 1394: debug("\tInput filter: %s\n", filter_name(c->in_filter));
! 1395: if (c->out_filter)
! 1396: debug("\tOutput filter: %s\n", filter_name(c->out_filter));
! 1397: }
! 1398:
! 1399: if (p->proto->dump && (p->proto_state != PS_DOWN))
! 1400: p->proto->dump(p);
! 1401: }
! 1402: }
! 1403:
! 1404: /**
! 1405: * proto_build - make a single protocol available
! 1406: * @p: the protocol
! 1407: *
! 1408: * After the platform specific initialization code uses protos_build()
! 1409: * to add all the standard protocols, it should call proto_build() for
! 1410: * all platform specific protocols to inform the core that they exist.
! 1411: */
! 1412: void
! 1413: proto_build(struct protocol *p)
! 1414: {
! 1415: add_tail(&protocol_list, &p->n);
! 1416: ASSERT(p->class);
! 1417: ASSERT(!class_to_protocol[p->class]);
! 1418: class_to_protocol[p->class] = p;
! 1419: }
! 1420:
! 1421: /* FIXME: convert this call to some protocol hook */
! 1422: extern void bfd_init_all(void);
! 1423:
! 1424: /**
! 1425: * protos_build - build a protocol list
! 1426: *
! 1427: * This function is called during BIRD startup to insert
! 1428: * all standard protocols to the global protocol list. Insertion
! 1429: * of platform specific protocols (such as the kernel syncer)
! 1430: * is in the domain of competence of the platform dependent
! 1431: * startup code.
! 1432: */
! 1433: void
! 1434: protos_build(void)
! 1435: {
! 1436: init_list(&proto_list);
! 1437: init_list(&protocol_list);
! 1438:
! 1439: proto_build(&proto_device);
! 1440: #ifdef CONFIG_RADV
! 1441: proto_build(&proto_radv);
! 1442: #endif
! 1443: #ifdef CONFIG_RIP
! 1444: proto_build(&proto_rip);
! 1445: #endif
! 1446: #ifdef CONFIG_STATIC
! 1447: proto_build(&proto_static);
! 1448: #endif
! 1449: #ifdef CONFIG_MRT
! 1450: proto_build(&proto_mrt);
! 1451: #endif
! 1452: #ifdef CONFIG_OSPF
! 1453: proto_build(&proto_ospf);
! 1454: #endif
! 1455: #ifdef CONFIG_PIPE
! 1456: proto_build(&proto_pipe);
! 1457: #endif
! 1458: #ifdef CONFIG_BGP
! 1459: proto_build(&proto_bgp);
! 1460: #endif
! 1461: #ifdef CONFIG_BFD
! 1462: proto_build(&proto_bfd);
! 1463: bfd_init_all();
! 1464: #endif
! 1465: #ifdef CONFIG_BABEL
! 1466: proto_build(&proto_babel);
! 1467: #endif
! 1468: #ifdef CONFIG_RPKI
! 1469: proto_build(&proto_rpki);
! 1470: #endif
! 1471: #ifdef CONFIG_PERF
! 1472: proto_build(&proto_perf);
! 1473: #endif
! 1474:
! 1475: proto_pool = rp_new(&root_pool, "Protocols");
! 1476: proto_shutdown_timer = tm_new(proto_pool);
! 1477: proto_shutdown_timer->hook = proto_shutdown_loop;
! 1478: }
! 1479:
! 1480:
! 1481: /* Temporary hack to propagate restart to BGP */
! 1482: int proto_restart;
! 1483:
! 1484: static void
! 1485: proto_shutdown_loop(timer *t UNUSED)
! 1486: {
! 1487: struct proto *p, *p_next;
! 1488:
! 1489: WALK_LIST_DELSAFE(p, p_next, proto_list)
! 1490: if (p->down_sched)
! 1491: {
! 1492: proto_restart = (p->down_sched == PDS_RESTART);
! 1493:
! 1494: p->disabled = 1;
! 1495: proto_rethink_goal(p);
! 1496: if (proto_restart)
! 1497: {
! 1498: p->disabled = 0;
! 1499: proto_rethink_goal(p);
! 1500: }
! 1501: }
! 1502: }
! 1503:
! 1504: static inline void
! 1505: proto_schedule_down(struct proto *p, byte restart, byte code)
! 1506: {
! 1507: /* Does not work for other states (even PS_START) */
! 1508: ASSERT(p->proto_state == PS_UP);
! 1509:
! 1510: /* Scheduled restart may change to shutdown, but not otherwise */
! 1511: if (p->down_sched == PDS_DISABLE)
! 1512: return;
! 1513:
! 1514: p->down_sched = restart ? PDS_RESTART : PDS_DISABLE;
! 1515: p->down_code = code;
! 1516: tm_start_max(proto_shutdown_timer, restart ? 250 MS : 0);
! 1517: }
! 1518:
! 1519: /**
! 1520: * proto_set_message - set administrative message to protocol
! 1521: * @p: protocol
! 1522: * @msg: message
! 1523: * @len: message length (-1 for NULL-terminated string)
! 1524: *
! 1525: * The function sets administrative message (string) related to protocol state
! 1526: * change. It is called by the nest code for manual enable/disable/restart
! 1527: * commands all routes to the protocol, and by protocol-specific code when the
! 1528: * protocol state change is initiated by the protocol. Using NULL message clears
! 1529: * the last message. The message string may be either NULL-terminated or with an
! 1530: * explicit length.
! 1531: */
! 1532: void
! 1533: proto_set_message(struct proto *p, char *msg, int len)
! 1534: {
! 1535: mb_free(p->message);
! 1536: p->message = NULL;
! 1537:
! 1538: if (!msg || !len)
! 1539: return;
! 1540:
! 1541: if (len < 0)
! 1542: len = strlen(msg);
! 1543:
! 1544: if (!len)
! 1545: return;
! 1546:
! 1547: p->message = mb_alloc(proto_pool, len + 1);
! 1548: memcpy(p->message, msg, len);
! 1549: p->message[len] = 0;
! 1550: }
! 1551:
! 1552:
! 1553: static const char *
! 1554: channel_limit_name(struct channel_limit *l)
! 1555: {
! 1556: const char *actions[] = {
! 1557: [PLA_WARN] = "warn",
! 1558: [PLA_BLOCK] = "block",
! 1559: [PLA_RESTART] = "restart",
! 1560: [PLA_DISABLE] = "disable",
! 1561: };
! 1562:
! 1563: return actions[l->action];
! 1564: }
! 1565:
! 1566: /**
! 1567: * channel_notify_limit: notify about limit hit and take appropriate action
! 1568: * @c: channel
! 1569: * @l: limit being hit
! 1570: * @dir: limit direction (PLD_*)
! 1571: * @rt_count: the number of routes
! 1572: *
! 1573: * The function is called by the route processing core when limit @l
! 1574: * is breached. It activates the limit and tooks appropriate action
! 1575: * according to @l->action.
! 1576: */
! 1577: void
! 1578: channel_notify_limit(struct channel *c, struct channel_limit *l, int dir, u32 rt_count)
! 1579: {
! 1580: const char *dir_name[PLD_MAX] = { "receive", "import" , "export" };
! 1581: const byte dir_down[PLD_MAX] = { PDC_RX_LIMIT_HIT, PDC_IN_LIMIT_HIT, PDC_OUT_LIMIT_HIT };
! 1582: struct proto *p = c->proto;
! 1583:
! 1584: if (l->state == PLS_BLOCKED)
! 1585: return;
! 1586:
! 1587: /* For warning action, we want the log message every time we hit the limit */
! 1588: if (!l->state || ((l->action == PLA_WARN) && (rt_count == l->limit)))
! 1589: log(L_WARN "Protocol %s hits route %s limit (%d), action: %s",
! 1590: p->name, dir_name[dir], l->limit, channel_limit_name(l));
! 1591:
! 1592: switch (l->action)
! 1593: {
! 1594: case PLA_WARN:
! 1595: l->state = PLS_ACTIVE;
! 1596: break;
! 1597:
! 1598: case PLA_BLOCK:
! 1599: l->state = PLS_BLOCKED;
! 1600: break;
! 1601:
! 1602: case PLA_RESTART:
! 1603: case PLA_DISABLE:
! 1604: l->state = PLS_BLOCKED;
! 1605: if (p->proto_state == PS_UP)
! 1606: proto_schedule_down(p, l->action == PLA_RESTART, dir_down[dir]);
! 1607: break;
! 1608: }
! 1609: }
! 1610:
! 1611: static void
! 1612: channel_verify_limits(struct channel *c)
! 1613: {
! 1614: struct channel_limit *l;
! 1615: u32 all_routes = c->stats.imp_routes + c->stats.filt_routes;
! 1616:
! 1617: l = &c->rx_limit;
! 1618: if (l->action && (all_routes > l->limit))
! 1619: channel_notify_limit(c, l, PLD_RX, all_routes);
! 1620:
! 1621: l = &c->in_limit;
! 1622: if (l->action && (c->stats.imp_routes > l->limit))
! 1623: channel_notify_limit(c, l, PLD_IN, c->stats.imp_routes);
! 1624:
! 1625: l = &c->out_limit;
! 1626: if (l->action && (c->stats.exp_routes > l->limit))
! 1627: channel_notify_limit(c, l, PLD_OUT, c->stats.exp_routes);
! 1628: }
! 1629:
! 1630: static inline void
! 1631: channel_reset_limit(struct channel_limit *l)
! 1632: {
! 1633: if (l->action)
! 1634: l->state = PLS_INITIAL;
! 1635: }
! 1636:
! 1637: static inline void
! 1638: proto_do_start(struct proto *p)
! 1639: {
! 1640: p->active = 1;
! 1641: p->do_start = 1;
! 1642: ev_schedule(p->event);
! 1643: }
! 1644:
! 1645: static void
! 1646: proto_do_up(struct proto *p)
! 1647: {
! 1648: if (!p->main_source)
! 1649: {
! 1650: p->main_source = rt_get_source(p, 0);
! 1651: rt_lock_source(p->main_source);
! 1652: }
! 1653:
! 1654: proto_start_channels(p);
! 1655: }
! 1656:
! 1657: static inline void
! 1658: proto_do_pause(struct proto *p)
! 1659: {
! 1660: proto_pause_channels(p);
! 1661: }
! 1662:
! 1663: static void
! 1664: proto_do_stop(struct proto *p)
! 1665: {
! 1666: p->down_sched = 0;
! 1667: p->gr_recovery = 0;
! 1668:
! 1669: p->do_stop = 1;
! 1670: ev_schedule(p->event);
! 1671:
! 1672: if (p->main_source)
! 1673: {
! 1674: rt_unlock_source(p->main_source);
! 1675: p->main_source = NULL;
! 1676: }
! 1677:
! 1678: proto_stop_channels(p);
! 1679: }
! 1680:
! 1681: static void
! 1682: proto_do_down(struct proto *p)
! 1683: {
! 1684: p->down_code = 0;
! 1685: neigh_prune();
! 1686: rfree(p->pool);
! 1687: p->pool = NULL;
! 1688:
! 1689: /* Shutdown is finished in the protocol event */
! 1690: if (proto_is_done(p))
! 1691: ev_schedule(p->event);
! 1692: }
! 1693:
! 1694:
! 1695:
! 1696: /**
! 1697: * proto_notify_state - notify core about protocol state change
! 1698: * @p: protocol the state of which has changed
! 1699: * @ps: the new status
! 1700: *
! 1701: * Whenever a state of a protocol changes due to some event internal
! 1702: * to the protocol (i.e., not inside a start() or shutdown() hook),
! 1703: * it should immediately notify the core about the change by calling
! 1704: * proto_notify_state() which will write the new state to the &proto
! 1705: * structure and take all the actions necessary to adapt to the new
! 1706: * state. State change to PS_DOWN immediately frees resources of protocol
! 1707: * and might execute start callback of protocol; therefore,
! 1708: * it should be used at tail positions of protocol callbacks.
! 1709: */
! 1710: void
! 1711: proto_notify_state(struct proto *p, uint state)
! 1712: {
! 1713: uint ps = p->proto_state;
! 1714:
! 1715: DBG("%s reporting state transition %s -> %s\n", p->name, p_states[ps], p_states[state]);
! 1716: if (state == ps)
! 1717: return;
! 1718:
! 1719: p->proto_state = state;
! 1720: p->last_state_change = current_time();
! 1721:
! 1722: switch (state)
! 1723: {
! 1724: case PS_START:
! 1725: ASSERT(ps == PS_DOWN || ps == PS_UP);
! 1726:
! 1727: if (ps == PS_DOWN)
! 1728: proto_do_start(p);
! 1729: else
! 1730: proto_do_pause(p);
! 1731: break;
! 1732:
! 1733: case PS_UP:
! 1734: ASSERT(ps == PS_DOWN || ps == PS_START);
! 1735:
! 1736: if (ps == PS_DOWN)
! 1737: proto_do_start(p);
! 1738:
! 1739: proto_do_up(p);
! 1740: break;
! 1741:
! 1742: case PS_STOP:
! 1743: ASSERT(ps == PS_START || ps == PS_UP);
! 1744:
! 1745: proto_do_stop(p);
! 1746: break;
! 1747:
! 1748: case PS_DOWN:
! 1749: if (ps != PS_STOP)
! 1750: proto_do_stop(p);
! 1751:
! 1752: proto_do_down(p);
! 1753: break;
! 1754:
! 1755: default:
! 1756: bug("%s: Invalid state %d", p->name, ps);
! 1757: }
! 1758:
! 1759: proto_log_state_change(p);
! 1760: }
! 1761:
! 1762: /*
! 1763: * CLI Commands
! 1764: */
! 1765:
! 1766: static char *
! 1767: proto_state_name(struct proto *p)
! 1768: {
! 1769: switch (p->proto_state)
! 1770: {
! 1771: case PS_DOWN: return p->active ? "flush" : "down";
! 1772: case PS_START: return "start";
! 1773: case PS_UP: return "up";
! 1774: case PS_STOP: return "stop";
! 1775: default: return "???";
! 1776: }
! 1777: }
! 1778:
! 1779: static void
! 1780: channel_show_stats(struct channel *c)
! 1781: {
! 1782: struct proto_stats *s = &c->stats;
! 1783:
! 1784: if (c->in_keep_filtered)
! 1785: cli_msg(-1006, " Routes: %u imported, %u filtered, %u exported, %u preferred",
! 1786: s->imp_routes, s->filt_routes, s->exp_routes, s->pref_routes);
! 1787: else
! 1788: cli_msg(-1006, " Routes: %u imported, %u exported, %u preferred",
! 1789: s->imp_routes, s->exp_routes, s->pref_routes);
! 1790:
! 1791: cli_msg(-1006, " Route change stats: received rejected filtered ignored accepted");
! 1792: cli_msg(-1006, " Import updates: %10u %10u %10u %10u %10u",
! 1793: s->imp_updates_received, s->imp_updates_invalid,
! 1794: s->imp_updates_filtered, s->imp_updates_ignored,
! 1795: s->imp_updates_accepted);
! 1796: cli_msg(-1006, " Import withdraws: %10u %10u --- %10u %10u",
! 1797: s->imp_withdraws_received, s->imp_withdraws_invalid,
! 1798: s->imp_withdraws_ignored, s->imp_withdraws_accepted);
! 1799: cli_msg(-1006, " Export updates: %10u %10u %10u --- %10u",
! 1800: s->exp_updates_received, s->exp_updates_rejected,
! 1801: s->exp_updates_filtered, s->exp_updates_accepted);
! 1802: cli_msg(-1006, " Export withdraws: %10u --- --- --- %10u",
! 1803: s->exp_withdraws_received, s->exp_withdraws_accepted);
! 1804: }
! 1805:
! 1806: void
! 1807: channel_show_limit(struct channel_limit *l, const char *dsc)
! 1808: {
! 1809: if (!l->action)
! 1810: return;
! 1811:
! 1812: cli_msg(-1006, " %-16s%d%s", dsc, l->limit, l->state ? " [HIT]" : "");
! 1813: cli_msg(-1006, " Action: %s", channel_limit_name(l));
! 1814: }
! 1815:
! 1816: void
! 1817: channel_show_info(struct channel *c)
! 1818: {
! 1819: cli_msg(-1006, " Channel %s", c->name);
! 1820: cli_msg(-1006, " State: %s", c_states[c->channel_state]);
! 1821: cli_msg(-1006, " Table: %s", c->table->name);
! 1822: cli_msg(-1006, " Preference: %d", c->preference);
! 1823: cli_msg(-1006, " Input filter: %s", filter_name(c->in_filter));
! 1824: cli_msg(-1006, " Output filter: %s", filter_name(c->out_filter));
! 1825:
! 1826: if (graceful_restart_state == GRS_ACTIVE)
! 1827: cli_msg(-1006, " GR recovery: %s%s",
! 1828: c->gr_lock ? " pending" : "",
! 1829: c->gr_wait ? " waiting" : "");
! 1830:
! 1831: channel_show_limit(&c->rx_limit, "Receive limit:");
! 1832: channel_show_limit(&c->in_limit, "Import limit:");
! 1833: channel_show_limit(&c->out_limit, "Export limit:");
! 1834:
! 1835: if (c->channel_state != CS_DOWN)
! 1836: channel_show_stats(c);
! 1837: }
! 1838:
! 1839: void
! 1840: proto_cmd_show(struct proto *p, uintptr_t verbose, int cnt)
! 1841: {
! 1842: byte buf[256], tbuf[TM_DATETIME_BUFFER_SIZE];
! 1843:
! 1844: /* First protocol - show header */
! 1845: if (!cnt)
! 1846: cli_msg(-2002, "%-10s %-10s %-10s %-6s %-12s %s",
! 1847: "Name", "Proto", "Table", "State", "Since", "Info");
! 1848:
! 1849: buf[0] = 0;
! 1850: if (p->proto->get_status)
! 1851: p->proto->get_status(p, buf);
! 1852: tm_format_time(tbuf, &config->tf_proto, p->last_state_change);
! 1853: cli_msg(-1002, "%-10s %-10s %-10s %-6s %-12s %s",
! 1854: p->name,
! 1855: p->proto->name,
! 1856: p->main_channel ? p->main_channel->table->name : "---",
! 1857: proto_state_name(p),
! 1858: tbuf,
! 1859: buf);
! 1860:
! 1861: if (verbose)
! 1862: {
! 1863: if (p->cf->dsc)
! 1864: cli_msg(-1006, " Description: %s", p->cf->dsc);
! 1865: if (p->message)
! 1866: cli_msg(-1006, " Message: %s", p->message);
! 1867: if (p->cf->router_id)
! 1868: cli_msg(-1006, " Router ID: %R", p->cf->router_id);
! 1869: if (p->vrf_set)
! 1870: cli_msg(-1006, " VRF: %s", p->vrf ? p->vrf->name : "default");
! 1871:
! 1872: if (p->proto->show_proto_info)
! 1873: p->proto->show_proto_info(p);
! 1874: else
! 1875: {
! 1876: struct channel *c;
! 1877: WALK_LIST(c, p->channels)
! 1878: channel_show_info(c);
! 1879: }
! 1880:
! 1881: cli_msg(-1006, "");
! 1882: }
! 1883: }
! 1884:
! 1885: void
! 1886: proto_cmd_disable(struct proto *p, uintptr_t arg, int cnt UNUSED)
! 1887: {
! 1888: if (p->disabled)
! 1889: {
! 1890: cli_msg(-8, "%s: already disabled", p->name);
! 1891: return;
! 1892: }
! 1893:
! 1894: log(L_INFO "Disabling protocol %s", p->name);
! 1895: p->disabled = 1;
! 1896: p->down_code = PDC_CMD_DISABLE;
! 1897: proto_set_message(p, (char *) arg, -1);
! 1898: proto_rethink_goal(p);
! 1899: cli_msg(-9, "%s: disabled", p->name);
! 1900: }
! 1901:
! 1902: void
! 1903: proto_cmd_enable(struct proto *p, uintptr_t arg, int cnt UNUSED)
! 1904: {
! 1905: if (!p->disabled)
! 1906: {
! 1907: cli_msg(-10, "%s: already enabled", p->name);
! 1908: return;
! 1909: }
! 1910:
! 1911: log(L_INFO "Enabling protocol %s", p->name);
! 1912: p->disabled = 0;
! 1913: proto_set_message(p, (char *) arg, -1);
! 1914: proto_rethink_goal(p);
! 1915: cli_msg(-11, "%s: enabled", p->name);
! 1916: }
! 1917:
! 1918: void
! 1919: proto_cmd_restart(struct proto *p, uintptr_t arg, int cnt UNUSED)
! 1920: {
! 1921: if (p->disabled)
! 1922: {
! 1923: cli_msg(-8, "%s: already disabled", p->name);
! 1924: return;
! 1925: }
! 1926:
! 1927: log(L_INFO "Restarting protocol %s", p->name);
! 1928: p->disabled = 1;
! 1929: p->down_code = PDC_CMD_RESTART;
! 1930: proto_set_message(p, (char *) arg, -1);
! 1931: proto_rethink_goal(p);
! 1932: p->disabled = 0;
! 1933: proto_rethink_goal(p);
! 1934: cli_msg(-12, "%s: restarted", p->name);
! 1935: }
! 1936:
! 1937: void
! 1938: proto_cmd_reload(struct proto *p, uintptr_t dir, int cnt UNUSED)
! 1939: {
! 1940: struct channel *c;
! 1941:
! 1942: if (p->disabled)
! 1943: {
! 1944: cli_msg(-8, "%s: already disabled", p->name);
! 1945: return;
! 1946: }
! 1947:
! 1948: /* If the protocol in not UP, it has no routes */
! 1949: if (p->proto_state != PS_UP)
! 1950: return;
! 1951:
! 1952: /* All channels must support reload */
! 1953: if (dir != CMD_RELOAD_OUT)
! 1954: WALK_LIST(c, p->channels)
! 1955: if ((c->channel_state == CS_UP) && !channel_reloadable(c))
! 1956: {
! 1957: cli_msg(-8006, "%s: reload failed", p->name);
! 1958: return;
! 1959: }
! 1960:
! 1961: log(L_INFO "Reloading protocol %s", p->name);
! 1962:
! 1963: /* re-importing routes */
! 1964: if (dir != CMD_RELOAD_OUT)
! 1965: WALK_LIST(c, p->channels)
! 1966: if (c->channel_state == CS_UP)
! 1967: channel_request_reload(c);
! 1968:
! 1969: /* re-exporting routes */
! 1970: if (dir != CMD_RELOAD_IN)
! 1971: WALK_LIST(c, p->channels)
! 1972: if (c->channel_state == CS_UP)
! 1973: channel_request_feeding(c);
! 1974:
! 1975: cli_msg(-15, "%s: reloading", p->name);
! 1976: }
! 1977:
! 1978: void
! 1979: proto_cmd_debug(struct proto *p, uintptr_t mask, int cnt UNUSED)
! 1980: {
! 1981: p->debug = mask;
! 1982: }
! 1983:
! 1984: void
! 1985: proto_cmd_mrtdump(struct proto *p, uintptr_t mask, int cnt UNUSED)
! 1986: {
! 1987: p->mrtdump = mask;
! 1988: }
! 1989:
! 1990: static void
! 1991: proto_apply_cmd_symbol(struct symbol *s, void (* cmd)(struct proto *, uintptr_t, int), uintptr_t arg)
! 1992: {
! 1993: if (s->class != SYM_PROTO)
! 1994: {
! 1995: cli_msg(9002, "%s is not a protocol", s->name);
! 1996: return;
! 1997: }
! 1998:
! 1999: cmd(s->proto->proto, arg, 0);
! 2000: cli_msg(0, "");
! 2001: }
! 2002:
! 2003: static void
! 2004: proto_apply_cmd_patt(char *patt, void (* cmd)(struct proto *, uintptr_t, int), uintptr_t arg)
! 2005: {
! 2006: struct proto *p;
! 2007: int cnt = 0;
! 2008:
! 2009: WALK_LIST(p, proto_list)
! 2010: if (!patt || patmatch(patt, p->name))
! 2011: cmd(p, arg, cnt++);
! 2012:
! 2013: if (!cnt)
! 2014: cli_msg(8003, "No protocols match");
! 2015: else
! 2016: cli_msg(0, "");
! 2017: }
! 2018:
! 2019: void
! 2020: proto_apply_cmd(struct proto_spec ps, void (* cmd)(struct proto *, uintptr_t, int),
! 2021: int restricted, uintptr_t arg)
! 2022: {
! 2023: if (restricted && cli_access_restricted())
! 2024: return;
! 2025:
! 2026: if (ps.patt)
! 2027: proto_apply_cmd_patt(ps.ptr, cmd, arg);
! 2028: else
! 2029: proto_apply_cmd_symbol(ps.ptr, cmd, arg);
! 2030: }
! 2031:
! 2032: struct proto *
! 2033: proto_get_named(struct symbol *sym, struct protocol *pr)
! 2034: {
! 2035: struct proto *p, *q;
! 2036:
! 2037: if (sym)
! 2038: {
! 2039: if (sym->class != SYM_PROTO)
! 2040: cf_error("%s: Not a protocol", sym->name);
! 2041:
! 2042: p = sym->proto->proto;
! 2043: if (!p || p->proto != pr)
! 2044: cf_error("%s: Not a %s protocol", sym->name, pr->name);
! 2045: }
! 2046: else
! 2047: {
! 2048: p = NULL;
! 2049: WALK_LIST(q, proto_list)
! 2050: if ((q->proto == pr) && (q->proto_state != PS_DOWN))
! 2051: {
! 2052: if (p)
! 2053: cf_error("There are multiple %s protocols running", pr->name);
! 2054: p = q;
! 2055: }
! 2056: if (!p)
! 2057: cf_error("There is no %s protocol running", pr->name);
! 2058: }
! 2059:
! 2060: return p;
! 2061: }
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 / bird2 / nest