From nobody Mon Sep 28 10:43:11 2026 Received: from mail-pj2-f10.google.com (mail-pj2-f10.google.com [74.125.227.138]) (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 D7C5C2868AB for ; Sun, 23 Aug 2026 14:17:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.227.138 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494667; cv=none; b=oHoOgrSDIiMcbNF2CZFiuWp/JTyCh35Doc+X5SbeQuMaZueTEKHiDLe4ZwBDCFmUaoQPDdPMcvUsqUA0t1kFe5FhoiKLJaDPS2+0jgsEskiqPZJ3q+JlsHOzBnLI/9nNOl6gyWpsihzJl132aQBkXZMg1b1Hr5hzwX8lcxePXFM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494667; c=relaxed/simple; bh=VMT+7O4PRfRA8hkUYOH4H8KA2oOaKuJWcfiM+CybF68=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BC+Z5kiZgbaeit3q5Z/QKq3zRuHxVkBjwLWK0En3WRCzidyp3fq+caAXU5vEMLiHV65PJeHwKbJUmO/abGPqJbycaWw/Cjl26ymkxDsBRyWMyRFtz6GM+KrIsQDinysRfgHG5uVOh7x7OvcwfKR9YKziuNUcracTLno470L0q8o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com; spf=pass smtp.mailfrom=gmail.com; arc=none smtp.client-ip=74.125.227.138 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-pj2-f10.google.com with SMTP id d9443c01a7336-2d3a0a81329so31981005ad.1 for ; Sun, 23 Aug 2026 07:17:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787494665; x=1788099465; 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=pDaTtrBueWZK/iU1B8CemJY/aBytAH9QHxpofZQQz3Q=; b=dkssDvdC3qm3UjGGczvtptYtvoQZ0XThDIpNZJv/gKP3ZNN6CI5oDieIbOCcWr9ahA nq+mfYj1IvG+GU8Htlk2Mca9b8+llRM0TaGjLlkED9Ny7yb/EuEz8L5LIGRDBZ5NHw3Z YgdIYauXV3Z5mgGc89jt5N10tR3iLowDWJWQSIrK3camXRCTFpk1tX4T+YsaXwyOqO// t25AjTo7b/dFUtvU2QqStsnAJywN0qgN7VRAm0G0DKFd8UgEPq1xExRd/Aldrdp5OZnn JGQrCbdHS1VV7HvGp59rtwI5fxVEEWgR1XTVgEhQXqsmw2N2okPSxVsXKt9EO0YEIdc+ 5bJw== X-Forwarded-Encrypted: i=1; AHgh+Rqn1BOixg4nY31OZ9/tpOEM6nZ8zB0ItvfayiRn7DKqbu2ESd/G33rsSZC7i8g+zeK1VqGranKNGiYwFMA=@vger.kernel.org X-Gm-Message-State: AFuF++n1siGvwXK5KYdpovhPVjYo5QWRNYtqeRUYQtPqsk+S9Jo1JvUO 26YxNzCSx7rG9/WedJDpzd+Z/0XjQOmOViZfs3ZSnIF3M1/Lu8caukxj X-Gm-Gg: AR+sD13mR9Bu3q+j1MA9MY71WLoMbjcOHZ3wemHl43CfwnkqT0ZPt7eNiNcbdk5RKYD b4/Tb6ea/WzB2GHE8v6ljoXdQXyFQFopZ3fiAziqWfGwOpLOKcYDAA8updv219EvI2UYUNSSO1t tO9qP5OC7NEpnonKJKxJZYN/oIxBvKzFKOimoUXVwDsKQy/S1aX5OZxusaW8MC3xm62fKTQuqkv f8lnU06Wv02dVemtBRdb9rrlkVZFeC2HfEuSI7eYJR8WLlyhlDT9SihPOcCmMw09P2W3UJX3Zbv iugEFa+4tkKewo+QG6PBDucZFNccLm0L52hRmqib/279kCjRT7xxfq1bIzI0YrIhH3NtrMqp86k WQxxqj5ssgjx62CmBtmPEOPJovOp44iWBFW8LTl/l6o4iuJsUqgp5ITZnI9Rj8woxAjkCf6qGBH vxbykeKFLd2kU5nzRzPwm6rlgS45YL5BWHE75hyRzkLkjoKMdtntoRrzLV2OESWrSNPsvxaFSHl zmG3Vg= X-Received: by 2002:a17:902:cf43:b0:2d0:cc92:f7ae with SMTP id d9443c01a7336-2d64ade9363mr383366805ad.3.1787494665150; Sun, 23 Aug 2026 07:17:45 -0700 (PDT) Received: from localhost.localdomain ([180.153.160.8]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d676791d44sm9944575ad.24.2026.08.23.07.17.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 23 Aug 2026 07:17:44 -0700 (PDT) From: Jianlin Shi To: bpf@vger.kernel.org, memxor@gmail.com Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, john.fastabend@gmail.com, kpsingh@chromium.org, sdf@falco.dk, haoluo@google.com, jolsa@kernel.org, emil@tsalapatis.com, pulehui@huawei.com, shuah@kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v4 1/5] bpf: roll back stream capacity when allocation fails Date: Sun, 23 Aug 2026 22:17:24 +0800 Message-ID: X-Mailer: git-send-email 2.43.0 In-Reply-To: References: 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" bpf_stream_push_str() accounts the string length before allocating a stream element. If the allocation fails, the length remains charged even though no element is queued and therefore cannot be released by a reader. Repeated failures can exhaust the stream capacity permanently until the BPF program is freed. Refactor bpf_stream_release_capacity() to take a length so the consume and release sides are symmetric, and use it to roll back the charge when creating the stream element fails. Fixes: 5ab154f1463a ("bpf: Introduce BPF standard streams") Signed-off-by: Jianlin Shi --- kernel/bpf/stream.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/kernel/bpf/stream.c b/kernel/bpf/stream.c index be9ce98e9469..0b157ec4e38e 100644 --- a/kernel/bpf/stream.c +++ b/kernel/bpf/stream.c @@ -68,10 +68,8 @@ static int bpf_stream_consume_capacity(struct bpf_stream= *stream, int len) return 0; } =20 -static void bpf_stream_release_capacity(struct bpf_stream *stream, struct = bpf_stream_elem *elem) +static void bpf_stream_release_capacity(struct bpf_stream *stream, int len) { - int len =3D elem->total_len; - atomic_sub(len, &stream->capacity); } =20 @@ -79,7 +77,14 @@ static int bpf_stream_push_str(struct bpf_stream *stream= , const char *str, int l { int ret =3D bpf_stream_consume_capacity(stream, len); =20 - return ret ?: __bpf_stream_push_str(&stream->log, str, len); + if (ret) + return ret; + + ret =3D __bpf_stream_push_str(&stream->log, str, len); + if (ret) + bpf_stream_release_capacity(stream, len); + + return ret; } =20 static struct bpf_stream *bpf_stream_get(enum bpf_stream_id stream_id, str= uct bpf_prog_aux *aux) @@ -188,7 +193,7 @@ static int bpf_stream_read(struct bpf_stream *stream, v= oid __user *buf, int len) if (cont) continue; bpf_stream_backlog_pop(stream); - bpf_stream_release_capacity(stream, elem); + bpf_stream_release_capacity(stream, elem->total_len); bpf_stream_free_elem(elem); } =20 --=20 2.43.0 From nobody Mon Sep 28 10:43:11 2026 Received: from mail-pj2-f10.google.com (mail-pj2-f10.google.com [74.125.227.138]) (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 628CE270EDF for ; Sun, 23 Aug 2026 14:17:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.227.138 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494674; cv=none; b=cz/ar2mwIpncTq7CMsNHsHYL/6z1ry3uaBlqMpK0Lx/Das1OJt86MA9HFMKZYD5qFzoyQsitx4/3GHIZdS/qoqb5oP4WvQn6Rj0HP/5r/SyHM+KpiYnJySsullqWeM87lXEal53ouXXLvyTrpos0BbKwGaUvQC9EpsUu9pm8yzI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494674; c=relaxed/simple; bh=TqMZ4MjNxmrd1cDxUtXOC6oUrOQ9f6GDMWyFj9PY888=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ql6wb0l7wm6X0SizglXfPmHmBVzoCgUQlov//iTCszdeadN8L06i34CI3w0jDxkN1+MkPPHNuAdXBCFYNdGU3z3rixeOMhq61SVk6UgAMeQLEtCA0BGi+R7EKb90PF4Er/k5xErZonarGkt9x87sADSe8dHH/ngBMUBdXn4J3EE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com; spf=pass smtp.mailfrom=gmail.com; arc=none smtp.client-ip=74.125.227.138 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-pj2-f10.google.com with SMTP id d9443c01a7336-2cf49dc298bso20890955ad.0 for ; Sun, 23 Aug 2026 07:17:52 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787494672; x=1788099472; 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=jgScuoQtFaIIIFVlTJbHUDFalROzqYBQ3imuXJJ7d/U=; b=Je3n0zWDXgR5zM2TEBm0vteL+eZKahirmurPdGbaV8OSnWnxrJWkZ0TB+dkXoOLov1 rMvG/i8brD+Gz2yldUrQFgN4dYSUBmgw1lbmW1KPQnuiY9D04dv8z3Dp4ienDZ9AsC8/ p/iCImzA4EIzbsrTYddXkWbgp75pxNKMmAfAXkJsTGqTOYe9YTiMglbVx2izyXrBZiDr iz9GhYr/isU9bQMf4duHOsKoNVFyUYhal9NtBXyiZKIIdPASlSebiHOULix6wT0L564o RJbp5JbtVO3h4xEtSIM5GU67D71EeKeT56q3/6bmPF7kngtkjdU0P7aT1Ff1HfYIlhLy l+/A== X-Forwarded-Encrypted: i=1; AHgh+RrEzJMoDp/UJPWzT07URWAc1fPZGAEwrvJwpAh8fUtkiIbBgWSpr69PzcqCnCFoXQdUhv7IptkXbhuKqaw=@vger.kernel.org X-Gm-Message-State: AFuF++kwOOjV0hR6UVMdr88Rhn1ArDzG1BbrbseU830FJWsDvhVhOF1f KPMXQYyEVTHqZNU+qUnflZf49CSEYw6+0MhXSTRhyq1ad/pOTrH5RfeF X-Gm-Gg: AR+sD13E7YVMlEVADHcuQ14tGGolWvUSLnY5ILmm/ZZb1omWAv67Vbt0p5LMyZm8V+C 2dKoLSw7TjhoGoDf9YXCpPAClVP796x3NEOGWgfD210OZJLIRgoMCH8+1SVEjYMfS+o4c5C0Kk8 Y0T6GgUZh8vpZLaC+330OJVe1F2q6QuarHBPjILtPw9mHSqwN9GM5RgNaOFwUq0+xFby//eyhOW FvxQFWILYxDqQEC2Q0QbaLnXaLOTLt50GBiZImiyn1oqz+A7Ds2Mhs2N1KfZ6taAusRmESVghyu psRQRlvMjzL5i39n8oLeMITXsvz62ljzK/1B4U/7YMgfOkreRk6HSgG8xqOK7NuiEt4Q2Z/iffk a1ZrSxQ1tIUa5ecAzxvGAeS5/VR1m0/kL5GeDoAeJLEMew47yyieJE3Zmlh+0TNQjVKP/fwlnNU MRPXebH5TQEOO0xpHFHZCI0zZEg/t90D7rdMi16wm3lTv/DBkyGu0i8ycFNhwNCGtRSQygQmQFm FhfJ9uPQFl1dehmiw== X-Received: by 2002:a17:902:da82:b0:2ca:61bc:317c with SMTP id d9443c01a7336-2d64b17b564mr336152235ad.13.1787494671665; Sun, 23 Aug 2026 07:17:51 -0700 (PDT) Received: from localhost.localdomain ([180.153.160.8]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d676791d44sm9944575ad.24.2026.08.23.07.17.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 23 Aug 2026 07:17:51 -0700 (PDT) From: Jianlin Shi To: bpf@vger.kernel.org, memxor@gmail.com Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, john.fastabend@gmail.com, kpsingh@chromium.org, sdf@falco.dk, haoluo@google.com, jolsa@kernel.org, emil@tsalapatis.com, pulehui@huawei.com, shuah@kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v4 2/5] bpf: fix stream capacity leak in staging path Date: Sun, 23 Aug 2026 22:17:25 +0800 Message-ID: <46898fb1ae482b2f8b1da459922b187378dfdc1d.1787492521.git.shijianlin11@foxmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: References: 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" bpf_stream_stage_printk() increments ss->len before pushing the formatted string to the staging log. If element allocation fails, ss->len remains inflated and bpf_stream_stage_commit() permanently charges the stream capacity for data that was never queued. Only account the string length after a successful push, and use vscnprintf() so the staged length is the truncated payload without the trailing NUL. Fixes: 5ab154f1463a ("bpf: Introduce BPF standard streams") Signed-off-by: Jianlin Shi --- kernel/bpf/stream.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/kernel/bpf/stream.c b/kernel/bpf/stream.c index 0b157ec4e38e..a36fc9338967 100644 --- a/kernel/bpf/stream.c +++ b/kernel/bpf/stream.c @@ -316,17 +316,18 @@ int bpf_stream_stage_printk(struct bpf_stream_stage *= ss, const char *fmt, ...) { struct bpf_bprintf_buffers *buf; va_list args; - int ret; + int len, ret; =20 if (bpf_try_get_buffers(&buf)) return -EBUSY; =20 va_start(args, fmt); - ret =3D vsnprintf(buf->buf, ARRAY_SIZE(buf->buf), fmt, args); + len =3D vscnprintf(buf->buf, ARRAY_SIZE(buf->buf), fmt, args); va_end(args); - ss->len +=3D ret; /* Exclude NULL byte during push. */ - ret =3D __bpf_stream_push_str(&ss->log, buf->buf, ret); + ret =3D __bpf_stream_push_str(&ss->log, buf->buf, len); + if (!ret) + ss->len +=3D len; bpf_put_buffers(); return ret; } --=20 2.43.0 From nobody Mon Sep 28 10:43:11 2026 Received: from mail-pj2-f9.google.com (mail-pj2-f9.google.com [74.125.227.137]) (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 1541D3168EF for ; Sun, 23 Aug 2026 14:17:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.227.137 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494681; cv=none; b=FUp8syTUvtyVzUuzI4Nm+88ujadFt2ApJMhq1B5eLZjvl2hX/cRiCFWz8xriHdH3zMvwRmCOt3s05CHnJ3gRAUOQNvkOX2LZccZkK8JvidhcYv/19J8FVSjTNeSHHQbPpzw6E+UeY2H5Fp8Ja3AgCNeUu5KxDcruVqcyQdH+Yhc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494681; c=relaxed/simple; bh=THAx6kKy6+ANuW2Ijm0TWq0Gw/XWcFP2cIc+C2dP7TE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Z+lVsKr0wsyIFBSrnGTXuMpmE1Kq+RA7DQhMV599mEQt962mhCy0Ao6hBAxn4O+pIA1ziNloreC67Aw4hnq8ZxyH9auyLz27XTjda4KtmJHlVjPfy12fqJ+toNnmp7bZYWsW9ldXpJUcuqxM8S3brclfbvzPtQg+jLJNHMB/vIo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com; spf=pass smtp.mailfrom=gmail.com; arc=none smtp.client-ip=74.125.227.137 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-pj2-f9.google.com with SMTP id 98e67ed59e1d1-38eaa0c5df6so268433a91.0 for ; Sun, 23 Aug 2026 07:17:59 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787494679; x=1788099479; 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=R/Ql4lEDJqP86btbQpei2w3GW3dnEXXUERLHfA2IhaU=; b=LbJoH1G22i2Jr1Jl8DZSUW5AijgjHt3BTex6WknFi1sAdhlzR4d5s9Ye5rIrnJX7kI 72TmT+HCozE316XG9aYF0nIeBE7Le5HgFpsWCcyijc2XEWOaO+md9k1l4F7KcJgQywja iXjCpanWtcg7mdr/hlZsdR3qM7My3WhrdLjak95kYZy6I9o1p9cXN4jTSN7sGoomUrfm cIB9xU85Xg5RC4363sg2k54e6tTAMWSpfCQ7R/hUWDCYMoHYqDq5GTuEla38xrsGgSRE SUe3iloyAyB0IkHxwVnRKc7BjYJMFXpwDcNlk17PaS0cOdJgubI8Dx8g4OG5cRBW6NHI l8Xw== X-Forwarded-Encrypted: i=1; AHgh+Rq1vQU+Ht6LvEug2ezKOysa3YFnpX2KQu4LG/UZr3bpRmtOcPmo/VhuFAUTZCHZL+ertaYgQlQOxk3M0gM=@vger.kernel.org X-Gm-Message-State: AFuF++n6Fdxw3Wc2+6+BF+cdpJ91qF7UhHT35ySrdf6/IjFRwTz0LufH y+/eAogrEf5XCa4xkwX5H/LIkWJejYBEdHadpc/NpauyL5ze9bZUYh0u X-Gm-Gg: AR+sD126LXaSbq6RU6N2rb2GjrQxIq7uMLkghzNYK7snsa00MBGs/OkJnwE0jh1QHzY WCnLSuLC5+StPwM9T10TEz3Uwcm+JSDeL6zh+TS02uHF9uTpfN4plWzqDb4Fp2IbRoe2OuHodtO HUnrAVCHnLgcWlvZlzowdgPJwpZHE9Xy8pR+m90hyudtnE8/pfm0dSzEgrvO5BZOytfdojr50lg w5/unpQoWu33J4WtsT272/HLSL0zTL2TZ/d10FSwmC+bn349Aw4Ra/3ASpQ1hexWWAzgMCYGWXG K+8vZ6/wb6Yn1pHEdAUVP2DyKjFqSANUyHg3vmp0huoqU1YPMoU3nVot9rp8hgNY+WKl+HgOdI+ UP/menwTwbUjHNUk6aIunFhHK3DMsg+XX3D6Kz+PnDvler47nhOijX2r7BpQL4mEabMuwfzxSe3 pi6vr7D7w+tw39Zfu0FFAJ0YGy0yi/azeH+0DdsCRa32Nw9+0+iK4LbXydYA1AYktVVFPQnCvcW a4aaH+XJpyaQN35dA== X-Received: by 2002:a17:903:1b2d:b0:2cf:8aa7:7810 with SMTP id d9443c01a7336-2d64d136829mr214712585ad.2.1787494679307; Sun, 23 Aug 2026 07:17:59 -0700 (PDT) Received: from localhost.localdomain ([180.153.160.8]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d676791d44sm9944575ad.24.2026.08.23.07.17.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 23 Aug 2026 07:17:58 -0700 (PDT) From: Jianlin Shi To: bpf@vger.kernel.org, memxor@gmail.com Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, john.fastabend@gmail.com, kpsingh@chromium.org, sdf@falco.dk, haoluo@google.com, jolsa@kernel.org, emil@tsalapatis.com, pulehui@huawei.com, shuah@kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v4 3/5] bpf: return partial progress from bpf_stream_read on fault Date: Sun, 23 Aug 2026 22:17:26 +0800 Message-ID: <7668c5838c6beafeea719df8d55319e2fe08cfef.1787492521.git.shijianlin11@foxmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: References: 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" bpf_stream_read() pops and frees stream elements after a successful copy_to_user(). If a later copy_to_user() fails, it currently restores only the current element's consumed_len and returns -EFAULT, hiding bytes already delivered to userspace and making the consumed data unrecoverable on retry. On a short copy, keep the successfully copied prefix of the current element and return the number of bytes copied. Return -EFAULT only when no bytes were copied for the call. Fixes: 5ab154f1463a ("bpf: Introduce BPF standard streams") Signed-off-by: Jianlin Shi --- kernel/bpf/stream.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/kernel/bpf/stream.c b/kernel/bpf/stream.c index a36fc9338967..09471a605268 100644 --- a/kernel/bpf/stream.c +++ b/kernel/bpf/stream.c @@ -167,6 +167,7 @@ static int bpf_stream_read(struct bpf_stream *stream, v= oid __user *buf, int len) =20 while (rem_len) { int pos =3D len - rem_len; + int chunk, n; bool cont; =20 node =3D bpf_stream_backlog_peek(stream); @@ -180,13 +181,14 @@ static int bpf_stream_read(struct bpf_stream *stream,= void __user *buf, int len) =20 cons_len =3D elem->consumed_len; cont =3D bpf_stream_consume_elem(elem, &rem_len) =3D=3D false; - - ret =3D copy_to_user(buf + pos, elem->str + cons_len, - elem->consumed_len - cons_len); - /* Restore in case of error. */ - if (ret) { - ret =3D -EFAULT; - elem->consumed_len =3D cons_len; + chunk =3D elem->consumed_len - cons_len; + + n =3D copy_to_user(buf + pos, elem->str + cons_len, chunk); + if (n) { + /* Keep any successfully copied bytes; -EFAULT only if none. */ + elem->consumed_len -=3D n; + rem_len +=3D n; + ret =3D (len =3D=3D rem_len) ? -EFAULT : 0; break; } =20 --=20 2.43.0 From nobody Mon Sep 28 10:43:11 2026 Received: from mail-pj2-f0.google.com (mail-pj2-f0.google.com [74.125.227.128]) (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 71C7932A3FF for ; Sun, 23 Aug 2026 14:18:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.227.128 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494687; cv=none; b=Dc8PZ1YNC3t0VBUbv4Z6cAkxM3NuecsqOVcbRcaHyOFn7zdeQgEA1AQ2uKU9kjdlvRxELrOCJnj9kk4/QED7+Wj/bEToOjeCgCsOR4ZTQgfWNdE3h3dIIFMaiqieK4ePUlccmne7JOHnu2H3r/yldPdYyfhDY5xQHJeQif2vJSg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494687; c=relaxed/simple; bh=5oRKg6K0iG5r/v/hXBuDVgSmeObrV9gsWMCfckR8DaU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=e+WRUSwvh1X06ipwO1NPHNO0I2kI4U3XuEq6xv5R3Dn+MToiMUYEmYRXiL0C6O7sPYmDlBuND9e89Grx08KcJUq4nsukW64i1FgEiI5AAxqvvoWDkoGjJuF3cJ/1VXfH/GAZsiJ6bjgz6KSyMAb6TCS16PR6gQXKmfbw3uRpguc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com; spf=pass smtp.mailfrom=gmail.com; arc=none smtp.client-ip=74.125.227.128 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-pj2-f0.google.com with SMTP id d9443c01a7336-2cc7a345f51so17651965ad.0 for ; Sun, 23 Aug 2026 07:18:06 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787494686; x=1788099486; 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=BLPNl7tv4b8gXirdXjyz87bURnmNqmX7AlYBb8DFG4I=; b=eex9xZwQu/+0ZvgiBoS0l3/o4BB3n9YuR+pDx3Qtsu5RO7568Zzem2Zo5yv+bdv38Z 2dwQBC48L6TU55WrOmiF3V7+Z++H3xgku8ctQNLCNe7vprKI5EsT83+mJJcFKccjJXGd ci3G4Va/jrMKnNCK8XTBDxfHQBDQcaX5Z4HRPj27NpepNsqZMQAV6GKI+jKw+l/5vq56 0opkKtw4UQbOYBa/CrobEBG9aoZ/hYsUE0868SMhHZZGmO+48qIF9IoEnAUIbAa4K4Fq xATcr2qg8A2XJA1KsMvFbCQSCrzfHNVQI89XnLwBfFeaw/1cyBYL4WyM+Y8T2VWild6Z 6jmA== X-Forwarded-Encrypted: i=1; AHgh+RroXDjM14+54EcEgAhFif1IxlW/wbz/MmDbKCZZUcmniClkF8RHYlP9YQLDaIZzGmIksnj7/PPyYyty3CA=@vger.kernel.org X-Gm-Message-State: AFuF++lt6tJPLU460g7m7R99gNc7cweFFXW6gskbPO0xnpgZrtUi3uFQ YpS1LJeMeH+W/FYKCPJ6yIfMtPug59bbzy6fYs6OI/UQjYQJUySopJbq X-Gm-Gg: AR+sD13CXt/N4Zas3FnJaFWeCWZ+DiDwrCzKuT6CNYCTWQ0BwLAIe6axefmRw60xXaR OElrpt4vFYg2qK4Ds5vhwZQxX4fkNdBk2pLbnLCP0h/tiaV9awH1RfiefsU5DWzxu+yhg0Io11N VTzNYYLJhIaYzbQf8pg0UH7FcMgEgByBgEtOePWROo/O31xLu02b9A9vR2/S/Igu6ZhBc3mLiTF 0WUBkgg6iT8fzt5JprV+Ka1vEUZNyo2sU/hLTsNvYztyh9tY+7zWuuBTOx22YhDUmc98Zjg/7Ps FD88V5meeF2ifLiCftPCiWeyv1Uz7SCKyxeZBd67C088joLqnOWgGGdSgmzv5DV6vn1yW2jf0Yb ECokJENm1eFIJMZgt5qMCkssyPDvLot3UDMv+0C2y0ORZbTS3nARrciIBH9kaHoKjxxCiffQ3hF GhsWucvFf5RmJTGG0Fe9yOHjHCDRw6uzqWIZcX0kEuNID5Xetxko3gJUEEZD4N3umuW6XntS7uB rT0I30= X-Received: by 2002:a17:902:cec7:b0:2d6:702e:b1ba with SMTP id d9443c01a7336-2d670b7f140mr195137145ad.3.1787494685686; Sun, 23 Aug 2026 07:18:05 -0700 (PDT) Received: from localhost.localdomain ([180.153.160.8]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d676791d44sm9944575ad.24.2026.08.23.07.17.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 23 Aug 2026 07:18:05 -0700 (PDT) From: Jianlin Shi To: bpf@vger.kernel.org, memxor@gmail.com Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, john.fastabend@gmail.com, kpsingh@chromium.org, sdf@falco.dk, haoluo@google.com, jolsa@kernel.org, emil@tsalapatis.com, pulehui@huawei.com, shuah@kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v4 4/5] bpf: reject oversized bpf_stream_vprintk output with -E2BIG Date: Sun, 23 Aug 2026 22:17:27 +0800 Message-ID: <74387ae5024d7e2996095e97211430285095b525.1787492521.git.shijianlin11@foxmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: References: 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" bstr_printf() returns the would-be length excluding the trailing NUL. When that value is >=3D MAX_BPRINTF_BUF the message was truncated, but bpf_stream_push_str() still tried to allocate with the inflated length and failed with -ENOMEM. The boundary case of exactly MAX_BPRINTF_BUF could also copy the trailing NUL into the stream element. Reject such lengths with -E2BIG before charging stream capacity, and tighten bpf_stream_elem_alloc() to accept only payloads strictly shorter than the bprintf buffer. Fixes: 5ab154f1463a ("bpf: Introduce BPF standard streams") Signed-off-by: Jianlin Shi --- kernel/bpf/stream.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/kernel/bpf/stream.c b/kernel/bpf/stream.c index 09471a605268..7a5c3ac8676b 100644 --- a/kernel/bpf/stream.c +++ b/kernel/bpf/stream.c @@ -22,11 +22,11 @@ static struct bpf_stream_elem *bpf_stream_elem_alloc(in= t len) size_t alloc_size; =20 /* - * Length denotes the amount of data to be written as part of stream elem= ent, - * thus includes '\0' byte. We're capped by how much bpf_bprintf_buffers = can - * accomodate, therefore deny allocations that won't fit into them. + * Length is the payload pushed into the stream, excluding the + * trailing NUL of the bprintf buffer. Reject anything that cannot + * fit without copying that NUL into the stream element. */ - if (len < 0 || len > max_len) + if (len < 0 || len >=3D max_len) return NULL; =20 alloc_size =3D offsetof(struct bpf_stream_elem, str[len]); @@ -245,6 +245,11 @@ __bpf_kfunc int bpf_stream_vprintk(int stream_id, cons= t char *fmt__str, const vo return ret; =20 ret =3D bstr_printf(data.buf, MAX_BPRINTF_BUF, fmt__str, data.bin_args); + /* Truncation: reject before capacity charge (not -ENOMEM). */ + if (ret >=3D MAX_BPRINTF_BUF) { + bpf_bprintf_cleanup(&data); + return -E2BIG; + } /* Exclude NULL byte during push. */ ret =3D bpf_stream_push_str(stream, data.buf, ret); bpf_bprintf_cleanup(&data); --=20 2.43.0 From nobody Mon Sep 28 10:43:11 2026 Received: from mail-pj2-f7.google.com (mail-pj2-f7.google.com [74.125.227.135]) (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 DDBA0331EB5 for ; Sun, 23 Aug 2026 14:18:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.227.135 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494694; cv=none; b=M7ByjpJStDpp1j9lUOIIEb4hoH7F9ggglPRswxNKwOD1e3iPPHja0gEWb3OC3uhG46BbIEbuSB8PIyE9iDSAdSa1bteZAQlhstqhQRZ7xuSvhejUldGNYgAoc/6IbQczzEp3tzhD4aOue22SU1YV+mGFis2XK8TaRhkV8JaLVHM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787494694; c=relaxed/simple; bh=f45uQTLcoCxQUacMtqdb5ScN6GaILQ79UNqIIFKowz4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=l0VQ0+xqrJnSLO1da8Hwf7mhOeIsURoD70RPUYO7OTTLJ7xMBuyqvkXIm/09aWBloqfmikvBKP5NDUJHy/GHTGsCbrWuZRga5QLfKB9QvFgEByIw74K69vS2gLMjfwhChGY4iY1oTK5kwdu6G0FVbyc5pXsxPlJUR3CgKfOooYE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com; spf=pass smtp.mailfrom=gmail.com; arc=none smtp.client-ip=74.125.227.135 Authentication-Results: smtp.subspace.kernel.org; dmarc=fail (p=none dis=none) header.from=foxmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-pj2-f7.google.com with SMTP id d9443c01a7336-2d561173f9fso16774485ad.0 for ; Sun, 23 Aug 2026 07:18:12 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787494692; x=1788099492; 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=e7oaM6iEIN9zmqUbo7qJbXRXk+4xR9zhjvD2NxdYN+M=; b=j6BgPX5iyuKI8ocnG0VbEeGWp5pNPvRFs0SONKgDqsCMYCvpp/icCEYO9CoJnhiFys jk0BmLx+EUiUUnzR2f1DliQpoFB0iara0J0C8mbBgZe1HJzTETOQvmOkaFV2yNZbQ0RA tGE0Fh3ZuZqfG66OGMM7hgaRcy1kcbsNnd9Fe/FZ94Qt/NwAGk4AnCNvvZsz3X0fUwhM P5T+lTr0gECFJPA7uG4MWCQ2lCjTIbWD3Edf8xNsRf2lpYVSMgX+KIvrD5Gs9rZrhGay BT4p6Y1BqvyLckwwEzOyd8T9EBbZJTBmRWokMXjSlAPxoqy0t+mBANRnOeeapfmvboCA 8hyw== X-Forwarded-Encrypted: i=1; AHgh+RpioxrK+sLZQuMMHp1/O6XS6/D4RVQeBRouh3p/LxL3yVClzFWiZvZxo/KYX0N+Ox/ZwQTOqS3+G4fmc7c=@vger.kernel.org X-Gm-Message-State: AFuF++m5BJgOuWwRiqRt4w9H2/33oChmUA7cL2vpJHARdQ0Fd57wcN5/ P3llQuKOa8FEwfJstutrCWQiDmNN/1wPvZMPBbElg/oqfPg5YsXFlA6F X-Gm-Gg: AR+sD13+tPyYZMmjKIKDmyjmt23QYxjypl44MaLAye2EpXCbwepPAaW6gMOMPE6BLJT MRoJHHSy8hMIbIEVqXoVaE6JpdXYk0eSoyFr+P+GtucH1PmLT6bLzSUZgYPU/luq0yDcmKcYxYq x04Y9KCX3WD8fOUPJvJmV6w7pT7aek+MsJhy4a36I3DWPkhcaYw5RQjM1/LmtOQYm2mLVDGjJ0D TaXnnIoyRRZIN5CvBHoIGJ11iWLU+NY6hBtdeiFr2MrI/9GwLrb1G4cgz18BaFuKvgWSTjLqpCG XxqdpAl07MGpCG83BZtucWwaOgiQS+c6yjt0NXLpGJex1Fq3Y03OD/QMBN+sscRIesVoSBsQ7+y 5gYo+PvAv11+yT198+DAc9SN8ApCBWccTvXQcMjLBTr5cBBu4/qq+tRqSRsWOWx6pG46L/YPqK9 zv81TIXa3Ndyd1U4N5yTJ+JcJkyvVTZp0l9lCQZXwYKe7Gm5JvKaKBjGJcIPEt2aRxnGjXpYBH5 NFNomVZ+gn7qWnirkM= X-Received: by 2002:a17:902:e784:b0:2cf:ba10:6d6 with SMTP id d9443c01a7336-2d64af6f8dbmr368136745ad.4.1787494691824; Sun, 23 Aug 2026 07:18:11 -0700 (PDT) Received: from localhost.localdomain ([180.153.160.8]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2d676791d44sm9944575ad.24.2026.08.23.07.18.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 23 Aug 2026 07:18:11 -0700 (PDT) From: Jianlin Shi To: bpf@vger.kernel.org, memxor@gmail.com Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, john.fastabend@gmail.com, kpsingh@chromium.org, sdf@falco.dk, haoluo@google.com, jolsa@kernel.org, emil@tsalapatis.com, pulehui@huawei.com, shuah@kernel.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH bpf-next v4 5/5] selftests/bpf: cover stream capacity and partial read edge cases Date: Sun, 23 Aug 2026 22:17:28 +0800 Message-ID: X-Mailer: git-send-email 2.43.0 In-Reply-To: References: 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 coverage for the stream fixes requested on the capacity rollback series: - oversized bpf_stream_printk() returns -E2BIG and does not leak capacity for a subsequent successful write on the same program; - bpf_prog_stream_read() returns the successfully copied prefix when the userspace buffer straddles an unmapped page. Signed-off-by: Jianlin Shi --- .../testing/selftests/bpf/prog_tests/stream.c | 65 +++++++++++++++++++ tools/testing/selftests/bpf/progs/stream.c | 18 +++++ 2 files changed, 83 insertions(+) diff --git a/tools/testing/selftests/bpf/prog_tests/stream.c b/tools/testin= g/selftests/bpf/prog_tests/stream.c index c3cce5c292bd..87170dcad3ad 100644 --- a/tools/testing/selftests/bpf/prog_tests/stream.c +++ b/tools/testing/selftests/bpf/prog_tests/stream.c @@ -58,6 +58,71 @@ void test_stream_syscall(void) stream__destroy(skel); } =20 +void test_stream_oversize(void) +{ + LIBBPF_OPTS(bpf_test_run_opts, opts); + struct stream *skel; + int ret, prog_fd; + char buf[8] =3D {}; + + skel =3D stream__open_and_load(); + if (!ASSERT_OK_PTR(skel, "stream__open_and_load")) + return; + + prog_fd =3D bpf_program__fd(skel->progs.stream_oversize); + ret =3D bpf_prog_test_run_opts(prog_fd, &opts); + ASSERT_OK(ret, "oversize run"); + ASSERT_OK(opts.retval, "oversize retval"); + + /* Oversized push must not permanently consume capacity on this prog. */ + ret =3D bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, sizeof(buf)= , NULL); + ASSERT_EQ(ret, 3, "bytes after oversize"); + ASSERT_OK(memcmp(buf, "foo", 3), "payload after oversize"); + + stream__destroy(skel); +} + +void test_stream_partial_read(void) +{ + LIBBPF_OPTS(bpf_test_run_opts, opts); + struct stream *skel; + int ret, prog_fd; + long page_size; + char *page, *buf; + char rest[8] =3D {}; + + skel =3D stream__open_and_load(); + if (!ASSERT_OK_PTR(skel, "stream__open_and_load")) + return; + + prog_fd =3D bpf_program__fd(skel->progs.stream_syscall); + ret =3D bpf_prog_test_run_opts(prog_fd, &opts); + ASSERT_OK(ret, "ret"); + ASSERT_OK(opts.retval, "retval"); + + page_size =3D sysconf(_SC_PAGESIZE); + page =3D mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if (!ASSERT_NEQ(page, MAP_FAILED, "mmap")) { + stream__destroy(skel); + return; + } + /* Leave only the first page mapped so a straddling copy faults. */ + ASSERT_OK(munmap(page + page_size, page_size), "munmap second page"); + + buf =3D page + page_size - 1; + ret =3D bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, buf, 3, NULL); + ASSERT_EQ(ret, 1, "partial bytes"); + ASSERT_EQ(buf[0], 'f', "first byte"); + + ret =3D bpf_prog_stream_read(prog_fd, BPF_STREAM_STDOUT, rest, sizeof(res= t), NULL); + ASSERT_EQ(ret, 2, "remaining bytes"); + ASSERT_OK(memcmp(rest, "oo", 2), "remaining data"); + + munmap(page, page_size); + stream__destroy(skel); +} + static void test_address(struct bpf_program *prog, unsigned long *fault_ad= dr_p) { LIBBPF_OPTS(bpf_test_run_opts, opts); diff --git a/tools/testing/selftests/bpf/progs/stream.c b/tools/testing/sel= ftests/bpf/progs/stream.c index 6f999ba951a3..9b97f5e01b83 100644 --- a/tools/testing/selftests/bpf/progs/stream.c +++ b/tools/testing/selftests/bpf/progs/stream.c @@ -36,7 +36,12 @@ struct { } array SEC(".maps"); =20 #define ENOSPC 28 +#define E2BIG 7 #define _STR "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +#define _X64 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx= xxxx" +/* 1024 bytes: truncated by bstr_printf, must return -E2BIG. */ +#define _BIG_STR (_X64 _X64 _X64 _X64 _X64 _X64 _X64 _X64 \ + _X64 _X64 _X64 _X64 _X64 _X64 _X64 _X64) =20 int size; u64 fault_addr; @@ -117,6 +122,19 @@ int stream_syscall(void *ctx) return 0; } =20 +SEC("syscall") +__success __retval(0) +int stream_oversize(void *ctx) +{ + int ret; + + ret =3D bpf_stream_printk(BPF_STDOUT, _BIG_STR); + if (ret !=3D -E2BIG) + return ret; + + return bpf_stream_printk(BPF_STDOUT, "foo"); +} + SEC("syscall") __arch_x86_64 __arch_arm64 --=20 2.43.0