From nobody Fri Oct 2 12:19:58 2026 Received: from mail-pf1-f170.google.com (mail-pf1-f170.google.com [209.85.210.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9131C3B38BC for ; Sat, 1 Aug 2026 10:26:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785580012; cv=none; b=bgppDhL7xoRglt+pgdIunjsdSocCbWUTunHSW6G/1R1mnRBwQPKIOTFqD41dTJ3aKqJbKSWPOBJ1cqFbiq7m6T4G9jB7D7EyQPh+bnUvunCNxYuhT87IRabkYGg3sY5xfvK9rgNSR/opmHBUQqMCvo5lLB27DKUtT2ouZrRAX28= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785580012; c=relaxed/simple; bh=s50HQiVyrsCromL2L3q/RiNQ/gpasUsy6U2BsrMt2zA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=N8RggS9s7tDT46NYBvw1rtekFU4zFWLZitItxU3W6j+4uxunRtpce7RSya9g+ebSdx7ioyOJ55wsqJApgapqNq7duFJEgSr7LKhujbepW6tWaM4osPvsnfdGAWwR9jB+ARdNjSXHDPNalV+XuTpA0acMQeHKRSivrc85j9BvXpY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=qRbcxWaX; arc=none smtp.client-ip=209.85.210.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="qRbcxWaX" Received: by mail-pf1-f170.google.com with SMTP id d2e1a72fcca58-8484f229529so1588891b3a.2 for ; Sat, 01 Aug 2026 03:26:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1785580011; x=1786184811; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=AwaHtEcTDpeuOMoaChwOIDZAJW1zODbpeMqtETGYSvk=; b=qRbcxWaX0CyLMPbwSkZiZohfcb4iKjeaCOGeQ+X61FadKLPgVliQeajveZP16axz6E HHUSKbT0NdEmeH2DxdOU/wqjevmUeAASgCoBW5qFFs5WrPt3NXe4XPRDYA01Q2bQA9MT c/ARQ+E++xjC44BjNNgomQKjlLH2HXq/pMVm/jTxHXZ4HmIoaYf5kusTkJy67O5QUXHt T2O8s9Ac9N3pk/G3U/l/sk0/kNz5OpDGlfZ75Ja6EhwsWW+XkfmpjbRXFBsR7gL1oaR2 nlHV1YI5RQqIsDB7RHszf+bYvfNp3hBh6dDbbBXsld0eA9fJjV2mcdjLmD4096212XiH D2GA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1785580011; x=1786184811; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=AwaHtEcTDpeuOMoaChwOIDZAJW1zODbpeMqtETGYSvk=; b=bELY11zqZHw+3bWaXvZePRIjV2tiYk5s6eMxlAUlSpYTtbwxta6zZPqaoVBDzAe243 d4Uyy/CMOL72DntkjH4MWF3cQlYdub2c2bcg8+ZcsiZfC9av+xBvEe+XvitNru9fIEfH aIwkzuMKutIWxYdYFhmVGQC1gLIufLbtSfQrY8wH17RtkMC6e/vG/01BfHmLPkxRPcrY XLovgnGsLLahF7v3jff8ENGyCgeUkANraaPuOhwVAO82AQXx1ttBHh5ZaqrZqsuqxcxM OzTp8eqO+BaqNW5sZMeaczgzwblzSW18VDKNvkRgybygMNaOIUXrxsY1OUzpPMrwtvPX w5gg== X-Forwarded-Encrypted: i=1; AHgh+RrUmpJxofVjin1Jg8iDl2K5c71i0QmtKQB3V9KJ2P69xIF5dm/w3VCnUoWdgxlhdVc5hvwtKlrl0E2DIdE=@vger.kernel.org X-Gm-Message-State: AOJu0YwYBfIU7088laOhzbuEl4nx3qLAXOLR6DBMF/0a4TnZQj4hx0vG Fe/WPuCE3ODIuoCnkALK0/Cw8HUNNqlUYUrZOne24PuxLQ25RNS+Y0wQ X-Gm-Gg: AR+sD13koeZSeD5fK2jsDjHF4gldC8ZxGa6fHklEBjNfOmVgj8eFbYADfecxWVca/+x KajLHHIGsaDqzLxLj27nPz7aNVKIZQiJHc//4sGYHcw2GlT1cYnYmVABKoxuh5n8JpPSriEBl74 nYdI7bOaVMDsY9mKR4iGEwYrleW0m3Jn7GAXG5heDNop5ceuVqbwCcj6pVzuI4CU1tiMbfdz+wN chNJEKpswFBksk4y9R8GZQ70dXS0+zc4ezlI6pB8IfBTFYJ/PCAg137c22L7PqqJz9McMH8OwXD 4oCFaovun2Ke9EcXGjwZDqP9Ln4AtrcpW7heerPebMVqBZRkeKkl3T1nS7iiObyAeBJ22+hoOEy 2NP6mu/47xOzdEgd/Emq3yP8x19ajAnzTuyEbtP6piwi/cjORogcNxd6BUgOU4L+qBMECi7BCvZ x16y+KRo4jeMny7yymKx+fHZDUcxmzLVgIaYKJ5c21vGK7gCpDS7vVfT0= X-Received: by 2002:a05:6a00:4190:b0:847:99bb:b6d0 with SMTP id d2e1a72fcca58-84ee479b0cfmr2404289b3a.15.1785580010742; Sat, 01 Aug 2026 03:26:50 -0700 (PDT) Received: from omen-arch ([147.46.174.207]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-84edc51cca2sm1526886b3a.61.2026.08.01.03.26.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 01 Aug 2026 03:26:49 -0700 (PDT) From: Junseo Lim To: John Fastabend , Jakub Sitnicki , Jiayuan Chen Cc: "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Andrii Nakryiko , Eduard Zingerman , linux-kernel@vger.kernel.org, bpf@vger.kernel.org, netdev@vger.kernel.org, Sechang Lim , Daniel Borkmann , Emil Tsalapatis , Junseo Lim Subject: [PATCH bpf v2 1/2] bpf, sockmap: settle sk_forward_alloc for strparser SK_PASS Date: Sat, 1 Aug 2026 19:26:32 +0900 Message-ID: <20260801102633.1872012-2-zirajs7@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260801102633.1872012-1-zirajs7@gmail.com> References: <20260801102633.1872012-1-zirajs7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The strparser SK_PASS path can queue cloned skbs back to the same socket. A single TCP receive skb may be split into multiple strparser messages, and each cloned message still carries the receive owner from the TCP receive path. sk_psock_skb_ingress_self() reassigns receive ownership with skb_set_owner_r(). That first orphans the skb, which runs the existing receive destructor, and then charges the skb to the socket again. When this is repeated for strparser clones, sk_forward_alloc can already be in deficit before the next owner transition. Releasing the queued skbs can then uncharge more memcg pages than were reserved and trigger a page_counter underflow. Call sk_rmem_schedule() with a size of zero before skb_set_owner_r() for strparser self-pass skbs. Use the zero-sized reservation to top up any existing sk_forward_alloc deficit without reserving the skb's full truesize again, then let skb_set_owner_r() perform the receive-owner transition. Apply the same handling when retrying the skb from the psock backlog. Fixes: 144748eb0c44 ("bpf, sockmap: Fix incorrect fwd_alloc accounting") Reported-by: Sechang Lim Suggested-by: Emil Tsalapatis Signed-off-by: Junseo Lim --- net/core/skmsg.c | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/net/core/skmsg.c b/net/core/skmsg.c index 2521b643fa05..ce5ad8160282 100644 --- a/net/core/skmsg.c +++ b/net/core/skmsg.c @@ -586,7 +586,8 @@ static int sk_psock_skb_ingress_enqueue(struct sk_buff = *skb, } =20 static int sk_psock_skb_ingress_self(struct sk_psock *psock, struct sk_buf= f *skb, - u32 off, u32 len, bool take_ref); + u32 off, u32 len, bool take_ref, + bool settle_fwd_alloc); =20 static int sk_psock_skb_ingress(struct sk_psock *psock, struct sk_buff *sk= b, u32 off, u32 len) @@ -595,12 +596,9 @@ static int sk_psock_skb_ingress(struct sk_psock *psock= , struct sk_buff *skb, struct sk_msg *msg; int err; =20 - /* If we are receiving on the same sock skb->sk is already assigned, - * skip memory accounting and owner transition seeing it already set - * correctly. - */ if (unlikely(skb->sk =3D=3D sk)) - return sk_psock_skb_ingress_self(psock, skb, off, len, true); + return sk_psock_skb_ingress_self(psock, skb, off, len, true, + skb_bpf_strparser(skb)); msg =3D sk_psock_create_ingress_msg(sk, skb); if (!msg) return -EAGAIN; @@ -618,12 +616,14 @@ static int sk_psock_skb_ingress(struct sk_psock *psoc= k, struct sk_buff *skb, return err; } =20 -/* Puts an skb on the ingress queue of the socket already assigned to the - * skb. In this case we do not need to check memory limits or skb_set_owne= r_r - * because the skb is already accounted for here. +/* Puts an skb on the ingress queue for psock->sk. + * + * Before assigning receive ownership to a direct strparser SK_PASS clone, + * settle any existing sk_forward_alloc deficit from earlier clone charges. */ static int sk_psock_skb_ingress_self(struct sk_psock *psock, struct sk_buf= f *skb, - u32 off, u32 len, bool take_ref) + u32 off, u32 len, bool take_ref, + bool settle_fwd_alloc) { struct sk_msg *msg =3D alloc_sk_msg(GFP_ATOMIC); struct sock *sk =3D psock->sk; @@ -631,6 +631,13 @@ static int sk_psock_skb_ingress_self(struct sk_psock *= psock, struct sk_buff *skb =20 if (unlikely(!msg)) return -EAGAIN; + + if (settle_fwd_alloc && + !sk_rmem_schedule(sk, skb, 0)) { + kfree(msg); + return -EAGAIN; + } + skb_set_owner_r(skb, sk); =20 /* This is used in tcp_bpf_recvmsg_parser() to determine whether the @@ -1017,6 +1024,8 @@ static int sk_psock_verdict_apply(struct sk_psock *ps= ock, struct sk_buff *skb, * retrying later from workqueue. */ if (skb_queue_empty(&psock->ingress_skb)) { + bool settle_fwd_alloc =3D false; + len =3D skb->len; off =3D 0; if (skb_bpf_strparser(skb)) { @@ -1024,8 +1033,10 @@ static int sk_psock_verdict_apply(struct sk_psock *p= sock, struct sk_buff *skb, =20 off =3D stm->offset; len =3D stm->full_len; + settle_fwd_alloc =3D true; } - err =3D sk_psock_skb_ingress_self(psock, skb, off, len, false); + err =3D sk_psock_skb_ingress_self(psock, skb, off, len, + false, settle_fwd_alloc); } if (err < 0) { spin_lock_bh(&psock->ingress_lock); --=20 2.55.0 From nobody Fri Oct 2 12:19:58 2026 Received: from mail-pf1-f178.google.com (mail-pf1-f178.google.com [209.85.210.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8B40C37A856 for ; Sat, 1 Aug 2026 10:27:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785580024; cv=none; b=tYrkW00uhQtO/Gf5I8KoXgHao2p2xeumWy3w9T236Je8UAjaH6/dAPBmuoy78dYsTv6vKz+lXSYufPnXWGNDmb6wsVFsDUNOuDQJRP+hbmZKh1e62gmJ5LG5oJKPlzHG4fn8vybeBaEaHG0c7rhTFDokrJjzf798O84efxwNeRY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785580024; c=relaxed/simple; bh=UGaXKViydcNHgiIYJqkogJCCwyxdJr51ddIZCkZf78c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=XnAZlhcwUjyvZkybpcQzVFHOfwncS0LXV2a2TN+TLbxhTTPgbpcjBW6KX2xeS9C739P2GXZ0dVspSpC9gpBhSfrMMkgUk0+F3eCR+MNY/NIRN6/FouympFDDwjcjm7I04Dq8F4ek81dhZARdLAI3aFDLbAu1U2fyvxNGUYV9lXI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=pQU4W2wn; arc=none smtp.client-ip=209.85.210.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="pQU4W2wn" Received: by mail-pf1-f178.google.com with SMTP id d2e1a72fcca58-84864086bfeso2038622b3a.1 for ; Sat, 01 Aug 2026 03:27:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1785580022; x=1786184822; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Bm6tU6uRMhMFMi+BnhXh/n8qQcLZIiln365T8/pycxA=; b=pQU4W2wn02nUIRwKm+okywFas6jfqzAZV/KNEQDXKeTQvJgYn4wOsjvrv3wUyJCniI zCTDGX//qMlZrNeEzcXz03rrKPfteFNZq88nvlEvkStc5lxJna6sByDwItCqg4w6Vdvr NmiiCDO2nMlEm/w7Ckgh9BERs15k0F8tuq9RSnwG8Uh1hlvpGdZSLZF4zvKIWYudsW0F A2eKeJlRyOSmIDTisWccc3NWEk9vDlI0n5s4eY5WwLc8Vk/sh/d1bxeHHHN9BxwctyFy dpDavudRRjqoKRaS+adJSxnMtTVtjQRtO1w7PlBRkl6qHw52/ZhVSKNAEkESmijy9x/Y 6CpQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1785580022; x=1786184822; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Bm6tU6uRMhMFMi+BnhXh/n8qQcLZIiln365T8/pycxA=; b=rG4FP1xnAww5Wnob+F2ORiEYzoGONK3ArdP8Ru4uA8HV+NyaUNDUtZzHpgjRjpopsN oEoYHL1ls8env8sCbOgIGZhkR8IGORsr9YiFE1xSpgrCPHU1z3qjWV7xLQgDjJZ7tgZo AoQn8WgucO0I3KubhOeUhA9uQSAoMc/fKQoj3835gLJhm/xeIaI23Vhk8Lc86U9S86HY C1wSUn9qjDHolLcgnNIBYtmC04RC3FcgtCA+oS8jWz/RHvcq9O8OeJuMlLvwXfioe8gd eHRimMomIjn0eb40h46vjcimEV/THfR9UKTTqr2b4R+3c4FAAlo1UFHcZu+yjYGl3Q2+ 5naw== X-Forwarded-Encrypted: i=1; AHgh+RqT5LqgoJEhl92eMBiQ0jmyEDeAXVweLxgyI1Uj3zsQnUMor9SDksYuWEXCy9eekIdDtgAvhwHzB8hvNhI=@vger.kernel.org X-Gm-Message-State: AOJu0Yx0s+NsslXuM573W4G8RtbvFYlsmCgmaW3MwKbkj/5rkaail+gU 8zcO5kd23N5xBUN+7XNa6+YePDqHfctdyZQ3HRk8kFx7cleLPiFVMMYz X-Gm-Gg: AR+sD13xoGITpYCvUiLH9VT+tD0YkWSOIeiRJuM3T1wEDfKFUZL/Wvnge1pvgi3K+l/ Yuv2B8w2hWa3LUpHydQsarxJsm7xrvzeWFayakdSVm3xe0UQolwq2dcy7qlxm43mONQnO848KoL +8YS1v5qv/LPCYezP8FD5FObAiCTgA0QXPJzI33rPSRmncQovgL/ZRD7XoQmLPhI8TwwziPkmb5 6XYHvXVTWCL8NP7Jc31nMDveGnnHvKep1X/+eUhIWjVeqtSyoZbSCCJETQ6tMziq1AuZs1UYdvp ykn8ROFgZARxmMmkiVWUUCPqJQrjAe8VOmuvzq3YAkBH/yeQvCXufFlBu1iB4CIdIm+WeFkGhXZ hAUWevc13T6JqUHvtzAerwGzao2R2PNHvKYWVJZdLYHLeQs7DdwBX6fnBPO7bxL6oevWoan8uL7 HLxXL9m7m4ecuByiLYxhEipi7zCAXBjfuGboCGZMgfLEA1MW9uzywZgqs= X-Received: by 2002:a05:6a00:410a:b0:848:2f84:739 with SMTP id d2e1a72fcca58-84ee4960de6mr2519444b3a.76.1785580021850; Sat, 01 Aug 2026 03:27:01 -0700 (PDT) Received: from omen-arch ([147.46.174.207]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-84edc51cca2sm1526886b3a.61.2026.08.01.03.26.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 01 Aug 2026 03:27:01 -0700 (PDT) From: Junseo Lim To: John Fastabend , Jakub Sitnicki , Jiayuan Chen Cc: "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Andrii Nakryiko , Eduard Zingerman , linux-kernel@vger.kernel.org, bpf@vger.kernel.org, netdev@vger.kernel.org, Sechang Lim , Daniel Borkmann , Emil Tsalapatis , Junseo Lim Subject: [PATCH bpf v2 2/2] selftests/bpf: Cover strparser self-pass forward allocation Date: Sat, 1 Aug 2026 19:26:33 +0900 Message-ID: <20260801102633.1872012-3-zirajs7@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260801102633.1872012-1-zirajs7@gmail.com> References: <20260801102633.1872012-1-zirajs7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a sockmap_strp regression test for strparser SK_PASS delivery to the same socket. A one-byte stream parser splits a single write into many messages, repeatedly exercising receive ownership transitions while the skbs remain queued. Verify through INET_DIAG_MEMINFO that sk_forward_alloc does not become negative after the self-pass path is exercised. Signed-off-by: Junseo Lim --- .../selftests/bpf/prog_tests/sockmap_strp.c | 171 ++++++++++++++++++ .../selftests/bpf/progs/test_sockmap_strp.c | 6 + 2 files changed, 177 insertions(+) diff --git a/tools/testing/selftests/bpf/prog_tests/sockmap_strp.c b/tools/= testing/selftests/bpf/prog_tests/sockmap_strp.c index 1d7231728eaf..c7ad21d0bbf4 100644 --- a/tools/testing/selftests/bpf/prog_tests/sockmap_strp.c +++ b/tools/testing/selftests/bpf/prog_tests/sockmap_strp.c @@ -1,5 +1,9 @@ // SPDX-License-Identifier: GPL-2.0 #include +#include +#include +#include +#include #include #include #include "sockmap_helpers.h" @@ -460,6 +464,171 @@ static void test_sockmap_strp_parser_reject(void) test_sockmap_strp__destroy(strp); } =20 +/* Read sk_forward_alloc through inet_diag meminfo. */ +static int sockmap_strp_get_fwd_alloc(int sock, int *fwd_alloc) +{ + struct sockaddr_storage local =3D {}, peer =3D {}; + struct sockaddr_in *local_in, *peer_in; + socklen_t addr_len =3D sizeof(local); + char buf[1024]; + struct { + struct nlmsghdr nlh; + struct inet_diag_req_v2 req; + } req =3D { + .nlh =3D { + .nlmsg_len =3D sizeof(req), + .nlmsg_type =3D SOCK_DIAG_BY_FAMILY, + .nlmsg_flags =3D NLM_F_REQUEST, + .nlmsg_seq =3D 1, + }, + .req =3D { + .sdiag_family =3D AF_INET, + .sdiag_protocol =3D IPPROTO_TCP, + .idiag_ext =3D 1 << (INET_DIAG_MEMINFO - 1), + .idiag_states =3D ~0U, + .id.idiag_cookie =3D { + INET_DIAG_NOCOOKIE, + INET_DIAG_NOCOOKIE, + }, + }, + }; + int diag_fd, ret, err =3D -ENOENT; + + if (getsockname(sock, (struct sockaddr *)&local, &addr_len)) + return -errno; + addr_len =3D sizeof(peer); + if (getpeername(sock, (struct sockaddr *)&peer, &addr_len)) + return -errno; + + local_in =3D (struct sockaddr_in *)&local; + peer_in =3D (struct sockaddr_in *)&peer; + req.req.id.idiag_sport =3D local_in->sin_port; + req.req.id.idiag_dport =3D peer_in->sin_port; + req.req.id.idiag_src[0] =3D local_in->sin_addr.s_addr; + req.req.id.idiag_dst[0] =3D peer_in->sin_addr.s_addr; + + diag_fd =3D socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, + NETLINK_SOCK_DIAG); + if (diag_fd < 0) + return -errno; + + ret =3D send(diag_fd, &req, sizeof(req), 0); + if (ret < 0) { + err =3D -errno; + goto out; + } + if (ret !=3D sizeof(req)) { + err =3D -EIO; + goto out; + } + + ret =3D recv(diag_fd, buf, sizeof(buf), 0); + if (ret < 0) { + err =3D -errno; + goto out; + } + + for (struct nlmsghdr *nlh =3D (struct nlmsghdr *)buf; + NLMSG_OK(nlh, ret); nlh =3D NLMSG_NEXT(nlh, ret)) { + struct inet_diag_msg *msg =3D NLMSG_DATA(nlh); + struct rtattr *attr; + int len; + + if (nlh->nlmsg_type =3D=3D NLMSG_ERROR) { + err =3D -EINVAL; + goto out; + } + if (nlh->nlmsg_type =3D=3D NLMSG_DONE) + break; + + len =3D nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*msg)); + for (attr =3D (struct rtattr *)(msg + 1); RTA_OK(attr, len); + attr =3D RTA_NEXT(attr, len)) { + struct inet_diag_meminfo *minfo; + + if (attr->rta_type !=3D INET_DIAG_MEMINFO) + continue; + minfo =3D RTA_DATA(attr); + *fwd_alloc =3D (__s32)minfo->idiag_fmem; + err =3D 0; + goto out; + } + } + +out: + close(diag_fd); + return err; +} + +/* Test strparser SK_PASS delivery to the same socket. */ +static void test_sockmap_strp_self_pass_fwd_alloc(void) +{ + struct test_sockmap_strp *strp =3D NULL; + char snd[4 * 1024]; + int c =3D -1, p =3D -1; + int fwd_alloc; + int sndbuf =3D sizeof(snd); + int zero =3D 0; + char rcv; + int sent, recvd; + int map; + int err; + + memset(snd, 0xa5, sizeof(snd)); + + strp =3D test_sockmap_strp__open_and_load(); + if (!ASSERT_OK_PTR(strp, "test_sockmap_strp__open_and_load")) + return; + + map =3D bpf_map__fd(strp->maps.sock_map); + err =3D xbpf_prog_attach(bpf_program__fd(strp->progs.prog_skb_parser_one), + map, BPF_SK_SKB_STREAM_PARSER, 0); + if (err) + goto out_destroy; + + err =3D xbpf_prog_attach(bpf_program__fd(strp->progs.prog_skb_verdict_pas= s), + map, BPF_SK_SKB_STREAM_VERDICT, 0); + if (err) + goto out_destroy; + + err =3D create_pair(AF_INET, SOCK_STREAM, &c, &p); + if (!ASSERT_OK(err, "create_pair")) + goto out_destroy; + + err =3D xsetsockopt(c, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)); + if (err) + goto out_destroy; + + err =3D xsetsockopt(p, SOL_SOCKET, SO_RCVBUF, &sndbuf, sizeof(sndbuf)); + if (err) + goto out_destroy; + + err =3D xbpf_map_update_elem(map, &zero, &p, BPF_NOEXIST); + if (err) + goto out_destroy; + + sent =3D send(c, snd, sizeof(snd), MSG_DONTWAIT); + if (!ASSERT_EQ(sent, sizeof(snd), "send")) + goto out_destroy; + + recvd =3D recv_timeout(p, &rcv, sizeof(rcv), MSG_DONTWAIT, + IO_TIMEOUT_SEC); + if (!ASSERT_EQ(recvd, sizeof(rcv), "recv_timeout") || + !ASSERT_EQ(rcv, snd[0], "data mismatch")) + goto out_destroy; + + err =3D sockmap_strp_get_fwd_alloc(p, &fwd_alloc); + if (!ASSERT_OK(err, "sockmap_strp_get_fwd_alloc") || + !ASSERT_GE(fwd_alloc, 0, "sk_forward_alloc")) + goto out_destroy; +out_destroy: + test_sockmap_strp__destroy(strp); + if (c >=3D 0) + close(c); + if (p >=3D 0) + close(p); +} + void test_sockmap_strp(void) { if (test__start_subtest("sockmap strp tcp pass")) @@ -482,4 +651,6 @@ void test_sockmap_strp(void) test_sockmap_strp_dispatch_pkt(AF_INET, SOCK_STREAM); if (test__start_subtest("sockmap strp parser reject pkt mod")) test_sockmap_strp_parser_reject(); + if (test__start_subtest("sockmap strp self pass fwd alloc")) + test_sockmap_strp_self_pass_fwd_alloc(); } diff --git a/tools/testing/selftests/bpf/progs/test_sockmap_strp.c b/tools/= testing/selftests/bpf/progs/test_sockmap_strp.c index fe88fa6d40bc..682e53d40751 100644 --- a/tools/testing/selftests/bpf/progs/test_sockmap_strp.c +++ b/tools/testing/selftests/bpf/progs/test_sockmap_strp.c @@ -50,6 +50,12 @@ int prog_skb_parser_partial(struct __sk_buff *skb) return 10; } =20 +SEC("sk_skb/stream_parser") +int prog_skb_parser_one(struct __sk_buff *skb) +{ + return 1; +} + SEC("sk_skb/stream_parser") int prog_skb_parser_resize(struct __sk_buff *skb) { --=20 2.55.0