On Wed, Nov 11, 2026 at 2:34 PM Dumitru Ceara <[email protected]> wrote:
> 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! > Hi Dumitru, Alexandra and Numan, > > > > 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). > I also don't think that this should be OVN's responsibility at all. Sure we have "maintain-vrf", but it shouldn't be there IMO. The benefit vs. maintenance cost and code size doesn't seem to favor those changes. And the discussion here solidifies that even more for me. > > 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. > I mean is this different from a name check? Unfortunately, the kernel doesn't allow us to filter by device group so we need to dump everything anyway. > > 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. > As I said above I'm not sure we should maintain this in OVN. Especially when the contract is a on the weak side, reconcile only on restart and if anything happens in between you might have a problem. However, if Dumitru and Numan are fine with this feature I won't block it. > > Thanks, Sasha > > > > Thanks for the discussion! > > Dumitru > Thanks, Ales > > >>> 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
