Received: by 2002:a05:6a10:f347:0:0:0:0 with SMTP id d7csp3323475pxu; Tue, 15 Dec 2020 04:25:28 -0800 (PST) X-Google-Smtp-Source: ABdhPJzonvAaNzzcBoXVTmbp04/7xlizB7tBc04EtBxNiuDYMtm+rVLGZQmb20CinNWK4g4gkI3k X-Received: by 2002:a17:906:c1c6:: with SMTP id bw6mr27353153ejb.199.1608035128155; Tue, 15 Dec 2020 04:25:28 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1608035128; cv=none; d=google.com; s=arc-20160816; b=ZEMIkSECEJUcf0YWsdWDRlc2+lfbxKOZwrL6C3yWYqiK/ABgxZ45IvD3HtUhWpF09j Vq2vLt/f78PyXdR+0n+q5nkpWI7yyv2cPBS+YB40slHxDhA0tbX0Ji+FT2lSxzMZsmhq a4FAW425BOAdHTWjMPtpqMFyQUDf0sLt6noWVCMXXNQSZkZxeFTUiI2fBcFBd3iV34So Re15sVk6Y+MJw5cNAbfuZaGvTL7+o+dGWbowEwPjE0RyU2P5WI2hLLoEomJ+0MJOfAmK K/PLqTiNsC2HVBXWOIZUJEts5kUreOuIpotr08pUAVB+oei2fqPJvoMpDKx9w/HlID8J p3eA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:from:subject:references:mime-version :message-id:in-reply-to:date:sender:dkim-signature; bh=JwbvZB6RCDhRszRJjrp2Er/lfJkBt9IXgQd2Q0xXqZo=; b=wckVHKqAyZ187eM/VEGhGRVOA5SpyuircO/f2sp1MbI2hR29fTkOp/XqkyXkHw9fSc srY3h/a1uKzp1rQTFb8AtqOnCNbOm54BaUQ0Qxrc5mkdrEVxO9oIKg5KeUWgKeqciMCe YY3JmgimE4sS80hekRPlZbvuAVBwDYkU9guUnwa5BZOfMcHbieYwpr81Kz7ChKUBlW1h 1dGCe2xK/g4rpVJB0XnJvgiD8vvMN78yDLYursK9aCwJo3YlV0/Ax1Rj/CEYTP/n/cS9 7vO61mP9jVLrubM8V/bTEv357qA29gWPjK3d37yk8iphF2FC6Jv85oBSsNzVq9wR8xR0 NslA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@google.com header.s=20161025 header.b="LWR5AA/Z"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id dn9si701499edb.347.2020.12.15.04.25.04; Tue, 15 Dec 2020 04:25:28 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@google.com header.s=20161025 header.b="LWR5AA/Z"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=google.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729423AbgLOMW0 (ORCPT + 99 others); Tue, 15 Dec 2020 07:22:26 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50376 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729257AbgLOMUE (ORCPT ); Tue, 15 Dec 2020 07:20:04 -0500 Received: from mail-qt1-x849.google.com (mail-qt1-x849.google.com [IPv6:2607:f8b0:4864:20::849]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 09EA0C0611CE for ; Tue, 15 Dec 2020 04:18:39 -0800 (PST) Received: by mail-qt1-x849.google.com with SMTP id p20so14225927qtq.3 for ; Tue, 15 Dec 2020 04:18:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:in-reply-to:message-id:mime-version:references:subject :from:to:cc; bh=JwbvZB6RCDhRszRJjrp2Er/lfJkBt9IXgQd2Q0xXqZo=; b=LWR5AA/ZfFpO8wBUhYMu1Y0hwS/IOneYQRIk5TJ+FlADpbD9oBpr4JaFVh4k5anlHU kPSp4HkP/aavJzr+OkijKXJXdAfBpdewYmwljPkUoCcZ7s3ojvKp2V8IT/xlv7iIa22B WoAf6I/Zu132pvKbVwRaIdQKQgZyhBLZEGu6TChl8NqdpEruc55eEzZcXYtxTB0EuDi1 TjVICdyAHWP9sIv79oVq2N9XwpFox7cFJ8uV7fgsDXbpb71AzNGHbnM28NicNOvjSYpQ 4mm4b8GKM2X0p0REtn2W4apFlbGVfig4XwgqxKix+Hjg+5serscKfnTAWcpnnBr5tWOV u8TA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=JwbvZB6RCDhRszRJjrp2Er/lfJkBt9IXgQd2Q0xXqZo=; b=c30wJYxsAqZOkUOXFK7FFOUvdkMbgzCRhE4IJGgsvkbEW3V9eHhNyCadTTnwL9MaSm jqH8CBn0xoIQsdh/4kGKMCqQAy9Nn7P2SWhSRjSeRGNxQ2RPwgF/y+mFB+Y6x3lP8w9m wzqFpoZGSA5RIjez2aQDTrVcOgULl6bEriJNqX4anbc0oK1akTAAq1I+IA8L9XiW5eMC VTyMrL0FBb46/sAhBqA6mQCyk2g5SXMlVq1WZl/Ru/MCgiuoKFTKP5OulzhIE1EewpOw GAcgNYHWOXA/25EuvG6VcBxtXqtIuWwgJiXishWpwa7jgf1l4hPeO0r97SsWFa4RwnHC T/2w== X-Gm-Message-State: AOAM53303Z03IKhk38zAEX+v8me68f1OKPLnqfshkQIFmBqY157uvQNV rtf3p+O3ik7Uo10mG2KjtWVV8ZiX/JUJFg== Sender: "jackmanb via sendgmr" X-Received: from beeg.c.googlers.com ([fda3:e722:ac3:cc00:28:9cb1:c0a8:11db]) (user=jackmanb job=sendgmr) by 2002:a0c:f54c:: with SMTP id p12mr32558067qvm.35.1608034718242; Tue, 15 Dec 2020 04:18:38 -0800 (PST) Date: Tue, 15 Dec 2020 12:18:11 +0000 In-Reply-To: <20201215121816.1048557-1-jackmanb@google.com> Message-Id: <20201215121816.1048557-8-jackmanb@google.com> Mime-Version: 1.0 References: <20201215121816.1048557-1-jackmanb@google.com> X-Mailer: git-send-email 2.29.2.684.gfbc64c5ab5-goog Subject: [PATCH bpf-next v5 06/11] bpf: Add BPF_FETCH field / create atomic_fetch_add instruction From: Brendan Jackman To: bpf@vger.kernel.org Cc: Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , KP Singh , Florent Revest , linux-kernel@vger.kernel.org, Brendan Jackman , Yonghong Song , John Fastabend Content-Type: text/plain; charset="UTF-8" Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The BPF_FETCH field can be set in bpf_insn.imm, for BPF_ATOMIC instructions, in order to have the previous value of the atomically-modified memory location loaded into the src register after an atomic op is carried out. Suggested-by: Yonghong Song Signed-off-by: Brendan Jackman Acked-by: John Fastabend --- arch/x86/net/bpf_jit_comp.c | 4 ++++ include/linux/filter.h | 1 + include/uapi/linux/bpf.h | 3 +++ kernel/bpf/core.c | 13 +++++++++++++ kernel/bpf/disasm.c | 7 +++++++ kernel/bpf/verifier.c | 33 ++++++++++++++++++++++++--------- tools/include/linux/filter.h | 1 + tools/include/uapi/linux/bpf.h | 3 +++ 8 files changed, 56 insertions(+), 9 deletions(-) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index b1829a534da1..eea7d8b0bb12 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -811,6 +811,10 @@ static int emit_atomic(u8 **pprog, u8 atomic_op, /* lock *(u32/u64*)(dst_reg + off) = src_reg */ EMIT1(simple_alu_opcodes[atomic_op]); break; + case BPF_ADD | BPF_FETCH: + /* src_reg = atomic_fetch_add(dst_reg + off, src_reg); */ + EMIT2(0x0F, 0xC1); + break; default: pr_err("bpf_jit: unknown atomic opcode %02x\n", atomic_op); return -EFAULT; diff --git a/include/linux/filter.h b/include/linux/filter.h index 3463ac0c0259..c3e87a63e0b8 100644 --- a/include/linux/filter.h +++ b/include/linux/filter.h @@ -264,6 +264,7 @@ static inline bool insn_is_zext(const struct bpf_insn *insn) * Atomic operations: * * BPF_ADD *(uint *) (dst_reg + off16) += src_reg + * BPF_ADD | BPF_FETCH src_reg = atomic_fetch_add(dst_reg + off16, src_reg); */ #define BPF_ATOMIC_OP(SIZE, OP, DST, SRC, OFF) \ diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 7bd3671bff20..760ae333a5ed 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -44,6 +44,9 @@ #define BPF_CALL 0x80 /* function call */ #define BPF_EXIT 0x90 /* function return */ +/* atomic op type fields (stored in immediate) */ +#define BPF_FETCH 0x01 /* fetch previous value into src reg */ + /* Register numbers */ enum { BPF_REG_0 = 0, diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c index 3abc6b250b18..2b1d3fea03fc 100644 --- a/kernel/bpf/core.c +++ b/kernel/bpf/core.c @@ -1624,16 +1624,29 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn, u64 *stack) /* lock xadd *(u32 *)(dst_reg + off16) += src_reg */ atomic_add((u32) SRC, (atomic_t *)(unsigned long) (DST + insn->off)); + break; + case BPF_ADD | BPF_FETCH: + SRC = (u32) atomic_fetch_add( + (u32) SRC, + (atomic_t *)(unsigned long) (DST + insn->off)); + break; default: goto default_label; } CONT; + STX_ATOMIC_DW: switch (IMM) { case BPF_ADD: /* lock xadd *(u64 *)(dst_reg + off16) += src_reg */ atomic64_add((u64) SRC, (atomic64_t *)(unsigned long) (DST + insn->off)); + break; + case BPF_ADD | BPF_FETCH: + SRC = (u64) atomic64_fetch_add( + (u64) SRC, + (atomic64_t *)(unsigned long) (DST + insn->off)); + break; default: goto default_label; } diff --git a/kernel/bpf/disasm.c b/kernel/bpf/disasm.c index 37c8d6e9b4cc..d2e20f6d0516 100644 --- a/kernel/bpf/disasm.c +++ b/kernel/bpf/disasm.c @@ -160,6 +160,13 @@ void print_bpf_insn(const struct bpf_insn_cbs *cbs, bpf_ldst_string[BPF_SIZE(insn->code) >> 3], insn->dst_reg, insn->off, insn->src_reg); + } else if (BPF_MODE(insn->code) == BPF_ATOMIC && + insn->imm == (BPF_ADD | BPF_FETCH)) { + verbose(cbs->private_data, "(%02x) r%d = atomic%s_fetch_add((%s *)(r%d %+d), r%d)\n", + insn->code, insn->src_reg, + BPF_SIZE(insn->code) == BPF_DW ? "64" : "", + bpf_ldst_string[BPF_SIZE(insn->code) >> 3], + insn->dst_reg, insn->off, insn->src_reg); } else { verbose(cbs->private_data, "BUG_%02x\n", insn->code); } diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 48e398667a69..449b2da9b6db 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -3608,7 +3608,11 @@ static int check_atomic(struct bpf_verifier_env *env, int insn_idx, struct bpf_i { int err; - if (insn->imm != BPF_ADD) { + switch (insn->imm) { + case BPF_ADD: + case BPF_ADD | BPF_FETCH: + break; + default: verbose(env, "BPF_ATOMIC uses invalid atomic opcode %02x\n", insn->imm); return -EINVAL; } @@ -3650,8 +3654,20 @@ static int check_atomic(struct bpf_verifier_env *env, int insn_idx, struct bpf_i return err; /* check whether we can write into the same memory */ - return check_mem_access(env, insn_idx, insn->dst_reg, insn->off, - BPF_SIZE(insn->code), BPF_WRITE, -1, true); + err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off, + BPF_SIZE(insn->code), BPF_WRITE, -1, true); + if (err) + return err; + + if (!(insn->imm & BPF_FETCH)) + return 0; + + /* check and record load of old value into src reg */ + err = check_reg_arg(env, insn->src_reg, DST_OP); + if (err) + return err; + + return 0; } static int __check_stack_boundary(struct bpf_verifier_env *env, u32 regno, @@ -9528,12 +9544,6 @@ static int do_check(struct bpf_verifier_env *env) } else if (class == BPF_STX) { enum bpf_reg_type *prev_dst_type, dst_reg_type; - if (((BPF_MODE(insn->code) != BPF_MEM && - BPF_MODE(insn->code) != BPF_ATOMIC) || insn->imm != 0)) { - verbose(env, "BPF_STX uses reserved fields\n"); - return -EINVAL; - } - if (BPF_MODE(insn->code) == BPF_ATOMIC) { err = check_atomic(env, env->insn_idx, insn); if (err) @@ -9542,6 +9552,11 @@ static int do_check(struct bpf_verifier_env *env) continue; } + if (BPF_MODE(insn->code) != BPF_MEM || insn->imm != 0) { + verbose(env, "BPF_STX uses reserved fields\n"); + return -EINVAL; + } + /* check src1 operand */ err = check_reg_arg(env, insn->src_reg, SRC_OP); if (err) diff --git a/tools/include/linux/filter.h b/tools/include/linux/filter.h index e870c9039f0d..7211ce9fba53 100644 --- a/tools/include/linux/filter.h +++ b/tools/include/linux/filter.h @@ -173,6 +173,7 @@ * Atomic operations: * * BPF_ADD *(uint *) (dst_reg + off16) += src_reg + * BPF_ADD | BPF_FETCH src_reg = atomic_fetch_add(dst_reg + off16, src_reg); */ #define BPF_ATOMIC_OP(SIZE, OP, DST, SRC, OFF) \ diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 7bd3671bff20..760ae333a5ed 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -44,6 +44,9 @@ #define BPF_CALL 0x80 /* function call */ #define BPF_EXIT 0x90 /* function return */ +/* atomic op type fields (stored in immediate) */ +#define BPF_FETCH 0x01 /* fetch previous value into src reg */ + /* Register numbers */ enum { BPF_REG_0 = 0, -- 2.29.2.684.gfbc64c5ab5-goog