Thank you Mark for your review. Agreed on using vector_push_array() here.

I'd use vector_get_array() and keep vector_destroy(&snapshot). Since the
append copies the data, the vector_steal_array() version would still need
to free the returned buffer to avoid a leak.

I'll wait for following reviews before updating the patch.

On Tue, Nov 10, 2026 at 9:46 PM Mark Michelson <[email protected]> wrote:

> Hi Guillaume, thanks for the submission. I am not as familiar with
> this area of code, but from what I can see, this behavior change seems
> correct. I have one small mechanical issue with the patch, which I
> have noted down below. Aside from that, though:
>
> Acked-by: Mark Michelson <[email protected]>
>
> I think the mechanical issue can be fixed during merge and doesn't
> require a new version to be posted. However, I'm going to leave this
> review up for another day or two in case one of my colleagues wants to
> take a look and comment on anything I may have missed. If they post
> findings, then please address those plus what I describe below in your
> next version.
>
> On Fri, Oct 30, 2026 at 12:21 PM Guillaume Boutry via dev
> <[email protected]> wrote:
> >
> > From: Guillaume Boutry <[email protected]>
> >
> > Neighbor synchronization ignores errors from the Netlink dump and can
> > process an incomplete neighbor table as a successful result. This
> > has been present since ad3a0a55b added Netlink neighbor synchronization.
> >
> > Collect the complete dump before processing observations or changing
> > kernel entries. For unfiltered dumps, check the family and interface
> > header before parsing attributes so unrelated non-Ethernet neighbors
> > cannot cause a false parse error. Keep malformed in-scope records fatal.
> >
> > Cover allocation failures, unrelated records, malformed input and
> > late dump errors, including preservation of caller observations
> > and prevention of kernel writes. Include a successful publication
> > control. Scripted failure tests wrap only the test executable's
> > Netlink transport. Normal commands use the real functions. Production
> > binaries do not use these wrappers.
> >
> > Assisted-By: Codex (gpt-6.1-sol)
> > Signed-off-by: Guillaume Boutry <[email protected]>
> > ---
> > Neighbor synchronization consumes an incomplete neighbor table when its
> > Netlink dump fails. ne_table_dump_one_ifindex() ignores nl_dump_done()'s
> > return value and processes observations before checking completion. The
> > caller can then publish partial observations or reconcile kernel entries
> > using an incomplete view.
> >
> > A failed dump should return its error without changing caller
> observations
> > or kernel neighbors. Linux documents that interrupted dumps can miss
> > entries and must be retried:
> >
> https://docs.kernel.org/userspace-api/netlink/intro.html#dump-consistency
> >
> > Reproducer
> > ----------
> > The patch adds a real EMFILE case and scripted late failures after valid
> > entries, with a nonempty desired set and a sentinel observation:
> >
> >   make check-kernel TESTSUITEFLAGS='-d -k netlink-dump-error'
> >
> > To exercise the old behavior, keep the test additions and use the
> original
> > production implementation. The patch buffers observations until the dump
> > succeeds. It also skips unrelated family/interface records before
> Ethernet
> > parsing, while rejecting malformed records within the requested scope.
> >
> > Validation
> > ----------
> > OVN 26.09.90, upstream base:
> >   1c8d7419a73743f79ff54102c6b66f6c8061b756
> >
> > The Werror build and Linux Netlink selection passed (10 tests, zero
> skips)
> > on source tree 91b48f512. The standalone export applies to the base
> above;
> > it was not rebuilt separately. The tests cover partial-dump rollback,
> > malformed input and a successful add/delete/learn control. No full-suite
> > or older-kernel/IPoIB hardware run was performed.
> >
> >  controller/neighbor-exchange-netlink.c |  85 +++++++--
> >  tests/automake.mk                      |   8 +
> >  tests/system-ovn-netlink.at            |  29 +++
> >  tests/test-ovn-netlink.c               | 233 +++++++++++++++++++++++++
> >  4 files changed, 339 insertions(+), 16 deletions(-)
> >
> > diff --git a/controller/neighbor-exchange-netlink.c
> b/controller/neighbor-exchange-netlink.c
> > index c6b21e7a2..9cd50037f 100644
> > --- a/controller/neighbor-exchange-netlink.c
> > +++ b/controller/neighbor-exchange-netlink.c
> > @@ -14,6 +14,7 @@
> >   */
> >
> >  #include <config.h>
> > +#include <errno.h>
> >  #include <stdbool.h>
> >  #include <linux/if_ether.h>
> >  #include <linux/rtnetlink.h>
> > @@ -48,10 +49,13 @@ static struct vlog_rate_limit rl =
> VLOG_RATE_LIMIT_INIT(5, 20);
> >  /* Inspired from route_table_dump_one_table() in OVS. */
> >  typedef void ne_table_handle_msg_callback(const struct ne_table_msg *,
> >                                            void *aux);
> > -static void ne_table_dump_one_ifindex(unsigned char address_family,
> > +static int ne_table_dump_one_ifindex(unsigned char address_family,
> >                                        int32_t if_index,
> >                                        ne_table_handle_msg_callback *,
> >                                        void *aux);
> > +static int ne_nl_dump_neigh(uint8_t family, int32_t if_index,
> > +                            struct vector *neighbors);
> > +
> >  struct ne_msg_handle_data {
> >      /* Stores 'struct advertise_neighbor_entry'. */
> >      struct hmapx *neighbors_to_advertise;
> > @@ -111,7 +115,21 @@ ne_nl_sync_neigh(uint8_t family, int32_t if_index,
> >          .stale_neighbors = &stale_neighbors,
> >          .neighbors = neighbors,
> >      };
> > -    ne_table_dump_one_ifindex(family, if_index, handle_ne_msg, &data);
> > +    struct vector snapshot =
> > +        VECTOR_EMPTY_INITIALIZER(struct ne_nl_received_neigh);
> > +    ret = ne_nl_dump_neigh(family, if_index, &snapshot);
> > +    if (ret) {
> > +        goto out;
> > +    }
> > +
> > +    struct ne_nl_received_neigh *ne;
> > +    VECTOR_FOR_EACH_PTR (&snapshot, ne) {
> > +        struct ne_table_msg msg = {
> > +            .nlmsg_type = RTM_NEWNEIGH,
> > +            .nd = *ne,
> > +        };
> > +        handle_ne_msg(&msg, &data);
> > +    }
> >
> >      /* Add any remaining neighbors in the neighbors_to_advertise hmapx
> to the
> >       * system table. */
> > @@ -141,7 +159,6 @@ ne_nl_sync_neigh(uint8_t family, int32_t if_index,
> >      }
> >
> >      /* Remove any stale neighbors from the system table. */
> > -    struct ne_nl_received_neigh *ne;
> >      VECTOR_FOR_EACH_PTR (&stale_neighbors, ne) {
> >          int err = ne_nl_del_neigh(ne->if_index, ne->family,
> >                                    &ne->lladdr, &ne->addr,
> > @@ -163,6 +180,8 @@ ne_nl_sync_neigh(uint8_t family, int32_t if_index,
> >          }
> >      }
> >
> > +out:
> > +    vector_destroy(&snapshot);
> >      hmapx_destroy(&neighbors_to_advertise);
> >      vector_destroy(&stale_neighbors);
> >      return ret;
> > @@ -220,6 +239,31 @@ ne_is_valid_static_arp(struct ne_nl_received_neigh
> *ne)
> >  }
> >
> >  static void
> > +collect_ne_msg(const struct ne_table_msg *msg, void *data)
> > +{
> > +    vector_push(data, &msg->nd);
> > +}
> > +
> > +/* Appends a complete, read-only snapshot of neighbors to 'neighbors'.
> On
> > + * failure, leaves 'neighbors' unchanged and returns an errno value. */
> > +static int
> > +ne_nl_dump_neigh(uint8_t family, int32_t if_index, struct vector
> *neighbors)
> > +{
> > +    struct vector snapshot =
> > +        VECTOR_EMPTY_INITIALIZER(struct ne_nl_received_neigh);
> > +    int error = ne_table_dump_one_ifindex(family, if_index,
> collect_ne_msg,
> > +                                         &snapshot);
> > +    if (!error) {
> > +        const struct ne_nl_received_neigh *ne;
> > +        VECTOR_FOR_EACH_PTR (&snapshot, ne) {
> > +            vector_push(neighbors, ne);
> > +        }
>
> The OVN vector library provides a way to push an entire array at once
> instead of having to loop like this.
>
> vector_push_array(neighbors, vector_get_array(&snapshot),
> vector_len(&snapshot));
>
> Alternately, if you don't want to have to call
> vector_destroy(&snapshot) afterwards, you could do:
>
> size_t snapshot_len = vector_len(&snapshot);
> vector_push_array(neighbors, vector_steal_array(&snapshot), snapshot_len);
>
> > +    }
> > +    vector_destroy(&snapshot);
> > +    return error;
> > +}
> > +
> > +static int
> >  ne_table_dump_one_ifindex(unsigned char address_family, int32_t
> if_index,
> >                            ne_table_handle_msg_callback *handle_msg_cb,
> >                            void *aux)
> > @@ -228,6 +272,7 @@ ne_table_dump_one_ifindex(unsigned char
> address_family, int32_t if_index,
> >      struct ofpbuf request, reply, buf;
> >      struct ndmsg *rq_msg;
> >      struct nl_dump dump;
> > +    int error = 0;
> >
> >      uint8_t request_stub[NETNL_REQ_BUFFER_SIZE];
> >      ofpbuf_use_stub(&request, request_stub, sizeof request_stub);
> > @@ -244,24 +289,32 @@ ne_table_dump_one_ifindex(unsigned char
> address_family, int32_t if_index,
> >
> >      ofpbuf_use_stub(&buf, reply_stub, sizeof reply_stub);
> >      while (nl_dump_next(&dump, &reply, &buf)) {
> > -        struct ne_table_msg msg;
> > +        const struct nlmsghdr *nlmsghdr = ofpbuf_at(&reply, 0,
> NLMSG_HDRLEN);
> > +        const struct ndmsg *nd = ofpbuf_at(&reply, NLMSG_HDRLEN, sizeof
> *nd);
> > +        if (!nlmsghdr || !nd) {
> > +            error = EPROTO;
> > +            break;
> > +        }
> >
> > -        if (ne_table_parse(&reply, &msg)) {
> > -            struct nlmsghdr *nlmsghdr = nl_msg_nlmsghdr(&reply);
> > +        /* Some kernels return unfiltered dumps.  Check the header
> before
> > +         * parsing attributes so unrelated non-Ethernet neighbors cannot
> > +         * abort synchronization of the requested interface. */
> > +        if (!(nlmsghdr->nlmsg_flags & NLM_F_DUMP_FILTERED)
> > +            && (nd->ndm_family != address_family
> > +                || (if_index && nd->ndm_ifindex != if_index))) {
> > +            continue;
> > +        }
> >
> > -            /* Older kernels do not support filtering.  If so, we
> > -             * filter ourselves. */
> > -            if (!(nlmsghdr->nlmsg_flags & NLM_F_DUMP_FILTERED)) {
> > -                if (msg.nd.family != address_family
> > -                    || (if_index && msg.nd.if_index != if_index)) {
> > -                    continue;
> > -                }
> > -            }
> > -            handle_msg_cb(&msg, aux);
> > +        struct ne_table_msg msg;
> > +        if (!ne_table_parse(&reply, &msg)) {
> > +            error = EPROTO;
> > +            break;
> >          }
> > +        handle_msg_cb(&msg, aux);
> >      }
> >      ofpbuf_uninit(&buf);
> > -    nl_dump_done(&dump);
> > +    int dump_error = nl_dump_done(&dump);
> > +    return dump_error ? dump_error : error;
> >  }
> >
> >  static int
> > diff --git a/tests/automake.mk b/tests/automake.mk
> > index 8f7a8c4fa..4579bd914 100644
> > --- a/tests/automake.mk
> > +++ b/tests/automake.mk
> > @@ -291,6 +291,14 @@ tests_ovstest_SOURCES = \
> >         northd/test-ipam.c
> >
> >  if HAVE_NETLINK
> > +# Deterministic dump failures exercise the production synchronization
> path.
> > +# Only ovstest uses these wrappers; inactive scripts call the real
> transport.
> > +tests_ovstest_LDFLAGS = $(AM_LDFLAGS) \
> > +       -Wl,--wrap=nl_dump_start \
> > +       -Wl,--wrap=nl_dump_next \
> > +       -Wl,--wrap=nl_dump_done \
> > +       -Wl,--wrap=nl_transact
> > +
> >  tests_ovstest_SOURCES += \
> >         controller/host-if-monitor.c \
> >         controller/host-if-monitor.h \
> > diff --git a/tests/system-ovn-netlink.at b/tests/system-ovn-netlink.at
> > index 69c25d6e9..78727785e 100644
> > --- a/tests/system-ovn-netlink.at
> > +++ b/tests/system-ovn-netlink.at
> > @@ -1,5 +1,34 @@
> >  AT_BANNER([system-ovn-netlink])
> >
> > +AT_SETUP([sync netlink neighbors - failed dump])
> > +AT_KEYWORDS([netlink-neighbors netlink-dump-error])
> > +AT_CHECK([ovstest test-ovn-netlink neighbor-sync-error], [0], [],
> [ignore])
> > +AT_CLEANUP
> > +
> > +AT_SETUP([sync netlink neighbors - filter unrelated dump records])
> > +AT_KEYWORDS([netlink-neighbors netlink-dump-error])
> > +check ovstest test-ovn-netlink neighbor-dump-script other-interface
> > +check ovstest test-ovn-netlink neighbor-dump-script other-family
> > +AT_CLEANUP
> > +
> > +AT_SETUP([sync netlink neighbors - malformed dump records])
> > +AT_KEYWORDS([netlink-neighbors netlink-dump-error])
> > +check ovstest test-ovn-netlink neighbor-dump-script malformed
> > +check ovstest test-ovn-netlink neighbor-dump-script filtered-malformed
> > +check ovstest test-ovn-netlink neighbor-dump-script truncated
> > +AT_CLEANUP
> > +
> > +AT_SETUP([sync netlink neighbors - partial dump rollback])
> > +AT_KEYWORDS([netlink-neighbors netlink-dump-error])
> > +check ovstest test-ovn-netlink neighbor-dump-script late-error
> > +check ovstest test-ovn-netlink neighbor-dump-script parse-and-dump-error
> > +AT_CLEANUP
> > +
> > +AT_SETUP([sync netlink neighbors - complete dump publication])
> > +AT_KEYWORDS([netlink-neighbors netlink-dump-error])
> > +check ovstest test-ovn-netlink neighbor-dump-script complete
> > +AT_CLEANUP
> > +
> >  AT_SETUP([sync netlink neighbors - learn VXLAN VTEP neighbors])
> >  AT_KEYWORDS([netlink-neighbors])
> >
> > diff --git a/tests/test-ovn-netlink.c b/tests/test-ovn-netlink.c
> > index f75a6f295..cc9a33a3a 100644
> > --- a/tests/test-ovn-netlink.c
> > +++ b/tests/test-ovn-netlink.c
> > @@ -14,7 +14,12 @@
> >   */
> >
> >  #include <config.h>
> > +#include <errno.h>
> > +#include <linux/rtnetlink.h>
> > +#include <sys/resource.h>
> >
> > +#include "netlink.h"
> > +#include "netlink-socket.h"
> >  #include "openvswitch/hmap.h"
> >  #include "route-table.h"
> >  #include "packets.h"
> > @@ -29,6 +34,231 @@
> >  #include "controller/route.h"
> >  #include "controller/route-exchange-netlink.h"
> >
> > +/* Script only the transport used by neighbor synchronization.  The
> normal
> > + * ovstest commands delegate to the real Netlink functions.  Production
> > + * binaries do not use these linker wrappers. */
> > +static struct {
> > +    bool active;
> > +    bool started;
> > +    bool finished;
> > +    struct ofpbuf messages[3];
> > +    size_t n_messages;
> > +    size_t next;
> > +    int error;
> > +    unsigned int adds;
> > +    unsigned int deletes;
> > +} neighbor_dump;
> > +
> > +void __real_nl_dump_start(struct nl_dump *, int, const struct ofpbuf *);
> > +bool __real_nl_dump_next(struct nl_dump *, struct ofpbuf *, struct
> ofpbuf *);
> > +int __real_nl_dump_done(struct nl_dump *);
> > +int __real_nl_transact(int, const struct ofpbuf *, struct ofpbuf **);
> > +void __wrap_nl_dump_start(struct nl_dump *, int, const struct ofpbuf *);
> > +bool __wrap_nl_dump_next(struct nl_dump *, struct ofpbuf *, struct
> ofpbuf *);
> > +int __wrap_nl_dump_done(struct nl_dump *);
> > +int __wrap_nl_transact(int, const struct ofpbuf *, struct ofpbuf **);
> > +
> > +void
> > +__wrap_nl_dump_start(struct nl_dump *dump, int protocol,
> > +                     const struct ofpbuf *request)
> > +{
> > +    if (!neighbor_dump.active) {
> > +        __real_nl_dump_start(dump, protocol, request);
> > +        return;
> > +    }
> > +    ovs_assert(protocol == NETLINK_ROUTE);
> > +    ovs_assert(nl_msg_nlmsghdr(request)->nlmsg_type == RTM_GETNEIGH);
> > +    ovs_assert(!neighbor_dump.started);
> > +    neighbor_dump.started = true;
> > +}
> > +
> > +bool
> > +__wrap_nl_dump_next(struct nl_dump *dump, struct ofpbuf *reply,
> > +                    struct ofpbuf *buf)
> > +{
> > +    if (!neighbor_dump.active) {
> > +        return __real_nl_dump_next(dump, reply, buf);
> > +    }
> > +    ovs_assert(neighbor_dump.started && !neighbor_dump.finished);
> > +    if (neighbor_dump.next == neighbor_dump.n_messages) {
> > +        return false;
> > +    }
> > +    *reply = neighbor_dump.messages[neighbor_dump.next++];
> > +    return true;
> > +}
> > +
> > +int
> > +__wrap_nl_dump_done(struct nl_dump *dump)
> > +{
> > +    if (!neighbor_dump.active) {
> > +        return __real_nl_dump_done(dump);
> > +    }
> > +    ovs_assert(neighbor_dump.started && !neighbor_dump.finished);
> > +    neighbor_dump.finished = true;
> > +    return neighbor_dump.error;
> > +}
> > +
> > +int
> > +__wrap_nl_transact(int protocol, const struct ofpbuf *request,
> > +                   struct ofpbuf **reply)
> > +{
> > +    if (!neighbor_dump.active) {
> > +        return __real_nl_transact(protocol, request, reply);
> > +    }
> > +    ovs_assert(protocol == NETLINK_ROUTE && !reply);
> > +    const struct ndmsg *nd = ofpbuf_at(request, NLMSG_HDRLEN, sizeof
> *nd);
> > +    ovs_assert(nd && nd->ndm_family == AF_INET && nd->ndm_ifindex ==
> 42);
> > +    switch (nl_msg_nlmsghdr(request)->nlmsg_type) {
> > +    case RTM_NEWNEIGH:
> > +        neighbor_dump.adds++;
> > +        break;
> > +    case RTM_DELNEIGH:
> > +        neighbor_dump.deletes++;
> > +        break;
> > +    default:
> > +        OVS_NOT_REACHED();
> > +    }
> > +    return 0;
> > +}
> > +
> > +static struct ofpbuf *
> > +neighbor_dump_message(void)
> > +{
> > +    ovs_assert(neighbor_dump.n_messages <
> ARRAY_SIZE(neighbor_dump.messages));
> > +    struct ofpbuf *message =
> > +        &neighbor_dump.messages[neighbor_dump.n_messages++];
> > +    ofpbuf_init(message, 128);
> > +    nl_msg_put_nlmsghdr(message, 0, RTM_NEWNEIGH, 0);
> > +    return message;
> > +}
> > +
> > +static void
> > +neighbor_dump_add(uint8_t family, int32_t if_index, uint16_t state,
> > +                  uint16_t flags, size_t lladdr_len, uint8_t last)
> > +{
> > +    struct ofpbuf *message = neighbor_dump_message();
> > +    struct ndmsg *nd = ofpbuf_put_zeros(message, sizeof *nd);
> > +    nd->ndm_family = family;
> > +    nd->ndm_ifindex = if_index;
> > +    nd->ndm_state = state;
> > +    ovs_be32 ip = htonl(0xc0000200 | last);
> > +    if (family == AF_INET) {
> > +        nl_msg_put_be32(message, NDA_DST, ip);
> > +    } else {
> > +        struct in6_addr ip6 = in6_addr_mapped_ipv4(ip);
> > +        nl_msg_put_in6_addr(message, NDA_DST, &ip6);
> > +    }
> > +    uint8_t mac[20] = { 0x02, 0, 0, 0, 0, last };
> > +    ovs_assert(lladdr_len <= sizeof mac);
> > +    nl_msg_put_unspec(message, NDA_LLADDR, mac, lladdr_len);
> > +    struct nlmsghdr *header = nl_msg_nlmsghdr(message);
> > +    header->nlmsg_flags = flags;
> > +    header->nlmsg_len = message->size;
> > +}
> > +
> > +static void
> > +test_neighbor_dump_script(struct ovs_cmdl_context *ctx)
> > +{
> > +    const char *scenario = ctx->argv[1];
> > +    bool complete = !strcmp(scenario, "complete");
> > +    bool other_interface = !strcmp(scenario, "other-interface");
> > +    bool other_family = !strcmp(scenario, "other-family");
> > +    bool malformed = !strcmp(scenario, "malformed");
> > +    bool filtered = !strcmp(scenario, "filtered-malformed");
> > +    bool truncated = !strcmp(scenario, "truncated");
> > +    bool late_error = !strcmp(scenario, "late-error");
> > +    bool both_errors = !strcmp(scenario, "parse-and-dump-error");
> > +    ovs_assert(complete || other_interface || other_family || malformed
> > +               || filtered || truncated || late_error || both_errors);
> > +
> > +    struct hmap neighbors = HMAP_INITIALIZER(&neighbors);
> > +    struct advertise_neighbor_entry desired = {
> > +        .lladdr = ETH_ADDR_C(02,00,00,00,00,03),
> > +        .addr = in6_addr_mapped_ipv4(htonl(0xc0000203)),
> > +    };
> > +    hmap_insert(&neighbors, &desired.node,
> > +                advertise_neigh_hash(&desired.lladdr, &desired.addr));
> > +    struct vector learned =
> > +        VECTOR_EMPTY_INITIALIZER(struct ne_nl_received_neigh);
> > +    struct ne_nl_received_neigh sentinel = { .if_index = 17 };
> > +    vector_push(&learned, &sentinel);
> > +
> > +    memset(&neighbor_dump, 0, sizeof neighbor_dump);
> > +    neighbor_dump.active = true;
> > +    /* A learned row and an obsolete OVN-owned row precede the fault.  A
> > +     * successful sync must publish the former, add the desired row and
> > +     * delete the latter; a failed dump must do none of those
> operations. */
> > +    neighbor_dump_add(AF_INET, 42, NUD_REACHABLE, 0, ETH_ADDR_LEN, 1);
> > +    neighbor_dump_add(AF_INET, 42, NUD_NOARP, 0, ETH_ADDR_LEN, 2);
> > +    if (other_interface || other_family || malformed || filtered
> > +        || both_errors) {
> > +        neighbor_dump_add(other_family ? AF_INET6 : AF_INET,
> > +                          other_interface ? 43 : 42, NUD_REACHABLE,
> > +                          filtered ? NLM_F_DUMP_FILTERED : 0, 20, 4);
> > +    } else if (truncated) {
> > +        struct ofpbuf *message = neighbor_dump_message();
> > +        ofpbuf_put_zeros(message, sizeof(struct ndmsg) - 1);
> > +        nl_msg_nlmsghdr(message)->nlmsg_len = message->size;
> > +    }
> > +    neighbor_dump.error = late_error || both_errors ? EINTR : 0;
> > +
> > +    int error = ne_nl_sync_neigh(AF_INET, 42, &neighbors, &learned);
> > +    ovs_assert(neighbor_dump.started && neighbor_dump.finished);
> > +    neighbor_dump.active = false;
> > +    bool success = complete || other_interface || other_family;
> > +    int expected_error = success ? 0 : EPROTO;
> > +    if (late_error || both_errors) {
> > +        expected_error = EINTR;
> > +    }
> > +    ovs_assert(error == expected_error);
> > +    ovs_assert(neighbor_dump.adds == (success ? 1 : 0));
> > +    ovs_assert(neighbor_dump.deletes == (success ? 1 : 0));
> > +    ovs_assert(hmap_count(&neighbors) == 1);
> > +    ovs_assert(learned.len == (success ? 2 : 1));
> > +    const struct ne_nl_received_neigh *rows = learned.buffer;
> > +    ovs_assert(!memcmp(&rows[0], &sentinel, sizeof sentinel));
> > +    if (success) {
> > +        struct eth_addr mac = ETH_ADDR_C(02,00,00,00,00,01);
> > +        struct in6_addr ip = in6_addr_mapped_ipv4(htonl(0xc0000201));
> > +        ovs_assert(rows[1].if_index == 42 && rows[1].family == AF_INET);
> > +        ovs_assert(rows[1].state == NUD_REACHABLE);
> > +        ovs_assert(eth_addr_equals(rows[1].lladdr, mac));
> > +        ovs_assert(ipv6_addr_equals(&rows[1].addr, &ip));
> > +    }
> > +    for (size_t i = 0; i < neighbor_dump.n_messages; i++) {
> > +        ofpbuf_uninit(&neighbor_dump.messages[i]);
> > +    }
> > +    vector_destroy(&learned);
> > +    hmap_destroy(&neighbors);
> > +}
> > +
> > +/* A failed dump must not be reported as successful synchronization. */
> > +static void
> > +test_neighbor_sync_error(struct ovs_cmdl_context *ctx OVS_UNUSED)
> > +{
> > +    struct hmap neighbors = HMAP_INITIALIZER(&neighbors);
> > +    struct vector learned =
> > +        VECTOR_EMPTY_INITIALIZER(struct ne_nl_received_neigh);
> > +    struct ne_nl_received_neigh sentinel = { .if_index = 42 };
> > +    vector_push(&learned, &sentinel);
> > +
> > +    /* This command starts without pooled Netlink sockets.  Exhaust its
> file
> > +     * descriptor allowance so the real dump fails before receiving
> data. */
> > +    struct rlimit original;
> > +    ovs_assert(!getrlimit(RLIMIT_NOFILE, &original));
> > +    struct rlimit limited = original;
> > +    limited.rlim_cur = 0;
> > +    ovs_assert(!setrlimit(RLIMIT_NOFILE, &limited));
> > +    int error = ne_nl_sync_neigh(AF_INET, 0, &neighbors, &learned);
> > +    ovs_assert(!setrlimit(RLIMIT_NOFILE, &original));
> > +
> > +    ovs_assert(error == EMFILE);
> > +    ovs_assert(learned.len == 1);
> > +    ovs_assert(!memcmp(learned.buffer, &sentinel, sizeof sentinel));
> > +    vector_destroy(&learned);
> > +    hmap_destroy(&neighbors);
> > +}
> > +
> >  static void
> >  test_neighbor_sync(struct ovs_cmdl_context *ctx)
> >  {
> > @@ -488,6 +718,9 @@ test_ovn_netlink(int argc, char *argv[])
> >  {
> >      set_program_name(argv[0]);
> >      static const struct ovs_cmdl_command commands[] = {
> > +        {"neighbor-dump-script", NULL, 1, 1,
> > +         test_neighbor_dump_script, OVS_RO},
> > +        {"neighbor-sync-error", NULL, 0, 0, test_neighbor_sync_error,
> OVS_RO},
> >          {"neighbor-sync", NULL, 2, INT_MAX, test_neighbor_sync, OVS_RO},
> >          {"neighbor-table-notify", NULL, 1, 1,
> >           test_neighbor_table_notify, OVS_RO},
> > _______________________________________________
> > 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