// SPDX-License-Identifier: GPL-2.0-or-later /* * * Copyright 2009-2016, LabN Consulting, L.L.C. * */ /* * File: rfapi_monitor.c */ /* TBD remove unneeded includes */ #include "lib/zebra.h" #include "lib/prefix.h" #include "lib/agg_table.h" #include "lib/vty.h" #include "lib/memory.h" #include "lib/log.h" #include "lib/table.h" #include "lib/skiplist.h" #include "bgpd/bgpd.h" #include "bgpd/rfapi/bgp_rfapi_cfg.h" #include "bgpd/rfapi/rfapi.h" #include "bgpd/rfapi/rfapi_backend.h" #include "bgpd/rfapi/rfapi.h" #include "bgpd/rfapi/rfapi_import.h" #include "bgpd/rfapi/vnc_import_bgp.h" #include "bgpd/rfapi/rfapi_private.h" #include "bgpd/rfapi/rfapi_monitor.h" #include "bgpd/rfapi/rfapi_vty.h" #include "bgpd/rfapi/rfapi_rib.h" #include "bgpd/rfapi/vnc_debug.h" #define DEBUG_L2_EXTRA 0 #define DEBUG_DUP_CHECK 0 #define DEBUG_ETH_SL 0 static void rfapiMonitorTimerRestart(struct rfapi_monitor_vpn *m); static void rfapiMonitorEthTimerRestart(struct rfapi_monitor_eth *m); /* * Forward declarations */ static void rfapiMonitorEthDetachImport(struct bgp *bgp, struct rfapi_monitor_eth *mon); #if DEBUG_ETH_SL /* * Debug function, special case */ void rfapiMonitorEthSlCheck(struct agg_node *rn, const char *tag1, const char *tag2) { struct agg_node *rn_saved = NULL; static struct skiplist *sl_saved = NULL; struct skiplist *sl; if (!rn) return; if (rn_saved && (rn != rn_saved)) return; if (!rn_saved) rn_saved = rn; sl = RFAPI_MONITOR_ETH(rn); if (sl || sl_saved) { vnc_zlog_debug_verbose( "%s[%s%s]: rn=%p, rn->lock=%d, old sl=%p, new sl=%p", __func__, (tag1 ? tag1 : ""), (tag2 ? tag2 : ""), rn, rn->lock, sl_saved, sl); sl_saved = sl; } } #endif /* * Debugging function that aborts when it finds monitors whose * "next" pointer * references themselves */ void rfapiMonitorLoopCheck(struct rfapi_monitor_vpn *mchain) { struct rfapi_monitor_vpn *m; for (m = mchain; m; m = m->next) assert(m != m->next); } #if DEBUG_DUP_CHECK /* * Debugging code: see if a monitor is mentioned more than once * in a HD's monitor list */ void rfapiMonitorDupCheck(struct bgp *bgp) { struct listnode *hnode; struct rfapi_descriptor *rfd; for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) { struct agg_node *mrn; if (!rfd->mon) continue; for (mrn = agg_route_top(rfd->mon); mrn; mrn = agg_route_next(mrn)) { struct rfapi_monitor_vpn *m; for (m = (struct rfapi_monitor_vpn *)(mrn->info); m; m = m->next) m->dcount = 0; } } for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) { struct agg_node *mrn; if (!rfd->mon) continue; for (mrn = agg_route_top(rfd->mon); mrn; mrn = agg_route_next(mrn)) { struct rfapi_monitor_vpn *m; for (m = (struct rfapi_monitor_vpn *)(mrn->info); m; m = m->next) assert(++m->dcount == 1); } } } #endif /* debug */ void rfapiMonitorCleanCheck(struct bgp *bgp) { struct listnode *hnode; struct rfapi_descriptor *rfd; for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) { assert(!rfd->import_table->vpn0_queries[AFI_IP]); assert(!rfd->import_table->vpn0_queries[AFI_IP6]); struct agg_node *rn; for (rn = agg_route_top( rfd->import_table->imported_vpn[AFI_IP]); rn; rn = agg_route_next(rn)) { assert(!RFAPI_MONITOR_VPN(rn)); } for (rn = agg_route_top( rfd->import_table->imported_vpn[AFI_IP6]); rn; rn = agg_route_next(rn)) { assert(!RFAPI_MONITOR_VPN(rn)); } } } /* debug */ void rfapiMonitorCheckAttachAllowed(void) { struct bgp *bgp = bgp_get_default(); assert(!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)); } void rfapiMonitorExtraFlush(safi_t safi, struct agg_node *rn) { struct rfapi_it_extra *hie; struct rfapi_monitor_vpn *v; struct rfapi_monitor_vpn *v_next; struct rfapi_monitor_encap *e = NULL; struct rfapi_monitor_encap *e_next = NULL; if (!rn) return; if (!rn->aggregate) return; hie = (struct rfapi_it_extra *)(rn->aggregate); switch (safi) { case SAFI_ENCAP: for (e = hie->u.encap.e; e; e = e_next) { e_next = e->next; e->next = NULL; XFREE(MTYPE_RFAPI_MONITOR_ENCAP, e); agg_unlock_node(rn); } hie->u.encap.e = NULL; break; case SAFI_MPLS_VPN: for (v = hie->u.vpn.v; v; v = v_next) { v_next = v->next; v->next = NULL; XFREE(MTYPE_RFAPI_MONITOR, e); agg_unlock_node(rn); } hie->u.vpn.v = NULL; if (hie->u.vpn.e.source) { while (!skiplist_delete_first(hie->u.vpn.e.source)) { agg_unlock_node(rn); } skiplist_free(hie->u.vpn.e.source); hie->u.vpn.e.source = NULL; agg_unlock_node(rn); } if (hie->u.vpn.idx_rd) { /* looping through bpi->extra->vnc.import.rd is tbd */ while (!skiplist_delete_first(hie->u.vpn.idx_rd)) { agg_unlock_node(rn); } skiplist_free(hie->u.vpn.idx_rd); hie->u.vpn.idx_rd = NULL; agg_unlock_node(rn); } if (hie->u.vpn.mon_eth) { while (!skiplist_delete_first(hie->u.vpn.mon_eth)) { agg_unlock_node(rn); } skiplist_free(hie->u.vpn.mon_eth); hie->u.vpn.mon_eth = NULL; agg_unlock_node(rn); } break; case SAFI_UNSPEC: case SAFI_UNICAST: case SAFI_MULTICAST: case SAFI_EVPN: case SAFI_LABELED_UNICAST: case SAFI_FLOWSPEC: case SAFI_MAX: assert(0); } XFREE(MTYPE_RFAPI_IT_EXTRA, hie); rn->aggregate = NULL; agg_unlock_node(rn); } /* * If the child lists are empty, release the rfapi_it_extra struct */ void rfapiMonitorExtraPrune(safi_t safi, struct agg_node *rn) { struct rfapi_it_extra *hie; if (!rn) return; if (!rn->aggregate) return; hie = (struct rfapi_it_extra *)(rn->aggregate); switch (safi) { case SAFI_ENCAP: if (hie->u.encap.e) return; break; case SAFI_MPLS_VPN: if (hie->u.vpn.v) return; if (hie->u.vpn.mon_eth) { if (skiplist_count(hie->u.vpn.mon_eth)) return; skiplist_free(hie->u.vpn.mon_eth); hie->u.vpn.mon_eth = NULL; agg_unlock_node(rn); /* uncount skiplist */ } if (hie->u.vpn.e.source) { if (skiplist_count(hie->u.vpn.e.source)) return; skiplist_free(hie->u.vpn.e.source); hie->u.vpn.e.source = NULL; agg_unlock_node(rn); } if (hie->u.vpn.idx_rd) { if (skiplist_count(hie->u.vpn.idx_rd)) return; skiplist_free(hie->u.vpn.idx_rd); hie->u.vpn.idx_rd = NULL; agg_unlock_node(rn); } if (hie->u.vpn.mon_eth) { if (skiplist_count(hie->u.vpn.mon_eth)) return; skiplist_free(hie->u.vpn.mon_eth); hie->u.vpn.mon_eth = NULL; agg_unlock_node(rn); } break; case SAFI_UNSPEC: case SAFI_UNICAST: case SAFI_MULTICAST: case SAFI_EVPN: case SAFI_LABELED_UNICAST: case SAFI_FLOWSPEC: case SAFI_MAX: assert(0); } XFREE(MTYPE_RFAPI_IT_EXTRA, hie); rn->aggregate = NULL; agg_unlock_node(rn); } /* * returns locked node */ struct agg_node *rfapiMonitorGetAttachNode(struct rfapi_descriptor *rfd, struct prefix *p) { afi_t afi; struct agg_node *rn; if (RFAPI_0_PREFIX(p)) { assert(1); } afi = family2afi(p->family); assert(afi); /* * It's possible that even though there is a route at this node, * there are no routes with valid UN addresses (i.e,. with no * valid tunnel routes). Check for that and walk back up the * tree if necessary. * * When the outer loop completes, the matched node, if any, is * locked (i.e., its reference count has been incremented) to * account for the VPN monitor we are about to attach. * * if a monitor is moved to another node, there must be * corresponding unlock/locks */ for (rn = agg_node_match(rfd->import_table->imported_vpn[afi], p); rn;) { struct bgp_path_info *bpi; struct prefix pfx_dummy; /* TBD update this code to use new valid_interior_count */ for (bpi = rn->info; bpi; bpi = bpi->next) { /* * If there is a cached ENCAP UN address, it's a usable * VPN route */ if (bpi->extra && bpi->extra->vnc.import.un_family) { break; } /* * Or if there is a valid Encap Attribute tunnel subtlv * address, * it's a usable VPN route. */ if (!rfapiGetVncTunnelUnAddr(bpi->attr, &pfx_dummy)) { break; } } if (bpi) break; agg_unlock_node(rn); if ((rn = agg_node_parent(rn))) { agg_lock_node(rn); } } if (!rn) { struct prefix pfx_default; memset(&pfx_default, 0, sizeof(pfx_default)); pfx_default.family = p->family; /* creates default node if none exists, and increments ref count */ rn = agg_node_get(rfd->import_table->imported_vpn[afi], &pfx_default); } return rn; } /* * If this function happens to attach the monitor to a radix tree * node (as opposed to the 0-prefix list), the node pointer is * returned (for the benefit of caller which might like to use it * to generate an immediate query response). */ static struct agg_node *rfapiMonitorAttachImport(struct rfapi_descriptor *rfd, struct rfapi_monitor_vpn *m) { struct agg_node *rn; rfapiMonitorCheckAttachAllowed(); if (RFAPI_0_PREFIX(&m->p)) { /* * Add new monitor entry to vpn0 list */ afi_t afi; afi = family2afi(m->p.family); assert(afi); m->next = rfd->import_table->vpn0_queries[afi]; rfd->import_table->vpn0_queries[afi] = m; vnc_zlog_debug_verbose("%s: attached monitor %p to vpn0 list", __func__, m); return NULL; } /* * Attach new monitor entry to import table node */ rn = rfapiMonitorGetAttachNode(rfd, &m->p); /* returns locked rn */ m->node = rn; m->next = RFAPI_MONITOR_VPN(rn); RFAPI_MONITOR_VPN_W_ALLOC(rn) = m; RFAPI_CHECK_REFCOUNT(rn, SAFI_MPLS_VPN, 0); vnc_zlog_debug_verbose("%s: attached monitor %p to rn %p", __func__, m, rn); return rn; } /* * reattach monitors for this HD to import table */ void rfapiMonitorAttachImportHd(struct rfapi_descriptor *rfd) { struct agg_node *mrn; if (!rfd->mon) { /* * No monitors for this HD */ return; } for (mrn = agg_route_top(rfd->mon); mrn; mrn = agg_route_next(mrn)) { if (!mrn->info) continue; (void)rfapiMonitorAttachImport( rfd, (struct rfapi_monitor_vpn *)(mrn->info)); } } /* * Adds a monitor for a query to the NVE descriptor's list * and, if callbacks are enabled, attaches it to the import table. * * If we happened to locate the import table radix tree attachment * point, return it so the caller can use it to generate a query * response without repeating the lookup. Note that when callbacks * are disabled, this function will not perform a lookup, and the * caller will have to do its own lookup. */ struct agg_node *rfapiMonitorAdd(struct bgp *bgp, struct rfapi_descriptor *rfd, struct prefix *p) { struct rfapi_monitor_vpn *m; struct agg_node *rn; /* * Initialize nve's monitor list if needed * NB use the same radix tree for IPv4 and IPv6 targets. * The prefix will always have full-length mask (/32, /128) * or be 0/0 so they won't get mixed up. */ if (!rfd->mon) { rfd->mon = agg_table_init(); } rn = agg_node_get(rfd->mon, p); if (rn->info) { /* * received this query before, no further action needed */ rfapiMonitorTimerRestart((struct rfapi_monitor_vpn *)rn->info); agg_unlock_node(rn); return NULL; } /* * New query for this nve, record it in the HD */ rn->info = XCALLOC(MTYPE_RFAPI_MONITOR, sizeof(struct rfapi_monitor_vpn)); m = (struct rfapi_monitor_vpn *)(rn->info); m->rfd = rfd; prefix_copy(&m->p, p); ++rfd->monitor_count; ++bgp->rfapi->monitor_count; rfapiMonitorTimerRestart(m); if (bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE) { /* * callbacks turned off, so don't attach monitor to import table */ return NULL; } /* * attach to import table */ return rfapiMonitorAttachImport(rfd, m); } /* * returns monitor pointer if found, NULL if not */ static struct rfapi_monitor_vpn * rfapiMonitorDetachImport(struct rfapi_monitor_vpn *m) { struct rfapi_monitor_vpn *prev; struct rfapi_monitor_vpn *this = NULL; if (RFAPI_0_PREFIX(&m->p)) { afi_t afi; /* * 0-prefix monitors are stored in a special list and not * in the import VPN tree */ afi = family2afi(m->p.family); assert(afi); if (m->rfd->import_table) { for (prev = NULL, this = m->rfd->import_table->vpn0_queries[afi]; this; prev = this, this = this->next) { if (this == m) break; } if (this) { if (!prev) { m->rfd->import_table ->vpn0_queries[afi] = this->next; } else { prev->next = this->next; } } } } else { if (m->node) { for (prev = NULL, this = RFAPI_MONITOR_VPN(m->node); this; prev = this, this = this->next) { if (this == m) break; } if (this) { if (prev) { prev->next = this->next; } else { RFAPI_MONITOR_VPN_W_ALLOC(m->node) = this->next; } RFAPI_CHECK_REFCOUNT(m->node, SAFI_MPLS_VPN, 1); agg_unlock_node(m->node); } m->node = NULL; } } return this; } void rfapiMonitorDetachImportHd(struct rfapi_descriptor *rfd) { struct agg_node *rn; if (!rfd->mon) return; for (rn = agg_route_top(rfd->mon); rn; rn = agg_route_next(rn)) { if (rn->info) { rfapiMonitorDetachImport( (struct rfapi_monitor_vpn *)(rn->info)); } } } void rfapiMonitorDel(struct bgp *bgp, struct rfapi_descriptor *rfd, struct prefix *p) { struct agg_node *rn; struct rfapi_monitor_vpn *m; assert(rfd->mon); rn = agg_node_get(rfd->mon, p); /* locks node */ m = rn->info; assert(m); /* * remove from import table */ if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) { rfapiMonitorDetachImport(m); } EVENT_OFF(m->timer); /* * remove from rfd list */ XFREE(MTYPE_RFAPI_MONITOR, m); rn->info = NULL; agg_unlock_node(rn); /* undo original lock when created */ agg_unlock_node(rn); /* undo lock in agg_node_get */ --rfd->monitor_count; --bgp->rfapi->monitor_count; } /* * returns count of monitors deleted */ int rfapiMonitorDelHd(struct rfapi_descriptor *rfd) { struct agg_node *rn; struct bgp *bgp; int count = 0; vnc_zlog_debug_verbose("%s: entry rfd=%p", __func__, rfd); bgp = bgp_get_default(); if (rfd->mon) { for (rn = agg_route_top(rfd->mon); rn; rn = agg_route_next(rn)) { struct rfapi_monitor_vpn *m; if ((m = rn->info)) { if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) { rfapiMonitorDetachImport(m); } EVENT_OFF(m->timer); XFREE(MTYPE_RFAPI_MONITOR, m); rn->info = NULL; agg_unlock_node(rn); /* undo original lock when created */ ++count; --rfd->monitor_count; --bgp->rfapi->monitor_count; } } agg_table_finish(rfd->mon); rfd->mon = NULL; } if (rfd->mon_eth) { struct rfapi_monitor_eth *mon_eth; while (!skiplist_first(rfd->mon_eth, NULL, (void **)&mon_eth)) { int rc; if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) { rfapiMonitorEthDetachImport(bgp, mon_eth); } else { #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: callbacks disabled, not attempting to detach mon_eth %p", __func__, mon_eth); #endif } EVENT_OFF(mon_eth->timer); /* * remove from rfd list */ rc = skiplist_delete(rfd->mon_eth, mon_eth, mon_eth); assert(!rc); vnc_zlog_debug_verbose("%s: freeing mon_eth %p", __func__, mon_eth); XFREE(MTYPE_RFAPI_MONITOR_ETH, mon_eth); ++count; --rfd->monitor_count; --bgp->rfapi->monitor_count; } skiplist_free(rfd->mon_eth); rfd->mon_eth = NULL; } return count; } void rfapiMonitorResponseRemovalOff(struct bgp *bgp) { if (bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE) { return; } bgp->rfapi_cfg->flags |= BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE; } void rfapiMonitorResponseRemovalOn(struct bgp *bgp) { if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE)) { return; } bgp->rfapi_cfg->flags &= ~BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE; } static void rfapiMonitorTimerExpire(struct event *t) { struct rfapi_monitor_vpn *m = EVENT_ARG(t); /* forget reference to thread, it's gone */ m->timer = NULL; /* delete the monitor */ rfapiMonitorDel(bgp_get_default(), m->rfd, &m->p); } static void rfapiMonitorTimerRestart(struct rfapi_monitor_vpn *m) { unsigned long remain = event_timer_remain_second(m->timer); /* unexpected case, but avoid wraparound problems below */ if (remain > m->rfd->response_lifetime) return; /* don't restart if we just restarted recently */ if (m->rfd->response_lifetime - remain < 2) return; EVENT_OFF(m->timer); { char buf[BUFSIZ]; vnc_zlog_debug_verbose( "%s: target %s life %u", __func__, rfapi_ntop(m->p.family, m->p.u.val, buf, BUFSIZ), m->rfd->response_lifetime); } event_add_timer(bm->master, rfapiMonitorTimerExpire, m, m->rfd->response_lifetime, &m->timer); } /* * called when an updated response is sent to the NVE. Per * ticket 255, restart timers for any monitors that could have * been responsible for the response, i.e., any monitors for * the exact prefix or a parent of it. */ void rfapiMonitorTimersRestart(struct rfapi_descriptor *rfd, const struct prefix *p) { struct agg_node *rn; if (AF_ETHERNET == p->family) { struct rfapi_monitor_eth *mon_eth; int rc; void *cursor; /* * XXX match any LNI */ for (cursor = NULL, rc = skiplist_next(rfd->mon_eth, NULL, (void **)&mon_eth, &cursor); rc == 0; rc = skiplist_next(rfd->mon_eth, NULL, (void **)&mon_eth, &cursor)) { if (!memcmp(mon_eth->macaddr.octet, p->u.prefix_eth.octet, ETH_ALEN)) { rfapiMonitorEthTimerRestart(mon_eth); } } } else { for (rn = agg_route_top(rfd->mon); rn; rn = agg_route_next(rn)) { struct rfapi_monitor_vpn *m; const struct prefix *p_node; if (!((m = rn->info))) continue; p_node = agg_node_get_prefix(m->node); /* NB order of test is significant ! */ if (!m->node || prefix_match(p_node, p)) { rfapiMonitorTimerRestart(m); } } } } /* * Find monitors at this node and all its parents. Call * rfapiRibUpdatePendingNode with this node and all corresponding NVEs. */ void rfapiMonitorItNodeChanged( struct rfapi_import_table *import_table, struct agg_node *it_node, struct rfapi_monitor_vpn *monitor_list) /* for base it node, NULL=all */ { struct skiplist *nves_seen; struct agg_node *rn = it_node; struct bgp *bgp = bgp_get_default(); const struct prefix *p = agg_node_get_prefix(rn); afi_t afi = family2afi(p->family); assert(bgp); assert(import_table); nves_seen = skiplist_new(0, NULL, NULL); #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: it=%p, it_node=%p, it_node->prefix=%pFX", __func__, import_table, it_node, &it_node->p); #endif if (AFI_L2VPN == afi) { struct rfapi_monitor_eth *m; struct skiplist *sl; void *cursor; int rc; if ((sl = RFAPI_MONITOR_ETH(rn))) { for (cursor = NULL, rc = skiplist_next(sl, NULL, (void **)&m, &cursor); !rc; rc = skiplist_next(sl, NULL, (void **)&m, &cursor)) { if (skiplist_search(nves_seen, m->rfd, NULL)) { /* * Haven't done this NVE yet. Add to * "seen" list. */ assert(!skiplist_insert(nves_seen, m->rfd, NULL)); /* * update its RIB */ rfapiRibUpdatePendingNode( bgp, m->rfd, import_table, it_node, m->rfd->response_lifetime); } } } } else { struct rfapi_monitor_vpn *m; if (monitor_list) { m = monitor_list; } else { m = RFAPI_MONITOR_VPN(rn); } do { /* * If we have reached the root node (parent==NULL) and * there * are no routes here (info==NULL), and the IT node that * changed was not the root node (it_node->parent != * NULL), * then any monitors at this node are here because they * had * no match at all. Therefore, do not send route updates * to them * because we haven't sent them an initial route. */ if (!agg_node_parent(rn) && !rn->info && it_node->parent) break; for (; m; m = m->next) { if (RFAPI_0_PREFIX(&m->p)) { /* shouldn't happen, but be safe */ continue; } if (skiplist_search(nves_seen, m->rfd, NULL)) { /* * Haven't done this NVE yet. Add to * "seen" list. */ assert(!skiplist_insert(nves_seen, m->rfd, NULL)); vnc_zlog_debug_verbose( "%s: update rfd %p attached to pfx %pRN (targ=%pFX)", __func__, m->rfd, m->node, &m->p); /* * update its RIB */ rfapiRibUpdatePendingNode( bgp, m->rfd, import_table, it_node, m->rfd->response_lifetime); } } rn = agg_node_parent(rn); if (rn) m = RFAPI_MONITOR_VPN(rn); } while (rn); } /* * All-routes L2 monitors */ if (AFI_L2VPN == afi) { struct rfapi_monitor_eth *e; #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: checking L2 all-routes monitors", __func__); #endif for (e = import_table->eth0_queries; e; e = e->next) { #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: checking eth0 mon=%p", __func__, e); #endif if (skiplist_search(nves_seen, e->rfd, NULL)) { /* * Haven't done this NVE yet. Add to "seen" * list. */ assert(!skiplist_insert(nves_seen, e->rfd, NULL)); /* * update its RIB */ #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: found L2 all-routes monitor %p", __func__, e); #endif rfapiRibUpdatePendingNode( bgp, e->rfd, import_table, it_node, e->rfd->response_lifetime); } } } else { struct rfapi_monitor_vpn *m; /* * All-routes IPv4. IPv6 monitors */ for (m = import_table->vpn0_queries[afi]; m; m = m->next) { if (skiplist_search(nves_seen, m->rfd, NULL)) { /* * Haven't done this NVE yet. Add to "seen" * list. */ assert(!skiplist_insert(nves_seen, m->rfd, NULL)); /* * update its RIB */ rfapiRibUpdatePendingNode( bgp, m->rfd, import_table, it_node, m->rfd->response_lifetime); } } } skiplist_free(nves_seen); } /* * For the listed monitors, update new node and its subtree, but * omit old node and its subtree */ void rfapiMonitorMovedUp(struct rfapi_import_table *import_table, struct agg_node *old_node, struct agg_node *new_node, struct rfapi_monitor_vpn *monitor_list) { struct bgp *bgp = bgp_get_default(); struct rfapi_monitor_vpn *m; assert(new_node); assert(old_node); assert(new_node != old_node); /* * If new node is 0/0 and there is no route there, don't * generate an update because it will not contain any * routes including the target. */ if (!new_node->parent && !new_node->info) { vnc_zlog_debug_verbose( "%s: new monitor at 0/0 and no routes, no updates", __func__); return; } for (m = monitor_list; m; m = m->next) { rfapiRibUpdatePendingNode(bgp, m->rfd, import_table, new_node, m->rfd->response_lifetime); rfapiRibUpdatePendingNodeSubtree(bgp, m->rfd, import_table, new_node, old_node, m->rfd->response_lifetime); } } static void rfapiMonitorEthTimerExpire(struct event *t) { struct rfapi_monitor_eth *m = EVENT_ARG(t); /* forget reference to thread, it's gone */ m->timer = NULL; /* delete the monitor */ rfapiMonitorEthDel(bgp_get_default(), m->rfd, &m->macaddr, m->logical_net_id); } static void rfapiMonitorEthTimerRestart(struct rfapi_monitor_eth *m) { unsigned long remain = event_timer_remain_second(m->timer); /* unexpected case, but avoid wraparound problems below */ if (remain > m->rfd->response_lifetime) return; /* don't restart if we just restarted recently */ if (m->rfd->response_lifetime - remain < 2) return; EVENT_OFF(m->timer); { char buf[BUFSIZ]; vnc_zlog_debug_verbose( "%s: target %s life %u", __func__, rfapiEthAddr2Str(&m->macaddr, buf, BUFSIZ), m->rfd->response_lifetime); } event_add_timer(bm->master, rfapiMonitorEthTimerExpire, m, m->rfd->response_lifetime, &m->timer); } static int mon_eth_cmp(const void *a, const void *b) { const struct rfapi_monitor_eth *m1; const struct rfapi_monitor_eth *m2; int i; m1 = (struct rfapi_monitor_eth *)a; m2 = (struct rfapi_monitor_eth *)b; /* * compare ethernet addresses */ for (i = 0; i < ETH_ALEN; ++i) { if (m1->macaddr.octet[i] != m2->macaddr.octet[i]) return (m1->macaddr.octet[i] - m2->macaddr.octet[i]); } /* * compare LNIs */ return (m1->logical_net_id - m2->logical_net_id); } static void rfapiMonitorEthAttachImport( struct rfapi_import_table *it, struct agg_node *rn, /* it node attach point if non-0 */ struct rfapi_monitor_eth *mon) /* monitor struct to attach */ { struct skiplist *sl; int rc; vnc_zlog_debug_verbose("%s: it=%p", __func__, it); rfapiMonitorCheckAttachAllowed(); if (RFAPI_0_ETHERADDR(&mon->macaddr)) { /* * These go on a different list */ mon->next = it->eth0_queries; it->eth0_queries = mon; #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: attached monitor %p to eth0 list", __func__, mon); #endif return; } if (rn == NULL) { #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: rn is null!", __func__); #endif return; } /* * Get sl to attach to */ sl = RFAPI_MONITOR_ETH_W_ALLOC(rn); if (!sl) { sl = RFAPI_MONITOR_ETH_W_ALLOC(rn) = skiplist_new(0, NULL, NULL); agg_lock_node(rn); /* count skiplist mon_eth */ } #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: rn=%p, rn->lock=%d, sl=%p, attaching eth mon %p", __func__, rn, rn->lock, sl, mon); #endif rc = skiplist_insert(sl, (void *)mon, (void *)mon); assert(!rc); /* count eth monitor */ agg_lock_node(rn); } /* * reattach monitors for this HD to import table */ static void rfapiMonitorEthAttachImportHd(struct bgp *bgp, struct rfapi_descriptor *rfd) { void *cursor; struct rfapi_monitor_eth *mon; int rc; if (!rfd->mon_eth) { /* * No monitors for this HD */ return; } for (cursor = NULL, rc = skiplist_next(rfd->mon_eth, NULL, (void **)&mon, &cursor); rc == 0; rc = skiplist_next(rfd->mon_eth, NULL, (void **)&mon, &cursor)) { struct rfapi_import_table *it; struct prefix pfx_mac_buf; struct agg_node *rn; it = rfapiMacImportTableGet(bgp, mon->logical_net_id); assert(it); memset((void *)&pfx_mac_buf, 0, sizeof(struct prefix)); pfx_mac_buf.family = AF_ETHERNET; pfx_mac_buf.prefixlen = 48; pfx_mac_buf.u.prefix_eth = mon->macaddr; rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf); assert(rn); (void)rfapiMonitorEthAttachImport(it, rn, mon); } } static void rfapiMonitorEthDetachImport( struct bgp *bgp, struct rfapi_monitor_eth *mon) /* monitor struct to detach */ { struct rfapi_import_table *it; struct prefix pfx_mac_buf; struct skiplist *sl; struct agg_node *rn; int rc; it = rfapiMacImportTableGet(bgp, mon->logical_net_id); assert(it); if (RFAPI_0_ETHERADDR(&mon->macaddr)) { struct rfapi_monitor_eth *prev; struct rfapi_monitor_eth *this = NULL; for (prev = NULL, this = it->eth0_queries; this; prev = this, this = this->next) { if (this == mon) break; } if (this) { if (!prev) { it->eth0_queries = this->next; } else { prev->next = this->next; } } #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: it=%p, LNI=%d, detached eth0 mon %p", __func__, it, mon->logical_net_id, mon); #endif return; } memset((void *)&pfx_mac_buf, 0, sizeof(struct prefix)); pfx_mac_buf.family = AF_ETHERNET; pfx_mac_buf.prefixlen = 48; pfx_mac_buf.u.prefix_eth = mon->macaddr; rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf); assert(rn); /* * Get sl to detach from */ sl = RFAPI_MONITOR_ETH(rn); #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: it=%p, rn=%p, rn->lock=%d, sl=%p, pfx=%pFX, LNI=%d, detaching eth mon %p", __func__, it, rn, rn->lock, sl, agg_node_get_prefix(rn), mon->logical_net_id, mon); #endif assert(sl); rc = skiplist_delete(sl, (void *)mon, (void *)mon); assert(!rc); /* uncount eth monitor */ agg_unlock_node(rn); } struct agg_node *rfapiMonitorEthAdd(struct bgp *bgp, struct rfapi_descriptor *rfd, struct ethaddr *macaddr, uint32_t logical_net_id) { int rc; struct rfapi_monitor_eth mon_buf; struct rfapi_monitor_eth *val; struct rfapi_import_table *it; struct agg_node *rn = NULL; struct prefix pfx_mac_buf; if (!rfd->mon_eth) { rfd->mon_eth = skiplist_new(0, mon_eth_cmp, NULL); } it = rfapiMacImportTableGet(bgp, logical_net_id); assert(it); /* * Get route node in import table. Here is where we attach the * monitor. * * Look it up now because we return it to caller regardless of * whether we create a new monitor or not. */ memset((void *)&pfx_mac_buf, 0, sizeof(struct prefix)); pfx_mac_buf.family = AF_ETHERNET; pfx_mac_buf.prefixlen = 48; pfx_mac_buf.u.prefix_eth = *macaddr; if (!RFAPI_0_ETHERADDR(macaddr)) { rn = agg_node_get(it->imported_vpn[AFI_L2VPN], &pfx_mac_buf); assert(rn); } memset((void *)&mon_buf, 0, sizeof(mon_buf)); mon_buf.rfd = rfd; mon_buf.macaddr = *macaddr; mon_buf.logical_net_id = logical_net_id; { char buf[BUFSIZ]; vnc_zlog_debug_verbose( "%s: LNI=%d: rfd=%p, pfx=%s", __func__, logical_net_id, rfd, rfapi_ntop(pfx_mac_buf.family, pfx_mac_buf.u.val, buf, BUFSIZ)); } /* * look up query */ rc = skiplist_search(rfd->mon_eth, (void *)&mon_buf, (void **)&val); if (!rc) { /* * Found monitor - we have seen this query before * restart timer */ vnc_zlog_debug_verbose( "%s: already present in rfd->mon_eth, not adding", __func__); rfapiMonitorEthTimerRestart(val); return rn; } /* * New query */ val = XCALLOC(MTYPE_RFAPI_MONITOR_ETH, sizeof(struct rfapi_monitor_eth)); assert(val); *val = mon_buf; ++rfd->monitor_count; ++bgp->rfapi->monitor_count; rc = skiplist_insert(rfd->mon_eth, val, val); #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: inserted rfd=%p mon_eth=%p, rc=%d", __func__, rfd, val, rc); #else (void)rc; #endif /* * start timer */ rfapiMonitorEthTimerRestart(val); if (bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE) { /* * callbacks turned off, so don't attach monitor to import table */ #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose( "%s: callbacks turned off, not attaching mon_eth %p to import table", __func__, val); #endif return rn; } /* * attach to import table */ rfapiMonitorEthAttachImport(it, rn, val); return rn; } void rfapiMonitorEthDel(struct bgp *bgp, struct rfapi_descriptor *rfd, struct ethaddr *macaddr, uint32_t logical_net_id) { struct rfapi_monitor_eth *val; struct rfapi_monitor_eth mon_buf; int rc; vnc_zlog_debug_verbose("%s: entry rfd=%p", __func__, rfd); assert(rfd->mon_eth); memset((void *)&mon_buf, 0, sizeof(mon_buf)); mon_buf.macaddr = *macaddr; mon_buf.logical_net_id = logical_net_id; rc = skiplist_search(rfd->mon_eth, (void *)&mon_buf, (void **)&val); assert(!rc); /* * remove from import table */ if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) { rfapiMonitorEthDetachImport(bgp, val); } EVENT_OFF(val->timer); /* * remove from rfd list */ rc = skiplist_delete(rfd->mon_eth, val, val); assert(!rc); #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: freeing mon_eth %p", __func__, val); #endif XFREE(MTYPE_RFAPI_MONITOR_ETH, val); --rfd->monitor_count; --bgp->rfapi->monitor_count; } void rfapiMonitorCallbacksOff(struct bgp *bgp) { struct rfapi_import_table *it; afi_t afi; struct agg_table *rt; struct agg_node *rn; void *cursor; int rc; struct rfapi *h = bgp->rfapi; if (bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE) { /* * Already off. */ return; } bgp->rfapi_cfg->flags |= BGP_VNC_CONFIG_CALLBACK_DISABLE; #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: turned off callbacks", __func__); #endif if (h == NULL) return; /* * detach monitors from import VPN tables. The monitors * will still be linked in per-nve monitor lists. */ for (it = h->imports; it; it = it->next) { for (afi = AFI_IP; afi < AFI_MAX; ++afi) { struct rfapi_monitor_vpn *m; struct rfapi_monitor_vpn *next; rt = it->imported_vpn[afi]; for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) { m = RFAPI_MONITOR_VPN(rn); if (RFAPI_MONITOR_VPN(rn)) RFAPI_MONITOR_VPN_W_ALLOC(rn) = NULL; for (; m; m = next) { next = m->next; m->next = NULL; /* gratuitous safeness */ m->node = NULL; agg_unlock_node(rn); /* uncount */ } } for (m = it->vpn0_queries[afi]; m; m = next) { next = m->next; m->next = NULL; /* gratuitous safeness */ m->node = NULL; } it->vpn0_queries[afi] = NULL; /* detach first monitor */ } } /* * detach monitors from import Eth tables. The monitors * will still be linked in per-nve monitor lists. */ /* * Loop over ethernet import tables */ for (cursor = NULL, rc = skiplist_next(h->import_mac, NULL, (void **)&it, &cursor); !rc; rc = skiplist_next(h->import_mac, NULL, (void **)&it, &cursor)) { struct rfapi_monitor_eth *e; struct rfapi_monitor_eth *enext; /* * The actual route table */ rt = it->imported_vpn[AFI_L2VPN]; /* * Find non-0 monitors (i.e., actual addresses, not FTD * monitors) */ for (rn = agg_route_top(rt); rn; rn = agg_route_next(rn)) { struct skiplist *sl; sl = RFAPI_MONITOR_ETH(rn); while (!skiplist_delete_first(sl)) { agg_unlock_node(rn); /* uncount monitor */ } } /* * Find 0-monitors (FTD queries) */ for (e = it->eth0_queries; e; e = enext) { #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: detaching eth0 mon %p", __func__, e); #endif enext = e->next; e->next = NULL; /* gratuitous safeness */ } it->eth0_queries = NULL; /* detach first monitor */ } } void rfapiMonitorCallbacksOn(struct bgp *bgp) { struct listnode *hnode; struct rfapi_descriptor *rfd; if (!(bgp->rfapi_cfg->flags & BGP_VNC_CONFIG_CALLBACK_DISABLE)) { /* * Already on. It's important that we don't try to reattach * monitors that are already attached because, in the interest * of performance, there is no checking at the lower level * whether a monitor is already attached. It leads to * corrupted chains (e.g., looped pointers) */ return; } bgp->rfapi_cfg->flags &= ~BGP_VNC_CONFIG_CALLBACK_DISABLE; #if DEBUG_L2_EXTRA vnc_zlog_debug_verbose("%s: turned on callbacks", __func__); #endif if (bgp->rfapi == NULL) return; /* * reattach monitors */ for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, hnode, rfd)) { rfapiMonitorAttachImportHd(rfd); rfapiMonitorEthAttachImportHd(bgp, rfd); } }