selftests: net: make the dump test less sensitive to mem accounting

Recent changes to make netlink socket memory accounting must
have broken the implicit assumption of the netlink-dump test
that we can fit exactly 64 dumps into the socket. Handle the
failure mode properly, and increase the dump count to 80
to make sure we still run into the error condition if
the default buffer size increases in the future.

Link: https://patch.msgid.link/20250906211351.3192412-1-kuba@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/tools/testing/selftests/net/netlink-dumps.c b/tools/testing/selftests/net/netlink-dumps.c
index 07423f256f963fca99ecef0721fdd7fd947b557d..7618ebe528a4c4e2612c91502848d881cfbcf121 100644 (file)
--- a/tools/testing/selftests/net/netlink-dumps.c
+++ b/tools/testing/selftests/net/netlink-dumps.c
@@ -31,9 +31,18 @@ struct ext_ack {
        const char *str;
 };
 
-/* 0: no done, 1: done found, 2: extack found, -1: error */
-static int nl_get_extack(char *buf, size_t n, struct ext_ack *ea)
+enum get_ea_ret {
+       ERROR = -1,
+       NO_CTRL = 0,
+       FOUND_DONE,
+       FOUND_ERR,
+       FOUND_EXTACK,
+};
+
+static enum get_ea_ret
+nl_get_extack(char *buf, size_t n, struct ext_ack *ea)
 {
+       enum get_ea_ret ret = NO_CTRL;
        const struct nlmsghdr *nlh;
        const struct nlattr *attr;
        ssize_t rem;
@@ -41,15 +50,19 @@ static int nl_get_extack(char *buf, size_t n, struct ext_ack *ea)
        for (rem = n; rem > 0; NLMSG_NEXT(nlh, rem)) {
                nlh = (struct nlmsghdr *)&buf[n - rem];
                if (!NLMSG_OK(nlh, rem))
-                       return -1;
+                       return ERROR;
 
-               if (nlh->nlmsg_type != NLMSG_DONE)
+               if (nlh->nlmsg_type == NLMSG_ERROR)
+                       ret = FOUND_ERR;
+               else if (nlh->nlmsg_type == NLMSG_DONE)
+                       ret = FOUND_DONE;
+               else
                        continue;
 
                ea->err = -*(int *)NLMSG_DATA(nlh);
 
                if (!(nlh->nlmsg_flags & NLM_F_ACK_TLVS))
-                       return 1;
+                       return ret;
 
                ynl_attr_for_each(attr, nlh, sizeof(int)) {
                        switch (ynl_attr_type(attr)) {
@@ -68,10 +81,10 @@ static int nl_get_extack(char *buf, size_t n, struct ext_ack *ea)
                        }
                }
 
-               return 2;
+               return FOUND_EXTACK;
        }
 
-       return 0;
+       return ret;
 }
 
 static const struct {
@@ -99,9 +112,9 @@ static const struct {
 TEST(dump_extack)
 {
        int netlink_sock;
+       int i, cnt, ret;
        char buf[8192];
        int one = 1;
-       int i, cnt;
        ssize_t n;
 
        netlink_sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
@@ -118,7 +131,7 @@ TEST(dump_extack)
        ASSERT_EQ(n, 0);
 
        /* Dump so many times we fill up the buffer */
-       cnt = 64;
+       cnt = 80;
        for (i = 0; i < cnt; i++) {
                n = send(netlink_sock, &dump_neigh_bad,
                         sizeof(dump_neigh_bad), 0);
@@ -140,10 +153,20 @@ TEST(dump_extack)
                }
                ASSERT_GE(n, (ssize_t)sizeof(struct nlmsghdr));
 
-               EXPECT_EQ(nl_get_extack(buf, n, &ea), 2);
+               ret = nl_get_extack(buf, n, &ea);
+               /* Once we fill the buffer we'll see one ENOBUFS followed
+                * by a number of EBUSYs. Then the last recv() will finally
+                * trigger and complete the dump.
+                */
+               if (ret == FOUND_ERR && (ea.err == ENOBUFS || ea.err == EBUSY))
+                       continue;
+               EXPECT_EQ(ret, FOUND_EXTACK);
+               EXPECT_EQ(ea.err, EINVAL);
                EXPECT_EQ(ea.attr_offs,
                          sizeof(struct nlmsghdr) + sizeof(struct ndmsg));
        }
+       /* Make sure last message was a full DONE+extack */
+       EXPECT_EQ(ret, FOUND_EXTACK);
 }
 
 static const struct {