Revert "zebra: move rtadv service from zrouter to zvrf"

This reverts commit f20e2a09c8aef399698fa074b36f24becdf49cbb.

diff --git a/zebra/rtadv.c b/zebra/rtadv.c
index 80ee112a85ae554b75ed9a70423920ccb4a06f41..5088e2e8e1f62ad95c04be4477bbf44a7efc0f58 100644 (file)
--- a/zebra/rtadv.c
+++ b/zebra/rtadv.c
@@ -42,6 +42,7 @@
 #include "zebra/debug.h"
 #include "zebra/rib.h"
 #include "zebra/zapi_msg.h"
+#include "zebra/zebra_ns.h"
 #include "zebra/zebra_vrf.h"
 #include "zebra/zebra_errors.h"
 #include "zebra/zebra_router.h"
@@ -80,18 +81,18 @@ enum rtadv_event {
        RTADV_READ
 };
 
-static void rtadv_event(struct zebra_vrf *, enum rtadv_event, int);
+static void rtadv_event(struct zebra_ns *, enum rtadv_event, int);
 
 static int if_join_all_router(int, struct interface *);
 static int if_leave_all_router(int, struct interface *);
 
-static int rtadv_increment_received(struct zebra_vrf *zvrf, ifindex_t *ifindex)
+static int rtadv_increment_received(struct zebra_ns *zns, ifindex_t *ifindex)
 {
        int ret = -1;
        struct interface *iface;
        struct zebra_if *zif;
 
-       iface = if_lookup_by_index(*ifindex, zvrf->vrf->vrf_id);
+       iface = if_lookup_by_index_per_ns(zns, *ifindex);
        if (iface && iface->info) {
                zif = iface->info;
                zif->ra_rcvd++;
@@ -100,7 +101,7 @@ static int rtadv_increment_received(struct zebra_vrf *zvrf, ifindex_t *ifindex)
        return ret;
 }
 
-static int rtadv_recv_packet(struct zebra_vrf *zvrf, int sock, uint8_t *buf,
+static int rtadv_recv_packet(struct zebra_ns *zns, int sock, uint8_t *buf,
                             int buflen, struct sockaddr_in6 *from,
                             ifindex_t *ifindex, int *hoplimit)
 {
@@ -148,7 +149,7 @@ static int rtadv_recv_packet(struct zebra_vrf *zvrf, int sock, uint8_t *buf,
                }
        }
 
-       rtadv_increment_received(zvrf, ifindex);
+       rtadv_increment_received(zns, ifindex);
        return ret;
 }
 
@@ -460,19 +461,19 @@ no_more_opts:
 
 static int rtadv_timer(struct thread *thread)
 {
-       struct zebra_vrf *zvrf = THREAD_ARG(thread);
+       struct zebra_ns *zns = THREAD_ARG(thread);
        struct vrf *vrf;
        struct interface *ifp;
        struct zebra_if *zif;
        int period;
 
-       zvrf->rtadv.ra_timer = NULL;
-       if (zvrf->rtadv.adv_msec_if_count == 0) {
+       zrouter.rtadv.ra_timer = NULL;
+       if (zrouter.rtadv.adv_msec_if_count == 0) {
                period = 1000; /* 1 s */
-               rtadv_event(zvrf, RTADV_TIMER, 1 /* 1 s */);
+               rtadv_event(zns, RTADV_TIMER, 1 /* 1 s */);
        } else {
                period = 10; /* 10 ms */
-               rtadv_event(zvrf, RTADV_TIMER_MSEC, 10 /* 10 ms */);
+               rtadv_event(zns, RTADV_TIMER_MSEC, 10 /* 10 ms */);
        }
 
        RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
@@ -499,7 +500,7 @@ static int rtadv_timer(struct thread *thread)
                                                        "Fast RA Rexmit on interface %s",
                                                        ifp->name);
 
-                                       rtadv_send_packet(zvrf->rtadv.sock,
+                                       rtadv_send_packet(zrouter.rtadv.sock,
                                                          ifp);
                                } else {
                                        zif->rtadv.AdvIntervalTimer -= period;
@@ -513,7 +514,7 @@ static int rtadv_timer(struct thread *thread)
                                                        zif->rtadv
                                                                .MaxRtrAdvInterval;
                                                rtadv_send_packet(
-                                                       zvrf->rtadv.sock,
+                                                       zrouter.rtadv.sock,
                                                        ifp);
                                        }
                                }
@@ -526,9 +527,10 @@ static int rtadv_timer(struct thread *thread)
 static void rtadv_process_solicit(struct interface *ifp)
 {
        struct zebra_vrf *zvrf = vrf_info_lookup(ifp->vrf_id);
+       struct zebra_ns *zns = zvrf->zns;
 
-       assert(zvrf);
-       rtadv_send_packet(zvrf->rtadv.sock, ifp);
+       assert(zns);
+       rtadv_send_packet(zrouter.rtadv.sock, ifp);
 }
 
 /*
@@ -650,7 +652,7 @@ static void rtadv_process_advert(uint8_t *msg, unsigned int len,
 static void rtadv_process_packet(uint8_t *buf, unsigned int len,
                                 ifindex_t ifindex, int hoplimit,
                                 struct sockaddr_in6 *from,
-                                struct zebra_vrf *zvrf)
+                                struct zebra_ns *zns)
 {
        struct icmp6_hdr *icmph;
        struct interface *ifp;
@@ -660,7 +662,7 @@ static void rtadv_process_packet(uint8_t *buf, unsigned int len,
        inet_ntop(AF_INET6, &from->sin6_addr, addr_str, INET6_ADDRSTRLEN);
 
        /* Interface search. */
-       ifp = if_lookup_by_index(ifindex, zvrf->vrf->vrf_id);
+       ifp = if_lookup_by_index_per_ns(zns, ifindex);
        if (ifp == NULL) {
                flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE,
                          "RA/RS received on unknown IF %u from %s", ifindex,
@@ -722,15 +724,15 @@ static int rtadv_read(struct thread *thread)
        struct sockaddr_in6 from;
        ifindex_t ifindex = 0;
        int hoplimit = -1;
-       struct zebra_vrf *zvrf = THREAD_ARG(thread);
+       struct zebra_ns *zns = THREAD_ARG(thread);
 
        sock = THREAD_FD(thread);
-       zvrf->rtadv.ra_read = NULL;
+       zrouter.rtadv.ra_read = NULL;
 
        /* Register myself. */
-       rtadv_event(zvrf, RTADV_READ, sock);
+       rtadv_event(zns, RTADV_READ, sock);
 
-       len = rtadv_recv_packet(zvrf, sock, buf, sizeof(buf), &from, &ifindex,
+       len = rtadv_recv_packet(zns, sock, buf, sizeof(buf), &from, &ifindex,
                                &hoplimit);
 
        if (len < 0) {
@@ -740,7 +742,7 @@ static int rtadv_read(struct thread *thread)
                return len;
        }
 
-       rtadv_process_packet(buf, (unsigned)len, ifindex, hoplimit, &from, zvrf);
+       rtadv_process_packet(buf, (unsigned)len, ifindex, hoplimit, &from, zns);
 
        return 0;
 }
@@ -873,27 +875,29 @@ static void ipv6_nd_suppress_ra_set(struct interface *ifp,
 {
        struct zebra_if *zif;
        struct zebra_vrf *zvrf;
+       struct zebra_ns *zns;
 
        zif = ifp->info;
        zvrf = vrf_info_lookup(ifp->vrf_id);
+       zns = zvrf->zns;
 
        if (status == RA_SUPPRESS) {
                /* RA is currently enabled */
                if (zif->rtadv.AdvSendAdvertisements) {
                        zif->rtadv.AdvSendAdvertisements = 0;
                        zif->rtadv.AdvIntervalTimer = 0;
-                       zvrf->rtadv.adv_if_count--;
+                       zrouter.rtadv.adv_if_count--;
 
-                       if_leave_all_router(zvrf->rtadv.sock, ifp);
+                       if_leave_all_router(zrouter.rtadv.sock, ifp);
 
-                       if (zvrf->rtadv.adv_if_count == 0)
-                               rtadv_event(zvrf, RTADV_STOP, 0);
+                       if (zrouter.rtadv.adv_if_count == 0)
+                               rtadv_event(zns, RTADV_STOP, 0);
                }
        } else {
                if (!zif->rtadv.AdvSendAdvertisements) {
                        zif->rtadv.AdvSendAdvertisements = 1;
                        zif->rtadv.AdvIntervalTimer = 0;
-                       zvrf->rtadv.adv_if_count++;
+                       zrouter.rtadv.adv_if_count++;
 
                        if (zif->rtadv.MaxRtrAdvInterval >= 1000) {
                                /* Enable Fast RA only when RA interval is in
@@ -903,11 +907,11 @@ static void ipv6_nd_suppress_ra_set(struct interface *ifp,
                                        RTADV_NUM_FAST_REXMITS;
                        }
 
-                       if_join_all_router(zvrf->rtadv.sock, ifp);
+                       if_join_all_router(zrouter.rtadv.sock, ifp);
 
-                       if (zvrf->rtadv.adv_if_count == 1)
-                               rtadv_event(zvrf, RTADV_START,
-                                           zvrf->rtadv.sock);
+                       if (zrouter.rtadv.adv_if_count == 1)
+                               rtadv_event(zns, RTADV_START,
+                                           zrouter.rtadv.sock);
                }
        }
 }
@@ -940,7 +944,7 @@ static void zebra_interface_radv_set(ZAPI_HANDLER_ARGS, int enable)
                           zebra_route_string(client->proto), ra_interval);
 
        /* Locate interface and check VRF match. */
-       ifp = if_lookup_by_index(ifindex, zvrf->vrf->vrf_id);
+       ifp = if_lookup_by_index_per_ns(zebra_ns_lookup(NS_DEFAULT), ifindex);
        if (!ifp) {
                flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE,
                          "%u: IF %u RA %s client %s - interface unknown",
@@ -1047,9 +1051,6 @@ DEFUN (ipv6_nd_ra_interval_msec,
        VTY_DECLVAR_CONTEXT(interface, ifp);
        unsigned interval;
        struct zebra_if *zif = ifp->info;
-       struct zebra_vrf *zvrf;
-
-       zvrf = vrf_info_lookup(ifp->vrf_id);
 
        interval = strtoul(argv[idx_number]->arg, NULL, 10);
        if ((zif->rtadv.AdvDefaultLifetime != -1
@@ -1060,10 +1061,10 @@ DEFUN (ipv6_nd_ra_interval_msec,
        }
 
        if (zif->rtadv.MaxRtrAdvInterval % 1000)
-               zvrf->rtadv.adv_msec_if_count--;
+               zrouter.rtadv.adv_msec_if_count--;
 
        if (interval % 1000)
-               zvrf->rtadv.adv_msec_if_count++;
+               zrouter.rtadv.adv_msec_if_count++;
 
        SET_FLAG(zif->rtadv.ra_configured, VTY_RA_INTERVAL_CONFIGURED);
        zif->rtadv.MaxRtrAdvInterval = interval;
@@ -1085,9 +1086,6 @@ DEFUN (ipv6_nd_ra_interval,
        VTY_DECLVAR_CONTEXT(interface, ifp);
        unsigned interval;
        struct zebra_if *zif = ifp->info;
-       struct zebra_vrf *zvrf;
-
-       zvrf = vrf_info_lookup(ifp->vrf_id);
 
        interval = strtoul(argv[idx_number]->arg, NULL, 10);
        if ((zif->rtadv.AdvDefaultLifetime != -1
@@ -1098,7 +1096,7 @@ DEFUN (ipv6_nd_ra_interval,
        }
 
        if (zif->rtadv.MaxRtrAdvInterval % 1000)
-               zvrf->rtadv.adv_msec_if_count--;
+               zrouter.rtadv.adv_msec_if_count--;
 
        /* convert to milliseconds */
        interval = interval * 1000;
@@ -1124,12 +1122,9 @@ DEFUN (no_ipv6_nd_ra_interval,
 {
        VTY_DECLVAR_CONTEXT(interface, ifp);
        struct zebra_if *zif = ifp->info;
-       struct zebra_vrf *zvrf = NULL;
-
-       zvrf = vrf_info_lookup(ifp->vrf_id);
 
        if (zif->rtadv.MaxRtrAdvInterval % 1000)
-               zvrf->rtadv.adv_msec_if_count--;
+               zrouter.rtadv.adv_msec_if_count--;
 
        UNSET_FLAG(zif->rtadv.ra_configured, VTY_RA_INTERVAL_CONFIGURED);
 
@@ -2099,15 +2094,15 @@ static int rtadv_config_write(struct vty *vty, struct interface *ifp)
 }
 
 
-static void rtadv_event(struct zebra_vrf *zvrf, enum rtadv_event event, int val)
+static void rtadv_event(struct zebra_ns *zns, enum rtadv_event event, int val)
 {
-       struct rtadv *rtadv = &zvrf->rtadv;
+       struct rtadv *rtadv = &zrouter.rtadv;
 
        switch (event) {
        case RTADV_START:
-               thread_add_read(zrouter.master, rtadv_read, zvrf, val,
+               thread_add_read(zrouter.master, rtadv_read, zns, val,
                                &rtadv->ra_read);
-               thread_add_event(zrouter.master, rtadv_timer, zvrf, 0,
+               thread_add_event(zrouter.master, rtadv_timer, zns, 0,
                                 &rtadv->ra_timer);
                break;
        case RTADV_STOP:
@@ -2121,15 +2116,15 @@ static void rtadv_event(struct zebra_vrf *zvrf, enum rtadv_event event, int val)
                }
                break;
        case RTADV_TIMER:
-               thread_add_timer(zrouter.master, rtadv_timer, zvrf, val,
+               thread_add_timer(zrouter.master, rtadv_timer, zns, val,
                                 &rtadv->ra_timer);
                break;
        case RTADV_TIMER_MSEC:
-               thread_add_timer_msec(zrouter.master, rtadv_timer, zvrf, val,
+               thread_add_timer_msec(zrouter.master, rtadv_timer, zns, val,
                                      &rtadv->ra_timer);
                break;
        case RTADV_READ:
-               thread_add_read(zrouter.master, rtadv_read, zvrf, val,
+               thread_add_read(zrouter.master, rtadv_read, zns, val,
                                &rtadv->ra_read);
                break;
        default:
@@ -2138,21 +2133,21 @@ static void rtadv_event(struct zebra_vrf *zvrf, enum rtadv_event event, int val)
        return;
 }
 
-void rtadv_init(struct zebra_vrf *zvrf)
+void rtadv_init(struct zebra_ns *zns)
 {
-       zvrf->rtadv.sock = rtadv_make_socket(zvrf->zns->ns_id);
+       zrouter.rtadv.sock = rtadv_make_socket(zns->ns_id);
 }
 
-void rtadv_terminate(struct zebra_vrf *zvrf)
+void rtadv_terminate(struct zebra_ns *zns)
 {
-       rtadv_event(zvrf, RTADV_STOP, 0);
-       if (zvrf->rtadv.sock >= 0) {
-               close(zvrf->rtadv.sock);
-               zvrf->rtadv.sock = -1;
+       rtadv_event(zns, RTADV_STOP, 0);
+       if (zrouter.rtadv.sock >= 0) {
+               close(zrouter.rtadv.sock);
+               zrouter.rtadv.sock = -1;
        }
 
-       zvrf->rtadv.adv_if_count = 0;
-       zvrf->rtadv.adv_msec_if_count = 0;
+       zrouter.rtadv.adv_if_count = 0;
+       zrouter.rtadv.adv_msec_if_count = 0;
 }
 
 void rtadv_cmd_init(void)
@@ -2248,11 +2243,11 @@ static int if_leave_all_router(int sock, struct interface *ifp)
 }
 
 #else
-void rtadv_init(struct zebra_vrf *zvrf)
+void rtadv_init(struct zebra_ns *zns)
 {
        /* Empty.*/;
 }
-void rtadv_terminate(struct zebra_vrf *zvrf)
+void rtadv_terminate(struct zebra_ns *zns)
 {
        /* Empty.*/;
 }

diff --git a/zebra/rtadv.h b/zebra/rtadv.h
index 8ad3de7f17a6064dae1576d982a8ce7f79405562..53c497fc09c49b4823c96e12d515c0c07e0fae6d 100644 (file)
--- a/zebra/rtadv.h
+++ b/zebra/rtadv.h
@@ -135,8 +135,8 @@ typedef enum {
        RA_SUPPRESS,
 } ipv6_nd_suppress_ra_status;
 
-extern void rtadv_init(struct zebra_vrf *);
-extern void rtadv_terminate(struct zebra_vrf *);
+extern void rtadv_init(struct zebra_ns *);
+extern void rtadv_terminate(struct zebra_ns *);
 extern void rtadv_cmd_init(void);
 extern void zebra_interface_radv_disable(ZAPI_HANDLER_ARGS);
 extern void zebra_interface_radv_enable(ZAPI_HANDLER_ARGS);

diff --git a/zebra/zebra_ns.c b/zebra/zebra_ns.c
index db4f9d0015c0df099394ff766af38119233043d9..0c743d86784b1ab848ab45ee44f1bae82b3cc1f9 100644 (file)
--- a/zebra/zebra_ns.c
+++ b/zebra/zebra_ns.c
@@ -27,6 +27,7 @@
 #include "lib/prefix.h"
 #include "lib/memory.h"
 
+#include "rtadv.h"
 #include "zebra_ns.h"
 #include "zebra_vrf.h"
 #include "zebra_memory.h"
@@ -121,6 +122,10 @@ int zebra_ns_enable(ns_id_t ns_id, void **info)
 
        zns->ns_id = ns_id;
 
+#if defined(HAVE_RTADV)
+       rtadv_init(zns);
+#endif
+
        kernel_init(zns);
        interface_list(zns);
        route_read(zns);
@@ -137,6 +142,9 @@ int zebra_ns_enable(ns_id_t ns_id, void **info)
 static int zebra_ns_disable_internal(struct zebra_ns *zns, bool complete)
 {
        route_table_finish(zns->if_table);
+#if defined(HAVE_RTADV)
+       rtadv_terminate(zns);
+#endif
 
        kernel_terminate(zns, complete);
 

diff --git a/zebra/zebra_router.h b/zebra/zebra_router.h
index 86422ea1eed52ae3301320f04a2d9a996b9a9c25..b3def297ac6bfdc59ce9da411df71da36fde8295 100644 (file)
--- a/zebra/zebra_router.h
+++ b/zebra/zebra_router.h
@@ -82,6 +82,10 @@ struct zebra_router {
 
        struct hash *iptable_hash;
 
+#if defined(HAVE_RTADV)
+       struct rtadv rtadv;
+#endif /* HAVE_RTADV */
+
        /* A sequence number used for tracking routes */
        _Atomic uint32_t sequence_num;
 

diff --git a/zebra/zebra_vrf.c b/zebra/zebra_vrf.c
index fdf0cbc693fc282b4570c443333f0d639baee37e..63430549438d9e9c1eef998066c9ae0c17d1fa24 100644 (file)
--- a/zebra/zebra_vrf.c
+++ b/zebra/zebra_vrf.c
@@ -29,7 +29,6 @@
 #include "vty.h"
 
 #include "zebra/zebra_router.h"
-#include "zebra/rtadv.h"
 #include "zebra/debug.h"
 #include "zebra/zapi_msg.h"
 #include "zebra/rib.h"
@@ -120,10 +119,6 @@ static int zebra_vrf_enable(struct vrf *vrf)
                zvrf->zns = zebra_ns_lookup((ns_id_t)vrf->vrf_id);
        else
                zvrf->zns = zebra_ns_lookup(NS_DEFAULT);
-#if defined(HAVE_RTADV)
-       rtadv_init(zvrf);
-#endif
-
        /* Inform clients that the VRF is now active. This is an
         * add for the clients.
         */
@@ -166,10 +161,6 @@ static int zebra_vrf_disable(struct vrf *vrf)
        /* Stop any VxLAN-EVPN processing. */
        zebra_vxlan_vrf_disable(zvrf);
 
-#if defined(HAVE_RTADV)
-       rtadv_terminate(zvrf);
-#endif
-
        /* Inform clients that the VRF is now inactive. This is a
         * delete for the clients.
         */

diff --git a/zebra/zebra_vrf.h b/zebra/zebra_vrf.h
index 972fe381cc1fbb89aa105d23cfa1559ec8cdbbba..febaf3c844efa0351b80e734514b7339cc2e87c7 100644 (file)
--- a/zebra/zebra_vrf.h
+++ b/zebra/zebra_vrf.h
@@ -169,10 +169,6 @@ struct zebra_vrf {
        uint64_t lsp_removals_queued;
        uint64_t lsp_installs;
        uint64_t lsp_removals;
-
-#if defined(HAVE_RTADV)
-       struct rtadv rtadv;
-#endif /* HAVE_RTADV */
 };
 #define PROTO_RM_NAME(zvrf, afi, rtype) zvrf->proto_rm[afi][rtype].name
 #define NHT_RM_NAME(zvrf, afi, rtype) zvrf->nht_rm[afi][rtype].name