On 11/11/26 2:07 PM, Rukomoinikova Aleksandra wrote:
> On 11.11.2026 13:58, Dumitru Ceara wrote:
>> On 11/11/26 11:32 AM, Rukomoinikova Aleksandra wrote:
>>> On 11.11.2026 01:48, Numan Siddique wrote:
>>>> On Fri, Aug 28, 2026 at 6:18 AM Alexandra Rukomoinikova via dev
>>>> <[email protected]> wrote:
>>>>> Until now the CMS had to create the EVPN interface stack (bridge,
>>>>> VXLAN and advertise devices) on every chassis itself and pass the
>>>>> interface names via the "dynamic-routing-bridge-ifname",
>>>>> "dynamic-routing-vxlan-ifname" and "dynamic-routing-advertise-ifname"
>>>>> options of the Logical_Switch.
>>>>>
>>>>> Add a new "dynamic-routing-maintain-evpn" option, which makes
>>>>> ovn-controller create and maintain those interfaces on its own on
>>>>> every chassis where the logical switch is local. The only supported
>>>>> value is "mvd", i.e. one VXLAN device per VNI. The devices are named
>>>>> after the VNI: ovnbr<vni>, ovnvxlan<vni> and ovnlo<vni>.
>>>>>
>>>>> If "dynamic-routing-redistribute" includes "ip", the logical router
>>>>> port has to be specified with "dynamic-routing-maintain-evpn-lrp".
>>>>> In that case ovn-controller also creates the ovnvrf<vni> VRF, enslaves
>>>>> the bridge to it and assigns the router port MAC to the bridge, so
>>>>> that the logical router addresses can be advertised over EVPN.
>>>>> The interfaces are removed on graceful shutdown of ovn-controller.
>>>>>
>>>>> The UDP destination port of the VXLAN device is configurable with
>>>>> the "dynamic-routing-maintain-evpn-vxlan-port" option and defaults
>>>>> to 4790. It has to differ from the port used by the OVS datapath
>>>>> VXLAN device, because the maintained device only carries EVPN state
>>>>> for the routing daemon.
>>>>>
>>>>> Signed-off-by: Alexandra Rukomoinikova <[email protected]>
>>>> Hi Alexandra,
>>>>
>> Hi Alexandra, Numan,
>>
>>>> Thanks for working on this; having ovn-controller own the EVPN
>>>> device stack is a nice improvement. I built the series (it
>>>> compiles cleanly) and went through it, and found a few issues that
>>>> I think need addressing before it can go in.
>>>>
>> Indeed, thanks for working on this! I can see how this would make the
>> CMS life easier. However, I have some more concerns, please see below.
>>
>>>> 1) Interface names can exceed IFNAMSIZ.
>>>>
>>>> The devices are named ovnvxlan<vni>, ovnbr<vni>, ovnlo<vni> and
>>>> ovnvrf<vni>. A VNI can have 8 digits, so for VNI >= 10000000
>>>> "ovnvxlan<vni>" is 16 characters, but Linux allows at most 15.
>>>> The buffers are IFNAMSIZ + 1, so snprintf() doesn't truncate,
>>>> and the kernel then rejects the name on every run. Could we use
>>>> a shorter prefix (e.g. "ovnvx"), or at least reject such VNIs
>>>> with a clear warning?
>>>>
>>>> 2) VRF names and table ids can collide with route-exchange.
>>>>
>>>> route-exchange already creates VRFs named "ovnvrf<table_id>"
>>>> (controller/route.c). This patch creates "ovnvrf<vni>" with the
>>>> VNI as the table id. If a router's dynamic-routing VRF id
>>>> happens to equal a switch's VNI, both features end up managing
>>>> the same device. route-exchange creates it with NLM_F_EXCL and
>>>> treats EEXIST as an error, the EVPN code treats EEXIST as
>>>> success, and whichever side tears down first deletes the
>>>> other's VRF. Using the VNI as the table id also clashes with any
>>>> other user of that table number.
>>>>
>>>> 3) VNI 253/254 maps onto the default/main routing table.
>>>>
>>>> Related to the above: TABLE_ID_VALID() doesn't exclude
>>>> RT_TABLE_DEFAULT or RT_TABLE_MAIN, so a VNI of 254 creates a VRF
>>>> bound to the host's main table. I think we need a separate
>>>> table id (configurable, or derived in a way that can't hit
>>>> reserved or already-used tables) rather than using the VNI
>>>> directly.
>>>>
>>>> 4) The link device is hard-coded to vxlan_sys_4789.
>>>>
>>>> ovn-controller creates the OVS EVPN VXLAN ports from the
>>>> chassis's ovn-evpn-vxlan-ports, which can be any port, so the
>>>> kernel device is vxlan_sys_<port>. On a chassis that isn't
>>>> using port 4789 (or has no EVPN VXLAN port yet) the lookup
>>>> fails. evpn_create_devices() then returns false, the entry
>>>> never becomes synced, and every engine run re-runs the whole
>>>> create path, sets the netlink error status (which keeps waking
>>>> the engine) and logs a warning. The system test works around
>>>> this by creating vxlan_sys_4789 by hand.
>>>>
>>>> Along the same lines, the documentation says the maintained
>>>> device's port (default 4790) must differ from "the OVS datapath
>>>> VXLAN device (4789)". It really has to differ from whatever is
>>>> in ovn-evpn-vxlan-ports; if that includes 4790, the two devices
>>>> compete for the same UDP port. Can we derive both the link
>>>> device and the conflict check from ovn-evpn-vxlan-ports?
>>>>
>>>> 5) Existing devices are adopted without checking them.
>>>>
>>>> EEXIST is treated as success and the reconcile state lives only
>>>> in memory, so after "ovn-controller exit --restart":
>>>>
>>>> - if the local IP, VXLAN port, LRP MAC or redistribute mode of a
>>>> VNI changed while ovn-controller was down, the old devices are
>>>> kept with the stale configuration;
>>>> - if a VNI was removed while ovn-controller was down, its devices
>>>> are never cleaned up;
>>>> - a CMS-created device that happens to be named ovnbr<vni> etc.
>>>> is taken over, and later deleted.
>>>>
>>>> The restart test passes because the VNI is still present after
>>>> the restart, but removing it while ovn-controller is down isn't
>>>> covered. I think we need to verify the kind and attributes of
>>>> an existing device before trusting EEXIST, and to sweep stale
>>>> ovn*<vni> devices on startup.
>>> Hi Numan and Dumitru and Ales,
>>>
>>> I’ve thought some more about why I implemented it this way, and I’d like
>>> to discuss one point.
>>>
>>> Some context for Dumitru and Ales: I added you to the thread because I’d
>>> be interested in your opinion. Currently, the code that creates the EVPN
>>> interfaces (|ovnbr<vni>|, |ovnvxlan<vni>|, |ovnlo<vni>|, and
>>> |ovnvrf<vni>|) does not check their actual state in the kernel. It only
>>> reacts to changes in the desired configuration: options, local IP, and
>>> so on. If an interface is modified or deleted externally, the controller
>>> won’t notice. It won’t even recreate a deleted interface until something
>>> changes in the configuration.
>>>
>>> I implemented it this way for two reasons:
>>>
>>> 1.
>>>
>>> I thought it made sense that, once we give OVN responsibility for
>>> these interfaces, the CMS has neither a need nor a reason to touch
>>> them. So the controller shouldn’t need to expect changes made
>>> outside its control. But I agree that this reasoning breaks down as
>>> soon as a person gets involved: someone could easily modify
>>> interfaces created by OVN, either by mistake or while debugging. My
>>> assumption here was that, if the CMS or a person changes something,
>>> OVN can already break things even without my code, because the
>>> controller currently retries failed netlink transactions in a loop.
>>>
>>> 2.
>>>
>>> I didn’t want to check kernel state on every controller iteration,
>>> as that seemed excessive. However, |neighbor_exchange_run()|already
>>> dumps the neighbor table for every tracked interface on every
>>> iteration, which is considerably more expensive than a few
>>> |RTM_GETLINK|requests. So this argument doesn’t seem to hold up.
>> You make a good point here but that is something we should address in
>> general anyway, we should add proper incremental processing for
>> monitoring kernel state (routes, neighbors, links, etc).
>>
>>> There is another case the current approach doesn’t cover: an
>>> |ovn-controller|restart (|exit --restart|or a crash), as Numan pointed
>>> out in the review above. After startup, the internal state is empty,
>>> interface creation returns |EEXIST|, and we consider the stack
>>> synchronized. If, for example, the VXLAN port or local IP changed while
>>> the controller was down, the device will retain the old values, and the
>>> controller won’t know.
>>>
>>> So the question is which approach would be better:
>>>
>>> 1.
>>>
>>> *Check on every iteration.*Send |RTM_GETLINK|requests for each VNI’s
>>> interfaces on every iteration. Check that each interface exists and
>>> verify its type, master, MAC address, and UP state; for VXLAN, also
>>> check the VNI, local IP, destination port, and link. Compare these
>>> against the desired configuration. Fix attributes that the kernel
>>> doesn’t allow changing on an existing device (port, local IP, VNI)
>>> by recreating the interface, and update everything else in place.
>>> The advantage is that this is simple and reliable: it doesn’t depend
>>> on what woke the controller up, and the same code handles restarts,
>>> lost events, and manual changes. The downside I’m not happy about is
>>> the amount of code needed to parse and compare attributes.
>>>
>>> 2.
>>>
>>> *Rely on *|*if_notifier_cb*|*.*Check kernel state only when
>>> |host-if-monitor|reports a change to our interfaces. To make this
>>> reliable, we would need to:
>>>
>>> *
>>>
>>> Keep a module-level dirty flag and clear it only after
>>> successful reconciliation here in evpn devices code.
>>>
>>> *
>>>
>>> Handle |ENOBUFS|on the netlink socket, indicating lost events,
>>> by marking everything dirty. Currently, the callback simply
>>> returns in this case.
>>>
>>> *
>>>
>>> Remove the |IFF_UP|filter in |if_notifier_cb|so that we also
>>> catch interfaces going down, and add |ovnvrf*|to the tracked
>>> interfaces.
>>>
>>> *
>>>
>>> Always reconcile with the kernel when ovn-controller starts,
>>> since devices left over from a previous run don’t generate any
>>> events.
>>> The advantage is that we query the kernel only when something
>>> has actually changed. The downside is more state and more edge
>>> cases that are easy to miss. It doesn’t really seem worth it.
>>>
>>> We need the attribute parsing and comparison code in both approaches, at
>>> least to handle restarts. The only difference is /when/we call it. So
>>> I’m leaning toward the first approach: it’s simpler and more reliable.
>>> But maybe you have different opinions.
>>>
>> This is, IIRC, the main reason why in internal discussions I had with
>> Ales when trying to figure out how to integrate OVN with EVPN
>> deployments we decided against maintaining the required host side
>> devices ourselves - it's quite a lot of (arguably uninteresting) work.
>> And probably with a lot of added code and the bugs that come with it.
>>
>>> What do you think?
>>>
>> I'm wondering now if it isn't better to just provide a helper utility as
>> part of OVN utilities that the CMS can run to ensure that the host side
>> interfaces are in the correct state (matching what's in the NB and SB
>> database). It doesn't have to but it could be a simple script I guess.
>> And it could reconcile the host side interfaces automatically if needed.
>>
>> It would still be up to the CMS to figure out the best way to run the
>> utility, e.g., triggered when specific interface changes are detected.
>>
>> Would it make sense to reconsider this as a different approach?
>
> Hi, thanks for the reply!
>
> To be honest, I’m not entirely sure the script is the right way to go.
> Let me describe how I picture it, so we can check it matches what you
> have in mind:
>
> 1. ovn-controller has a handler that validates all the interface
> attributes against the current configuration and recreates the
> interfaces if needed.
The way I was imagining it (maybe over-simplified) was that
ovn-controller doesn't do any of this work. It would be the
responsibility of the CMS to call the script whenever it (re)starts
ovn-controller (e.g., as part of the systemd scripts).
> 2. We call it on ovn-controller startup, which solves the problem Numan
> described (more on that below).
See above.
> 3. If the CMS isn’t sure the interfaces are valid, it can call the same
> entry point.
>
> The upside is that ovn-controller doesn’t have to check every attribute
> on every iteration. But I have some doubts about it, because it means
> one more knob and one more entry point. The whole idea of maintain-evpn
> is that OVN owns these interfaces and the CMS doesn’t have to think
> about them. A “check it if you’re not sure” knob hands that
> responsibility back to the CMS. That said, if you think this approach
> sounds good, I’m happy to add it. I will cast aside all my doubts
>
I'm not sure it's the best thing, I was just trying to reconsider it as
an alternative. :)
> About the problem Numan described: it also applies to the VRFs in
> dynamic routing. If ovn-controller is stopped without cleanup and
> someone changes the configuration in the meantime (removes the VNI or
> the maintain-vrf option), then after the restart ovn-controller will
> never clean up the leftover interfaces.
>
> I think this can be solved separately from this patch, for EVPN and VRF
> at the same time. My idea is:
>
> * Put all interfaces created by OVN into the same device group
> (IFLA_GROUP). It can be set right when the interface is created.
> * On ovn-controller startup, dump the interfaces and delete the ones
> in our group that are no longer in the current configuration.
> * Do this only once, on startup.
> * Interfaces created by the CMS (e.g. a VRF without maintain-vrf)
> aren’t in our group, so we won’t touch them.
>
> The group number should probably be configurable, in case groups are
> already used for something else on the host.
>
This is a nice idea! I'd argue however that the group number should be
mandatory if we go this way.
> With this approach, on ovn-controller startup we can call the routine
> that syncs the attributes and cleans up the stale interfaces.
>
> What do you think?
>
I guess as long as we document it well that CMS touching anything that's
in that group results in a misconfiguration it's probably fine.
I'm curious what others think about this (Ales, Numan, ..) though.
> Thanks, Sasha
>
Thanks for the discussion!
Dumitru
>>> Thanks!
>>> Sasha
>>>
>>>> A few smaller things:
>>>>
>>>> - The "Unable to create VRF %s for datapath %s" message passes the
>>>> error string as the datapath, and the "Unable to enslave %s to
>>>> bridge %s" message is also used when the master is the VRF.
>>>>
>>>> - The comments in neighbor.h and neighbor-exchange.h say that
>>>> maintain_evpn may be NULL, but neighbor_run() and
>>>> neighbor_exchange_maintain_evpn_run() dereference it
>>>> unconditionally. Either handle NULL or drop the comments.
>>>>
>>>> - ovnlo<vni> is always added to the monitored interfaces, but it's
>>>> only created when "fdb" redistribution is enabled.
>>>>
>>>> - "mainatain" is misspelled throughout (enum, field and variable
>>>> names), and the comment on neighbor_bridge_iface_config refers to
>>>> "dynamic-routing-evpn-lrp" instead of
>>>> "dynamic-routing-maintain-evpn-lrp".
>>>>
>>>> Thanks,
>>>> Numan
>>>>
>>>>
>> Regards,
>> Dumitru
>>
>>>>> ---
>>>>> controller/host-if-monitor.c | 15 ++
>>>>> controller/host-if-monitor.h | 2 +-
>>>>> controller/neighbor-exchange-stub.c | 10 +
>>>>> controller/neighbor-exchange.c | 350 +++++++++++++++++++++++++++-
>>>>> controller/neighbor-exchange.h | 8 +
>>>>> controller/neighbor.c | 205 +++++++++++++---
>>>>> controller/neighbor.h | 37 +++
>>>>> controller/netlink-utils.h | 4 +-
>>>>> controller/ovn-controller.c | 20 ++
>>>>> lib/ovn-util.c | 24 ++
>>>>> lib/ovn-util.h | 2 +-
>>>>> northd/en-datapath-logical-switch.c | 22 ++
>>>>> ovn-nb.xml | 113 ++++++++-
>>>>> tests/system-ovn.at | 325 ++++++++++++++++++++++++++
>>>>> 14 files changed, 1094 insertions(+), 43 deletions(-)
>>>>>
>>>>> diff --git a/controller/host-if-monitor.c b/controller/host-if-monitor.c
>>>>> index 65110d2a3..bbd86aaa5 100644
>>>>> --- a/controller/host-if-monitor.c
>>>>> +++ b/controller/host-if-monitor.c
>>>>> @@ -65,6 +65,21 @@ host_if_monitor_run(void)
>>>>> return monitor.changes_detected;
>>>>> }
>>>>>
>>>>> +void
>>>>> +host_if_monitor_invalidate(const char *if_name)
>>>>> +{
>>>>> + if (!sset_contains(&monitor.watched_interfaces, if_name)) {
>>>>> + return;
>>>>> + }
>>>>> +
>>>>> + int32_t ifindex = if_nametoindex(if_name);
>>>>> + if (ifindex) {
>>>>> + simap_put(&monitor.ifname_to_ifindex, if_name, ifindex);
>>>>> + } else {
>>>>> + simap_find_and_delete(&monitor.ifname_to_ifindex, if_name);
>>>>> + }
>>>>> +}
>>>>> +
>>>>> void
>>>>> host_if_monitor_update_watches(const struct sset *if_names)
>>>>> {
>>>>> diff --git a/controller/host-if-monitor.h b/controller/host-if-monitor.h
>>>>> index a41c5869c..f625d839c 100644
>>>>> --- a/controller/host-if-monitor.h
>>>>> +++ b/controller/host-if-monitor.h
>>>>> @@ -22,7 +22,7 @@
>>>>>
>>>>> void host_if_monitor_wait(void);
>>>>> bool host_if_monitor_run(void);
>>>>> -
>>>>> +void host_if_monitor_invalidate(const char *if_name);
>>>>> void host_if_monitor_update_watches(const struct sset *if_names);
>>>>>
>>>>> int32_t host_if_monitor_ifname_toindex(const char *if_name);
>>>>> diff --git a/controller/neighbor-exchange-stub.c
>>>>> b/controller/neighbor-exchange-stub.c
>>>>> index a1c89ed2b..5a0912b73 100644
>>>>> --- a/controller/neighbor-exchange-stub.c
>>>>> +++ b/controller/neighbor-exchange-stub.c
>>>>> @@ -45,3 +45,13 @@ void
>>>>> evpn_static_entries_clear(struct hmap *static_entries OVS_UNUSED)
>>>>> {
>>>>> }
>>>>> +
>>>>> +void
>>>>> +neighbor_exchange_maintain_evpn_cleanup_all(void)
>>>>> +{
>>>>> +}
>>>>> +
>>>>> +void
>>>>> +neighbor_exchange_maintain_evpn_destroy(void)
>>>>> +{
>>>>> +}
>>>>> diff --git a/controller/neighbor-exchange.c
>>>>> b/controller/neighbor-exchange.c
>>>>> index 43626cc21..e21eaf8f0 100644
>>>>> --- a/controller/neighbor-exchange.c
>>>>> +++ b/controller/neighbor-exchange.c
>>>>> @@ -15,12 +15,16 @@
>>>>>
>>>>> #include <config.h>
>>>>>
>>>>> +#include <errno.h>
>>>>> #include <linux/neighbour.h>
>>>>> +#include <net/if.h>
>>>>>
>>>>> #include "host-if-monitor.h"
>>>>> +#include "lib/sset.h"
>>>>> #include "neighbor.h"
>>>>> #include "neighbor-exchange.h"
>>>>> #include "neighbor-exchange-netlink.h"
>>>>> +#include "route-exchange-netlink.h"
>>>>> #include "openvswitch/poll-loop.h"
>>>>> #include "openvswitch/vlog.h"
>>>>> #include "ovn-util.h"
>>>>> @@ -47,6 +51,8 @@ static uint32_t evpn_static_entry_hash(const struct
>>>>> eth_addr *mac,
>>>>> const struct in6_addr *ip,
>>>>> uint32_t vni, uint32_t nh_id);
>>>>>
>>>>> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
>>>>> +
>>>>> /* Last neighbor_exchange netlink operation. */
>>>>> static int neighbor_exchange_nl_status;
>>>>>
>>>>> @@ -65,10 +71,353 @@ static int neighbor_exchange_nl_status;
>>>>> } \
>>>>> } while (0)
>>>>>
>>>>> +/* Tracks the EVPN interface stack of a single VNI.
>>>>> + *
>>>>> + * Presence in 'maintained_evpn_entries' means "OVN may have created
>>>>> kernel
>>>>> + * devices for this VNI and is therefore responsible for tearing them
>>>>> down".
>>>>> + * An entry is inserted before the first netlink call is issued, so that
>>>>> a
>>>>> + * stack that was only partially created is still cleaned up later. */
>>>>> +struct maintained_evpn_entry {
>>>>> + struct hmap_node node;
>>>>> + /* The configuration the devices were last (re)created with, i.e.
>>>>> what
>>>>> + * the kernel is expected to hold. It is updated as soon as the
>>>>> + * previous devices are gone, even if creating the new ones then
>>>>> fails,
>>>>> + * so that a partial failure doesn't leave a permanent difference
>>>>> + * against the desired configuration. */
>>>>> + struct neighbor_ovn_maintain_entry entry;
>>>>> + /* False if the last attempt to apply 'entry' didn't fully succeed.
>>>>> The
>>>>> + * next run then repairs the stack by re-running the idempotent
>>>>> create
>>>>> + * path instead of tearing it down and rebuilding it. */
>>>>> + bool synced;
>>>>> +};
>>>>> +
>>>>> +static struct hmap maintained_evpn_entries =
>>>>> + HMAP_INITIALIZER(&maintained_evpn_entries);
>>>>> +
>>>>> +static struct maintained_evpn_entry *
>>>>> +maintained_evpn_entry_find(const struct hmap *entries, uint32_t vni)
>>>>> +{
>>>>> + struct maintained_evpn_entry *me;
>>>>> + HMAP_FOR_EACH_WITH_HASH (me, node, hash_int(vni, 0), entries) {
>>>>> + if (me->entry.vni == vni) {
>>>>> + return me;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + return NULL;
>>>>> +}
>>>>> +
>>>>> +/* Deletes the interfaces for 'entry'. Returns true if all of them were
>>>>> + * deleted (or were already absent), false if any netlink call failed. */
>>>>> +static bool
>>>>> +evpn_delete_devices(struct neighbor_ovn_maintain_entry *entry)
>>>>> +{
>>>>> + int error;
>>>>> + bool ok = true;
>>>>> +
>>>>> + error = ne_nl_delete_iface(entry->br_if_name);
>>>>> + if (error && error != ENODEV) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to delete bridge interface %s: %s",
>>>>> + entry->br_if_name, ovs_strerror(error));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(error);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + error = ne_nl_delete_iface(entry->vxlan_if_name);
>>>>> + if (error && error != ENODEV) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to delete VXLAN interface %s: %s",
>>>>> + entry->vxlan_if_name, ovs_strerror(error));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(error);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + error = ne_nl_delete_iface(entry->vrf_if_name);
>>>>> + if (error && error != ENODEV) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to delete vrf interface %s: %s",
>>>>> + entry->vrf_if_name, ovs_strerror(error));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(error);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + error = ne_nl_delete_iface(entry->lo_if_name);
>>>>> + if (error && error != ENODEV) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to delete dummy interface %s: %s",
>>>>> + entry->lo_if_name, ovs_strerror(error));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(error);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + /* Refresh the host-if-monitor ifindex cache for the interfaces we
>>>>> + * monitor for neighbor sync, so a lookup later in this same engine
>>>>> + * iteration doesn't use a stale ifindex. */
>>>>> + host_if_monitor_invalidate(entry->br_if_name);
>>>>> + host_if_monitor_invalidate(entry->vxlan_if_name);
>>>>> + host_if_monitor_invalidate(entry->lo_if_name);
>>>>> +
>>>>> + return ok;
>>>>> +}
>>>>> +
>>>>> +static bool
>>>>> +set_bridge_evpn_device_addr(struct neighbor_ovn_maintain_entry *entry)
>>>>> +{
>>>>> + int err;
>>>>> + if (entry->br_config.has_addr) {
>>>>> + err = ne_nl_set_iface_mac_addr(entry->br_if_name,
>>>>> + &entry->br_config.lladdr);
>>>>> + if (err) {
>>>>> + VLOG_WARN_RL(&rl, "Unable set mac address on interface %s:
>>>>> %s",
>>>>> + entry->br_if_name, ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + return false;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + return true;
>>>>> +}
>>>>> +
>>>>> +/* Creates the interfaces for 'entry'. Returns true if the whole stack
>>>>> was
>>>>> + * created successfully (or already existed), false if any netlink call
>>>>> + * failed. */
>>>>> +static bool
>>>>> +evpn_create_devices(struct neighbor_ovn_maintain_entry *entry)
>>>>> +{
>>>>> + static const char *link_dev = "vxlan_sys_4789";
>>>>> + int32_t link_ifindex = ne_nl_ifindex_get(link_dev);
>>>>> + int err;
>>>>> + bool ok = true;
>>>>> +
>>>>> + if (!link_ifindex) {
>>>>> + err = ENODEV;
>>>>> + VLOG_WARN_RL(&rl,
>>>>> + "Unable to find OVS system vxlan interface");
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + if (entry->br_config.has_addr
>>>>> + && nrm_mode_IP_is_set(entry->redistribute_mode)) {
>>>>> + err = ne_nl_create_vrf(entry->vrf_if_name, entry->vni);
>>>>> + if (err && err != EEXIST) {
>>>>> + VLOG_WARN_RL(&rl,
>>>>> + "Unable to create VRF %s for datapath %s",
>>>>> + entry->vrf_if_name, ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + err = ne_nl_create_vxlan(entry->vxlan_if_name, entry->vni,
>>>>> + &entry->local_ip, entry->fake_vxlan_port,
>>>>> + link_ifindex);
>>>>> + if (err && err != EEXIST) {
>>>>> + VLOG_WARN_RL(&rl,
>>>>> + "Unable to create VXLAN interface %s for "
>>>>> + "VNI %"PRIu32": %s",
>>>>> + entry->vxlan_if_name, entry->vni,
>>>>> ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + err = ne_nl_create_bridge(entry->br_if_name);
>>>>> + if (err && err != EEXIST) {
>>>>> + VLOG_WARN_RL(&rl,
>>>>> + "Unable to create bridge interface %s for "
>>>>> + "VNI %"PRIu32": %s",
>>>>> + entry->br_if_name, entry->vni, ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + if (!set_bridge_evpn_device_addr(entry)) {
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + if (entry->br_config.has_addr
>>>>> + && nrm_mode_IP_is_set(entry->redistribute_mode)) {
>>>>> + err = ne_nl_set_master(entry->br_if_name, entry->vrf_if_name);
>>>>> + if (err) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to enslave %s to bridge %s: %s",
>>>>> + entry->br_if_name, entry->vrf_if_name,
>>>>> + ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + if (nrm_mode_FDB_is_set(entry->redistribute_mode)) {
>>>>> + err = ne_nl_create_lo(entry->lo_if_name);
>>>>> + if (err && err != EEXIST) {
>>>>> + VLOG_WARN_RL(&rl,
>>>>> + "Unable to create dummy interface %s for "
>>>>> + "VNI %"PRIu32": %s",
>>>>> + entry->lo_if_name, entry->vni,
>>>>> ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> + err = ne_nl_set_master(entry->lo_if_name, entry->br_if_name);
>>>>> + if (err) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to enslave %s to bridge %s: %s",
>>>>> + entry->lo_if_name, entry->br_if_name,
>>>>> + ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + err = ne_nl_set_master(entry->vxlan_if_name, entry->br_if_name);
>>>>> + if (err) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to enslave %s to bridge %s: %s",
>>>>> + entry->vxlan_if_name, entry->br_if_name,
>>>>> + ovs_strerror(err));
>>>>> + SET_NEIGHBOR_EXCHANGE_NL_STATUS(err);
>>>>> + ok = false;
>>>>> + }
>>>>> +
>>>>> + /* Refresh the host-if-monitor ifindex cache so a lookup later in
>>>>> this
>>>>> + * same engine iteration picks up the newly (re)created interfaces
>>>>> + * instead of a stale ifindex left over from before they were
>>>>> + * deleted/recreated. */
>>>>> + host_if_monitor_invalidate(entry->br_if_name);
>>>>> + host_if_monitor_invalidate(entry->vxlan_if_name);
>>>>> + host_if_monitor_invalidate(entry->lo_if_name);
>>>>> +
>>>>> + return ok;
>>>>> +}
>>>>> +
>>>>> +/* Returns true if a change between 'old_entry' and 'entry' requires
>>>>> + * deleting and recreating the whole VRF/bridge/VXLAN/lo interface stack,
>>>>> + * rather than updating it in place. This is the case when:
>>>>> + *
>>>>> + * - The VXLAN device's local IP or UDP destination port changed: Netlink
>>>>> + * offers no way to change either on an existing VXLAN interface.
>>>>> + *
>>>>> + * - The bridge gained or lost its L3 address ('has_addr'): this changes
>>>>> + * whether a VRF is needed at all.
>>>>> + *
>>>>> + * - The redistribution mode changed (FDB and/or IP bits): this changes
>>>>> + * whether the loopback advertise interface is needed at all.
>>>>> + *
>>>>> + * Recreating the whole stack in these cases is simpler and less
>>>>> + * error-prone than trying to patch each interface individually. */
>>>>> +static bool
>>>>> +should_destroy_interfaces(const struct neighbor_ovn_maintain_entry
>>>>> *entry,
>>>>> + const struct neighbor_ovn_maintain_entry
>>>>> *old_entry)
>>>>> +{
>>>>> + return !ipv6_addr_equals(&old_entry->local_ip, &entry->local_ip) ||
>>>>> + old_entry->fake_vxlan_port != entry->fake_vxlan_port ||
>>>>> + old_entry->br_config.has_addr != entry->br_config.has_addr ||
>>>>> + old_entry->redistribute_mode != entry->redistribute_mode ||
>>>>> + (entry->br_config.has_addr
>>>>> + && !eth_addr_equals(old_entry->br_config.lladdr,
>>>>> + entry->br_config.lladdr));
>>>>> +}
>>>>> +
>>>>> +/* Brings the kernel devices of a VNI in line with the desired
>>>>> configuration
>>>>> + * 'entry', recording in 'me' what was actually applied. 'has_old' tells
>>>>> + * whether 'me->entry' describes devices we created in a previous run. */
>>>>> +static void
>>>>> +maintain_evpn_devices(const struct neighbor_ovn_maintain_entry *entry,
>>>>> + struct maintained_evpn_entry *me, bool has_old)
>>>>> +{
>>>>> + if (has_old && should_destroy_interfaces(entry, &me->entry)) {
>>>>> + if (!evpn_delete_devices(&me->entry)) {
>>>>> + /* The old devices are (partly) still around, so 'me->entry'
>>>>> + * keeps describing them and the next run retries the
>>>>> + * teardown. */
>>>>> + me->synced = false;
>>>>> + return;
>>>>> + }
>>>>> + } else if (me->synced) {
>>>>> + /* Nothing changed and the stack was fully applied. */
>>>>> + return;
>>>>> + }
>>>>> +
>>>>> + /* Either there were no devices yet, or the old ones are now gone:
>>>>> from
>>>>> + * here on 'entry' is what the kernel is expected to hold, even if
>>>>> the
>>>>> + * creation below only partially succeeds. Otherwise the difference
>>>>> + * against 'entry' would never go away and we would tear the stack
>>>>> down
>>>>> + * and rebuild it on every single run. */
>>>>> + me->entry = *entry;
>>>>> + me->synced = evpn_create_devices(&me->entry);
>>>>> +}
>>>>> +
>>>>> +static void
>>>>> +neighbor_exchange_maintain_evpn_run(const struct vector *maintain_evpn)
>>>>> +{
>>>>> + struct hmap old_maintained_evpn_entries =
>>>>> + HMAP_INITIALIZER(&old_maintained_evpn_entries);
>>>>> + hmap_swap(&maintained_evpn_entries, &old_maintained_evpn_entries);
>>>>> +
>>>>> + struct neighbor_ovn_maintain_entry *entry;
>>>>> + VECTOR_FOR_EACH_PTR (maintain_evpn, entry) {
>>>>> + struct maintained_evpn_entry *me =
>>>>> + maintained_evpn_entry_find(&old_maintained_evpn_entries,
>>>>> + entry->vni);
>>>>> + bool has_old = me != NULL;
>>>>> +
>>>>> + if (has_old) {
>>>>> + hmap_remove(&old_maintained_evpn_entries, &me->node);
>>>>> + } else {
>>>>> + me = xzalloc(sizeof *me);
>>>>> + }
>>>>> +
>>>>> + /* Start tracking the VNI before issuing any netlink call to be
>>>>> + * responsible for deleting/updating its devices */
>>>>> + hmap_insert(&maintained_evpn_entries, &me->node,
>>>>> + hash_int(entry->vni, 0));
>>>>> +
>>>>> + maintain_evpn_devices(entry, me, has_old);
>>>>> + }
>>>>> +
>>>>> + struct maintained_evpn_entry *stale_me;
>>>>> + HMAP_FOR_EACH_POP (stale_me, node, &old_maintained_evpn_entries) {
>>>>> + if (evpn_delete_devices(&stale_me->entry)) {
>>>>> + free(stale_me);
>>>>> + } else {
>>>>> + /* Deletion failed: keep tracking it so it's retried as stale
>>>>> + * again on the next run (it's no longer in 'maintain_evpn').
>>>>> + * Some devices may already be gone, so if the VNI comes back
>>>>> + * before the teardown completes, the stack has to be
>>>>> repaired
>>>>> + * rather than assumed to be in shape. */
>>>>> + stale_me->synced = false;
>>>>> + hmap_insert(&maintained_evpn_entries, &stale_me->node,
>>>>> + hash_int(stale_me->entry.vni, 0));
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + hmap_destroy(&old_maintained_evpn_entries);
>>>>> +}
>>>>> +
>>>>> +void
>>>>> +neighbor_exchange_maintain_evpn_cleanup_all(void)
>>>>> +{
>>>>> + struct maintained_evpn_entry *me;
>>>>> + HMAP_FOR_EACH (me, node, &maintained_evpn_entries) {
>>>>> + evpn_delete_devices(&me->entry);
>>>>> + }
>>>>> +}
>>>>> +
>>>>> +void
>>>>> +neighbor_exchange_maintain_evpn_destroy(void)
>>>>> +{
>>>>> + struct maintained_evpn_entry *me;
>>>>> + HMAP_FOR_EACH_POP (me, node, &maintained_evpn_entries) {
>>>>> + free(me);
>>>>> + }
>>>>> + hmap_destroy(&maintained_evpn_entries);
>>>>> +}
>>>>> +
>>>>> void
>>>>> neighbor_exchange_run(const struct neighbor_exchange_ctx_in *n_ctx_in,
>>>>> struct neighbor_exchange_ctx_out *n_ctx_out)
>>>>> {
>>>>> + /* Reset once for the whole run: errors hit while maintaining the
>>>>> EVPN
>>>>> + * devices must survive into neighbor_exchange_status_run(),
>>>>> otherwise
>>>>> + * the engine is never woken up to retry a failed or partial apply.
>>>>> */
>>>>> + CLEAR_NEIGHBOR_EXCHANGE_NL_STATUS();
>>>>> +
>>>>> + neighbor_exchange_maintain_evpn_run(n_ctx_in->maintain_evpn);
>>>>> +
>>>>> struct neighbor_interface_monitor *nim;
>>>>>
>>>>> struct sset if_names = SSET_INITIALIZER(&if_names);
>>>>> @@ -78,7 +427,6 @@ neighbor_exchange_run(const struct
>>>>> neighbor_exchange_ctx_in *n_ctx_in,
>>>>> host_if_monitor_update_watches(&if_names);
>>>>> sset_destroy(&if_names);
>>>>>
>>>>> - CLEAR_NEIGHBOR_EXCHANGE_NL_STATUS();
>>>>> VECTOR_FOR_EACH (n_ctx_in->monitored_interfaces, nim) {
>>>>> int32_t if_index =
>>>>> host_if_monitor_ifname_toindex(nim->if_name);
>>>>>
>>>>> diff --git a/controller/neighbor-exchange.h
>>>>> b/controller/neighbor-exchange.h
>>>>> index 456ff23df..509655788 100644
>>>>> --- a/controller/neighbor-exchange.h
>>>>> +++ b/controller/neighbor-exchange.h
>>>>> @@ -27,6 +27,9 @@ struct unixctl_conn;
>>>>> struct neighbor_exchange_ctx_in {
>>>>> /* Contains struct neighbor_interface_monitor pointers. */
>>>>> const struct vector *monitored_interfaces;
>>>>> + /* Contains struct neighbor_ovn_maintain_entry for VNIs whose kernel
>>>>> + * interfaces OVN must create/maintain. May be NULL. */
>>>>> + const struct vector *maintain_evpn;
>>>>> };
>>>>>
>>>>> struct neighbor_exchange_ctx_out {
>>>>> @@ -73,4 +76,9 @@ void evpn_remote_vtep_list(struct unixctl_conn *, int
>>>>> argc,
>>>>> const char *argv[], void *data_);
>>>>> void evpn_static_entries_clear(struct hmap *static_entries);
>>>>>
>>>>> +/* EVPN kernel interfaces lifecycle. Call cleanup_all on graceful
>>>>> shutdown,
>>>>> + * destroy to release module-level state. */
>>>>> +void neighbor_exchange_maintain_evpn_cleanup_all(void);
>>>>> +void neighbor_exchange_maintain_evpn_destroy(void);
>>>>> +
>>>>> #endif /* NEIGHBOR_EXCHANGE_H */
>>>>> diff --git a/controller/neighbor.c b/controller/neighbor.c
>>>>> index c06183063..cb4d5fda2 100644
>>>>> --- a/controller/neighbor.c
>>>>> +++ b/controller/neighbor.c
>>>>> @@ -18,6 +18,7 @@
>>>>> #include "lib/hash.h"
>>>>> #include "lib/packets.h"
>>>>> #include "lib/sset.h"
>>>>> +#include "lib/ovn-util.h"
>>>>> #include "local_data.h"
>>>>> #include "lport.h"
>>>>> #include "openvswitch/ofp-parse.h"
>>>>> @@ -27,6 +28,7 @@
>>>>> #include "neighbor.h"
>>>>>
>>>>> VLOG_DEFINE_THIS_MODULE(neighbor);
>>>>> +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
>>>>>
>>>>> static const char *neighbor_opt_name[] = {
>>>>> [NEIGH_IFACE_BRIDGE] = "dynamic-routing-bridge-ifname",
>>>>> @@ -91,13 +93,133 @@ neigh_parse_device_name(struct sset *device_names,
>>>>> struct local_datapath *ld,
>>>>> neighbor_opt_name[type], "");
>>>>> sset_from_delimited_string(device_names, names, ",");
>>>>> if (sset_is_empty(device_names)) {
>>>>> - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
>>>>> VLOG_WARN_RL(&rl, "Datapath "UUID_FMT" misses %s",
>>>>> UUID_ARGS(&ld->datapath->header_.uuid),
>>>>> neighbor_opt_name[type]);
>>>>> }
>>>>> }
>>>>>
>>>>> +static bool
>>>>> +create_maintain_evpn_entry(const struct neighbor_ctx_in *n_ctx_in,
>>>>> + const struct local_datapath *ld, uint32_t vni,
>>>>> + enum neigh_redistribute_mode
>>>>> redistribute_mode,
>>>>> + enum neighbor_mainatain_mode mainatain_mode,
>>>>> + struct neighbor_ovn_maintain_entry *entry)
>>>>> +{
>>>>> + long long int vxlan_port =
>>>>> + ovn_smap_get_llong(&ld->datapath->external_ids,
>>>>> + "dynamic-routing-maintain-evpn-vxlan-port",
>>>>> + EVPN_DEFAULT_FAKE_VXLAN_PORT);
>>>>> + if (vxlan_port <= 0 || vxlan_port > UINT16_MAX) {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn-vxlan-port "
>>>>> + "%lld for datapath "UUID_FMT" is not a valid UDP
>>>>> port",
>>>>> + vxlan_port, UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + return false;
>>>>> + }
>>>>> +
>>>>> + *entry = (struct neighbor_ovn_maintain_entry) {
>>>>> + .redistribute_mode = redistribute_mode,
>>>>> + .mainatain_mode = mainatain_mode,
>>>>> + .vni = vni,
>>>>> + .fake_vxlan_port = vxlan_port,
>>>>> + };
>>>>> +
>>>>> + snprintf(entry->vxlan_if_name, sizeof entry->vxlan_if_name,
>>>>> + "ovnvxlan%"PRIu32, vni);
>>>>> + snprintf(entry->br_if_name, sizeof entry->br_if_name,
>>>>> + "ovnbr%"PRIu32, vni);
>>>>> + snprintf(entry->lo_if_name, sizeof entry->lo_if_name,
>>>>> + "ovnlo%"PRIu32, vni);
>>>>> + snprintf(entry->vrf_if_name, sizeof entry->vrf_if_name,
>>>>> + "ovnvrf%"PRIu32, vni);
>>>>> +
>>>>> + const struct in6_addr *local_ip =
>>>>> + evpn_local_ip_map_lookup(n_ctx_in->evpn_local_ip_map, vni);
>>>>> +
>>>>> + if (local_ip) {
>>>>> + entry->local_ip = *local_ip;
>>>>> + } else {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn set for
>>>>> datapath "
>>>>> + UUID_FMT" VNI %"PRIu32" but no ovn-evpn-local-ip "
>>>>> + "configured",
>>>>> + UUID_ARGS(&ld->datapath->header_.uuid), vni);
>>>>> + return false;
>>>>> + }
>>>>> +
>>>>> + if (nrm_mode_IP_is_set(redistribute_mode)) {
>>>>> + const char *lrp_name = smap_get(&ld->datapath->external_ids,
>>>>> +
>>>>> "dynamic-routing-maintain-evpn-lrp");
>>>>> + if (!lrp_name) {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn=mvd is set
>>>>> with "
>>>>> + "IP redistribution on datapath "UUID_FMT" but "
>>>>> + "dynamic-routing-maintain-evpn-lrp is not
>>>>> configured",
>>>>> + UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + return false;
>>>>> + }
>>>>> +
>>>>> + /* The option may either name a logical router port or directly
>>>>> + * specify the MAC address to be used on the bridge interface.
>>>>> The
>>>>> + * latter is useful when the router port has multiple MAC
>>>>> addresses
>>>>> + * and the CMS needs to pick a specific one. */
>>>>> + struct eth_addr mac;
>>>>> + if (eth_addr_from_string(lrp_name, &mac)) {
>>>>> + entry->br_config.has_addr = true;
>>>>> + entry->br_config.lladdr = mac;
>>>>> + return true;
>>>>> + }
>>>>> +
>>>>> + const struct sbrec_port_binding *pb =
>>>>> + lport_lookup_by_name(n_ctx_in->sbrec_pb_by_name, lrp_name);
>>>>> + if (!pb) {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn-lrp: port
>>>>> \"%s\" "
>>>>> + "not found", lrp_name);
>>>>> + return false;
>>>>> + }
>>>>> +
>>>>> + const struct sbrec_port_binding *peer =
>>>>> + lport_get_peer(pb, n_ctx_in->sbrec_pb_by_name);
>>>>> + if (!peer) {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn-lrp: port
>>>>> \"%s\" "
>>>>> + "is not a router port", lrp_name);
>>>>> + return false;
>>>>> + }
>>>>> + if (peer->datapath != ld->datapath) {
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn-lrp: router
>>>>> port "
>>>>> + "\"%s\" is not attached to datapath "UUID_FMT,
>>>>> + lrp_name,
>>>>> UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + return false;
>>>>> + }
>>>>> +
>>>>> + entry->br_config.has_addr =
>>>>> + extract_sbrec_binding_first_mac(pb,
>>>>> &entry->br_config.lladdr);
>>>>> + if (!entry->br_config.has_addr) {
>>>>> + VLOG_WARN_RL(&rl, "Unable to parse mac address on router "
>>>>> + "port %s for configuring EVPN devices",
>>>>> lrp_name);
>>>>> + return false;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + return true;
>>>>> +}
>>>>> +
>>>>> +static enum neighbor_mainatain_mode
>>>>> +parse_neigh_maintain_mode(const struct smap *external_ids)
>>>>> +{
>>>>> + const char *val = smap_get(external_ids,
>>>>> "dynamic-routing-maintain-evpn");
>>>>> + if (!val) {
>>>>> + return NEIGH_MAINTAIN_NONE;
>>>>> + }
>>>>> +
>>>>> + if (!strcmp(val, "mvd")) {
>>>>> + return NEIGH_MAINTAIN_MVD;
>>>>> + }
>>>>> +
>>>>> + VLOG_WARN_RL(&rl, "dynamic-routing-maintain-evpn: unknown value
>>>>> \"%s\", "
>>>>> + "expected \"mvd\"", val);
>>>>> +
>>>>> + return NEIGH_MAINTAIN_NONE;
>>>>> +}
>>>>> +
>>>>> void
>>>>> neighbor_run(struct neighbor_ctx_in *n_ctx_in,
>>>>> struct neighbor_ctx_out *n_ctx_out)
>>>>> @@ -119,24 +241,50 @@ neighbor_run(struct neighbor_ctx_in *n_ctx_in,
>>>>> continue;
>>>>> }
>>>>>
>>>>> + enum neigh_redistribute_mode redistribute_mode =
>>>>> +
>>>>> parse_neigh_dynamic_redistribute(&ld->datapath->external_ids);
>>>>> +
>>>>> + enum neighbor_mainatain_mode mainatain_mode =
>>>>> + parse_neigh_maintain_mode(&ld->datapath->external_ids);
>>>>> +
>>>>> + struct neighbor_ovn_maintain_entry maintain_entry;
>>>>> + if (mainatain_mode != NEIGH_MAINTAIN_NONE) {
>>>>> + if (create_maintain_evpn_entry(n_ctx_in, ld, (uint32_t) vni,
>>>>> + redistribute_mode,
>>>>> mainatain_mode,
>>>>> + &maintain_entry)) {
>>>>> + vector_push(n_ctx_out->maintain_evpn, &maintain_entry);
>>>>> + } else {
>>>>> + continue;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> struct sset device_names;
>>>>> - neigh_parse_device_name(&device_names, ld, NEIGH_IFACE_VXLAN);
>>>>> + if (mainatain_mode != NEIGH_MAINTAIN_NONE) {
>>>>> + sset_init(&device_names);
>>>>> + sset_add(&device_names, maintain_entry.vxlan_if_name);
>>>>> + } else {
>>>>> + neigh_parse_device_name(&device_names, ld,
>>>>> NEIGH_IFACE_VXLAN);
>>>>> + }
>>>>> const char *name;
>>>>> SSET_FOR_EACH (name, &device_names) {
>>>>> - struct neighbor_interface_monitor *vxlan =
>>>>> + struct neighbor_interface_monitor *nim =
>>>>> neighbor_interface_monitor_alloc(NEIGH_AF_BRIDGE,
>>>>> NEIGH_IFACE_VXLAN,
>>>>> vni, name);
>>>>> - vector_push(n_ctx_out->monitored_interfaces, &vxlan);
>>>>> + vector_push(n_ctx_out->monitored_interfaces, &nim);
>>>>> }
>>>>> sset_destroy(&device_names);
>>>>>
>>>>> struct neighbor_interface_monitor *lo = NULL;
>>>>> - neigh_parse_device_name(&device_names, ld, NEIGH_IFACE_LOOPBACK);
>>>>> - if (sset_count(&device_names) > 1) {
>>>>> - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1,
>>>>> 5);
>>>>> - VLOG_WARN_RL(&rl, "Datapath "UUID_FMT" too many names
>>>>> provided "
>>>>> - "for loopback device",
>>>>> - UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + if (mainatain_mode != NEIGH_MAINTAIN_NONE) {
>>>>> + sset_init(&device_names);
>>>>> + sset_add(&device_names, maintain_entry.lo_if_name);
>>>>> + } else {
>>>>> + neigh_parse_device_name(&device_names, ld,
>>>>> NEIGH_IFACE_LOOPBACK);
>>>>> + if (sset_count(&device_names) > 1) {
>>>>> + VLOG_WARN_RL(&rl, "Datapath "UUID_FMT" too many names
>>>>> for "
>>>>> + "loopback device",
>>>>> + UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + }
>>>>> }
>>>>>
>>>>> if (!sset_is_empty(&device_names)) {
>>>>> @@ -149,32 +297,31 @@ neighbor_run(struct neighbor_ctx_in *n_ctx_in,
>>>>>
>>>>> struct neighbor_interface_monitor *br_v4 = NULL;
>>>>> struct neighbor_interface_monitor *br_v6 = NULL;
>>>>> - neigh_parse_device_name(&device_names, ld, NEIGH_IFACE_BRIDGE);
>>>>> - if (sset_count(&device_names) > 1) {
>>>>> - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1,
>>>>> 5);
>>>>> - VLOG_WARN_RL(&rl, "Datapath "UUID_FMT" too many names
>>>>> provided "
>>>>> - "for bridge device",
>>>>> - UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + if (mainatain_mode != NEIGH_MAINTAIN_NONE) {
>>>>> + sset_init(&device_names);
>>>>> + sset_add(&device_names, maintain_entry.br_if_name);
>>>>> + } else {
>>>>> + neigh_parse_device_name(&device_names, ld,
>>>>> NEIGH_IFACE_BRIDGE);
>>>>> + if (sset_count(&device_names) > 1) {
>>>>> + VLOG_WARN_RL(&rl, "Datapath "UUID_FMT" too many names
>>>>> for "
>>>>> + "bridge device",
>>>>> + UUID_ARGS(&ld->datapath->header_.uuid));
>>>>> + }
>>>>> }
>>>>>
>>>>> if (!sset_is_empty(&device_names)) {
>>>>> - br_v4 =
>>>>> - neighbor_interface_monitor_alloc(NEIGH_AF_INET,
>>>>> - NEIGH_IFACE_BRIDGE, vni,
>>>>> -
>>>>> SSET_FIRST(&device_names));
>>>>> + br_v4 = neighbor_interface_monitor_alloc(
>>>>> + NEIGH_AF_INET, NEIGH_IFACE_BRIDGE, vni,
>>>>> + SSET_FIRST(&device_names));
>>>>> vector_push(n_ctx_out->monitored_interfaces, &br_v4);
>>>>> -
>>>>> - br_v6 =
>>>>> - neighbor_interface_monitor_alloc(NEIGH_AF_INET6,
>>>>> - NEIGH_IFACE_BRIDGE, vni,
>>>>> -
>>>>> SSET_FIRST(&device_names));
>>>>> + br_v6 = neighbor_interface_monitor_alloc(
>>>>> + NEIGH_AF_INET6, NEIGH_IFACE_BRIDGE, vni,
>>>>> + SSET_FIRST(&device_names));
>>>>> vector_push(n_ctx_out->monitored_interfaces, &br_v6);
>>>>> }
>>>>> sset_destroy(&device_names);
>>>>>
>>>>> - enum neigh_redistribute_mode mode =
>>>>> -
>>>>> parse_neigh_dynamic_redistribute(&ld->datapath->external_ids);
>>>>> - if (nrm_mode_FDB_is_set(mode) && lo) {
>>>>> + if (nrm_mode_FDB_is_set(redistribute_mode) && lo) {
>>>>> neighbor_collect_mac_to_advertise(n_ctx_in,
>>>>> &lo->announced_neighbors,
>>>>>
>>>>> n_ctx_out->advertised_pbs,
>>>>> @@ -189,7 +336,7 @@ neighbor_run(struct neighbor_ctx_in *n_ctx_in,
>>>>> * meant to be advertised. With 'fdb' set, also program them
>>>>> as FDB
>>>>> * entries. */
>>>>> neighbor_collect_advertised_mac_bindings(
>>>>> - n_ctx_in, mode, lo ? &lo->announced_neighbors : NULL,
>>>>> + n_ctx_in, redistribute_mode, lo ? &lo->announced_neighbors :
>>>>> NULL,
>>>>> br_v4 ? &br_v4->announced_neighbors : NULL,
>>>>> br_v6 ? &br_v6->announced_neighbors : NULL,
>>>>> n_ctx_out->advertised_pbs, ld->datapath);
>>>>> diff --git a/controller/neighbor.h b/controller/neighbor.h
>>>>> index cd158a0f1..fd19367cc 100644
>>>>> --- a/controller/neighbor.h
>>>>> +++ b/controller/neighbor.h
>>>>> @@ -24,6 +24,7 @@
>>>>> #include "hmapx.h"
>>>>> #include "lib/sset.h"
>>>>> #include "openvswitch/hmap.h"
>>>>> +#include "lib/ovn-util.h"
>>>>>
>>>>> #include "vec.h"
>>>>>
>>>>> @@ -54,6 +55,7 @@ struct neighbor_ctx_in {
>>>>> /* Index for FDB by dp_key. */
>>>>> struct ovsdb_idl_index *sbrec_fdb_by_dp_key;
>>>>> const struct sbrec_chassis *chassis;
>>>>> + struct evpn_local_ip_map *evpn_local_ip_map;
>>>>> };
>>>>>
>>>>> struct neighbor_ctx_out {
>>>>> @@ -64,6 +66,9 @@ struct neighbor_ctx_out {
>>>>> /* Contains 'struct local_datapath' pointers for datapaths with FDB
>>>>> * advertisement enabled. */
>>>>> struct hmapx *fdb_datapaths;
>>>>> + /* Contains struct neighbor_ovn_maintain_entry for VNIs that need
>>>>> + * maintained interfaces. May be NULL if caller does not need this.
>>>>> */
>>>>> + struct vector *maintain_evpn;
>>>>> };
>>>>>
>>>>> enum neighbor_interface_type {
>>>>> @@ -72,6 +77,38 @@ enum neighbor_interface_type {
>>>>> NEIGH_IFACE_LOOPBACK,
>>>>> };
>>>>>
>>>>> +enum neighbor_mainatain_mode {
>>>>> + NEIGH_MAINTAIN_NONE,
>>>>> + NEIGH_MAINTAIN_MVD,
>>>>> +};
>>>>> +
>>>>> +/* UDP destination port used for the OVN maintained VXLAN devices if
>>>>> + * "dynamic-routing-maintain-evpn-vxlan-port" is not set. It must differ
>>>>> + * from the port used by the OVS datapath VXLAN device (4789), because
>>>>> + * those devices are only used to exchange EVPN state with the routing
>>>>> + * daemon and never carry traffic. */
>>>>> +#define EVPN_DEFAULT_FAKE_VXLAN_PORT 4790
>>>>> +
>>>>> +/* IP/MAC to configure on the bridge interface so BGP can use it as
>>>>> next-hop.
>>>>> + * Filled from the LRP named by dynamic-routing-evpn-lrp. */
>>>>> +struct neighbor_bridge_iface_config {
>>>>> + bool has_addr;
>>>>> + struct eth_addr lladdr;
>>>>> +};
>>>>> +
>>>>> +struct neighbor_ovn_maintain_entry {
>>>>> + enum neigh_redistribute_mode redistribute_mode;
>>>>> + enum neighbor_mainatain_mode mainatain_mode;
>>>>> + char vxlan_if_name[IFNAMSIZ + 1];
>>>>> + char vrf_if_name[IFNAMSIZ + 1];
>>>>> + char br_if_name[IFNAMSIZ + 1];
>>>>> + char lo_if_name[IFNAMSIZ + 1];
>>>>> + struct neighbor_bridge_iface_config br_config;
>>>>> + struct in6_addr local_ip;
>>>>> + uint32_t vni;
>>>>> + uint16_t fake_vxlan_port;
>>>>> +};
>>>>> +
>>>>> struct neighbor_interface_monitor {
>>>>> enum neighbor_family family;
>>>>> char if_name[IFNAMSIZ + 1];
>>>>> diff --git a/controller/netlink-utils.h b/controller/netlink-utils.h
>>>>> index 51e4ebb08..a34c9db93 100644
>>>>> --- a/controller/netlink-utils.h
>>>>> +++ b/controller/netlink-utils.h
>>>>> @@ -1,6 +1,4 @@
>>>>> -/*
>>>>> - * Copyright (c) 2025 Canonical, Ltd.
>>>>> - * Copyright (c) 2025, STACKIT GmbH & Co. KG
>>>>> +/* Copyright (c) 2025, Red Hat, Inc.
>>>>> *
>>>>> * Licensed under the Apache License, Version 2.0 (the "License");
>>>>> * you may not use this file except in compliance with the License.
>>>>> diff --git a/controller/ovn-controller.c b/controller/ovn-controller.c
>>>>> index be02d2864..a0861f641 100644
>>>>> --- a/controller/ovn-controller.c
>>>>> +++ b/controller/ovn-controller.c
>>>>> @@ -44,6 +44,7 @@
>>>>> #include "lib/lflow-conj-ids.h"
>>>>> #include "lib/vswitch-idl.h"
>>>>> #include "lib/ovsdb-types.h"
>>>>> +#include "lib/ovn-util.h"
>>>>> #include "local_data.h"
>>>>> #include "lport.h"
>>>>> #include "memory.h"
>>>>> @@ -6164,6 +6165,9 @@ struct ed_type_neighbor {
>>>>> /* Contains 'struct local_datapath' pointers for datapaths with FDB
>>>>> * advertisement enabled. */
>>>>> struct hmapx fdb_datapaths;
>>>>> + /* Contains struct neighbor_ovn_maintain_entry, one per VNI
>>>>> + * whose EVPN interfaces are auto-created and maintained. */
>>>>> + struct vector maintain_evpn;
>>>>> };
>>>>>
>>>>> static void *
>>>>> @@ -6177,6 +6181,8 @@ en_neighbor_init(struct engine_node *node
>>>>> OVS_UNUSED,
>>>>> VECTOR_EMPTY_INITIALIZER(struct neighbor_interface_monitor
>>>>> *),
>>>>> .advertised_pbs = SSET_INITIALIZER(&data->advertised_pbs),
>>>>> .fdb_datapaths = HMAPX_INITIALIZER(&data->fdb_datapaths),
>>>>> + .maintain_evpn =
>>>>> + VECTOR_EMPTY_INITIALIZER(struct neighbor_ovn_maintain_entry),
>>>>> };
>>>>> return data;
>>>>> }
>>>>> @@ -6188,6 +6194,7 @@ en_neighbor_cleanup(void *data)
>>>>>
>>>>> neighbor_cleanup(&ne_data->monitored_interfaces);
>>>>> vector_destroy(&ne_data->monitored_interfaces);
>>>>> + vector_destroy(&ne_data->maintain_evpn);
>>>>> sset_destroy(&ne_data->advertised_pbs);
>>>>> hmapx_destroy(&ne_data->fdb_datapaths);
>>>>> }
>>>>> @@ -6231,6 +6238,12 @@ en_neighbor_run(struct engine_node *node
>>>>> OVS_UNUSED, void *data)
>>>>> chassis_lookup_by_name(sbrec_chassis_by_name, chassis_id);
>>>>> ovs_assert(chassis);
>>>>>
>>>>> + struct evpn_local_ip_map evpn_ip_map = {
>>>>> + .vni_ip4 = HMAP_INITIALIZER(&evpn_ip_map.vni_ip4),
>>>>> + .vni_ip6 = HMAP_INITIALIZER(&evpn_ip_map.vni_ip6),
>>>>> + };
>>>>> + evpn_local_ip_map_init(&evpn_ip_map, &chassis->other_config);
>>>>> +
>>>>> struct neighbor_ctx_in n_ctx_in = {
>>>>> .local_datapaths = &rt_data->local_datapaths,
>>>>> .sbrec_pb_by_dp = sbrec_port_binding_by_datapath,
>>>>> @@ -6239,18 +6252,22 @@ en_neighbor_run(struct engine_node *node
>>>>> OVS_UNUSED, void *data)
>>>>> .sbrec_pb_by_key = sbrec_port_binding_by_key,
>>>>> .sbrec_fdb_by_dp_key = sbrec_fdb_by_dp_key,
>>>>> .chassis = chassis,
>>>>> + .evpn_local_ip_map = &evpn_ip_map,
>>>>> };
>>>>>
>>>>> struct neighbor_ctx_out n_ctx_out = {
>>>>> .monitored_interfaces = &ne_data->monitored_interfaces,
>>>>> .advertised_pbs = &ne_data->advertised_pbs,
>>>>> .fdb_datapaths = &ne_data->fdb_datapaths,
>>>>> + .maintain_evpn = &ne_data->maintain_evpn,
>>>>> };
>>>>>
>>>>> neighbor_cleanup(&ne_data->monitored_interfaces);
>>>>> sset_clear(&ne_data->advertised_pbs);
>>>>> hmapx_clear(&ne_data->fdb_datapaths);
>>>>> + vector_clear(&ne_data->maintain_evpn);
>>>>> neighbor_run(&n_ctx_in, &n_ctx_out);
>>>>> + evpn_local_ip_map_destroy(&evpn_ip_map);
>>>>>
>>>>> return EN_UPDATED;
>>>>> }
>>>>> @@ -6612,6 +6629,7 @@ en_neighbor_exchange_run(struct engine_node *node,
>>>>> void *data_)
>>>>>
>>>>> struct neighbor_exchange_ctx_in n_ctx_in = {
>>>>> .monitored_interfaces = &neighbor_data->monitored_interfaces,
>>>>> + .maintain_evpn = &neighbor_data->maintain_evpn,
>>>>> };
>>>>> struct neighbor_exchange_ctx_out n_ctx_out = {
>>>>> .neighbor_table_watches = &nt_notify->watches,
>>>>> @@ -8798,6 +8816,7 @@ loop_done:
>>>>> poll_block();
>>>>> }
>>>>> route_exchange_cleanup_vrfs();
>>>>> + neighbor_exchange_maintain_evpn_cleanup_all();
>>>>> }
>>>>>
>>>>> /* The engine cleanup should happen only after threads have been
>>>>> @@ -8836,6 +8855,7 @@ loop_done:
>>>>> dns_resolve_destroy();
>>>>> route_exchange_destroy();
>>>>> ovn_netlink_notifiers_destroy();
>>>>> + neighbor_exchange_maintain_evpn_destroy();
>>>>>
>>>>> exit(retval);
>>>>> }
>>>>> diff --git a/lib/ovn-util.c b/lib/ovn-util.c
>>>>> index 6e9d1150e..f36fefc03 100644
>>>>> --- a/lib/ovn-util.c
>>>>> +++ b/lib/ovn-util.c
>>>>> @@ -1898,6 +1898,30 @@ port_contains_duplicate_ip(struct lport_addresses
>>>>> *laddrs1,
>>>>> return false;
>>>>> }
>>>>>
>>>>> +const struct in6_addr *
>>>>> +evpn_local_ip_map_lookup(const struct evpn_local_ip_map *map, uint32_t
>>>>> vni)
>>>>> +{
>>>>> + const struct in6_addr *addr = evpn_local_ip_lookup(&map->vni_ip4,
>>>>> vni);
>>>>> + if (addr) {
>>>>> + return addr;
>>>>> + }
>>>>> +
>>>>> + addr = evpn_local_ip_lookup(&map->vni_ip6, vni);
>>>>> + if (addr) {
>>>>> + return addr;
>>>>> + }
>>>>> +
>>>>> + if (ipv6_addr_is_set(&map->default_ip4)) {
>>>>> + return &map->default_ip4;
>>>>> + }
>>>>> +
>>>>> + if (ipv6_addr_is_set(&map->default_ip6)) {
>>>>> + return &map->default_ip6;
>>>>> + }
>>>>> +
>>>>> + return NULL;
>>>>> +}
>>>>> +
>>>>> const struct in6_addr *
>>>>> evpn_local_ip_lookup(const struct hmap *map, uint32_t vni)
>>>>> {
>>>>> diff --git a/lib/ovn-util.h b/lib/ovn-util.h
>>>>> index 8364ede5c..8fb28a9d4 100644
>>>>> --- a/lib/ovn-util.h
>>>>> +++ b/lib/ovn-util.h
>>>>> @@ -861,7 +861,7 @@ void evpn_local_ip_map_init(struct evpn_local_ip_map
>>>>> *vni_ip_map,
>>>>> const struct smap *config);
>>>>> const struct in6_addr *
>>>>> evpn_local_ip_map_lookup(const struct evpn_local_ip_map *map,
>>>>> - uint32_t vni, bool ipv4);
>>>>> + uint32_t vni);
>>>>> void evpn_local_ip_map_destroy(struct evpn_local_ip_map *map);
>>>>>
>>>>> #endif /* OVN_UTIL_H */
>>>>> diff --git a/northd/en-datapath-logical-switch.c
>>>>> b/northd/en-datapath-logical-switch.c
>>>>> index 874a608a7..528cccb96 100644
>>>>> --- a/northd/en-datapath-logical-switch.c
>>>>> +++ b/northd/en-datapath-logical-switch.c
>>>>> @@ -173,6 +173,28 @@ gather_external_ids(const struct
>>>>> nbrec_logical_switch *nbs,
>>>>> smap_add(external_ids, "dynamic-routing-redistribute",
>>>>> redistribute);
>>>>> }
>>>>> +
>>>>> + const char *ovn_maintain_evpn_mode =
>>>>> + smap_get(&nbs->other_config,
>>>>> "dynamic-routing-maintain-evpn");
>>>>> + if (ovn_maintain_evpn_mode) {
>>>>> + smap_add(external_ids, "dynamic-routing-maintain-evpn",
>>>>> + ovn_maintain_evpn_mode);
>>>>> + }
>>>>> +
>>>>> + const char *ovn_maintain_evpn_lrp =
>>>>> + smap_get(&nbs->other_config,
>>>>> "dynamic-routing-maintain-evpn-lrp");
>>>>> + if (ovn_maintain_evpn_lrp) {
>>>>> + smap_add(external_ids, "dynamic-routing-maintain-evpn-lrp",
>>>>> + ovn_maintain_evpn_lrp);
>>>>> + }
>>>>> +
>>>>> + const char *ovn_maintain_evpn_vxlan_port =
>>>>> + smap_get(&nbs->other_config,
>>>>> + "dynamic-routing-maintain-evpn-vxlan-port");
>>>>> + if (ovn_maintain_evpn_vxlan_port) {
>>>>> + smap_add(external_ids,
>>>>> "dynamic-routing-maintain-evpn-vxlan-port",
>>>>> + ovn_maintain_evpn_vxlan_port);
>>>>> + }
>>>>> }
>>>>>
>>>>> /* For backwards-compatibility, also store the NB UUID in
>>>>> diff --git a/ovn-nb.xml b/ovn-nb.xml
>>>>> index c741a3b32..81c9e7ee7 100644
>>>>> --- a/ovn-nb.xml
>>>>> +++ b/ovn-nb.xml
>>>>> @@ -967,15 +967,30 @@
>>>>> </p>
>>>>>
>>>>> <p>
>>>>> - All of the following configuration options must also be
>>>>> provided
>>>>> - in order for the configuration to be valid:
>>>>> - <ref column="other_config" key="dynamic-routing-bridge-ifname"
>>>>> - table="Logical_switch"/>,
>>>>> - <ref column="other_config" key="dynamic-routing-vxlan-ifname"
>>>>> - table="Logical_switch"/>,
>>>>> - <ref column="other_config"
>>>>> key="dynamic-routing-advertise-ifname"
>>>>> - table="Logical_switch"/>.
>>>>> + The EVPN interfaces (VXLAN, bridge and advertise devices) can
>>>>> + either be named explicitly by the CMS, or auto-created and
>>>>> + maintained by <code>ovn-controller</code>:
>>>>> </p>
>>>>> +
>>>>> + <ul>
>>>>> + <li>
>>>>> + To name the interfaces explicitly, all of the following
>>>>> + configuration options must also be provided in order for the
>>>>> + configuration to be valid:
>>>>> + <ref column="other_config"
>>>>> key="dynamic-routing-bridge-ifname"
>>>>> + table="Logical_switch"/>,
>>>>> + <ref column="other_config" key="dynamic-routing-vxlan-ifname"
>>>>> + table="Logical_switch"/>,
>>>>> + <ref column="other_config"
>>>>> key="dynamic-routing-advertise-ifname"
>>>>> + table="Logical_switch"/>.
>>>>> + </li>
>>>>> + <li>
>>>>> + To have <code>ovn-controller</code> create and maintain the
>>>>> + interfaces automatically instead, set
>>>>> + <ref column="other_config"
>>>>> key="dynamic-routing-maintain-evpn"
>>>>> + table="Logical_switch"/>.
>>>>> + </li>
>>>>> + </ul>
>>>>> </column>
>>>>>
>>>>> <column name="other_config" key="dynamic-routing-bridge-ifname">
>>>>> @@ -998,6 +1013,88 @@
>>>>> table="Logical_switch"/> is set to valid
>>>>> VNI.
>>>>> </column>
>>>>>
>>>>> + <column name="other_config" key="dynamic-routing-maintain-evpn"
>>>>> + type='{"type": "string", "enum": ["set", ["mvd"]]}'>
>>>>> + <p>
>>>>> + Enables automatic management of the EVPN interface stack by
>>>>> + <code>ovn-controller</code> for the VNI specified by
>>>>> + <ref column="other_config" key="dynamic-routing-vni"
>>>>> + table="Logical_switch"/>.
>>>>> + Instead of requiring the CMS to create and configure the
>>>>> interfaces,
>>>>> + <code>ovn-controller</code> creates and maintains them on every
>>>>> + chassis where the logical switch is local.
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + The only supported value is <code>mvd</code> (VXLAN device per
>>>>> VNI).
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + In this mode, <code>ovn-controller</code> creates the following
>>>>> + interfaces, each suffixed with the VNI:
>>>>> + <code>ovnbr<vni></code>,
>>>>> + <code>ovnvxlan<vni></code>, and
>>>>> + <code>ovnlo<vni></code>
>>>>> + (for example, <code>ovnvxlan100</code>).
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + If <ref column="other_config"
>>>>> key="dynamic-routing-redistribute"
>>>>> + table="Logical_switch"/> includes <code>ip</code> and
>>>>> + <ref column="other_config"
>>>>> key="dynamic-routing-maintain-evpn-lrp"
>>>>> + table="Logical_switch"/> is configured,
>>>>> + <code>ovn-controller</code> also creates a VRF named
>>>>> + <code>ovnvrf<vni></code> and enslaves the bridge
>>>>> interface
>>>>> + to it. This allows the logical router IP addresses to be
>>>>> advertised
>>>>> + through EVPN.
>>>>> + </p>
>>>>> + </column>
>>>>> +
>>>>> + <column name="other_config"
>>>>> key="dynamic-routing-maintain-evpn-lrp">
>>>>> + <p>
>>>>> + Specifies the
>>>>> + <ref table="Logical_Router_Port"/> whose MAC address is
>>>>> assigned
>>>>> + to the auto-created bridge interface managed by
>>>>> + <ref column="other_config" key="dynamic-routing-maintain-evpn"
>>>>> + table="Logical_switch"/>.
>>>>> + This ensures that L3/IRB traffic terminating on the EVPN VNI
>>>>> uses
>>>>> + the logical router's MAC address.
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + Alternatively, an Ethernet address (for example,
>>>>> + <code>00:00:00:00:01:00</code>) may be specified directly
>>>>> instead
>>>>> + of a port name; it is then used as is for the bridge interface.
>>>>> + This is useful when the router port is configured with
>>>>> multiple MAC
>>>>> + addresses and the CMS needs to select a specific one.
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + This option is required only when
>>>>> + <ref column="other_config" key="dynamic-routing-maintain-evpn"
>>>>> + table="Logical_switch"/> is enabled and
>>>>> + <ref column="other_config" key="dynamic-routing-redistribute"
>>>>> + table="Logical_switch"/> includes <code>ip</code>.
>>>>> + </p>
>>>>> + </column>
>>>>> +
>>>>> + <column name="other_config"
>>>>> + key="dynamic-routing-maintain-evpn-vxlan-port"
>>>>> + type='{"type": "integer", "minInteger": 1,
>>>>> + "maxInteger": 65535}'>
>>>>> + <p>
>>>>> + The UDP destination port configured on the VXLAN device
>>>>> created by
>>>>> + <ref column="other_config" key="dynamic-routing-maintain-evpn"
>>>>> + table="Logical_switch"/>. Defaults to <code>4790</code>.
>>>>> + </p>
>>>>> +
>>>>> + <p>
>>>>> + This device is only used to exchange EVPN state with the
>>>>> routing
>>>>> + daemon, it never carries traffic, so the port must differ from
>>>>> the
>>>>> + one used by the OVS datapath VXLAN device (<code>4789</code>).
>>>>> + </p>
>>>>> + </column>
>>>>> +
>>>>> <column name="other_config"
>>>>> key="dynamic-routing-fdb-prefer-local"
>>>>> type='{"type": "boolean"}'>
>>>>> <p>
>>>>> diff --git a/tests/system-ovn.at b/tests/system-ovn.at
>>>>> index 973c46728..5f619c17e 100644
>>>>> --- a/tests/system-ovn.at
>>>>> +++ b/tests/system-ovn.at
>>>>> @@ -23741,3 +23741,328 @@ OVS_TRAFFIC_VSWITCHD_STOP(["/failed to query
>>>>> port patch-.*/d
>>>>>
>>>>> AT_CLEANUP
>>>>> ])
>>>>> +
>>>>> +OVN_FOR_EACH_NORTHD([
>>>>> +AT_SETUP([dynamic-routing - EVPN maintain-evpn mvd])
>>>>> +AT_KEYWORDS([dynamic-routing evpn maintain-evpn])
>>>>> +
>>>>> +CHECK_VRF()
>>>>> +
>>>>> +vni=100
>>>>> +VRF_RESERVE([$vni])
>>>>> +
>>>>> +ovn_start
>>>>> +OVS_TRAFFIC_VSWITCHD_START()
>>>>> +ADD_BR([br-int])
>>>>> +
>>>>> +# Create a fake VXLAN interface, since there's no real peer chassis in
>>>>> +# this test to make OVS create vxlan_sys_<port> automatically.
>>>>> +ip link add vxlan_sys_4789 type vxlan dstport 4789 external
>>>>> +ip link set vxlan_sys_4789 up
>>>>> +
>>>>> +check ovs-vsctl \
>>>>> + -- set Open_vSwitch . external-ids:system-id=hv1 \
>>>>> + -- set Open_vSwitch .
>>>>> external-ids:ovn-remote=unix:$ovs_base/ovn-sb/ovn-sb.sock \
>>>>> + -- set Open_vSwitch . external-ids:ovn-encap-type=geneve \
>>>>> + -- set Open_vSwitch . external-ids:ovn-encap-ip=169.0.0.1 \
>>>>> + -- set Open_vSwitch . external-ids:ovn-evpn-local-ip=169.0.0.1 \
>>>>> + -- set bridge br-int fail-mode=secure
>>>>> other-config:disable-in-band=true
>>>>> +
>>>>> +start_daemon ovn-controller
>>>>> +ovs-vsctl add-port br-int p1 -- \
>>>>> + set Interface p1 external_ids:iface-id=ls-p1 -- \
>>>>> + set Interface p1 type=internal
>>>>> +check ovn-nbctl ls-add ls-evpn
>>>>> +check ovn-nbctl lsp-add ls-evpn ls-p1
>>>>> +check ovn-nbctl lsp-set-addresses ls-p1 "00:00:00:00:00:02 20.20.20.2"
>>>>> +
>>>>> +AS_BOX([Create EVPN interface stack - L2 VNI])
>>>>> +check ovn-nbctl \
>>>>> + -- set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-vni=$vni \
>>>>> + other_config:dynamic-routing-maintain-evpn=mvd \
>>>>> + other_config:dynamic-routing-redistribute=fdb
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +# check no vrf exists since it's only fdb mode configured
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [1])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [0])
>>>>> +
>>>>> +AT_CHECK([ip -d link show ovnvxlan$vni | grep -oP ' id \K[[0-9]]+'],
>>>>> [0], [dnl
>>>>> +100
>>>>> +], [ignore])
>>>>> +
>>>>> +# The default dstport is used since it is not requested explicitly.
>>>>> +AT_CHECK([ip -d link show ovnvxlan$vni | grep -oP 'dstport
>>>>> \K[[0-9]]+'],[0], [dnl
>>>>> +4790
>>>>> +], ignore)
>>>>> +
>>>>> +# Request a different dstport for the VXLAN device.
>>>>> +check ovn-nbctl \
>>>>> + -- set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-vxlan-port=4791
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +OVS_WAIT_UNTIL([test "$(ip -d link show ovnvxlan$vni |
>>>>> + grep -oP 'dstport \K[[0-9]]+')" = "4791"])
>>>>> +
>>>>> +check ovn-nbctl \
>>>>> + -- remove Logical_Switch ls-evpn other_config \
>>>>> + dynamic-routing-maintain-evpn-vxlan-port
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +OVS_WAIT_UNTIL([test "$(ip -d link show ovnvxlan$vni |
>>>>> + grep -oP 'dstport \K[[0-9]]+')" = "4790"])
>>>>> +
>>>>> +AT_CHECK([ip -d link show ovnvxlan$vni | grep -q 'local 169.0.0.1'],
>>>>> [0], [ignore], [ignore])
>>>>> +
>>>>> +AT_CHECK([ip -d link show ovnvxlan$vni | grep -q 'nolearning'], [0],
>>>>> [ignore], [ignore])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'],[0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnlo$vni | grep -oP 'master \K\S+'],[0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +
>>>>> +AS_BOX([Bridge MAC via dynamic-routing-evpn-lrp])
>>>>> +# Add LRP connected to ls-evpn; its MAC/IP will be applied to the bridge.
>>>>> +check ovn-nbctl \
>>>>> + -- lr-add R-evpn \
>>>>> + -- lrp-add R-evpn rp-evpn 00:00:00:aa:bb:01 192.168.100.1/24 \
>>>>> + -- lsp-add ls-evpn ls-evpn-rp \
>>>>> + -- set Logical_Switch_Port ls-evpn-rp type=router \
>>>>> + options:router-port=rp-evpn \
>>>>> + -- lsp-set-addresses ls-evpn-rp router \
>>>>> + -- set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp=rp-evpn \
>>>>> + other_config:dynamic-routing-redistribute=fdb,ip
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +# check vrf exists since it's fdb + ip mode
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [0])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnlo$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnvrf100
>>>>> +])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'link/ether \K\S+'], [0],
>>>>> [dnl
>>>>> +00:00:00:aa:bb:01
>>>>> +])
>>>>> +
>>>>> +AS_BOX([Bridge MAC address changes])
>>>>> +check ovn-nbctl set Logical_Router_Port rp-evpn \
>>>>> + mac='"00:00:00:00:00:08"'
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'link/ether \K\S+'],[0], [dnl
>>>>> +00:00:00:00:00:08
>>>>> +])
>>>>> +
>>>>> +AS_BOX([dynamic-routing-maintain-evpn-lrp must name a router port of
>>>>> this LS])
>>>>> +# The MAC of that port is advertised as the EVPN next-hop for this VNI,
>>>>> so a
>>>>> +# port that is not a router port must be rejected.
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp=ls-p1
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +OVS_WAIT_UNTIL([grep -q 'is not a router port' ovn-controller.log])
>>>>> +AT_CHECK([ip link show ovnbr$vni], [1], [ignore], [ignore])
>>>>> +
>>>>> +# A router port of a different Logical Switch must be rejected as well:
>>>>> its
>>>>> +# MAC does not belong to this L2 domain. ls-other needs a port bound to
>>>>> +# this chassis so that its port bindings are actually monitored here.
>>>>> +ovs-vsctl add-port br-int p2 -- \
>>>>> + set Interface p2 external_ids:iface-id=ls-other-p1 -- \
>>>>> + set Interface p2 type=internal
>>>>> +check ovn-nbctl \
>>>>> + -- ls-add ls-other \
>>>>> + -- lsp-add ls-other ls-other-p1 \
>>>>> + -- lsp-set-addresses ls-other-p1 "00:00:00:00:00:03 20.20.30.3" \
>>>>> + -- lr-add R-other \
>>>>> + -- lrp-add R-other rp-other 00:00:00:aa:bb:02 192.168.200.1/24 \
>>>>> + -- lsp-add ls-other ls-other-rp \
>>>>> + -- set Logical_Switch_Port ls-other-rp type=router \
>>>>> + options:router-port=rp-other \
>>>>> + -- lsp-set-addresses ls-other-rp router \
>>>>> + -- set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp=rp-other
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +OVS_WAIT_UNTIL([grep -q 'is not attached to datapath'
>>>>> ovn-controller.log])
>>>>> +AT_CHECK([ip link show ovnbr$vni], [1], [ignore], [ignore])
>>>>> +
>>>>> +# Back to the router port of ls-evpn: the stack must come back.
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp=rp-evpn
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'link/ether \K\S+'],[0], [dnl
>>>>> +00:00:00:00:00:08
>>>>> +])
>>>>> +
>>>>> +AS_BOX([dynamic-routing-maintain-evpn-lrp accepts a MAC address])
>>>>> +# Instead of a port name, the option may carry an Ethernet address,
>>>>> which is
>>>>> +# then used as is.
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp='"00:00:00:aa:bb:09"'
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +OVS_WAIT_UNTIL([test "$(ip link show ovnbr$vni |
>>>>> + grep -oP 'link/ether \K\S+')" =
>>>>> "00:00:00:aa:bb:09"])
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [0])
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnvrf100
>>>>> +])
>>>>> +
>>>>> +# Back to the port name: the MAC of the router port is used again.
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-maintain-evpn-lrp=rp-evpn
>>>>> +check ovn-nbctl set Logical_Router_Port rp-evpn mac='"00:00:00:00:00:08"'
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +OVS_WAIT_UNTIL([test "$(ip link show ovnbr$vni |
>>>>> + grep -oP 'link/ether \K\S+')" =
>>>>> "00:00:00:00:00:08"])
>>>>> +
>>>>> +
>>>>> +AS_BOX([Redistribute mode change fdb,ip -> fdb: VRF destroyed, lo kept])
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-redistribute=fdb
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +# check vrf exists since it's fdb + ip mode
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [1])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [0])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnlo$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +
>>>>> +AS_BOX([Redistribute mode change fdb -> ip: lo destroyed, VRF recreated])
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-redistribute=ip
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [1])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'],[0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'master \K\S+'],[0], [dnl
>>>>> +ovnvrf100
>>>>> +])
>>>>> +
>>>>> +AS_BOX([Redistribute mode change ip -> fdb,ip: lo and VRF both present
>>>>> again])
>>>>> +check ovn-nbctl set Logical_Switch ls-evpn \
>>>>> + other_config:dynamic-routing-redistribute=fdb,ip
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [0])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [0])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnlo$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'master \K\S+'],[0], [dnl
>>>>> +ovnvrf100
>>>>> +])
>>>>> +
>>>>> +AS_BOX([ovn-controller exit --restart: EVPN stack must survive])
>>>>> +br_ifindex=$(cat /sys/class/net/ovnbr$vni/ifindex)
>>>>> +vxlan_ifindex=$(cat /sys/class/net/ovnvxlan$vni/ifindex)
>>>>> +lo_ifindex=$(cat /sys/class/net/ovnlo$vni/ifindex)
>>>>> +vrf_ifindex=$(cat /sys/class/net/ovnvrf$vni/ifindex)
>>>>> +
>>>>> +TMPPID=$(cat $OVS_RUNDIR/ovn-controller.pid)
>>>>> +check ovs-appctl -t ovn-controller exit --restart
>>>>> +OVS_WAIT_WHILE([kill -0 $TMPPID 2>/dev/null])
>>>>> +
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnvrf$vni/ifindex)" =
>>>>> "$vrf_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnbr$vni/ifindex)" =
>>>>> "$br_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnvxlan$vni/ifindex)" =
>>>>> "$vxlan_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnlo$vni/ifindex)" =
>>>>> "$lo_ifindex"])
>>>>> +
>>>>> +# Starting again must adopt the existing stack instead of recreating it:
>>>>> +# the ifindexes have to stay the same and the topology must be intact.
>>>>> +start_daemon ovn-controller
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnvrf$vni/ifindex)" =
>>>>> "$vrf_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnbr$vni/ifindex)" =
>>>>> "$br_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnvxlan$vni/ifindex)" =
>>>>> "$vxlan_ifindex"])
>>>>> +AT_CHECK([test "$(cat /sys/class/net/ovnlo$vni/ifindex)" =
>>>>> "$lo_ifindex"])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnvrf100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnlo$vni | grep -oP 'master \K\S+'], [0], [dnl
>>>>> +ovnbr100
>>>>> +])
>>>>> +AT_CHECK([ip link show ovnbr$vni | grep -oP 'link/ether \K\S+'], [0],
>>>>> [dnl
>>>>> +00:00:00:00:00:08
>>>>> +])
>>>>> +
>>>>> +AS_BOX([Graceful ovn-controller exit: EVPN stack must be cleaned up])
>>>>> +OVS_APP_EXIT_AND_WAIT([ovn-controller])
>>>>> +
>>>>> +AT_CHECK([ip link show ovnvrf$vni], [1], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnbr$vni], [1], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni], [1], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnlo$vni], [1], [ignore], [ignore])
>>>>> +
>>>>> +# Bring the stack back for the remaining checks.
>>>>> +start_daemon ovn-controller
>>>>> +OVS_WAIT_UNTIL([test "$(ovn-sbctl --bare --columns=name find chassis \
>>>>> + name=hv1)" = "hv1"])
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +AT_CHECK([ip link show ovnvrf$vni], [0], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnbr$vni], [0], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnvxlan$vni], [0], [ignore], [ignore])
>>>>> +AT_CHECK([ip link show ovnlo$vni], [0], [ignore], [ignore])
>>>>> +
>>>>> +AS_BOX([Remove maintain-evpn - full stack cleanup])
>>>>> +check ovn-nbctl \
>>>>> + -- remove Logical_Switch ls-evpn other_config
>>>>> dynamic-routing-maintain-evpn
>>>>> +check ovn-nbctl --wait=hv sync
>>>>> +
>>>>> +AT_CHECK([ip a | grep -q ovnvrf100], [1])
>>>>> +AT_CHECK([ip a | grep -q ovnbr100], [1])
>>>>> +AT_CHECK([ip a | grep -q ovnvxlan100], [1])
>>>>> +AT_CHECK([ip a | grep -q ovnlo100], [1])
>>>>> +
>>>>> +ip link del vxlan_sys_4789
>>>>> +
>>>>> +OVN_CLEANUP_CONTROLLER([hv1])
>>>>> +OVN_CLEANUP_NORTHD
>>>>> +as
>>>>> +OVS_TRAFFIC_VSWITCHD_STOP(["/failed to query port patch-.*/d
>>>>> +/connection dropped.*/d
>>>>> +/misses dynamic-routing.*/d
>>>>> +/dynamic-routing-maintain-evpn-lrp.*/d"])
>>>>> +AT_CLEANUP
>>>>> +])
>>>>> --
>>>>> 2.48.1
>>>>>
>>>>> _______________________________________________
>>>>> dev mailing list
>>>>> [email protected]
>>>>> https://mail.openvswitch.org/mailman/listinfo/ovs-dev
>
_______________________________________________
dev mailing list
[email protected]
https://mail.openvswitch.org/mailman/listinfo/ovs-dev