From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by passt.top (Postfix) with ESMTPS id 5BB285A026F for ; Mon, 24 Jul 2023 08:09:45 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gibson.dropbear.id.au; s=201602; t=1690178979; bh=aL2nX28QuH19Pe5labpHu3YrKdMUxd5FTKMgTk/5kV0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=D50vNUP0Fp6g6dMOf1WGHgqFI9MxpdvGwC6DnWNPg9kv8EN9PE05kreLA6GHblRUY WCLMVN5/WdHzXPGUENmeineqLI44+NlBjvwS7ejSobnP+PAAepw8jY72uB4clT8Qk2 YTCO907dKFhmytvQ/LM7BxawPJvxPBLr2uC7I2zA= Received: by gandalf.ozlabs.org (Postfix, from userid 1007) id 4R8V9v4cTvz4wyf; Mon, 24 Jul 2023 16:09:39 +1000 (AEST) From: David Gibson To: Stefano Brivio , passt-dev@passt.top Subject: [PATCH 06/17] netlink: Make nl_*_dup() use a separate datagram for each request Date: Mon, 24 Jul 2023 16:09:25 +1000 Message-ID: <20230724060936.952659-7-david@gibson.dropbear.id.au> X-Mailer: git-send-email 2.41.0 In-Reply-To: <20230724060936.952659-1-david@gibson.dropbear.id.au> References: <20230724060936.952659-1-david@gibson.dropbear.id.au> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Message-ID-Hash: GMS2YUQ6QTEXZ7QPNEPP5H7S6V72B5VD X-Message-ID-Hash: GMS2YUQ6QTEXZ7QPNEPP5H7S6V72B5VD X-MailFrom: dgibson@gandalf.ozlabs.org X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; emergency; loop; banned-address; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header CC: David Gibson X-Mailman-Version: 3.3.8 Precedence: list List-Id: Development discussion and patches for passt Archived-At: Archived-At: List-Archive: List-Archive: List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: nl_req() is designed to handle a single netlink request message: it only receives a single reply datagram for the request, and only waits for a single NLMSG_DONE or NLMSG_ERROR message at the beginning to clear out things from previous requests. However, in both nl_addr_dup() and nl_route_dup() we can send multiple request messages as a single datagram, with a single nl_req() call. This can easily mean that the replies nl_req() collects get out of sync with requests. We only get away with this because after we call these functions we don't make any netlink calls where we need to parse the replies. This is fragile, so alter nl_*_dup() to make an nl_req() call for each address it is adding in the target namespace. For nl_route_dup() this fixes an additional minor problem: because routes can have dependencies, some of the route add requests might fail on the first attempt, so we need to repeat the requests a number of times. When we did that, we weren't updating the sequence number on each new attempt. This works, but not updating the sequence number for each new request isn't ideal. Now that we're making the requests one at a time, it's easier to make sure we update the sequence number each time. Link: https://bugs.passt.top/show_bug.cgi?id=67 Signed-off-by: David Gibson --- netlink.c | 50 +++++++++++++++++++++++++++----------------------- 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/netlink.c b/netlink.c index 72044cd..bd76098 100644 --- a/netlink.c +++ b/netlink.c @@ -351,18 +351,16 @@ void nl_route_dup(int s_src, unsigned int ifi_src, .rta.rta_len = RTA_LENGTH(sizeof(unsigned int)), .ifi = ifi_src, }; - char buf[NLBUFSIZ], resp[NLBUFSIZ]; unsigned dup_routes = 0; ssize_t n, nlmsgs_size; struct nlmsghdr *nh; + char buf[NLBUFSIZ]; unsigned i; - if ((n = nl_req(s_src, buf, &req, req.nlh.nlmsg_len)) < 0) + if ((nlmsgs_size = nl_req(s_src, buf, &req, req.nlh.nlmsg_len)) < 0) return; - nlmsgs_size = n; - - for (nh = (struct nlmsghdr *)buf; + for (nh = (struct nlmsghdr *)buf, n = nlmsgs_size; NLMSG_OK(nh, n) && nh->nlmsg_type != NLMSG_DONE; nh = NLMSG_NEXT(nh, n)) { struct rtmsg *rtm = (struct rtmsg *)NLMSG_DATA(nh); @@ -372,7 +370,6 @@ void nl_route_dup(int s_src, unsigned int ifi_src, if (nh->nlmsg_type != RTM_NEWROUTE) continue; - nh->nlmsg_seq = nl_seq++; nh->nlmsg_pid = 0; nh->nlmsg_flags &= ~NLM_F_DUMP_FILTERED; nh->nlmsg_flags |= NLM_F_REQUEST | NLM_F_ACK | @@ -386,17 +383,27 @@ void nl_route_dup(int s_src, unsigned int ifi_src, } } - nh = (struct nlmsghdr *)buf; /* Routes might have dependencies between each other, and the * kernel processes RTM_NEWROUTE messages sequentially. For n - * valid routes, we might need to send up to n requests to get - * all of them inserted. Routes that have been already - * inserted won't cause the whole request to fail, so we can - * simply repeat the whole request. This approach avoids the - * need to calculate dependencies: let the kernel do that. + * routes, we might need to send the requests up to n times to + * get all of them inserted. Routes that have been already + * inserted will return -EEXIST, but we can safely ignore that + * and repeat the requests. This avoids the need to calculate + * dependencies: let the kernel do that. */ - for (i = 0; i < dup_routes; i++) - nl_req(s_dst, resp, nh, nlmsgs_size); + for (i = 0; i < dup_routes; i++) { + for (nh = (struct nlmsghdr *)buf, n = nlmsgs_size; + NLMSG_OK(nh, n) && nh->nlmsg_type != NLMSG_DONE; + nh = NLMSG_NEXT(nh, n)) { + char resp[NLBUFSIZ]; + + if (nh->nlmsg_type != RTM_NEWROUTE) + continue; + + nh->nlmsg_seq = nl_seq++; + nl_req(s_dst, resp, nh, nh->nlmsg_len); + } + } } /** @@ -560,19 +567,18 @@ void nl_addr_dup(int s_src, unsigned int ifi_src, .ifa.ifa_index = ifi_src, .ifa.ifa_prefixlen = 0, }; - char buf[NLBUFSIZ], resp[NLBUFSIZ]; - ssize_t n, nlmsgs_size; + char buf[NLBUFSIZ]; struct nlmsghdr *nh; + ssize_t n; if ((n = nl_req(s_src, buf, &req, sizeof(req))) < 0) return; - nlmsgs_size = n; - for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, n) && nh->nlmsg_type != NLMSG_DONE; nh = NLMSG_NEXT(nh, n)) { struct ifaddrmsg *ifa; + char resp[NLBUFSIZ]; struct rtattr *rta; size_t na; @@ -587,10 +593,8 @@ void nl_addr_dup(int s_src, unsigned int ifi_src, ifa = (struct ifaddrmsg *)NLMSG_DATA(nh); if (ifa->ifa_scope == RT_SCOPE_LINK || - ifa->ifa_index != ifi_src) { - ifa->ifa_family = AF_UNSPEC; + ifa->ifa_index != ifi_src) continue; - } ifa->ifa_index = ifi_dst; @@ -599,9 +603,9 @@ void nl_addr_dup(int s_src, unsigned int ifi_src, if (rta->rta_type == IFA_LABEL) rta->rta_type = IFA_UNSPEC; } - } - nl_req(s_dst, resp, buf, nlmsgs_size); + nl_req(s_dst, resp, nh, nh->nlmsg_len); + } } /** -- 2.41.0