pimd: Make msdp `struct pim_instance *` aware

Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>

diff --git a/pimd/pim_cmd.c b/pimd/pim_cmd.c
index c25907c81f0c86b0278ed88b9eb7d75b17f546c1..a65e4a41598b9cadfb6d5e5e79cf91d1a14cb6b5 100644 (file)
--- a/pimd/pim_cmd.c
+++ b/pimd/pim_cmd.c
@@ -6526,7 +6526,7 @@ static int ip_msdp_peer_cmd_worker(struct vty *vty, const char *peer,
                return CMD_WARNING_CONFIG_FAILED;
        }
 
-       result = pim_msdp_peer_add(peer_addr, local_addr, "default",
+       result = pim_msdp_peer_add(pimg, peer_addr, local_addr, "default",
                                   NULL /* mp_p */);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
@@ -6572,7 +6572,7 @@ static int ip_no_msdp_peer_cmd_worker(struct vty *vty, const char *peer)
                return CMD_WARNING_CONFIG_FAILED;
        }
 
-       result = pim_msdp_peer_del(peer_addr);
+       result = pim_msdp_peer_del(pimg, peer_addr);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;
@@ -6611,7 +6611,7 @@ static int ip_msdp_mesh_group_member_cmd_worker(struct vty *vty, const char *mg,
                return CMD_WARNING_CONFIG_FAILED;
        }
 
-       result = pim_msdp_mg_mbr_add(mg, mbr_ip);
+       result = pim_msdp_mg_mbr_add(pimg, mg, mbr_ip);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;
@@ -6659,7 +6659,7 @@ static int ip_no_msdp_mesh_group_member_cmd_worker(struct vty *vty,
                return CMD_WARNING_CONFIG_FAILED;
        }
 
-       result = pim_msdp_mg_mbr_del(mg, mbr_ip);
+       result = pim_msdp_mg_mbr_del(pimg, mg, mbr_ip);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;
@@ -6703,7 +6703,7 @@ static int ip_msdp_mesh_group_source_cmd_worker(struct vty *vty, const char *mg,
                return CMD_WARNING_CONFIG_FAILED;
        }
 
