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&lt;vni&gt;</code>,
>>>>> +          <code>ovnvxlan&lt;vni&gt;</code>, and
>>>>> +          <code>ovnlo&lt;vni&gt;</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&lt;vni&gt;</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

Reply via email to