Received: from mail-qt1-f169.google.com (mail-qt1-f169.google.com [209.85.160.169]) (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 7343B3CC9E5 for ; Sat, 28 Feb 2026 18:48:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.160.169 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772304493; cv=none; b=AU5An4KDYVKDsnDeRqruuPf9n8Ze9lsqmFN1HxPPf81ISdTpAagsv6h+EbB/QD5cAnEuDkljJNBQLoJPZ/o4QKrvh3AZAb5dyj4IEk0jzJii1dESeT58/5+zGI5j+UNOy6buMuUw9U/luf5pN5FgNAlyBbJM3+D/xVRHq8gRICk= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772304493; c=relaxed/simple; bh=DI6+3oEAq0W7nFzM92FFhyHu2m6O4G4BDmHAkkyF9kI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=le63UVAtmOaFhFCqy8YG31+OZFtvLPT1m+KmGLF/EiJGKS3/l27XPpCS47lpAPUlzf4jsBgP62DHcCqPEENbscAH7tcFzrUW1SFMQxWXh2nF5D6E6GIhRHoMssR1Hfu1FsQdV7vBrbG8/CVJ1NJPhMWEJSCAiWYoZa5T0Uotr/Y= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=etsalapatis.com; spf=pass smtp.mailfrom=etsalapatis.com; dkim=pass (2048-bit key) header.d=etsalapatis-com.20230601.gappssmtp.com header.i=@etsalapatis-com.20230601.gappssmtp.com header.b=oKs7VwDd; arc=none smtp.client-ip=209.85.160.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=etsalapatis.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=etsalapatis.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=etsalapatis-com.20230601.gappssmtp.com header.i=@etsalapatis-com.20230601.gappssmtp.com header.b="oKs7VwDd" Received: by mail-qt1-f169.google.com with SMTP id d75a77b69052e-506aa68065eso32566061cf.1 for ; Sat, 28 Feb 2026 10:48:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=etsalapatis-com.20230601.gappssmtp.com; s=20230601; t=1772304491; x=1772909291; 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; bh=FYH7AuX7gssCQMJp4a/mv/tCLfm0bArG2TuCBv3BYGI=; b=oKs7VwDdlOt4Dqz9LBMS2Cpcma7SIAYS25e6WQnTFKZL19MzVgw/6HjTEiYX0rrCJ5 fMmVODwl78+ItqnemLWxyp21V4ixuHeWurYmw7Fg86o9HLQklYTiJ+FPkGOsKRN1jxP1 ObEjz973nAdi8ZH8N/JkQRIQeRJZ9oNP0ZnkmE+07/Q7vtR1/eAudb4lvLVqvv1y7qA/ ZZUqneBNJuaULsoFgakMic7PZ6AqCbjp3IMT6HHpVpz28UiTMIXrLi3Mmk+DLLeNxeUG F2nZBxsyjDIU91crSpmSFp5xwIbSuhqBHwqjeTV1CXgXtU0XHngsruLFS/l961lt8r2k RDJw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1772304491; x=1772909291; 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; bh=FYH7AuX7gssCQMJp4a/mv/tCLfm0bArG2TuCBv3BYGI=; b=PH7i+2vSDeX5AWOCG7J56dih10bMVaukhuNEy7Ar9CHQu0btVcBKw7zPrVwEl819Zd zw5Eem+38RahKslbjm+GiInqpwd59H6AspK6R8PAgObM6TmAkFupDuJHrWtkJE8q3OQw ++Lrx1+LlP/43Sgq5HY5x0okPMKv2FvjYSRhXkcJDMtgKseRBuPW9YLtT/83c+7gg4WY ajWXIge82eCVjH0u+G079UbvyBvUdGMOwio+Zv6+c0RBLbAU1b3yFUVwIfHzCeqUxtzq Ky4OGpaiRptHvUbrSSvTjVskEbCeppitoY3f5TT8v8R5qJEvUjsXk6hLNuxa88+T4cut +Q4w== X-Gm-Message-State: AOJu0Yykd/Cyo+Se20Nfxpurx1piBdfTMXM4sm9eEmGIcFfZ7uz45J+9 youPIH7EmLvc9n0NZF3w5KgQAJvMog2znalDqM/ZHrlzPWOM1xk90TbdZeLRkkJPLLGN1lXDmBG RE862ggU= X-Gm-Gg: ATEYQzxPYvbn8Dus/J5VFBaI6m9cXBwdHqs5gMz5eG+fsxjRVoHSk/UQ0pgjy3pLVyw aFOzxoORP98+NBJa9dTyGAY7gmxriKuWaK26PCuRFbK9avMBPEIZPELUeKmATpyr/VKbG0ed0Vi zhkavGRhyE10UVU0zrNcyJ+bnlzQymFuThYCV1yiCRKfSABDYtUEDwRNp4lGlBQanh6rySTY46U aHfXC++qehg9TOAdNZtXoZyeQX1wt5uoFD52RKMyrwumEvLp1w+n0K2Vo1XNz8PSuZ4p5eUv3h1 qUne9wgvQIbELtn6n6LuVkRhhwQari/DfVNw/iWxj9bPvrFyw3FnnrA1+wCMSjTR4yVPtSRRQSi 2YopHKG6DAgFJs/TlScA3ON2IwQ77+RM4lb4EKjVvg+AnZ3tuC3uMizzRHd5sTWp3LEaROJsugB C/CG8lLbGIIFVvxHGaCIVXqg== X-Received: by 2002:ac8:580d:0:b0:4ee:61f8:68d6 with SMTP id d75a77b69052e-50752879239mr99121551cf.6.1772304491396; Sat, 28 Feb 2026 10:48:11 -0800 (PST) Received: from boreas.. ([140.174.219.137]) by smtp.gmail.com with ESMTPSA id d75a77b69052e-50744ab3d88sm76160561cf.21.2026.02.28.10.48.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 28 Feb 2026 10:48:11 -0800 (PST) From: Emil Tsalapatis To: bpf@vger.kernel.org Cc: andrii@kernel.org, ast@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, martin.lau@kernel.org, memxor@gmail.com, song@kernel.org, yonghong.song@linux.dev, Emil Tsalapatis Subject: [PATCH bpf-next v6 3/5] bpf: extract check_global_subprog_return_code() for clarity Date: Sat, 28 Feb 2026 13:47:57 -0500 Message-ID: <20260228184759.108145-4-emil@etsalapatis.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20260228184759.108145-1-emil@etsalapatis.com> References: <20260228184759.108145-1-emil@etsalapatis.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: Eduard Zingerman From: Eduard Zingerman Both main progs and subprogs use the same function in the verifier, check_return_code, to verify the type and value range of the register being returned. However, subprogs only need a subset of the logic in check_return_code. this also goes the way - check_return_code explicitly checks whether it is handling a subprogram in multiple places, complicating the logic. Separate the handling of the two into separate functions. Signed-off-by: Eduard Zingerman Signed-off-by: Emil Tsalapatis --- kernel/bpf/verifier.c | 62 ++++++++++++++++++++++++++++++------------- 1 file changed, 44 insertions(+), 18 deletions(-) diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 80b6fb821456..ebcca81ccdaf 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -17943,17 +17943,14 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char struct bpf_retval_range range = retval_range(0, 1); enum bpf_prog_type prog_type = resolve_prog_type(env->prog); struct bpf_func_state *frame = env->cur_state->frame[0]; - const bool is_subprog = frame->subprogno; const struct btf_type *reg_type, *ret_type = NULL; int err; /* LSM and struct_ops func-ptr's return type could be "void" */ - if (!is_subprog || frame->in_exception_callback_fn) { - if (program_returns_void(env)) - return 0; - } + if (!frame->in_async_callback_fn && program_returns_void(env)) + return 0; - if (!is_subprog && prog_type == BPF_PROG_TYPE_STRUCT_OPS) { + if (prog_type == BPF_PROG_TYPE_STRUCT_OPS) { /* Allow a struct_ops program to return a referenced kptr if it * matches the operator's return type and is in its unmodified * form. A scalar zero (i.e., a null pointer) is also allowed. @@ -17987,15 +17984,6 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char goto enforce_retval; } - if (is_subprog && !frame->in_exception_callback_fn) { - if (reg->type != SCALAR_VALUE) { - verbose(env, "At subprogram exit the register R%d is not a scalar value (%s)\n", - regno, reg_type_str(env, reg->type)); - return -EINVAL; - } - return 0; - } - if (prog_type == BPF_PROG_TYPE_STRUCT_OPS && !ret_type) return 0; @@ -18018,8 +18006,7 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char if (!retval_range_within(range, reg)) { verbose_invalid_scalar(env, reg, range, exit_ctx, reg_name); - if (!is_subprog && - prog->expected_attach_type == BPF_LSM_CGROUP && + if (prog->expected_attach_type == BPF_LSM_CGROUP && prog_type == BPF_PROG_TYPE_LSM && !prog->aux->attach_func_proto->type) verbose(env, "Note, BPF_LSM_CGROUP that attach to void LSM hooks can't modify return value!\n"); @@ -18032,6 +18019,29 @@ static int check_return_code(struct bpf_verifier_env *env, int regno, const char return 0; } +static int check_global_subprog_return_code(struct bpf_verifier_env *env) +{ + struct bpf_reg_state *reg = reg_state(env, BPF_REG_0); + int err; + + err = check_reg_arg(env, BPF_REG_0, SRC_OP); + if (err) + return err; + + if (is_pointer_value(env, BPF_REG_0)) { + verbose(env, "R%d leaks addr as return value\n", BPF_REG_0); + return -EACCES; + } + + if (reg->type != SCALAR_VALUE) { + verbose(env, "At subprogram exit the register R0 is not a scalar value (%s)\n", + reg_type_str(env, reg->type)); + return -EINVAL; + } + + return 0; +} + static void mark_subprog_changes_pkt_data(struct bpf_verifier_env *env, int off) { struct bpf_subprog_info *subprog; @@ -20825,6 +20835,8 @@ static int process_bpf_exit_full(struct bpf_verifier_env *env, bool *do_print_state, bool exception_exit) { + struct bpf_func_state *cur_frame = cur_func(env); + /* We must do check_reference_leak here before * prepare_func_exit to handle the case when * state->curframe > 0, it may be a callback function, @@ -20858,7 +20870,21 @@ static int process_bpf_exit_full(struct bpf_verifier_env *env, return 0; } - err = check_return_code(env, BPF_REG_0, "R0"); + /* + * Return from a regular global subprogram differs from return + * from the main program or async/exception callback. + * Main program exit implies return code restrictions + * that depend on program type. + * Exit from exception callback is equivalent to main program exit. + * Exit from async callback implies return code restrictions + * that depend on async scheduling mechanism. + */ + if (cur_frame->subprogno && + !cur_frame->in_async_callback_fn && + !cur_frame->in_exception_callback_fn) + err = check_global_subprog_return_code(env); + else + err = check_return_code(env, BPF_REG_0, "R0"); if (err) return err; return PROCESS_BPF_EXIT; -- 2.49.0