From nobody Wed Dec 17 21:15:13 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 13573C77B72 for ; Tue, 18 Apr 2023 01:45:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231186AbjDRBpo (ORCPT ); Mon, 17 Apr 2023 21:45:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53842 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230502AbjDRBpI (ORCPT ); Mon, 17 Apr 2023 21:45:08 -0400 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 107CF61A3 for ; Mon, 17 Apr 2023 18:42:32 -0700 (PDT) Received: by mail-yb1-xb4a.google.com with SMTP id d10-20020a25cd0a000000b00b956d4a5a04so134197ybf.22 for ; Mon, 17 Apr 2023 18:42:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1681782120; x=1684374120; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=YCFXbIE/7zM5T1Zxz4s1sjI+Fr3ZActGUdsgPEik6eM=; b=FB1wts4EjjmXAYzwfnd2fXz7dClLikX5H2f+j5h+pJVNsx6Q6NlCRmHSItjyPUrnLv YKyra7iCWVEBF0LSP7pSpNJnt31Essq6CEOYUvx3a7DeB1H1zp6/AzOIMV4nIMmPQ1qh qMCnxSgQQEmKpoo+wUGmGbWJWaPB9mdD+g4OxND3tsdF6PhQCvPKTZ1L9qfeLvvDeRwC diebbFiKsuAfFKHUnGox1H1Vm8nPX77oEHMs7kh9H6yCekzNrbtTKcZMsq9SW5ZfMvTo tES6furCQMp++TtGvH27jawxyKvTX19Ki63HlB/d0cozAwalDTSnp6pYD+fi6iqjgBt8 e32w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1681782120; x=1684374120; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=YCFXbIE/7zM5T1Zxz4s1sjI+Fr3ZActGUdsgPEik6eM=; b=eEAs0MlFzrJaPfavObY5Pu1M5MnzFWkRaOI7/ttd0rhM8gUYoZAXoIIcwHLbr3wD2i KqUm8L+Z6XhC1eLMzMScaIrx4Dt3NsGinBWW4qVEXV6WIEGJD8HZ6PLG9gyO8WN9qKII I/chx/2Qv/rzW+aOGXYaJ0JYoi+Z9pr2tUx+0F/FF66UmlUvx220Umgk6Ld1/qTvie4W f2TP1g9NAWL6E/kyz8rmsRbQtoi6cJnEd5S0A9HHXnDAYlmIRWlCprKaT4T0ijG++JSl 19R4qtTW3jPzrBKjCeTUXeR72jiOBXMDWszKq0eAzHJiTvr4XldqVK5mq0RsMGFxkmuM GmaQ== X-Gm-Message-State: AAQBX9epe0QkbDyucAKj0IBW8i205zeATNw5AGwwSIAvv0olg1yhxG3X Xn0JpyOXe1FVHkTIvyseYJ6mwak2lec= X-Google-Smtp-Source: AKy350bP8nkD4q8ZefsJwT0Q2ZhJNsKNBRwFjIJbXhB6OG/HhtE2gYEray13+6teD80zVxL1NhMk7TiPsY0= X-Received: from drosen.mtv.corp.google.com ([2620:15c:211:201:e67a:98b0:942d:86aa]) (user=drosen job=sendgmr) by 2002:a81:af0c:0:b0:54c:2889:7105 with SMTP id n12-20020a81af0c000000b0054c28897105mr10920487ywh.0.1681782120540; Mon, 17 Apr 2023 18:42:00 -0700 (PDT) Date: Mon, 17 Apr 2023 18:40:31 -0700 In-Reply-To: <20230418014037.2412394-1-drosen@google.com> Mime-Version: 1.0 References: <20230418014037.2412394-1-drosen@google.com> X-Mailer: git-send-email 2.40.0.634.g4ca3ef3211-goog Message-ID: <20230418014037.2412394-32-drosen@google.com> Subject: [RFC PATCH v3 31/37] fuse-bpf: Set fuse_ops at mount or lookup time From: Daniel Rosenberg To: Miklos Szeredi , bpf@vger.kernel.org, Alexei Starovoitov Cc: Amir Goldstein , linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-unionfs@vger.kernel.org, Daniel Borkmann , John Fastabend , Andrii Nakryiko , Martin KaFai Lau , Song Liu , Yonghong Song , KP Singh , Stanislav Fomichev , Hao Luo , Jiri Olsa , Shuah Khan , Jonathan Corbet , Joanne Koong , Mykola Lysenko , kernel-team@android.com, Daniel Rosenberg Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This adds the ability to associate a fuse_op struct_op program with inodes in fuse. This can be done at mount time at the root level, or by inode at lookup time. Signed-off-by: Daniel Rosenberg --- fs/fuse/backing.c | 91 +++++++++++++++++++++++++++++++++++++++++++---- fs/fuse/dir.c | 16 +++++++-- fs/fuse/fuse_i.h | 12 +++++++ fs/fuse/inode.c | 28 ++++++++++++++- 4 files changed, 138 insertions(+), 9 deletions(-) diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c index 898ef9e05e9d..d5ba1e334e69 100644 --- a/fs/fuse/backing.c +++ b/fs/fuse/backing.c @@ -6,6 +6,7 @@ =20 #include "fuse_i.h" =20 +#include #include #include #include @@ -168,12 +169,13 @@ static void fuse_get_backing_path(struct file *file, = struct path *path) =20 static bool has_file(int type) { - return type =3D=3D FUSE_ENTRY_BACKING; + return (type =3D=3D FUSE_ENTRY_BACKING); } =20 /* - * The optional fuse bpf entry lists the backing file for a particular - * lookup. These are inherited by default. + * The optional fuse bpf entry lists the bpf and backing files for a parti= cular + * lookup. These are inherited by default. A Bpf requires a backing file t= o be + * meaningful. * * In the future, we may support multiple bpfs, and multiple backing files= for * the bpf to choose between. @@ -182,14 +184,14 @@ static bool has_file(int type) * file. Changing only the bpf is valid, though meaningless if there isn't= an * inherited backing file. * - * Support for the bpf program will be added in a later patch - * */ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe, int num) { struct fuse_bpf_entry_out *fbeo; + struct fuse_ops *ops; struct file *file; bool has_backing =3D false; + bool has_bpf_ops =3D false; int num_entries; int err =3D -EINVAL; int i; @@ -227,6 +229,11 @@ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe, i= nt num) goto out_err; fbe->backing_action =3D FUSE_BPF_REMOVE; break; + case FUSE_ENTRY_REMOVE_BPF: + if (fbe->bpf_action || i =3D=3D 2) + goto out_err; + fbe->bpf_action =3D FUSE_BPF_REMOVE; + break; case FUSE_ENTRY_BACKING: if (fbe->backing_action) goto out_err; @@ -234,8 +241,17 @@ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe, i= nt num) fbe->backing_action =3D FUSE_BPF_SET; has_backing =3D true; break; + case FUSE_ENTRY_BPF: + if (fbe->bpf_action || i =3D=3D 2) + goto out_err; + ops =3D find_fuse_ops(fbeo->name); + if (!ops) + goto out_err; + has_bpf_ops =3D true; + fbe->bpf_action =3D FUSE_BPF_SET; + fbe->ops =3D ops; + break; default: - err =3D -EINVAL; goto out_err; } if (has_file(fbeo->entry_type)) { @@ -252,6 +268,10 @@ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe, i= nt num) fput(file); if (has_backing) path_put_init(&fbe->backing_path); + if (has_bpf_ops) { + put_fuse_ops(fbe->ops); + fbe->ops =3D NULL; + } return err; } =20 @@ -527,6 +547,15 @@ static int fuse_create_open_backing(struct bpf_fuse_ar= gs *fa, int *out, goto out; } =20 + if (get_fuse_inode(inode)->bpf_ops) + put_fuse_ops(get_fuse_inode(inode)->bpf_ops); + get_fuse_inode(inode)->bpf_ops =3D dir_fuse_inode->bpf_ops; + if (get_fuse_inode(inode)->bpf_ops) + if (!get_fuse_ops(get_fuse_inode(inode)->bpf_ops)) { + *out =3D -EINVAL; + goto out; + } + newent =3D d_splice_alias(inode, entry); if (IS_ERR(newent)) { *out =3D PTR_ERR(newent); @@ -1842,6 +1871,52 @@ int fuse_handle_backing(struct fuse_bpf_entry *fbe, = struct path *backing_path) return 0; } =20 +int fuse_handle_bpf_ops(struct fuse_bpf_entry *fbe, struct inode *parent, + struct fuse_ops **ops) +{ + struct fuse_ops *new_ops; + + /* Parent isn't presented, but we want to keep + * Don't touch bpf program at all in this case + */ + if (fbe->bpf_action =3D=3D FUSE_BPF_UNCHANGED && !parent) + return 0; + + switch (fbe->bpf_action) { + case FUSE_BPF_UNCHANGED: { + struct fuse_inode *pi =3D get_fuse_inode(parent); + + new_ops =3D pi->bpf_ops; + if (new_ops && !get_fuse_ops(new_ops)) + return -EINVAL; + break; + } + + case FUSE_BPF_REMOVE: + new_ops =3D NULL; + break; + + case FUSE_BPF_SET: + new_ops =3D fbe->ops; + + if (!new_ops) + return -EINVAL; + break; + + default: + return -EINVAL; + } + + /* Cannot change existing program */ + if (*ops) { + put_fuse_ops(new_ops); + return new_ops =3D=3D *ops ? 0 : -EINVAL; + } + + *ops =3D new_ops; + return 0; +} + static int fuse_lookup_finalize(struct bpf_fuse_args *fa, struct dentry **= out, struct inode *dir, struct dentry *entry, unsigned int flags) { @@ -1879,6 +1954,10 @@ static int fuse_lookup_finalize(struct bpf_fuse_args= *fa, struct dentry **out, if (IS_ERR(inode)) return PTR_ERR(inode); =20 + error =3D fuse_handle_bpf_ops(fbe, dir, &get_fuse_inode(inode)->bpf_ops); + if (error) + return error; + get_fuse_inode(inode)->nodeid =3D feo->nodeid; =20 *out =3D d_splice_alias(inode, entry); diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c index d1c3b2bfb0b1..b7bc8260a537 100644 --- a/fs/fuse/dir.c +++ b/fs/fuse/dir.c @@ -10,6 +10,7 @@ =20 #include #include +#include #include #include #include @@ -185,6 +186,7 @@ static bool backing_data_changed(struct fuse_inode *fi,= struct dentry *entry, { struct path new_backing_path; struct inode *new_backing_inode; + struct fuse_ops *ops =3D NULL; int err; bool ret =3D true; =20 @@ -199,9 +201,15 @@ static bool backing_data_changed(struct fuse_inode *fi= , struct dentry *entry, if (err) goto put_inode; =20 - ret =3D (fi->backing_inode !=3D new_backing_inode || - !path_equal(&get_fuse_dentry(entry)->backing_path, &new_backing_path)); + err =3D fuse_handle_bpf_ops(bpf_arg, entry->d_parent->d_inode, &ops); + if (err) + goto put_bpf; =20 + ret =3D (ops !=3D fi->bpf_ops || fi->backing_inode !=3D new_backing_inode= || + !path_equal(&get_fuse_dentry(entry)->backing_path, &new_backing_path)); +put_bpf: + if (ops) + put_fuse_ops(ops); put_inode: path_put(&new_backing_path); return ret; @@ -466,6 +474,10 @@ int fuse_lookup_name(struct super_block *sb, u64 nodei= d, *inode =3D fuse_iget_backing(sb, outarg->nodeid, backing_inode); if (!*inode) goto out_queue_forget; + + err =3D fuse_handle_bpf_ops(&bpf_arg, NULL, &get_fuse_inode(*inode)->bpf= _ops); + if (err) + goto out; } else #endif { diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h index 84c591d02e43..15962ab3b381 100644 --- a/fs/fuse/fuse_i.h +++ b/fs/fuse/fuse_i.h @@ -33,6 +33,7 @@ #include #include #include +#include #include =20 /** Default max number of pages that can be used in a single read request = */ @@ -109,6 +110,12 @@ struct fuse_inode { * If this is set, nodeid is 0. */ struct inode *backing_inode; + + /** + * fuse_ops, provides handlers to run on all operations to determine + * whether to pass through or handle in place + */ + struct fuse_ops *bpf_ops; #endif =20 /** Unique ID, which identifies the inode between userspace @@ -571,6 +578,7 @@ struct fuse_fs_context { unsigned int max_read; unsigned int blksize; const char *subtype; + struct fuse_ops *root_ops; struct file *root_dir; =20 /* DAX device, may be NULL */ @@ -1428,6 +1436,8 @@ struct fuse_bpf_entry { =20 enum fuse_bpf_set backing_action; struct path backing_path; + enum fuse_bpf_set bpf_action; + struct fuse_ops *ops; bool is_used; }; =20 @@ -1651,6 +1661,8 @@ static inline int fuse_bpf_access(int *out, struct in= ode *inode, int mask) ssize_t fuse_backing_mmap(struct file *file, struct vm_area_struct *vma); =20 int fuse_handle_backing(struct fuse_bpf_entry *fbe, struct path *backing_p= ath); +int fuse_handle_bpf_ops(struct fuse_bpf_entry *fbe, struct inode *parent, + struct fuse_ops **ops); =20 int fuse_revalidate_backing(struct dentry *entry, unsigned int flags); =20 diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c index 31f34962bc9b..7fd79efbdac1 100644 --- a/fs/fuse/inode.c +++ b/fs/fuse/inode.c @@ -80,6 +80,7 @@ static struct inode *fuse_alloc_inode(struct super_block = *sb) fi->inval_mask =3D 0; #ifdef CONFIG_FUSE_BPF fi->backing_inode =3D NULL; + fi->bpf_ops =3D NULL; #endif fi->nodeid =3D 0; fi->nlookup =3D 0; @@ -125,6 +126,9 @@ static void fuse_evict_inode(struct inode *inode) =20 #ifdef CONFIG_FUSE_BPF iput(fi->backing_inode); + if (fi->bpf_ops) + put_fuse_ops(fi->bpf_ops); + fi->bpf_ops =3D NULL; #endif =20 truncate_inode_pages_final(&inode->i_data); @@ -755,6 +759,7 @@ enum { OPT_ALLOW_OTHER, OPT_MAX_READ, OPT_BLKSIZE, + OPT_ROOT_BPF, OPT_ROOT_DIR, OPT_NO_DAEMON, OPT_ERR @@ -771,6 +776,7 @@ static const struct fs_parameter_spec fuse_fs_parameter= s[] =3D { fsparam_u32 ("max_read", OPT_MAX_READ), fsparam_u32 ("blksize", OPT_BLKSIZE), fsparam_string ("subtype", OPT_SUBTYPE), + fsparam_string ("root_bpf", OPT_ROOT_BPF), fsparam_u32 ("root_dir", OPT_ROOT_DIR), fsparam_flag ("no_daemon", OPT_NO_DAEMON), {} @@ -856,6 +862,18 @@ static int fuse_parse_param(struct fs_context *fsc, st= ruct fs_parameter *param) ctx->blksize =3D result.uint_32; break; =20 + case OPT_ROOT_BPF: + if (strnlen(param->string, BPF_FUSE_NAME_MAX + 1) > BPF_FUSE_NAME_MAX) { + return invalfc(fsc, "root_bpf name too long. Max length is %d", BPF_FUS= E_NAME_MAX); + } + + ctx->root_ops =3D find_fuse_ops(param->string); + if (IS_ERR_OR_NULL(ctx->root_ops)) { + ctx->root_ops =3D NULL; + return invalfc(fsc, "Unable to find bpf program"); + } + break; + case OPT_ROOT_DIR: ctx->root_dir =3D fget(result.uint_32); if (!ctx->root_dir) @@ -881,6 +899,8 @@ static void fuse_free_fsc(struct fs_context *fsc) if (ctx) { if (ctx->root_dir) fput(ctx->root_dir); + if (ctx->root_ops) + put_fuse_ops(ctx->root_ops); kfree(ctx->subtype); kfree(ctx); } @@ -1010,6 +1030,7 @@ EXPORT_SYMBOL_GPL(fuse_conn_get); =20 static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned int mode, + struct fuse_ops *root_bpf_ops, struct file *backing_fd) { struct fuse_attr attr; @@ -1024,6 +1045,10 @@ static struct inode *fuse_get_root_inode(struct supe= r_block *sb, return NULL; =20 #ifdef CONFIG_FUSE_BPF + get_fuse_inode(inode)->bpf_ops =3D root_bpf_ops; + if (root_bpf_ops) + get_fuse_ops(root_bpf_ops); + if (backing_fd) { get_fuse_inode(inode)->backing_inode =3D backing_fd->f_inode; ihold(backing_fd->f_inode); @@ -1704,7 +1729,8 @@ int fuse_fill_super_common(struct super_block *sb, st= ruct fuse_fs_context *ctx) fc->no_daemon =3D ctx->no_daemon; =20 err =3D -ENOMEM; - root =3D fuse_get_root_inode(sb, ctx->rootmode, ctx->root_dir); + root =3D fuse_get_root_inode(sb, ctx->rootmode, ctx->root_ops, + ctx->root_dir); sb->s_d_op =3D &fuse_root_dentry_operations; root_dentry =3D d_make_root(root); if (!root_dentry) --=20 2.40.0.634.g4ca3ef3211-goog