From patchwork Sat Jun 8 00:44:43 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 13690804 X-Patchwork-Delegate: bpf@iogearbox.net Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.172]) (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 9BA636AA1 for ; Sat, 8 Jun 2024 00:44:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807497; cv=none; b=JkOUpGTbTBr9CM+vhti+qro02z/FUaVZjKmMAahweMeDQ6Tqb6oMd3WVEGMAcBhEVUdqDZwQK7VlTxYyBEJznxmqa/pI5KdZJry+pB2BsX7b7fLoYF3RV3O07Tr/76W3NGtIpCc1vMegoKRVwJyY0iOlsEt3fCh7vVmh0DChJXc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807497; c=relaxed/simple; bh=cWQp9cpnIT6yOcrplMnFHgtQrgk7m+NU3FJ2xhMV748=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=XEWiNM9DFlLIRNii/XAV1NlmKEuNdGvveUgdpzX1rO6xhSJUIgrZngA4YVM+BHPjZnseZH16Zv42lCG7OsZxvJc9hXvXMGnJZ6EdM3VqQMZuy/NAQJXZEGB3z3iPOgRSx7J1tOa4Ru9wEDHDpP5MyRcby0bxg/yMzqapYh2vQoI= 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=RcnZVP8d; arc=none smtp.client-ip=209.85.214.172 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="RcnZVP8d" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-1f6dfc17006so7926065ad.0 for ; Fri, 07 Jun 2024 17:44:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1717807494; x=1718412294; 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=wVntBV37zIxUp8fMqU7jbR4MhrS6IWwAY/8pSVV5tCI=; b=RcnZVP8d96z522KeVfAOuvj8S2HsyB0N11r2JWUq9nwT5b4wWO3Aq4DxBeNmmgvtSo /it2W22MkHR+heZLO0Rsnry7PkA8Zyjo+VyGF1iC7pBkY12bTdJmgW5M0ER1CbXWcb0j JUdOy3dD1E74ikeG+5j/SS82w+X94Nzz6AYazl36jFBdukLQOf2HQDPC9uN2q+q4z3rm BDAWwPqxa6/TsjT+PHDRiD3pbVOdyk30Wd9P84fKa8+Py4vRad7pYDwmLCAY4iSg/Q3m vnPxx6csf5k0dYROvfrn+IhZNjYI0bOdmFvDkhIB+5JT5cBCjZEjzjhFVmbWkL8QPAwm wPNw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1717807494; x=1718412294; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=wVntBV37zIxUp8fMqU7jbR4MhrS6IWwAY/8pSVV5tCI=; b=ekWLFk2A41gcOC7/WLklV7fEUexqxhK/E6WCys3h6kLcnATLn8a1pAoueO2IXdi4sQ VAe9DAfXAmCA4j2h/BTgiuYhU11T1PKc5dCjNF6KRFmm/5uTj/DWxL6pI85cmztzjHQZ k0gWvfcVX6V2ZfuJ9/gY5jop/cikpJXrlLTDi1aFkjixPpBPwBS5bvZ3KGdIxUjuUSHA StIMg5K4Op0zLex2gN+aIyf1rSwhrb/H5iz/9+OfgdC69uonPNJSOnFNL+HOIQpUj7rv wAA2810C82KdUERRXgVAmg+ARMwv70DUoox92vSAP/mlqb5rXqqyijoONYUT/S6Wnh+/ a2yQ== X-Gm-Message-State: AOJu0YwR/NZUYNlloxRr7TAus25dj2jqeyRbRDHq3xN26urvsrQkvNLV CRSu5c1FyiGD65TpA01K0vEznJuXTZt21CpDyEIIbdcbAveMUFi+iJrQ4A== X-Google-Smtp-Source: AGHT+IF8OzFWDoMdgT/OU+rC1JkQCM9VZQpwPy9nFs3LryXgrOaRP4FDjSRAvXDvv5ftfQa9g8lSFQ== X-Received: by 2002:a17:903:2307:b0:1f6:a662:f5f1 with SMTP id d9443c01a7336-1f6d039d38bmr45839345ad.55.1717807494277; Fri, 07 Jun 2024 17:44:54 -0700 (PDT) Received: from localhost.localdomain ([2620:10d:c090:400::5:81a]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1f6bd7ec539sm40583165ad.238.2024.06.07.17.44.52 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 07 Jun 2024 17:44:53 -0700 (PDT) From: Alexei Starovoitov To: bpf@vger.kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, memxor@gmail.com, eddyz87@gmail.com, kernel-team@fb.com Subject: [PATCH bpf-next 1/4] bpf: Relax tuple len requirement for sk helpers. Date: Fri, 7 Jun 2024 17:44:43 -0700 Message-Id: <20240608004446.54199-2-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.3 (Apple Git-146) In-Reply-To: <20240608004446.54199-1-alexei.starovoitov@gmail.com> References: <20240608004446.54199-1-alexei.starovoitov@gmail.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net From: Alexei Starovoitov __bpf_skc_lookup() safely handles incorrect values of tuple len, hence we can allow zero to be passed as tuple len. This patch alone doesn't make an observable verifier difference. It's a trivial improvement that might simplify bpf programs. Signed-off-by: Alexei Starovoitov --- net/core/filter.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/net/core/filter.c b/net/core/filter.c index 7c46ecba3b01..cb133232a887 100644 --- a/net/core/filter.c +++ b/net/core/filter.c @@ -6815,7 +6815,7 @@ static const struct bpf_func_proto bpf_skc_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCK_COMMON_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6834,7 +6834,7 @@ static const struct bpf_func_proto bpf_sk_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6853,7 +6853,7 @@ static const struct bpf_func_proto bpf_sk_lookup_udp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6877,7 +6877,7 @@ static const struct bpf_func_proto bpf_tc_skc_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCK_COMMON_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6901,7 +6901,7 @@ static const struct bpf_func_proto bpf_tc_sk_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6925,7 +6925,7 @@ static const struct bpf_func_proto bpf_tc_sk_lookup_udp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6963,7 +6963,7 @@ static const struct bpf_func_proto bpf_xdp_sk_lookup_udp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -6987,7 +6987,7 @@ static const struct bpf_func_proto bpf_xdp_skc_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCK_COMMON_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -7011,7 +7011,7 @@ static const struct bpf_func_proto bpf_xdp_sk_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -7031,7 +7031,7 @@ static const struct bpf_func_proto bpf_sock_addr_skc_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCK_COMMON_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -7050,7 +7050,7 @@ static const struct bpf_func_proto bpf_sock_addr_sk_lookup_tcp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; @@ -7069,7 +7069,7 @@ static const struct bpf_func_proto bpf_sock_addr_sk_lookup_udp_proto = { .ret_type = RET_PTR_TO_SOCKET_OR_NULL, .arg1_type = ARG_PTR_TO_CTX, .arg2_type = ARG_PTR_TO_MEM | MEM_RDONLY, - .arg3_type = ARG_CONST_SIZE, + .arg3_type = ARG_CONST_SIZE_OR_ZERO, .arg4_type = ARG_ANYTHING, .arg5_type = ARG_ANYTHING, }; From patchwork Sat Jun 8 00:44:44 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 13690805 X-Patchwork-Delegate: bpf@iogearbox.net Received: from mail-pf1-f179.google.com (mail-pf1-f179.google.com [209.85.210.179]) (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 F1AD48480 for ; Sat, 8 Jun 2024 00:44:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807501; cv=none; b=ct9EA69i5tdSZrQ8mhC0SPDtibelBHpLBDwO01Wv9n2phZISOn45tRYmTZn07djaGKZ9so8UTQFagcGyGfO54TnR3pEGXT8MIUyFwCQ1pqcWOzdaJheyfk6HUlmjzBQdXyYa+gvr4MQSSRVT+BN5kFDEGWME37WxnbhI9FCUay0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807501; c=relaxed/simple; bh=yEsXy2y7qkBPSOE5CsRjLKHfWK1kE7+Mntnbd+XSngE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=EtCC2cZABMgaUyw+/Y7lp1aRkMkc/he2Y8O+pjfZItnfWqqKUtklbbemhU3y6AScjiiIWRHf8E+jlY+cV+L+IkCKLMnRXGSIQzM+Vmr3CoO/ULHsBpCZsCNJ922/DELPIgDykXkKlHjtVWIngGJRt6Bd/ojOWFZuWuE5NGilHLw= 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=ZRAv0IYW; arc=none smtp.client-ip=209.85.210.179 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="ZRAv0IYW" Received: by mail-pf1-f179.google.com with SMTP id d2e1a72fcca58-7024791a950so2578992b3a.0 for ; Fri, 07 Jun 2024 17:44:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1717807498; x=1718412298; 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=nZf0EHgmdIf50Bl79ZsaN7cmxd5qvbl03RzkcK+MKME=; b=ZRAv0IYW+b8U7soshouUT6TUJL52KhiRkLyboV9Vxe++iBcsebdX6TP8l63knx5oP9 a0T/hXdGSCf1CDkAewHBplRdh+nm9L6SmBwoNd4xo06HXvSbF5hITyU1MMB05uI0nqQW CTEr5MnGbOJRcL2Qn7yHRq8YJOguRkDFkb6Ec/pi3UO9flLcaCxmVb6BQdWO11h1VV4I VVepRbYu5gOAVe4tUGtojymk3rxxU6w1Z0YB79vgOOTMjKLue/Cx7wDEIC0wiP2jCuQK dbBwV6MPaOgrkpJubuREyXwsl3D2QeCbDxhrETGKQC70twx6SlYetn7ZEQacuFJXxypl 8dag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1717807498; x=1718412298; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=nZf0EHgmdIf50Bl79ZsaN7cmxd5qvbl03RzkcK+MKME=; b=oPC7v6ZEjUAtqEOaZRakBbWo1UB8rp/etsRb/b7ZR/OmB72jZ8UH2mkKBGDSMYIOwb i15KEbhVrevXEaRXWOgOOKSL3rzSA4FkBCh9h/uL453GdLJawGHEqWtf3jps0Uuxy0dc 0XmW+daaoQmwChprD0XEziM7f9DCJA3jQUCE02Vc7RO98PgJbiKPIYbdyZwej+mGlA4h 6S1RVXHIiRGgAsl7JbVtQ/NP7Sqo8M79nYUYQ25wj+AzE2TWQStrOmM4v1tfxo38erat T2nyRvLG3Lk6ANLDAY++wIlth5Rhxr0ZG/3yb0L7qgl7ZicM75l2XMzuy84VdTt0JyWr /fMw== X-Gm-Message-State: AOJu0Yxeexq7a11HxTDjTuKag2CjKWtWOz3bURuNtifMfQZSvFA3jCIO 4UPOOypwluDpi3SKM7KMoNHuwYeI2YlV0WdkIFIGIc8UaOquYE78coe1xA== X-Google-Smtp-Source: AGHT+IFNrHftsOqsx5aHm88tz42ZX/hMrE1+7T6NoXaRyavsdBXndb7YcsfeJAskteKnV0tqlJsdyQ== X-Received: by 2002:a05:6a20:7354:b0:1b2:b137:f864 with SMTP id adf61e73a8af0-1b2e6c469b2mr5920176637.7.1717807497930; Fri, 07 Jun 2024 17:44:57 -0700 (PDT) Received: from localhost.localdomain ([2620:10d:c090:400::5:81a]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-6de276061e3sm3261755a12.80.2024.06.07.17.44.56 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 07 Jun 2024 17:44:57 -0700 (PDT) From: Alexei Starovoitov To: bpf@vger.kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, memxor@gmail.com, eddyz87@gmail.com, kernel-team@fb.com Subject: [PATCH bpf-next 2/4] bpf: Track delta between "linked" registers. Date: Fri, 7 Jun 2024 17:44:44 -0700 Message-Id: <20240608004446.54199-3-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.3 (Apple Git-146) In-Reply-To: <20240608004446.54199-1-alexei.starovoitov@gmail.com> References: <20240608004446.54199-1-alexei.starovoitov@gmail.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net From: Alexei Starovoitov Compilers can generate the code r1 = r2 r1 += 0x1 if r2 < 1000 goto ... use knowledge of r2 range in subsequent r1 operations So remember constant delta between r2 and r1 and update r1 after 'if' condition. Unfortunately LLVM still uses this pattern for loops with 'can_loop' construct: for (i = 0; i < 1000 && can_loop; i++) The "undo" pass was introduced in LLVM https://reviews.llvm.org/D121937 to prevent this optimization, but it cannot cover all cases. Instead of fighting middle end optimizer in BPF backend teach the verifier about this pattern. Signed-off-by: Alexei Starovoitov --- include/linux/bpf_verifier.h | 12 ++++- kernel/bpf/log.c | 4 +- kernel/bpf/verifier.c | 90 ++++++++++++++++++++++++++++++++---- 3 files changed, 95 insertions(+), 11 deletions(-) diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h index 50aa87f8d77f..2b54e25d2364 100644 --- a/include/linux/bpf_verifier.h +++ b/include/linux/bpf_verifier.h @@ -73,7 +73,10 @@ enum bpf_iter_state { struct bpf_reg_state { /* Ordering of fields matters. See states_equal() */ enum bpf_reg_type type; - /* Fixed part of pointer offset, pointer types only */ + /* + * Fixed part of pointer offset, pointer types only. + * Or constant delta between "linked" scalars with the same ID. + */ s32 off; union { /* valid when type == PTR_TO_PACKET */ @@ -167,6 +170,13 @@ struct bpf_reg_state { * Similarly to dynptrs, we use ID to track "belonging" of a reference * to a specific instance of bpf_iter. */ + /* + * Upper bit of ID is used to remember relationship between "linked" + * registers. Example: + * r1 = r2; both will have r1->id == r2->id == N + * r1 += 10; r1->id == N | BPF_ADD_CONST and r1->off == 10 + */ +#define BPF_ADD_CONST (1U << 31) u32 id; /* PTR_TO_SOCKET and PTR_TO_TCP_SOCK could be a ptr returned * from a pointer-cast helper, bpf_sk_fullsock() and diff --git a/kernel/bpf/log.c b/kernel/bpf/log.c index 4bd8f17a9f24..3f4ae92e549f 100644 --- a/kernel/bpf/log.c +++ b/kernel/bpf/log.c @@ -708,7 +708,9 @@ static void print_reg_state(struct bpf_verifier_env *env, verbose(env, "%s", btf_type_name(reg->btf, reg->btf_id)); verbose(env, "("); if (reg->id) - verbose_a("id=%d", reg->id); + verbose_a("id=%d", reg->id & ~BPF_ADD_CONST); + if (reg->id & BPF_ADD_CONST) + verbose(env, "%+d", reg->off); if (reg->ref_obj_id) verbose_a("ref_obj_id=%d", reg->ref_obj_id); if (type_is_non_owning_ref(reg->type)) diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 81a3d2ced78d..e282625995fc 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -4438,8 +4438,20 @@ static bool __is_pointer_value(bool allow_ptr_leaks, static void assign_scalar_id_before_mov(struct bpf_verifier_env *env, struct bpf_reg_state *src_reg) { - if (src_reg->type == SCALAR_VALUE && !src_reg->id && - !tnum_is_const(src_reg->var_off)) + if (src_reg->type != SCALAR_VALUE) + return; + + if (src_reg->id & BPF_ADD_CONST) { + /* + * The verifier is processing rX = rY insn and + * rY->id has special linked register already. + * Cleared it, since multiple rX += const are not supported. + */ + src_reg->id = 0; + src_reg->off = 0; + } + + if (!src_reg->id && !tnum_is_const(src_reg->var_off)) /* Ensure that src_reg has a valid ID that will be copied to * dst_reg and then will be used by find_equal_scalars() to * propagate min/max range. @@ -14026,6 +14038,7 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env, struct bpf_func_state *state = vstate->frame[vstate->curframe]; struct bpf_reg_state *regs = state->regs, *dst_reg, *src_reg; struct bpf_reg_state *ptr_reg = NULL, off_reg = {0}; + bool alu32 = (BPF_CLASS(insn->code) != BPF_ALU64); u8 opcode = BPF_OP(insn->code); int err; @@ -14048,11 +14061,7 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env, if (dst_reg->type != SCALAR_VALUE) ptr_reg = dst_reg; - else - /* Make sure ID is cleared otherwise dst_reg min/max could be - * incorrectly propagated into other registers by find_equal_scalars() - */ - dst_reg->id = 0; + if (BPF_SRC(insn->code) == BPF_X) { src_reg = ®s[insn->src_reg]; if (src_reg->type != SCALAR_VALUE) { @@ -14116,7 +14125,40 @@ static int adjust_reg_min_max_vals(struct bpf_verifier_env *env, verbose(env, "verifier internal error: no src_reg\n"); return -EINVAL; } - return adjust_scalar_min_max_vals(env, insn, dst_reg, *src_reg); + err = adjust_scalar_min_max_vals(env, insn, dst_reg, *src_reg); + if (err) + return err; + /* + * Compilers can generate the code + * r1 = r2 + * r1 += 0x1 + * if r2 < 1000 goto ... + * use r1 in memory access + * So remember constant delta between r2 and r1 and update r1 after + * 'if' condition. + */ + if (BPF_OP(insn->code) == BPF_ADD && dst_reg->id && is_reg_const(src_reg, alu32)) { + u64 val = reg_const_value(src_reg, alu32); + + if ((dst_reg->id & BPF_ADD_CONST) || val > (u32)S32_MAX) { + /* + * If the register already went through rX += val + * we cannot accumulate another val into rx->off. + */ + dst_reg->off = 0; + dst_reg->id = 0; + } else { + dst_reg->id |= BPF_ADD_CONST; + dst_reg->off = val; + } + } else { + /* + * Make sure ID is cleared otherwise dst_reg min/max could be + * incorrectly propagated into other registers by find_equal_scalars() + */ + dst_reg->id = 0; + } + return 0; } /* check validity of 32-bit and 64-bit arithmetic operations */ @@ -15088,13 +15130,43 @@ static bool try_match_pkt_pointers(const struct bpf_insn *insn, static void find_equal_scalars(struct bpf_verifier_state *vstate, struct bpf_reg_state *known_reg) { + struct bpf_reg_state fake_reg; struct bpf_func_state *state; struct bpf_reg_state *reg; bpf_for_each_reg_in_vstate(vstate, state, reg, ({ - if (reg->type == SCALAR_VALUE && reg->id == known_reg->id) + if (reg->type != SCALAR_VALUE || reg == known_reg) + continue; + if ((reg->id & ~BPF_ADD_CONST) != (known_reg->id & ~BPF_ADD_CONST)) + continue; + if ((reg->id & BPF_ADD_CONST) == (known_reg->id & BPF_ADD_CONST)) { copy_register_state(reg, known_reg); + } else if ((reg->id & BPF_ADD_CONST) && reg->off) { + /* reg = known_reg; reg += const */ + copy_register_state(reg, known_reg); + + fake_reg.type = SCALAR_VALUE; + __mark_reg_known(&fake_reg, reg->off); + scalar32_min_max_add(reg, &fake_reg); + scalar_min_max_add(reg, &fake_reg); + reg->var_off = tnum_add(reg->var_off, fake_reg.var_off); + reg->off = 0; + reg->id &= ~BPF_ADD_CONST; + } else if ((known_reg->id & BPF_ADD_CONST) && known_reg->off) { + /* reg = known_reg; reg -= const' */ + copy_register_state(reg, known_reg); + + fake_reg.type = SCALAR_VALUE; + __mark_reg_known(&fake_reg, known_reg->off); + scalar32_min_max_sub(reg, &fake_reg); + scalar_min_max_sub(reg, &fake_reg); + reg->var_off = tnum_sub(reg->var_off, fake_reg.var_off); + } })); + if (known_reg->id & BPF_ADD_CONST) { + known_reg->id = 0; + known_reg->off = 0; + } } static int check_cond_jmp_op(struct bpf_verifier_env *env, From patchwork Sat Jun 8 00:44:45 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 13690806 X-Patchwork-Delegate: bpf@iogearbox.net Received: from mail-pf1-f177.google.com (mail-pf1-f177.google.com [209.85.210.177]) (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 26CF58F47 for ; Sat, 8 Jun 2024 00:45:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.177 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807504; cv=none; b=CIUjZv+L7+6LxDavgqYjvhwVHVcWM5S1/me9gNlnvXNIRtu3TbAb8k74zGU9oFUFOYVjantX/wwz8VtQMls09iqrDULlFGoHT6nn/jy+fyFrTKCk9g+FH1cAkzn0SWWPM9vxQqqWCjgidJobVJJ74VVOUnjBT7ypH6ZG2P8jX7I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807504; c=relaxed/simple; bh=yV6yP5ikBMdRk/2I4aZIJg+33sDLYKhwECezcDyBXRk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Zfu7jY3GDznksL+KBYQPQ5JsioEUuOBraHKWFYwpW6/+NnfDYjUMhUDM5QgDmr48GUVG4RMmdq+0+qatQDghlBlSQ64L9t8a1TcADggYejcI4wRsOqEW+qwa7rEOuAYgz/pcxvnpqKohMM+vu75YsFQCLabFIlYQGesRc7V3ZXw= 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=VEUhgqJy; arc=none smtp.client-ip=209.85.210.177 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="VEUhgqJy" Received: by mail-pf1-f177.google.com with SMTP id d2e1a72fcca58-7041ed475acso510183b3a.2 for ; Fri, 07 Jun 2024 17:45:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1717807502; x=1718412302; 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=L6cOdf9Cu6zqOkqikPzS0/9PNzRSpjAjgooQVzDyA8I=; b=VEUhgqJymTPQswzyuSGMmaiAeYI+7jiRUrgyDpgyZuH5XPd3H8k2PhiSNTFWINHOnX tQoBG9zFGbN07fGrfeDeIV/gocSKBx8kXSQNo02HDN4im3zgleIYs2IyU3HNv3UknW2v 7ZLa7NcuLB1925kqGUY7HP30nmkjPdQ16Qwpbk9UhrguBU2SkZErsnjOnw2lPsLmGB4U mHraHqpt+fXmHAjL/gd+pPdKUTfWYjdlkDmZ2sDhSd3ETekH8IvDxFPtTRVkpeKb3skD xSaOXeJ8oW4flEqHu81pXCPs0GM1A2i5ohngd0eB5kqHE0oaFuUQkHiLbTOFj0JpQDsP xDJg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1717807502; x=1718412302; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=L6cOdf9Cu6zqOkqikPzS0/9PNzRSpjAjgooQVzDyA8I=; b=wAsV7JDzpFY1PnlniMVy6zoPwHUgdUiTsrGIfabBTJaOziW8sU1lAD9iHvyy8U4ZUi xfrYwgPBjBw3bfC7I9n9Cwfx0BSGMMsgDmNTXTBX86ByK51kCoK8u3vx7B5Pf1dMVqOO VoXI8m2u7In97i/yh1HRV6H4On9k2W9i42U6cNtwhK9NWd3SZlAvIIiXp6ZM7YbUjtOM H5l/ugqeIrbLRUxdEsZJMsMR6dJOc8mGdwZ8eCoj5cY+QhJbwU/HXbplhDo4fn5XoCv5 XMOsk5o0nvkjhf6G5E2CxML/0+Z/EvcYP8AFWyARYr2C/u36M/jy+MAFLXoXKPht4TmW PRTA== X-Gm-Message-State: AOJu0YxKtmeHhRAMncanhOoY2B0CENUJGL8t1vvlJR8F2xgugT+7wCOd +Kazk+7ZjpHXWZ5G5SY+EDBQvVQol/VwyEMy93zqSLZR80ur3BpKwDH9vA== X-Google-Smtp-Source: AGHT+IF2FcNHxKcsxcwylXZrA3UH1vxAjMnC7YE29LOVKhqLFSfQeqbH+2hWiq+riAboOqyCJd+39w== X-Received: by 2002:a05:6a00:1791:b0:702:3183:2ae1 with SMTP id d2e1a72fcca58-7040c73ef2cmr3866932b3a.27.1717807501547; Fri, 07 Jun 2024 17:45:01 -0700 (PDT) Received: from localhost.localdomain ([2620:10d:c090:400::5:81a]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-7041f06b6a0sm554077b3a.127.2024.06.07.17.45.00 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 07 Jun 2024 17:45:01 -0700 (PDT) From: Alexei Starovoitov To: bpf@vger.kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, memxor@gmail.com, eddyz87@gmail.com, kernel-team@fb.com Subject: [PATCH bpf-next 3/4] bpf: Support can_loop/cond_break on big endian Date: Fri, 7 Jun 2024 17:44:45 -0700 Message-Id: <20240608004446.54199-4-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.3 (Apple Git-146) In-Reply-To: <20240608004446.54199-1-alexei.starovoitov@gmail.com> References: <20240608004446.54199-1-alexei.starovoitov@gmail.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net From: Alexei Starovoitov Add big endian support for can_loop/cond_break macros. Signed-off-by: Alexei Starovoitov Acked-by: Yonghong Song --- .../testing/selftests/bpf/bpf_experimental.h | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/tools/testing/selftests/bpf/bpf_experimental.h b/tools/testing/selftests/bpf/bpf_experimental.h index 3d9e4b8c6b81..82b73c37b50b 100644 --- a/tools/testing/selftests/bpf/bpf_experimental.h +++ b/tools/testing/selftests/bpf/bpf_experimental.h @@ -351,6 +351,7 @@ l_true: \ l_continue:; \ }) #else +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #define can_loop \ ({ __label__ l_break, l_continue; \ bool ret = true; \ @@ -376,6 +377,33 @@ l_true: \ l_break: break; \ l_continue:; \ }) +#else +#define can_loop \ + ({ __label__ l_break, l_continue; \ + bool ret = true; \ + asm volatile goto("1:.byte 0xe5; \ + .byte 0; \ + .long (((%l[l_break] - 1b - 8) / 8) & 0xffff) << 16; \ + .short 0" \ + :::: l_break); \ + goto l_continue; \ + l_break: ret = false; \ + l_continue:; \ + ret; \ + }) + +#define cond_break \ + ({ __label__ l_break, l_continue; \ + asm volatile goto("1:.byte 0xe5; \ + .byte 0; \ + .long (((%l[l_break] - 1b - 8) / 8) & 0xffff) << 16; \ + .short 0" \ + :::: l_break); \ + goto l_continue; \ + l_break: break; \ + l_continue:; \ + }) +#endif #endif #ifndef bpf_nop_mov From patchwork Sat Jun 8 00:44:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 13690807 X-Patchwork-Delegate: bpf@iogearbox.net Received: from mail-pl1-f180.google.com (mail-pl1-f180.google.com [209.85.214.180]) (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 83DA13233 for ; Sat, 8 Jun 2024 00:45:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807508; cv=none; b=W7i9yohRX3aEdyJf4OIXnrSNO30NIf+Ummj0EEb2tk/RYwCrbf02a5JB9Cija7A9GQcQsEzLXEISzKUTGgC91/nXsgEd7EOYS/Rj2TxqCenakYSGWczn2UlvcXgl5Dzs7aBhgrjyMqYJpmTFHFLM0ZSKG4rRbjNK8rcZ58AcxAk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1717807508; c=relaxed/simple; bh=svYUJxRLhK+Ar/Pb0aXx0A8My+1JrYoxvxWKJTuxCwo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=JdLTHMWV+2nnRwpBk4EkqF6ubaUPf62HGwAVfcs3KWB8LO1BkZEoVgT0zPzurkTn+8Bjlu9R/6oeWlhoCJuYRiZ5Kvq3+hS3GjinDZqirJiXgD22rhKhha4tqz6XoNyvXuI4nxuExB1o3jimJ+77ks7+bZrBt9OUG3WPFMyU5tY= 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=RzvE7YeV; arc=none smtp.client-ip=209.85.214.180 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="RzvE7YeV" Received: by mail-pl1-f180.google.com with SMTP id d9443c01a7336-1f6f1677b26so618575ad.0 for ; Fri, 07 Jun 2024 17:45:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1717807505; x=1718412305; 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=RyB3X3azGpw+Z0mg2bBe8ODTsijUAxM9gasrro+/apc=; b=RzvE7YeVYdpnpGsvGzZFhEvWdzSRrGKnRFu+eD8ctj9itegR32Gno7kUuXHE5R6nia j+YNXJmWodEoYdCj3UWgxdzSZLEQZXjGqTfe0IBVn/GGAE4tcyxYz0Cdpm3IaAnPNjBS 1yW7gg0Bsej9JeOz8nIX0LOzugifdorANe2Ytt8yUPhZ1JDUooA4+bJDAQm1qOfi3oc6 LVO5v+wl7nEnV8m2en0C6ZNJ60WEAypK07m2oLd23hdYQvbEICVdTwgVLNnMnMvqDv/s 3rQsu8qlHa2gMDKrL2kzXIQtGyJrm3BeQY2tMVMH7G2KmR24WMShpSFbB+ajExPEsFxg Xe9Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1717807505; x=1718412305; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=RyB3X3azGpw+Z0mg2bBe8ODTsijUAxM9gasrro+/apc=; b=gftS5HTENpBQbMc96C9IIm359ee/rW37/oHG2Hroe+BdpaK3iQ4hjs4bFX2a/ZXaV9 JbSZ9TqrXeBcSDE3mW8G0G97ckWOJ4XsZX4/o2pbPBiBwmUW9uX1XJ45jLDukfmGldA8 jp4HDhhNUBFQYC9wJKf96VVCXDprxCfI9/gHFt9K5ibI6bOIsH5+git3ZY3+w5LlGr+5 keHnWR5KkyZ8uPtEyFqyuc145dIHroTITTkxT+7346KF383XlmGWAsO24egkp/8TXyTR I9LTm+D6c6baa+7Tth1S5/IxXsSI5jkeAwBasUoAIwztl+Kl/AsOb70gd7bWyk18WK5/ kBpQ== X-Gm-Message-State: AOJu0YwTjN4JwvLfCT4HNlXQGBPzCHsv9umfKo3SYESM8wsEbVwu5ykC wiAQqgTGn03MvqyNN6/sqRkS+uNpnYhIciV1wBavqxi4ujeiIqDcNXuTOg== X-Google-Smtp-Source: AGHT+IHvLACCDF/mL4R/Bg5fDwJ4F2Rm/RgcovSWkO0x/NcnqfkFIH6g/I7tUu/UJirFLCFKNPix4g== X-Received: by 2002:a17:902:cec9:b0:1eb:7162:82c7 with SMTP id d9443c01a7336-1f6d0154d0cmr63828335ad.18.1717807505275; Fri, 07 Jun 2024 17:45:05 -0700 (PDT) Received: from localhost.localdomain ([2620:10d:c090:400::5:81a]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-1f6bd7ed6desm40645115ad.243.2024.06.07.17.45.04 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 07 Jun 2024 17:45:04 -0700 (PDT) From: Alexei Starovoitov To: bpf@vger.kernel.org Cc: daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, memxor@gmail.com, eddyz87@gmail.com, kernel-team@fb.com Subject: [PATCH bpf-next 4/4] selftests/bpf: Add tests for add_const Date: Fri, 7 Jun 2024 17:44:46 -0700 Message-Id: <20240608004446.54199-5-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.3 (Apple Git-146) In-Reply-To: <20240608004446.54199-1-alexei.starovoitov@gmail.com> References: <20240608004446.54199-1-alexei.starovoitov@gmail.com> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net From: Alexei Starovoitov Improve arena based tests and add several C and asm tests with specific pattern. These tests would have failed without add_const verifier support. Also add several loop_inside_iter*() tests that are not related to add_const, but nice to have. Signed-off-by: Alexei Starovoitov --- .../testing/selftests/bpf/progs/arena_htab.c | 16 +- .../bpf/progs/verifier_iterating_callbacks.c | 150 ++++++++++++++++++ 2 files changed, 163 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/bpf/progs/arena_htab.c b/tools/testing/selftests/bpf/progs/arena_htab.c index 1e6ac187a6a0..cd598348725e 100644 --- a/tools/testing/selftests/bpf/progs/arena_htab.c +++ b/tools/testing/selftests/bpf/progs/arena_htab.c @@ -18,25 +18,35 @@ void __arena *htab_for_user; bool skip = false; int zero = 0; +char __arena arr1[100000]; +char arr2[1000]; SEC("syscall") int arena_htab_llvm(void *ctx) { #if defined(__BPF_FEATURE_ADDR_SPACE_CAST) || defined(BPF_ARENA_FORCE_ASM) struct htab __arena *htab; + char __arena *arr = arr1; __u64 i; htab = bpf_alloc(sizeof(*htab)); cast_kern(htab); htab_init(htab); + cast_kern(arr); + /* first run. No old elems in the table */ - for (i = zero; i < 1000; i++) + for (i = zero; i < 100000 && can_loop; i++) { htab_update_elem(htab, i, i); + arr[i] = i; + } - /* should replace all elems with new ones */ - for (i = zero; i < 1000; i++) + /* should replace some elems with new ones */ + for (i = zero; i < 1000 && can_loop; i++) { htab_update_elem(htab, i, i); + /* Access mem to make the verifier use bounded loop logic */ + arr2[i] = i; + } cast_user(htab); htab_for_user = htab; #else diff --git a/tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c b/tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c index bd676d7e615f..a87100bf3862 100644 --- a/tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c +++ b/tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c @@ -405,4 +405,154 @@ int cond_break5(const void *ctx) return cnt1 > 1 && cnt2 > 1 ? 1 : 0; } +#define ARR2_SZ 1000 +SEC(".data.arr2") +char arr2[ARR2_SZ]; + +SEC("socket") +__success __flag(BPF_F_TEST_STATE_FREQ) +int loop_inside_iter(const void *ctx) +{ + struct bpf_iter_num it; + int *v, sum = 0; + __u64 i = 0; + + bpf_iter_num_new(&it, 0, ARR2_SZ); + while ((v = bpf_iter_num_next(&it))) { + if (i < ARR2_SZ) + sum += arr2[i++]; + } + bpf_iter_num_destroy(&it); + return sum; +} + +SEC("socket") +__success __flag(BPF_F_TEST_STATE_FREQ) +int loop_inside_iter_signed(const void *ctx) +{ + struct bpf_iter_num it; + int *v, sum = 0; + long i = 0; + + bpf_iter_num_new(&it, 0, ARR2_SZ); + while ((v = bpf_iter_num_next(&it))) { + if (i < ARR2_SZ && i >= 0) + sum += arr2[i++]; + } + bpf_iter_num_destroy(&it); + return sum; +} + +volatile const int limit = ARR2_SZ; + +SEC("socket") +__success __flag(BPF_F_TEST_STATE_FREQ) +int loop_inside_iter_volatile_limit(const void *ctx) +{ + struct bpf_iter_num it; + int *v, sum = 0; + __u64 i = 0; + + bpf_iter_num_new(&it, 0, ARR2_SZ); + while ((v = bpf_iter_num_next(&it))) { + if (i < limit) + sum += arr2[i++]; + } + bpf_iter_num_destroy(&it); + return sum; +} + +#define ARR_LONG_SZ 1000 + +SEC(".data.arr_long") +long arr_long[ARR_LONG_SZ]; + +SEC("socket") +__success +int test1(const void *ctx) +{ + long i; + + for (i = 0; i < ARR_LONG_SZ && can_loop; i++) + arr_long[i] = i; + return 0; +} + +SEC("socket") +__success +int test2(const void *ctx) +{ + __u64 i; + + for (i = zero; i < ARR_LONG_SZ && can_loop; i++) { + barrier_var(i); + arr_long[i] = i; + } + return 0; +} + +SEC(".data.arr_foo") +struct { + int a; + int b; +} arr_foo[ARR_LONG_SZ]; + +SEC("socket") +__success +int test3(const void *ctx) +{ + __u64 i; + + for (i = zero; i < ARR_LONG_SZ && can_loop; i++) { + barrier_var(i); + arr_foo[i].a = i; + arr_foo[i].b = i; + } + return 0; +} + +SEC("socket") +__success +int test4(const void *ctx) +{ + long i; + + for (i = zero + ARR_LONG_SZ - 1; i < ARR_LONG_SZ && i >= 0 && can_loop; i--) { + barrier_var(i); + arr_foo[i].a = i; + arr_foo[i].b = i; + } + return 0; +} + +char buf[10] SEC(".data.buf"); + +SEC("socket") +__description("check add const") +__success +__naked void check_add_const(void) +{ + /* typical LLVM generated loop with may_goto */ + asm volatile (" \ + call %[bpf_ktime_get_ns]; \ + if r0 >= 10 goto l1_%=; \ +l0_%=: r1 = %[buf]; \ + r1 += r0; \ + r3 = *(u8 *)(r1 +0); \ + .byte 0xe5; /* may_goto */ \ + .byte 0; /* regs */ \ + .short 4; /* off of l1_%=: */ \ + .long 0; /* imm */ \ + r2 = r0; \ + r2 += 1; \ + if r2 <= 10 goto l0_%=; \ + exit; \ +l1_%=: r0 = 0; \ + exit; \ +" : + : __imm(bpf_ktime_get_ns), + __imm_ptr(buf) + : __clobber_common); +} + char _license[] SEC("license") = "GPL";