-       result = pim_msdp_mg_src_add(mg, src_ip);
+       result = pim_msdp_mg_src_add(pimg, mg, src_ip);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;
@@ -6740,7 +6740,7 @@ static int ip_no_msdp_mesh_group_source_cmd_worker(struct vty *vty,
 {
        enum pim_msdp_err result;
 
-       result = pim_msdp_mg_src_del(mg);
+       result = pim_msdp_mg_src_del(pimg, mg);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;
@@ -6758,7 +6758,7 @@ static int ip_no_msdp_mesh_group_cmd_worker(struct vty *vty, const char *mg)
 {
        enum pim_msdp_err result;
 
-       result = pim_msdp_mg_del(mg);
+       result = pim_msdp_mg_del(pimg, mg);
        switch (result) {
        case PIM_MSDP_ERR_NONE:
                break;

diff --git a/pimd/pim_msdp.c b/pimd/pim_msdp.c
index 07b8e04abcc9ce5869afec36ac6c3d1eb9219b53..63ead7817ec95b1c3fec25c13ed031e304bc3ca8 100644 (file)
--- a/pimd/pim_msdp.c
+++ b/pimd/pim_msdp.c
@@ -37,6 +37,7 @@
 #include "pim_str.h"
 #include "pim_time.h"
 #include "pim_upstream.h"
+#include "pim_oil.h"
 
 #include "pim_msdp.h"
 #include "pim_msdp_packet.h"
@@ -50,8 +51,8 @@ static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start);
 static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp,
                                           bool start);
 static void pim_msdp_peer_free(struct pim_msdp_peer *mp);
-static void pim_msdp_enable(void);
-static void pim_msdp_sa_adv_timer_setup(bool start);
+static void pim_msdp_enable(struct pim_instance *pim);
+static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start);
 static void pim_msdp_sa_deref(struct pim_msdp_sa *sa,
                              enum pim_msdp_sa_flags flags);
 static int pim_msdp_mg_mbr_comp(const void *p1, const void *p2);
@@ -69,21 +70,23 @@ static void pim_msdp_sa_timer_expiry_log(struct pim_msdp_sa *sa,
 /* RFC-3618:Sec-5.1 - global active source advertisement timer */
 static int pim_msdp_sa_adv_timer_cb(struct thread *t)
 {
+       struct pim_instance *pim = THREAD_ARG(t);
+
        if (PIM_DEBUG_MSDP_EVENTS) {
                zlog_debug("MSDP SA advertisment timer expired");
        }
 
-       pim_msdp_sa_adv_timer_setup(true /* start */);
-       pim_msdp_pkt_sa_tx();
+       pim_msdp_sa_adv_timer_setup(pim, true /* start */);
+       pim_msdp_pkt_sa_tx(pim);
        return 0;
 }
-static void pim_msdp_sa_adv_timer_setup(bool start)
+static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start)
 {
-       THREAD_OFF(pimg->msdp.sa_adv_timer);
+       THREAD_OFF(pim->msdp.sa_adv_timer);
        if (start) {
-               thread_add_timer(pimg->msdp.master, pim_msdp_sa_adv_timer_cb,
-                                NULL, PIM_MSDP_SA_ADVERTISMENT_TIME,
-                                &pimg->msdp.sa_adv_timer);
+               thread_add_timer(pim->msdp.master, pim_msdp_sa_adv_timer_cb,
+                                pim, PIM_MSDP_SA_ADVERTISMENT_TIME,
+                                &pim->msdp.sa_adv_timer);
        }
 }
 
@@ -105,9 +108,9 @@ static void pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
 {
        THREAD_OFF(sa->sa_state_timer);
        if (start) {
-               thread_add_timer(pimg->msdp.master, pim_msdp_sa_state_timer_cb,
-                                sa, PIM_MSDP_SA_HOLD_TIME,
-                                &sa->sa_state_timer);
+               thread_add_timer(sa->pim->msdp.master,
+                                pim_msdp_sa_state_timer_cb, sa,
+                                PIM_MSDP_SA_HOLD_TIME, &sa->sa_state_timer);
        }
 }
 
@@ -122,7 +125,7 @@ static void pim_msdp_sa_upstream_del(struct pim_msdp_sa *sa)
        if (PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(up->flags)) {
                PIM_UPSTREAM_FLAG_UNSET_SRC_MSDP(up->flags);
                sa->flags |= PIM_MSDP_SAF_UP_DEL_IN_PROG;
-               pim_upstream_del(pimg, up, __PRETTY_FUNCTION__);
+               pim_upstream_del(sa->pim, up, __PRETTY_FUNCTION__);
                sa->flags &= ~PIM_MSDP_SAF_UP_DEL_IN_PROG;
        }
 
@@ -139,7 +142,7 @@ static bool pim_msdp_sa_upstream_add_ok(struct pim_msdp_sa *sa,
                return false;
        }
        /* check if we are RP */
-       if (!I_am_RP(pimg, sa->sg.grp)) {
+       if (!I_am_RP(sa->pim, sa->sg.grp)) {
                return false;
        }
 
@@ -150,7 +153,7 @@ static bool pim_msdp_sa_upstream_add_ok(struct pim_msdp_sa *sa,
                memset(&sg, 0, sizeof(sg));
                sg.grp = sa->sg.grp;
 
-               xg_up = pim_upstream_find(pimg, &sg);
+               xg_up = pim_upstream_find(sa->pim, &sg);
        }
        if (!xg_up || (xg_up->join_state != PIM_UPSTREAM_JOINED)) {
                /* join desired will be true for such (*, G) entries so we will
@@ -187,7 +190,7 @@ static void pim_msdp_sa_upstream_update(struct pim_msdp_sa *sa,
                return;
        }
 
-       up = pim_upstream_find(pimg, &sa->sg);
+       up = pim_upstream_find(sa->pim, &sa->sg);
        if (up && (PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(up->flags))) {
                /* somehow we lost track of the upstream ptr? best log it */
                sa->up = up;
@@ -207,7 +210,7 @@ static void pim_msdp_sa_upstream_update(struct pim_msdp_sa *sa,
        sa->up = up;
        if (up) {
                /* update inherited oil */
-               pim_upstream_inherited_olist(pimg, up);
+               pim_upstream_inherited_olist(sa->pim, up);
                /* should we also start the kat in parallel? we will need it
                 * when the
                 * SA ages out */
@@ -228,7 +231,8 @@ static void pim_msdp_sa_free(struct pim_msdp_sa *sa)
        XFREE(MTYPE_PIM_MSDP_SA, sa);
 }
 
-static struct pim_msdp_sa *pim_msdp_sa_new(struct prefix_sg *sg,
+static struct pim_msdp_sa *pim_msdp_sa_new(struct pim_instance *pim,
+                                          struct prefix_sg *sg,
                                           struct in_addr rp)
 {
        struct pim_msdp_sa *sa;
@@ -240,19 +244,20 @@ static struct pim_msdp_sa *pim_msdp_sa_new(struct prefix_sg *sg,
                return NULL;
        }
 
+       sa->pim = pim;
        sa->sg = *sg;
        pim_str_sg_set(sg, sa->sg_str);
        sa->rp = rp;
        sa->uptime = pim_time_monotonic_sec();
 
        /* insert into misc tables for easy access */
-       sa = hash_get(pimg->msdp.sa_hash, sa, hash_alloc_intern);
+       sa = hash_get(pim->msdp.sa_hash, sa, hash_alloc_intern);
        if (!sa) {
                zlog_err("%s: PIM hash get failure", __PRETTY_FUNCTION__);
                pim_msdp_sa_free(sa);
                return NULL;
        }
-       listnode_add_sort(pimg->msdp.sa_list, sa);
+       listnode_add_sort(pim->msdp.sa_list, sa);
 
        if (PIM_DEBUG_MSDP_EVENTS) {
                zlog_debug("MSDP SA %s created", sa->sg_str);
@@ -261,25 +266,27 @@ static struct pim_msdp_sa *pim_msdp_sa_new(struct prefix_sg *sg,
        return sa;
 }
 
-static struct pim_msdp_sa *pim_msdp_sa_find(struct prefix_sg *sg)
+static struct pim_msdp_sa *pim_msdp_sa_find(struct pim_instance *pim,
+                                           struct prefix_sg *sg)
 {
        struct pim_msdp_sa lookup;
 
        lookup.sg = *sg;
-       return hash_lookup(pimg->msdp.sa_hash, &lookup);
+       return hash_lookup(pim->msdp.sa_hash, &lookup);
 }
 
-static struct pim_msdp_sa *pim_msdp_sa_add(struct prefix_sg *sg,
+static struct pim_msdp_sa *pim_msdp_sa_add(struct pim_instance *pim,
+                                          struct prefix_sg *sg,
                                           struct in_addr rp)
 {
        struct pim_msdp_sa *sa;
 
-       sa = pim_msdp_sa_find(sg);
+       sa = pim_msdp_sa_find(pim, sg);
        if (sa) {
                return sa;
        }
 
-       return pim_msdp_sa_new(sg, rp);
+       return pim_msdp_sa_new(pim, sg, rp);
 }
 
 static void pim_msdp_sa_del(struct pim_msdp_sa *sa)
@@ -292,8 +299,8 @@ static void pim_msdp_sa_del(struct pim_msdp_sa *sa)
        pim_msdp_sa_state_timer_setup(sa, false /* start */);
 
        /* remove the entry from various tables */
-       listnode_delete(pimg->msdp.sa_list, sa);
-       hash_release(pimg->msdp.sa_hash, sa);
+       listnode_delete(sa->pim->msdp.sa_list, sa);
+       hash_release(sa->pim->msdp.sa_hash, sa);
 
        if (PIM_DEBUG_MSDP_EVENTS) {
                zlog_debug("MSDP SA %s deleted", sa->sg_str);
@@ -316,7 +323,7 @@ static void pim_msdp_sa_peer_ip_set(struct pim_msdp_sa *sa,
 
        /* any time the peer ip changes also update the rp address */
        if (PIM_INADDR_ISNOT_ANY(sa->peer)) {
-               old_mp = pim_msdp_peer_find(sa->peer);
+               old_mp = pim_msdp_peer_find(sa->pim, sa->peer);
                if (old_mp && old_mp->sa_cnt) {
                        --old_mp->sa_cnt;
                }
@@ -350,8 +357,8 @@ static void pim_msdp_sa_deref(struct pim_msdp_sa *sa,
                                zlog_debug("MSDP SA %s local reference removed",
                                           sa->sg_str);
                        }
-                       if (pimg->msdp.local_cnt)
-                               --pimg->msdp.local_cnt;
+                       if (sa->pim->msdp.local_cnt)
+                               --sa->pim->msdp.local_cnt;
                }
        }
 
@@ -383,12 +390,12 @@ static void pim_msdp_sa_deref(struct pim_msdp_sa *sa,
        }
 }
 
-void pim_msdp_sa_ref(struct pim_msdp_peer *mp, struct prefix_sg *sg,
-                    struct in_addr rp)
+void pim_msdp_sa_ref(struct pim_instance *pim, struct pim_msdp_peer *mp,
+                    struct prefix_sg *sg, struct in_addr rp)
 {
        struct pim_msdp_sa *sa;
 
-       sa = pim_msdp_sa_add(sg, rp);
+       sa = pim_msdp_sa_add(pim, sg, rp);
        if (!sa) {
                return;
        }
@@ -413,7 +420,7 @@ void pim_msdp_sa_ref(struct pim_msdp_peer *mp, struct prefix_sg *sg,
        } else {
                if (!(sa->flags & PIM_MSDP_SAF_LOCAL)) {
                        sa->flags |= PIM_MSDP_SAF_LOCAL;
-                       ++pimg->msdp.local_cnt;
+                       ++sa->pim->msdp.local_cnt;
                        if (PIM_DEBUG_MSDP_EVENTS) {
                                zlog_debug("MSDP SA %s added locally",
                                           sa->sg_str);
@@ -439,7 +446,9 @@ void pim_msdp_sa_ref(struct pim_msdp_peer *mp, struct prefix_sg *sg,
  */
 static bool pim_msdp_sa_local_add_ok(struct pim_upstream *up)
 {
-       if (!(pimg->msdp.flags & PIM_MSDPF_ENABLE)) {
+       struct pim_instance *pim = up->channel_oil->pim;
+
+       if (!(pim->msdp.flags & PIM_MSDPF_ENABLE)) {
                return false;
        }
 
@@ -448,7 +457,7 @@ static bool pim_msdp_sa_local_add_ok(struct pim_upstream *up)
                return false;
        }
 
-       if (!I_am_RP(pimg, up->sg.grp)) {
+       if (!I_am_RP(pim, up->sg.grp)) {
                /* we are not RP for the group */
                return false;
        }
@@ -463,18 +472,19 @@ static bool pim_msdp_sa_local_add_ok(struct pim_upstream *up)
        return false;
 }
 
-static void pim_msdp_sa_local_add(struct prefix_sg *sg)
+static void pim_msdp_sa_local_add(struct pim_instance *pim,
+                                 struct prefix_sg *sg)
 {
        struct in_addr rp;
        rp.s_addr = 0;
-       pim_msdp_sa_ref(NULL /* mp */, sg, rp);
+       pim_msdp_sa_ref(pim, NULL /* mp */, sg, rp);
 }
 
-void pim_msdp_sa_local_del(struct prefix_sg *sg)
+void pim_msdp_sa_local_del(struct pim_instance *pim, struct prefix_sg *sg)
 {
        struct pim_msdp_sa *sa;
 
-       sa = pim_msdp_sa_find(sg);
+       sa = pim_msdp_sa_find(pim, sg);
        if (sa) {
                pim_msdp_sa_deref(sa, PIM_MSDP_SAF_LOCAL);
        }
@@ -482,11 +492,12 @@ void pim_msdp_sa_local_del(struct prefix_sg *sg)
 
 /* we need to be very cautious with this API as SA del too can trigger an
  * upstream del and we will get stuck in a simple loop */
-static void pim_msdp_sa_local_del_on_up_del(struct prefix_sg *sg)
+static void pim_msdp_sa_local_del_on_up_del(struct pim_instance *pim,
+                                           struct prefix_sg *sg)
 {
        struct pim_msdp_sa *sa;
 
-       sa = pim_msdp_sa_find(sg);
+       sa = pim_msdp_sa_find(pim, sg);
        if (sa) {
                if (PIM_DEBUG_MSDP_INTERNAL) {
                        zlog_debug("MSDP local sa %s del on up del",
@@ -544,32 +555,34 @@ static void pim_msdp_sa_local_del_on_up_del(struct prefix_sg *sg)
  */
 void pim_msdp_sa_local_update(struct pim_upstream *up)
 {
+       struct pim_instance *pim = up->channel_oil->pim;
+
        if (pim_msdp_sa_local_add_ok(up)) {
-               pim_msdp_sa_local_add(&up->sg);
+               pim_msdp_sa_local_add(pim, &up->sg);
        } else {
-               pim_msdp_sa_local_del(&up->sg);
+               pim_msdp_sa_local_del(pim, &up->sg);
        }
 }
 
-static void pim_msdp_sa_local_setup(void)
+static void pim_msdp_sa_local_setup(struct pim_instance *pim)
 {
        struct pim_upstream *up;
        struct listnode *up_node;
 
-       for (ALL_LIST_ELEMENTS_RO(pimg->upstream_list, up_node, up)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, up_node, up)) {
                pim_msdp_sa_local_update(up);
        }
 }
 
 /* whenever the RP changes we need to re-evaluate the "local" SA-cache */
 /* XXX: needs to be tested */
-void pim_msdp_i_am_rp_changed(void)
+void pim_msdp_i_am_rp_changed(struct pim_instance *pim)
 {
        struct listnode *sanode;
        struct listnode *nextnode;
        struct pim_msdp_sa *sa;
 
-       if (!(pimg->msdp.flags & PIM_MSDPF_ENABLE)) {
+       if (!(pim->msdp.flags & PIM_MSDPF_ENABLE)) {
                /* if the feature is not enabled do nothing */
                return;
        }
@@ -579,16 +592,16 @@ void pim_msdp_i_am_rp_changed(void)
        }
 
        /* mark all local entries as stale */
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.sa_list, sanode, sa)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->msdp.sa_list, sanode, sa)) {
                if (sa->flags & PIM_MSDP_SAF_LOCAL) {
                        sa->flags |= PIM_MSDP_SAF_STALE;
                }
        }
 
        /* re-setup local SA entries */
-       pim_msdp_sa_local_setup();
+       pim_msdp_sa_local_setup(pim);
 
-       for (ALL_LIST_ELEMENTS(pimg->msdp.sa_list, sanode, nextnode, sa)) {
+       for (ALL_LIST_ELEMENTS(pim->msdp.sa_list, sanode, nextnode, sa)) {
                /* purge stale SA entries */
                if (sa->flags & PIM_MSDP_SAF_STALE) {
                        /* clear the stale flag; the entry may be kept even
@@ -614,6 +627,7 @@ void pim_msdp_up_join_state_changed(struct pim_upstream *xg_up)
 {
        struct listnode *sanode;
        struct pim_msdp_sa *sa;
+       struct pim_instance *pim = xg_up->channel_oil->pim;
 
        if (PIM_DEBUG_MSDP_INTERNAL) {
                zlog_debug("MSDP join state changed for %s", xg_up->sg_str);
@@ -627,7 +641,7 @@ void pim_msdp_up_join_state_changed(struct pim_upstream *xg_up)
 
        /* XXX: Need to maintain SAs per-group to avoid all this unnecessary
         * walking */
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.sa_list, sanode, sa)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->msdp.sa_list, sanode, sa)) {
                if (sa->sg.grp.s_addr != xg_up->sg.grp.s_addr) {
                        continue;
                }
@@ -635,7 +649,7 @@ void pim_msdp_up_join_state_changed(struct pim_upstream *xg_up)
        }
 }
 
-static void pim_msdp_up_xg_del(struct prefix_sg *sg)
+static void pim_msdp_up_xg_del(struct pim_instance *pim, struct prefix_sg *sg)
 {
        struct listnode *sanode;
        struct pim_msdp_sa *sa;
@@ -651,7 +665,7 @@ static void pim_msdp_up_xg_del(struct prefix_sg *sg)
 
        /* XXX: Need to maintain SAs per-group to avoid all this unnecessary
         * walking */
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.sa_list, sanode, sa)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->msdp.sa_list, sanode, sa)) {
                if (sa->sg.grp.s_addr != sg->grp.s_addr) {
                        continue;
                }
@@ -659,15 +673,15 @@ static void pim_msdp_up_xg_del(struct prefix_sg *sg)
        }
 }
 
-void pim_msdp_up_del(struct prefix_sg *sg)
+void pim_msdp_up_del(struct pim_instance *pim, struct prefix_sg *sg)
 {
        if (PIM_DEBUG_MSDP_INTERNAL) {
                zlog_debug("MSDP up %s del", pim_str_sg_dump(sg));
        }
        if (sg->src.s_addr == INADDR_ANY) {
-               pim_msdp_up_xg_del(sg);
+               pim_msdp_up_xg_del(pim, sg);
        } else {
-               pim_msdp_sa_local_del_on_up_del(sg);
+               pim_msdp_sa_local_del_on_up_del(pim, sg);
        }
 }
 
@@ -798,7 +812,7 @@ static void pim_msdp_peer_listen(struct pim_msdp_peer *mp)
        * first listening peer is configured; but don't bother tearing it down
        * when
        * all the peers go down */
-       pim_msdp_sock_listen();
+       pim_msdp_sock_listen(mp->pim);
 }
 
 /* 11.2.A4 and 11.2.A5: transition active or passive peer to
@@ -914,11 +928,13 @@ static int pim_msdp_peer_hold_timer_cb(struct thread *t)
        pim_msdp_peer_reset_tcp_conn(mp, "ht-expired");
        return 0;
 }
+
 static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
 {
+       struct pim_instance *pim = mp->pim;
        THREAD_OFF(mp->hold_timer);
        if (start) {
-               thread_add_timer(pimg->msdp.master, pim_msdp_peer_hold_timer_cb,
+               thread_add_timer(pim->msdp.master, pim_msdp_peer_hold_timer_cb,
                                 mp, PIM_MSDP_PEER_HOLD_TIME, &mp->hold_timer);
        }
 }
@@ -943,8 +959,9 @@ static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
 {
        THREAD_OFF(mp->ka_timer);
        if (start) {
-               thread_add_timer(pimg->msdp.master, pim_msdp_peer_ka_timer_cb,
-                                mp, PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
+               thread_add_timer(mp->pim->msdp.master,
+                                pim_msdp_peer_ka_timer_cb, mp,
+                                PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
        }
 }
 
@@ -1006,9 +1023,9 @@ static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
 {
        THREAD_OFF(mp->cr_timer);
        if (start) {
-               thread_add_timer(pimg->msdp.master, pim_msdp_peer_cr_timer_cb,
-                                mp, PIM_MSDP_PEER_CONNECT_RETRY_TIME,
-                                &mp->cr_timer);
+               thread_add_timer(
+                       mp->pim->msdp.master, pim_msdp_peer_cr_timer_cb, mp,
+                       PIM_MSDP_PEER_CONNECT_RETRY_TIME, &mp->cr_timer);
        }
 }
 
@@ -1044,14 +1061,15 @@ static void pim_msdp_addr2su(union sockunion *su, struct in_addr addr)
 }
 
 /* 11.2.A1: create a new peer and transition state to listen or connecting */
-static enum pim_msdp_err pim_msdp_peer_new(struct in_addr peer_addr,
+static enum pim_msdp_err pim_msdp_peer_new(struct pim_instance *pim,
+                                          struct in_addr peer_addr,
                                           struct in_addr local_addr,
                                           const char *mesh_group_name,
                                           struct pim_msdp_peer **mp_p)
 {
        struct pim_msdp_peer *mp;
 
-       pim_msdp_enable();
+       pim_msdp_enable(pim);
 
        mp = XCALLOC(MTYPE_PIM_MSDP_PEER, sizeof(*mp));
        if (!mp) {
@@ -1060,12 +1078,13 @@ static enum pim_msdp_err pim_msdp_peer_new(struct in_addr peer_addr,
                return PIM_MSDP_ERR_OOM;
        }
 
+       mp->pim = pim;
        mp->peer = peer_addr;
        pim_inet4_dump("<peer?>", mp->peer, mp->key_str, sizeof(mp->key_str));
        pim_msdp_addr2su(&mp->su_peer, mp->peer);
        mp->local = local_addr;
        /* XXX: originator_id setting needs to move to the mesh group */
-       pimg->msdp.originator_id = local_addr;
+       pim->msdp.originator_id = local_addr;
        pim_msdp_addr2su(&mp->su_local, mp->local);
        mp->mesh_group_name = XSTRDUP(MTYPE_PIM_MSDP_MG_NAME, mesh_group_name);
        mp->state = PIM_MSDP_INACTIVE;
@@ -1081,8 +1100,8 @@ static enum pim_msdp_err pim_msdp_peer_new(struct in_addr peer_addr,
        mp->obuf = stream_fifo_new();
 
        /* insert into misc tables for easy access */
-       mp = hash_get(pimg->msdp.peer_hash, mp, hash_alloc_intern);
-       listnode_add_sort(pimg->msdp.peer_list, mp);
+       mp = hash_get(pim->msdp.peer_hash, mp, hash_alloc_intern);
+       listnode_add_sort(pim->msdp.peer_list, mp);
 
        if (PIM_DEBUG_MSDP_EVENTS) {
                zlog_debug("MSDP peer %s created", mp->key_str);
@@ -1102,16 +1121,18 @@ static enum pim_msdp_err pim_msdp_peer_new(struct in_addr peer_addr,
        return PIM_MSDP_ERR_NONE;
 }
 
-struct pim_msdp_peer *pim_msdp_peer_find(struct in_addr peer_addr)
+struct pim_msdp_peer *pim_msdp_peer_find(struct pim_instance *pim,
+                                        struct in_addr peer_addr)
 {
        struct pim_msdp_peer lookup;
 
        lookup.peer = peer_addr;
-       return hash_lookup(pimg->msdp.peer_hash, &lookup);
+       return hash_lookup(pim->msdp.peer_hash, &lookup);
 }
 
 /* add peer configuration if it doesn't already exist */
-enum pim_msdp_err pim_msdp_peer_add(struct in_addr peer_addr,
+enum pim_msdp_err pim_msdp_peer_add(struct pim_instance *pim,
+                                   struct in_addr peer_addr,
                                    struct in_addr local_addr,
                                    const char *mesh_group_name,
                                    struct pim_msdp_peer **mp_p)
@@ -1134,7 +1155,7 @@ enum pim_msdp_err pim_msdp_peer_add(struct in_addr peer_addr,
                return PIM_MSDP_ERR_SIP_EQ_DIP;
        }
 
-       mp = pim_msdp_peer_find(peer_addr);
+       mp = pim_msdp_peer_find(pim, peer_addr);
        if (mp) {
                if (mp_p) {
                        *mp_p = mp;
@@ -1142,7 +1163,8 @@ enum pim_msdp_err pim_msdp_peer_add(struct in_addr peer_addr,
                return PIM_MSDP_ERR_PEER_EXISTS;
        }
 
-       return pim_msdp_peer_new(peer_addr, local_addr, mesh_group_name, mp_p);
+       return pim_msdp_peer_new(pim, peer_addr, local_addr, mesh_group_name,
+                                mp_p);
 }
 
 /* release all mem associated with a peer */
@@ -1169,8 +1191,8 @@ static enum pim_msdp_err pim_msdp_peer_do_del(struct pim_msdp_peer *mp)
        pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
 
        /* remove the session from various tables */
-       listnode_delete(pimg->msdp.peer_list, mp);
-       hash_release(pimg->msdp.peer_hash, mp);
+       listnode_delete(mp->pim->msdp.peer_list, mp);
+       hash_release(mp->pim->msdp.peer_hash, mp);
 
        if (PIM_DEBUG_MSDP_EVENTS) {
                zlog_debug("MSDP peer %s deleted", mp->key_str);
@@ -1182,11 +1204,12 @@ static enum pim_msdp_err pim_msdp_peer_do_del(struct pim_msdp_peer *mp)
        return PIM_MSDP_ERR_NONE;
 }
 
-enum pim_msdp_err pim_msdp_peer_del(struct in_addr peer_addr)
+enum pim_msdp_err pim_msdp_peer_del(struct pim_instance *pim,
+                                   struct in_addr peer_addr)
 {
        struct pim_msdp_peer *mp;
 
-       mp = pim_msdp_peer_find(peer_addr);
+       mp = pim_msdp_peer_find(pim, peer_addr);
        if (!mp) {
                return PIM_MSDP_ERR_NO_PEER;
        }
@@ -1224,7 +1247,7 @@ static int pim_msdp_peer_comp(const void *p1, const void *p2)
 }
 
 /************************** Mesh group management **************************/
-static void pim_msdp_mg_free(struct pim_msdp_mg *mg)
+static void pim_msdp_mg_free(struct pim_instance *pim, struct pim_msdp_mg *mg)
 {
        /* If the mesh-group has valid member or src_ip don't delete it */
        if (!mg || mg->mbr_cnt || (mg->src_ip.s_addr != INADDR_ANY)) {
@@ -1241,7 +1264,7 @@ static void pim_msdp_mg_free(struct pim_msdp_mg *mg)
                list_free(mg->mbr_list);
 
        XFREE(MTYPE_PIM_MSDP_MG, mg);
-       pimg->msdp.mg = NULL;
+       pim->msdp.mg = NULL;
 }
 
 static struct pim_msdp_mg *pim_msdp_mg_new(const char *mesh_group_name)
@@ -1266,9 +1289,10 @@ static struct pim_msdp_mg *pim_msdp_mg_new(const char *mesh_group_name)
        return mg;
 }
 
-enum pim_msdp_err pim_msdp_mg_del(const char *mesh_group_name)
+enum pim_msdp_err pim_msdp_mg_del(struct pim_instance *pim,
+                                 const char *mesh_group_name)
 {
-       struct pim_msdp_mg *mg = pimg->msdp.mg;
+       struct pim_msdp_mg *mg = pim->msdp.mg;
        struct pim_msdp_mg_mbr *mbr;
 
        if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
@@ -1285,22 +1309,23 @@ enum pim_msdp_err pim_msdp_mg_del(const char *mesh_group_name)
        mg->src_ip.s_addr = INADDR_ANY;
 
        /* free up the mesh-group */
-       pim_msdp_mg_free(mg);
+       pim_msdp_mg_free(pim, mg);
        return PIM_MSDP_ERR_NONE;
 }
 
-static enum pim_msdp_err pim_msdp_mg_add(const char *mesh_group_name)
+static enum pim_msdp_err pim_msdp_mg_add(struct pim_instance *pim,
+                                        const char *mesh_group_name)
 {
-       if (pimg->msdp.mg) {
-               if (!strcmp(pimg->msdp.mg->mesh_group_name, mesh_group_name)) {
+       if (pim->msdp.mg) {
+               if (!strcmp(pim->msdp.mg->mesh_group_name, mesh_group_name)) {
                        return PIM_MSDP_ERR_NONE;
                }
                /* currently only one mesh-group can exist at a time */
                return PIM_MSDP_ERR_MAX_MESH_GROUPS;
        }
 
-       pimg->msdp.mg = pim_msdp_mg_new(mesh_group_name);
-       if (!pimg->msdp.mg) {
+       pim->msdp.mg = pim_msdp_mg_new(mesh_group_name);
+       if (!pim->msdp.mg) {
                return PIM_MSDP_ERR_OOM;
        }
 
@@ -1326,17 +1351,18 @@ static void pim_msdp_mg_mbr_free(struct pim_msdp_mg_mbr *mbr)
        XFREE(MTYPE_PIM_MSDP_MG_MBR, mbr);
 }
 
-static struct pim_msdp_mg_mbr *pim_msdp_mg_mbr_find(struct in_addr mbr_ip)
+static struct pim_msdp_mg_mbr *pim_msdp_mg_mbr_find(struct pim_instance *pim,
+                                                   struct in_addr mbr_ip)
 {
        struct pim_msdp_mg_mbr *mbr;
        struct listnode *mbr_node;
 
-       if (!pimg->msdp.mg) {
+       if (!pim->msdp.mg) {
                return NULL;
        }
        /* we can move this to a hash but considering that number of peers in
         * a mesh-group that seems like bit of an overkill */
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.mg->mbr_list, mbr_node, mbr)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->msdp.mg->mbr_list, mbr_node, mbr)) {
                if (mbr->mbr_ip.s_addr == mbr_ip.s_addr) {
                        return mbr;
                }
@@ -1344,20 +1370,21 @@ static struct pim_msdp_mg_mbr *pim_msdp_mg_mbr_find(struct in_addr mbr_ip)
        return mbr;
 }
 
-enum pim_msdp_err pim_msdp_mg_mbr_add(const char *mesh_group_name,
+enum pim_msdp_err pim_msdp_mg_mbr_add(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr mbr_ip)
 {
        int rc;
        struct pim_msdp_mg_mbr *mbr;
        struct pim_msdp_mg *mg;
 
-       rc = pim_msdp_mg_add(mesh_group_name);
+       rc = pim_msdp_mg_add(pim, mesh_group_name);
        if (rc != PIM_MSDP_ERR_NONE) {
                return rc;
        }
 
-       mg = pimg->msdp.mg;
-       mbr = pim_msdp_mg_mbr_find(mbr_ip);
+       mg = pim->msdp.mg;
+       mbr = pim_msdp_mg_mbr_find(pim, mbr_ip);
        if (mbr) {
                return PIM_MSDP_ERR_MG_MBR_EXISTS;
        }
@@ -1367,7 +1394,7 @@ enum pim_msdp_err pim_msdp_mg_mbr_add(const char *mesh_group_name,
                zlog_err("%s: PIM XCALLOC(%zu) failure", __PRETTY_FUNCTION__,
                         sizeof(*mbr));
                /* if there are no references to the mg free it */
-               pim_msdp_mg_free(mg);
+               pim_msdp_mg_free(pim, mg);
                return PIM_MSDP_ERR_OOM;
        }
        mbr->mbr_ip = mbr_ip;
@@ -1375,7 +1402,7 @@ enum pim_msdp_err pim_msdp_mg_mbr_add(const char *mesh_group_name,
 
        /* if valid SIP has been configured add peer session */
        if (mg->src_ip.s_addr != INADDR_ANY) {
-               pim_msdp_peer_add(mbr_ip, mg->src_ip, mesh_group_name,
+               pim_msdp_peer_add(pim, mbr_ip, mg->src_ip, mesh_group_name,
                                  &mbr->mp);
        }
 
@@ -1410,33 +1437,34 @@ static void pim_msdp_mg_mbr_do_del(struct pim_msdp_mg *mg,
        }
 }
 
-enum pim_msdp_err pim_msdp_mg_mbr_del(const char *mesh_group_name,
+enum pim_msdp_err pim_msdp_mg_mbr_del(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr mbr_ip)
 {
        struct pim_msdp_mg_mbr *mbr;
-       struct pim_msdp_mg *mg = pimg->msdp.mg;
+       struct pim_msdp_mg *mg = pim->msdp.mg;
 
        if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
                return PIM_MSDP_ERR_NO_MG;
        }
 
-       mbr = pim_msdp_mg_mbr_find(mbr_ip);
+       mbr = pim_msdp_mg_mbr_find(pim, mbr_ip);
        if (!mbr) {
                return PIM_MSDP_ERR_NO_MG_MBR;
        }
 
        pim_msdp_mg_mbr_do_del(mg, mbr);
        /* if there are no references to the mg free it */
-       pim_msdp_mg_free(mg);
+       pim_msdp_mg_free(pim, mg);
 
        return PIM_MSDP_ERR_NONE;
 }
 
-static void pim_msdp_mg_src_do_del(void)
+static void pim_msdp_mg_src_do_del(struct pim_instance *pim)
 {
        struct pim_msdp_mg_mbr *mbr;
        struct listnode *mbr_node;
-       struct pim_msdp_mg *mg = pimg->msdp.mg;
+       struct pim_msdp_mg *mg = pim->msdp.mg;
 
        /* SIP is being removed - tear down all active peer sessions */
        for (ALL_LIST_ELEMENTS_RO(mg->mbr_list, mbr_node, mbr)) {
@@ -1451,9 +1479,10 @@ static void pim_msdp_mg_src_do_del(void)
        }
 }
 
-enum pim_msdp_err pim_msdp_mg_src_del(const char *mesh_group_name)
+enum pim_msdp_err pim_msdp_mg_src_del(struct pim_instance *pim,
+                                     const char *mesh_group_name)
 {
-       struct pim_msdp_mg *mg = pimg->msdp.mg;
+       struct pim_msdp_mg *mg = pim->msdp.mg;
 
        if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
                return PIM_MSDP_ERR_NO_MG;
@@ -1461,14 +1490,15 @@ enum pim_msdp_err pim_msdp_mg_src_del(const char *mesh_group_name)
 
        if (mg->src_ip.s_addr != INADDR_ANY) {
                mg->src_ip.s_addr = INADDR_ANY;
-               pim_msdp_mg_src_do_del();
+               pim_msdp_mg_src_do_del(pim);
                /* if there are no references to the mg free it */
-               pim_msdp_mg_free(mg);
+               pim_msdp_mg_free(pim, mg);
        }
        return PIM_MSDP_ERR_NONE;
 }
 
-enum pim_msdp_err pim_msdp_mg_src_add(const char *mesh_group_name,
+enum pim_msdp_err pim_msdp_mg_src_add(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr src_ip)
 {
        int rc;
@@ -1477,23 +1507,23 @@ enum pim_msdp_err pim_msdp_mg_src_add(const char *mesh_group_name,
        struct pim_msdp_mg *mg;
 
        if (src_ip.s_addr == INADDR_ANY) {
-               pim_msdp_mg_src_del(mesh_group_name);
+               pim_msdp_mg_src_del(pim, mesh_group_name);
                return PIM_MSDP_ERR_NONE;
        }
 
-       rc = pim_msdp_mg_add(mesh_group_name);
+       rc = pim_msdp_mg_add(pim, mesh_group_name);
        if (rc != PIM_MSDP_ERR_NONE) {
                return rc;
        }
 
-       mg = pimg->msdp.mg;
+       mg = pim->msdp.mg;
        if (mg->src_ip.s_addr != INADDR_ANY) {
-               pim_msdp_mg_src_do_del();
+               pim_msdp_mg_src_do_del(pim);
        }
        mg->src_ip = src_ip;
 
        for (ALL_LIST_ELEMENTS_RO(mg->mbr_list, mbr_node, mbr)) {
-               pim_msdp_peer_add(mbr->mbr_ip, mg->src_ip, mesh_group_name,
+               pim_msdp_peer_add(pim, mbr->mbr_ip, mg->src_ip, mesh_group_name,
                                  &mbr->mp);
        }
 
@@ -1507,11 +1537,12 @@ enum pim_msdp_err pim_msdp_mg_src_add(const char *mesh_group_name,
 }
 
 /*********************** MSDP feature APIs *********************************/
-int pim_msdp_config_write(struct vty *vty)
+static int pim_msdp_config_write_helper(struct pim_instance *pim,
+                                       struct vty *vty)
 {
        struct listnode *mbrnode;
        struct pim_msdp_mg_mbr *mbr;
-       struct pim_msdp_mg *mg = pimg->msdp.mg;
+       struct pim_msdp_mg *mg = pim->msdp.mg;
        char mbr_str[INET_ADDRSTRLEN];
        char src_str[INET_ADDRSTRLEN];
        int count = 0;
@@ -1536,25 +1567,30 @@ int pim_msdp_config_write(struct vty *vty)
        return count;
 }
 
+int pim_msdp_config_write(struct vty *vty)
+{
+       return pim_msdp_config_write_helper(pimg, vty);
+}
+
 /* Enable feature including active/periodic timers etc. on the first peer
  * config. Till then MSDP should just stay quiet. */
-static void pim_msdp_enable(void)
+static void pim_msdp_enable(struct pim_instance *pim)
 {
-       if (pimg->msdp.flags & PIM_MSDPF_ENABLE) {
+       if (pim->msdp.flags & PIM_MSDPF_ENABLE) {
                /* feature is already enabled */
                return;
        }
-       pimg->msdp.flags |= PIM_MSDPF_ENABLE;
-       pimg->msdp.work_obuf = stream_new(PIM_MSDP_MAX_PACKET_SIZE);
-       pim_msdp_sa_adv_timer_setup(true /* start */);
+       pim->msdp.flags |= PIM_MSDPF_ENABLE;
+       pim->msdp.work_obuf = stream_new(PIM_MSDP_MAX_PACKET_SIZE);
+       pim_msdp_sa_adv_timer_setup(pim, true /* start */);
        /* setup sa cache based on local sources */
-       pim_msdp_sa_local_setup();
+       pim_msdp_sa_local_setup(pim);
 }
 
 /* MSDP init */
 void pim_msdp_init(struct thread_master *master, struct pim_instance *pim)
 {
-       pimg->msdp.master = master;
+       pim->msdp.master = master;
 
        pim->msdp.peer_hash = hash_create(pim_msdp_peer_hash_key_make,
                                          pim_msdp_peer_hash_eq, NULL);

diff --git a/pimd/pim_msdp.h b/pimd/pim_msdp.h
index 88bef4bc7994ce169a96919da1764cd913b9535e..b53391bdd1434a7d79cbd6b1049fe0d921ca5f32 100644 (file)
--- a/pimd/pim_msdp.h
+++ b/pimd/pim_msdp.h
@@ -74,6 +74,8 @@ enum pim_msdp_sa_flags {
 };
 
 struct pim_msdp_sa {
+       struct pim_instance *pim;
+
        struct prefix_sg sg;
        char sg_str[PIM_SG_LEN];
        struct in_addr rp;   /* Last RP address associated with this SA */
@@ -97,6 +99,8 @@ enum pim_msdp_peer_flags {
 };
 
 struct pim_msdp_peer {
+       struct pim_instance *pim;
+
        /* configuration */
        struct in_addr local;
        struct in_addr peer;
@@ -203,11 +207,11 @@ struct pim_msdp {
 };
 
 #define PIM_MSDP_PEER_READ_ON(mp)                                              \
-       thread_add_read(pimg->msdp.master, pim_msdp_read, mp, mp->fd,          \
+       thread_add_read(mp->pim->msdp.master, pim_msdp_read, mp, mp->fd,       \
                        &mp->t_read)
 
 #define PIM_MSDP_PEER_WRITE_ON(mp)                                             \
-       thread_add_write(pimg->msdp.master, pim_msdp_write, mp, mp->fd,        \
+       thread_add_write(mp->pim->msdp.master, pim_msdp_write, mp, mp->fd,     \
                         &mp->t_write)
 
 #define PIM_MSDP_PEER_READ_OFF(mp) THREAD_READ_OFF(mp->t_read)
@@ -217,13 +221,16 @@ struct pim_msdp {
 struct pim_instance;
 void pim_msdp_init(struct thread_master *master, struct pim_instance *pim);
 void pim_msdp_exit(struct pim_instance *pim);
-enum pim_msdp_err pim_msdp_peer_add(struct in_addr peer, struct in_addr local,
+enum pim_msdp_err pim_msdp_peer_add(struct pim_instance *pim,
+                                   struct in_addr peer, struct in_addr local,
                                    const char *mesh_group_name,
                                    struct pim_msdp_peer **mp_p);
-enum pim_msdp_err pim_msdp_peer_del(struct in_addr peer_addr);
+enum pim_msdp_err pim_msdp_peer_del(struct pim_instance *pim,
+                                   struct in_addr peer_addr);
 char *pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf,
                          int buf_size);
-struct pim_msdp_peer *pim_msdp_peer_find(struct in_addr peer_addr);
+struct pim_msdp_peer *pim_msdp_peer_find(struct pim_instance *pim,
+                                        struct in_addr peer_addr);
 void pim_msdp_peer_established(struct pim_msdp_peer *mp);
 void pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp);
 void pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state);
@@ -233,20 +240,25 @@ char *pim_msdp_peer_key_dump(struct pim_msdp_peer *mp, char *buf, int buf_size,
                             bool long_format);
 int pim_msdp_config_write(struct vty *vty);
 void pim_msdp_peer_pkt_txed(struct pim_msdp_peer *mp);
-void pim_msdp_sa_ref(struct pim_msdp_peer *mp, struct prefix_sg *sg,
-                    struct in_addr rp);
+void pim_msdp_sa_ref(struct pim_instance *pim, struct pim_msdp_peer *mp,
+                    struct prefix_sg *sg, struct in_addr rp);
 void pim_msdp_sa_local_update(struct pim_upstream *up);
-void pim_msdp_sa_local_del(struct prefix_sg *sg);
-void pim_msdp_i_am_rp_changed(void);
+void pim_msdp_sa_local_del(struct pim_instance *pim, struct prefix_sg *sg);
+void pim_msdp_i_am_rp_changed(struct pim_instance *pim);
 bool pim_msdp_peer_rpf_check(struct pim_msdp_peer *mp, struct in_addr rp);
 void pim_msdp_up_join_state_changed(struct pim_upstream *xg_up);
-void pim_msdp_up_del(struct prefix_sg *sg);
-enum pim_msdp_err pim_msdp_mg_mbr_add(const char *mesh_group_name,
+void pim_msdp_up_del(struct pim_instance *pim, struct prefix_sg *sg);
+enum pim_msdp_err pim_msdp_mg_mbr_add(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr mbr_ip);
-enum pim_msdp_err pim_msdp_mg_mbr_del(const char *mesh_group_name,
+enum pim_msdp_err pim_msdp_mg_mbr_del(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr mbr_ip);
-enum pim_msdp_err pim_msdp_mg_src_del(const char *mesh_group_name);
-enum pim_msdp_err pim_msdp_mg_src_add(const char *mesh_group_name,
+enum pim_msdp_err pim_msdp_mg_src_del(struct pim_instance *pim,
+                                     const char *mesh_group_name);
+enum pim_msdp_err pim_msdp_mg_src_add(struct pim_instance *pim,
+                                     const char *mesh_group_name,
                                      struct in_addr src_ip);
-enum pim_msdp_err pim_msdp_mg_del(const char *mesh_group_name);
+enum pim_msdp_err pim_msdp_mg_del(struct pim_instance *pim,
+                                 const char *mesh_group_name);
 #endif

diff --git a/pimd/pim_msdp_packet.c b/pimd/pim_msdp_packet.c
index 7860a6ac2a278c5b2a39d5c2db7dfeee735ffa5f..8f93e65715a7a8811f11b18d95185a06c2fa0716 100644 (file)
--- a/pimd/pim_msdp_packet.c
+++ b/pimd/pim_msdp_packet.c
@@ -318,7 +318,7 @@ static void pim_msdp_pkt_sa_push_to_one_peer(struct pim_msdp_peer *mp)
                /* don't tx anything unless a session is established */
                return;
        }
-       s = stream_dup(pimg->msdp.work_obuf);
+       s = stream_dup(mp->pim->msdp.work_obuf);
        if (s) {
                pim_msdp_pkt_send(mp, s);
                mp->flags |= PIM_MSDP_PEERF_SA_JUST_SENT;
@@ -333,7 +333,8 @@ static void pim_msdp_pkt_sa_push(struct pim_msdp_peer *mp)
        if (mp) {
                pim_msdp_pkt_sa_push_to_one_peer(mp);
        } else {
-               for (ALL_LIST_ELEMENTS_RO(pimg->msdp.peer_list, mpnode, mp)) {
+               for (ALL_LIST_ELEMENTS_RO(mp->pim->msdp.peer_list, mpnode,
+                                         mp)) {
                        if (PIM_DEBUG_MSDP_INTERNAL) {
                                zlog_debug("MSDP peer %s pim_msdp_pkt_sa_push",
                                           mp->key_str);
@@ -343,30 +344,30 @@ static void pim_msdp_pkt_sa_push(struct pim_msdp_peer *mp)
        }
 }
 
-static int pim_msdp_pkt_sa_fill_hdr(int local_cnt)
+static int pim_msdp_pkt_sa_fill_hdr(struct pim_instance *pim, int local_cnt)
 {
        int curr_tlv_ecnt;
 
-       stream_reset(pimg->msdp.work_obuf);
+       stream_reset(pim->msdp.work_obuf);
        curr_tlv_ecnt = local_cnt > PIM_MSDP_SA_MAX_ENTRY_CNT
                                ? PIM_MSDP_SA_MAX_ENTRY_CNT
                                : local_cnt;
        local_cnt -= curr_tlv_ecnt;
-       stream_putc(pimg->msdp.work_obuf, PIM_MSDP_V4_SOURCE_ACTIVE);
-       stream_putw(pimg->msdp.work_obuf,
+       stream_putc(pim->msdp.work_obuf, PIM_MSDP_V4_SOURCE_ACTIVE);
+       stream_putw(pim->msdp.work_obuf,
                    PIM_MSDP_SA_ENTRY_CNT2SIZE(curr_tlv_ecnt));
-       stream_putc(pimg->msdp.work_obuf, curr_tlv_ecnt);
-       stream_put_ipv4(pimg->msdp.work_obuf, pimg->msdp.originator_id.s_addr);
+       stream_putc(pim->msdp.work_obuf, curr_tlv_ecnt);
+       stream_put_ipv4(pim->msdp.work_obuf, pim->msdp.originator_id.s_addr);
 
        return local_cnt;
 }
 
 static void pim_msdp_pkt_sa_fill_one(struct pim_msdp_sa *sa)
 {
-       stream_put3(pimg->msdp.work_obuf, 0 /* reserved */);
-       stream_putc(pimg->msdp.work_obuf, 32 /* sprefix len */);
-       stream_put_ipv4(pimg->msdp.work_obuf, sa->sg.grp.s_addr);
-       stream_put_ipv4(pimg->msdp.work_obuf, sa->sg.src.s_addr);
+       stream_put3(sa->pim->msdp.work_obuf, 0 /* reserved */);
+       stream_putc(sa->pim->msdp.work_obuf, 32 /* sprefix len */);
+       stream_put_ipv4(sa->pim->msdp.work_obuf, sa->sg.grp.s_addr);
+       stream_put_ipv4(sa->pim->msdp.work_obuf, sa->sg.src.s_addr);
 }
 
 static void pim_msdp_pkt_sa_gen(struct pim_msdp_peer *mp)
@@ -374,16 +375,16 @@ static void pim_msdp_pkt_sa_gen(struct pim_msdp_peer *mp)
        struct listnode *sanode;
        struct pim_msdp_sa *sa;
        int sa_count;
-       int local_cnt = pimg->msdp.local_cnt;
+       int local_cnt = mp->pim->msdp.local_cnt;
 
        sa_count = 0;
        if (PIM_DEBUG_MSDP_INTERNAL) {
                zlog_debug("  sa gen  %d", local_cnt);
        }
 
-       local_cnt = pim_msdp_pkt_sa_fill_hdr(local_cnt);
+       local_cnt = pim_msdp_pkt_sa_fill_hdr(mp->pim, local_cnt);
 
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.sa_list, sanode, sa)) {
+       for (ALL_LIST_ELEMENTS_RO(mp->pim->msdp.sa_list, sanode, sa)) {
                if (!(sa->flags & PIM_MSDP_SAF_LOCAL)) {
                        /* current implementation of MSDP is for anycast i.e.
                         * full mesh. so
@@ -402,7 +403,8 @@ static void pim_msdp_pkt_sa_gen(struct pim_msdp_peer *mp)
                                zlog_debug("  sa gen for remainder %d",
                                           local_cnt);
                        }
-                       local_cnt = pim_msdp_pkt_sa_fill_hdr(local_cnt);
+                       local_cnt =
+                               pim_msdp_pkt_sa_fill_hdr(mp->pim, local_cnt);
                }
        }
 
@@ -412,14 +414,14 @@ static void pim_msdp_pkt_sa_gen(struct pim_msdp_peer *mp)
        return;
 }
 
-static void pim_msdp_pkt_sa_tx_done(void)
+static void pim_msdp_pkt_sa_tx_done(struct pim_instance *pim)
 {
        struct listnode *mpnode;
        struct pim_msdp_peer *mp;
 
        /* if SA were sent to the peers we restart ka timer and avoid
         * unnecessary ka noise */
-       for (ALL_LIST_ELEMENTS_RO(pimg->msdp.peer_list, mpnode, mp)) {
+       for (ALL_LIST_ELEMENTS_RO(pim->msdp.peer_list, mpnode, mp)) {
                if (mp->flags & PIM_MSDP_PEERF_SA_JUST_SENT) {
                        mp->flags &= ~PIM_MSDP_PEERF_SA_JUST_SENT;
                        pim_msdp_peer_pkt_txed(mp);
@@ -427,25 +429,25 @@ static void pim_msdp_pkt_sa_tx_done(void)
        }
 }
 
-void pim_msdp_pkt_sa_tx(void)
+void pim_msdp_pkt_sa_tx(struct pim_instance *pim)
 {
        pim_msdp_pkt_sa_gen(NULL /* mp */);
-       pim_msdp_pkt_sa_tx_done();
+       pim_msdp_pkt_sa_tx_done(pim);
 }
 
 void pim_msdp_pkt_sa_tx_one(struct pim_msdp_sa *sa)
 {
-       pim_msdp_pkt_sa_fill_hdr(1 /* cnt */);
+       pim_msdp_pkt_sa_fill_hdr(sa->pim, 1 /* cnt */);
        pim_msdp_pkt_sa_fill_one(sa);
        pim_msdp_pkt_sa_push(NULL);
-       pim_msdp_pkt_sa_tx_done();
+       pim_msdp_pkt_sa_tx_done(sa->pim);
 }
 
 /* when a connection is first established we push all SAs immediately */
 void pim_msdp_pkt_sa_tx_to_one_peer(struct pim_msdp_peer *mp)
 {
        pim_msdp_pkt_sa_gen(mp);
-       pim_msdp_pkt_sa_tx_done();
+       pim_msdp_pkt_sa_tx_done(mp->pim);
 }
 
 static void pim_msdp_pkt_rxed_with_fatal_error(struct pim_msdp_peer *mp)
@@ -485,7 +487,7 @@ static void pim_msdp_pkt_sa_rx_one(struct pim_msdp_peer *mp, struct in_addr rp)
        if (PIM_DEBUG_MSDP_PACKETS) {
                zlog_debug("  sg %s", pim_str_sg_dump(&sg));
        }
-       pim_msdp_sa_ref(mp, &sg, rp);
+       pim_msdp_sa_ref(mp->pim, mp, &sg, rp);
 }
 
 static void pim_msdp_pkt_sa_rx(struct pim_msdp_peer *mp, int len)

diff --git a/pimd/pim_msdp_packet.h b/pimd/pim_msdp_packet.h
index 986fa3b32ae739fad6e3b1ac80c21a68f8a3c66d..d922fa50dfb8e059ea30480261c5e4d0dfd3c7a4 100644 (file)
--- a/pimd/pim_msdp_packet.h
+++ b/pimd/pim_msdp_packet.h
@@ -64,7 +64,7 @@
 
 void pim_msdp_pkt_ka_tx(struct pim_msdp_peer *mp);
 int pim_msdp_read(struct thread *thread);
-void pim_msdp_pkt_sa_tx(void);
+void pim_msdp_pkt_sa_tx(struct pim_instance *pim);
 void pim_msdp_pkt_sa_tx_one(struct pim_msdp_sa *sa);
 void pim_msdp_pkt_sa_tx_to_one_peer(struct pim_msdp_peer *mp);
 

diff --git a/pimd/pim_msdp_socket.c b/pimd/pim_msdp_socket.c
index 9b955d47c65a31687bb3276fe2e9aba898b1eb52..897a1b3d04518d460a860b0f121b5c7edf5d2460 100644 (file)
--- a/pimd/pim_msdp_socket.c
+++ b/pimd/pim_msdp_socket.c
@@ -56,7 +56,7 @@ static void pim_msdp_update_sock_send_buffer_size(int fd)
 static int pim_msdp_sock_accept(struct thread *thread)
 {
        union sockunion su;
-       struct pim_msdp_listener *listener = THREAD_ARG(thread);
+       struct pim_instance *pim = THREAD_ARG(thread);
        int accept_sock;
        int msdp_sock;
        struct pim_msdp_peer *mp;
@@ -70,9 +70,9 @@ static int pim_msdp_sock_accept(struct thread *thread)
                zlog_err("accept_sock is negative value %d", accept_sock);
                return -1;
        }
-       listener->thread = NULL;
-       thread_add_read(master, pim_msdp_sock_accept, listener, accept_sock,
-                       &listener->thread);
+       pim->msdp.listener.thread = NULL;
+       thread_add_read(master, pim_msdp_sock_accept, pim, accept_sock,
+                       &pim->msdp.listener.thread);
 
        /* accept client connection. */
        msdp_sock = sockunion_accept(accept_sock, &su);
@@ -83,9 +83,9 @@ static int pim_msdp_sock_accept(struct thread *thread)
        }
 
        /* see if have peer config for this */
-       mp = pim_msdp_peer_find(su.sin.sin_addr);
+       mp = pim_msdp_peer_find(pim, su.sin.sin_addr);
        if (!mp || !PIM_MSDP_PEER_IS_LISTENER(mp)) {
-               ++pimg->msdp.rejected_accepts;
+               ++pim->msdp.rejected_accepts;
                if (PIM_DEBUG_MSDP_EVENTS) {
                        zlog_err("msdp peer connection refused from %s",
                                 sockunion2str(&su, buf, SU_ADDRSTRLEN));
@@ -117,15 +117,15 @@ static int pim_msdp_sock_accept(struct thread *thread)
 }
 
 /* global listener for the MSDP well know TCP port */
-int pim_msdp_sock_listen(void)
+int pim_msdp_sock_listen(struct pim_instance *pim)
 {
        int sock;
        int socklen;
        struct sockaddr_in sin;
        int rc;
-       struct pim_msdp_listener *listener = &pimg->msdp.listener;
+       struct pim_msdp_listener *listener = &pim->msdp.listener;
 
-       if (pimg->msdp.flags & PIM_MSDPF_LISTENER) {
+       if (pim->msdp.flags & PIM_MSDPF_LISTENER) {
                /* listener already setup */
                return 0;
        }
@@ -178,10 +178,10 @@ int pim_msdp_sock_listen(void)
        listener->fd = sock;
        memcpy(&listener->su, &sin, socklen);
        listener->thread = NULL;
-       thread_add_read(pimg->msdp.master, pim_msdp_sock_accept, listener, sock,
+       thread_add_read(pim->msdp.master, pim_msdp_sock_accept, pim, sock,
                        &listener->thread);
 
-       pimg->msdp.flags |= PIM_MSDPF_LISTENER;
+       pim->msdp.flags |= PIM_MSDPF_LISTENER;
        return 0;
 }
 

diff --git a/pimd/pim_msdp_socket.h b/pimd/pim_msdp_socket.h
index 0abcd57da021faa63afa3ea84cf3d20de409e253..8f46683dff94948c7b8bd7f54cc3c34ca1912f8d 100644 (file)
--- a/pimd/pim_msdp_socket.h
+++ b/pimd/pim_msdp_socket.h
@@ -19,6 +19,6 @@
 #ifndef PIM_MSDP_SOCKET_H
 #define PIM_MSDP_SOCKET_H
 
-int pim_msdp_sock_listen(void);
+int pim_msdp_sock_listen(struct pim_instance *pim);
 int pim_msdp_sock_connect(struct pim_msdp_peer *mp);
 #endif

diff --git a/pimd/pim_rp.c b/pimd/pim_rp.c
index 969b28f7fb7443ce537ade031c02c2e1ef09611e..8e42bf6fbd97260fb2af3d3e9edf6b7a5521bfd7 100644 (file)
--- a/pimd/pim_rp.c
+++ b/pimd/pim_rp.c
@@ -212,9 +212,9 @@ static struct rp_info *pim_rp_find_match_group(struct pim_instance *pim,
  *
  * This is a placeholder function for now.
  */
-static void pim_rp_refresh_group_to_rp_mapping()
+static void pim_rp_refresh_group_to_rp_mapping(struct pim_instance *pim)
 {
-       pim_msdp_i_am_rp_changed();
+       pim_msdp_i_am_rp_changed(pim);
 }
 
 void pim_rp_prefix_list_update(struct pim_instance *pim,
@@ -233,7 +233,7 @@ void pim_rp_prefix_list_update(struct pim_instance *pim,
        }
 
        if (refresh_needed)
-               pim_rp_refresh_group_to_rp_mapping();
+               pim_rp_refresh_group_to_rp_mapping(pim);
 }
 
 static int pim_rp_check_interface_addrs(struct rp_info *rp_info,
@@ -419,7 +419,7 @@ int pim_rp_new(struct pim_instance *pim, const char *rp,
                                        return PIM_RP_NO_PATH;
                        }
                        pim_rp_check_interfaces(pim, rp_all);
-                       pim_rp_refresh_group_to_rp_mapping();
+                       pim_rp_refresh_group_to_rp_mapping(pim);
                        return PIM_SUCCESS;
                }
 
@@ -487,7 +487,7 @@ int pim_rp_new(struct pim_instance *pim, const char *rp,
        }
 
        pim_rp_check_interfaces(pim, rp_info);
-       pim_rp_refresh_group_to_rp_mapping();
+       pim_rp_refresh_group_to_rp_mapping(pim);
        return PIM_SUCCESS;
 }
 
@@ -550,7 +550,7 @@ int pim_rp_del(struct pim_instance *pim, const char *rp,
        }
 
        listnode_delete(pim->rp_list, rp_info);
-       pim_rp_refresh_group_to_rp_mapping();
+       pim_rp_refresh_group_to_rp_mapping(pim);
        return PIM_SUCCESS;
 }
 
@@ -629,7 +629,7 @@ void pim_rp_check_on_if_add(struct pim_interface *pim_ifp)
        }
 
        if (i_am_rp_changed) {
-               pim_msdp_i_am_rp_changed();
+               pim_msdp_i_am_rp_changed(pim);
        }
 }
 
@@ -671,7 +671,7 @@ void pim_i_am_rp_re_evaluate(struct pim_instance *pim)
        }
 
        if (i_am_rp_changed) {
-               pim_msdp_i_am_rp_changed();
+               pim_msdp_i_am_rp_changed(pim);
        }
 }
 

diff --git a/pimd/pim_upstream.c b/pimd/pim_upstream.c
index 6e255d677cd8e027ba0d468ef7b1ad3d19be1620..acaa8df80110e28db5b718d3c766d8cefd625f13 100644 (file)
--- a/pimd/pim_upstream.c
+++ b/pimd/pim_upstream.c
@@ -222,7 +222,7 @@ struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
        hash_release(pim->upstream_hash, up);
 
        if (notify_msdp) {
-               pim_msdp_up_del(&up->sg);
+               pim_msdp_up_del(pim, &up->sg);
        }
 
        /* Deregister addr with Zebra NHT */
@@ -1095,7 +1095,7 @@ static int pim_upstream_keep_alive_timer(struct thread *t)
        }
 
        /* source is no longer active - pull the SA from MSDP's cache */
-       pim_msdp_sa_local_del(&up->sg);
+       pim_msdp_sa_local_del(pim, &up->sg);
 
        /* if entry was created because of activity we need to deref it */
        if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
@@ -1132,12 +1132,11 @@ void pim_upstream_keep_alive_timer_start(struct pim_upstream *up, uint32_t time)
 /* MSDP on RP needs to know if a source is registerable to this RP */
 static int pim_upstream_msdp_reg_timer(struct thread *t)
 {
-       struct pim_upstream *up;
-
-       up = THREAD_ARG(t);
+       struct pim_upstream *up = THREAD_ARG(t);
+       struct pim_instance *pim = up->channel_oil->pim;
 
        /* source is no longer active - pull the SA from MSDP's cache */
-       pim_msdp_sa_local_del(&up->sg);
+       pim_msdp_sa_local_del(pim, &up->sg);
        return 1;
 }
 void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)