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 9983CC77B7E for ; Tue, 18 Apr 2023 01:43:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230105AbjDRBnR (ORCPT ); Mon, 17 Apr 2023 21:43:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54366 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230513AbjDRBmT (ORCPT ); Mon, 17 Apr 2023 21:42:19 -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 D0D1C6E9A for ; Mon, 17 Apr 2023 18:41:28 -0700 (PDT) Received: by mail-yb1-xb4a.google.com with SMTP id j193-20020a2523ca000000b00b8f6b82ec94so9094765ybj.18 for ; Mon, 17 Apr 2023 18:41:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1681782085; x=1684374085; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=EclmRuCEs8AtdYsWbPtv7S1s8N7D3XoEPaguP9KMkfI=; b=mmwYVHjRAK5Z159C4imU0XQjkYtfnCBYjv6l4C4bOCpMXKwBtApNX02vwb7wGKRz4N 5XN3HQ4NzLI38FzrpsJ+pijncme7++sNr3Lhf5SYjX2+5hrrxG0qic8LTCsLQ/L3V1tl ZnXYn62ItIO97Ypuoa624x4qnYf6vElPXxFcygSYU7x1tbJdV1rnJIz2kFBABcJUHC/R ODYpnlJdo3GOx6g8lnndopkLGXfrP5bGFTxF2LWebBVsKgZtSOfuB1fZS4av1rYR4v8d dXRXapxs4gY9IzCAWPPhicID2CTLtG3lyLn96zZ5kfplK6rLfb34n9wqbKDNzu3jXRVL DyFQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1681782085; x=1684374085; 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=EclmRuCEs8AtdYsWbPtv7S1s8N7D3XoEPaguP9KMkfI=; b=gqQR1a75mVSzecRZ1mgYJEZgyyVrNHzovVLe8EG+gHdoD2HtCVOkrNzQ94yRm2qdzQ ZlmALhr+xiNPILUYEjGVxpIcV1YagB0xnMBVNuy7IsP575m6nmClXoBbVWYmSU0wm8PE 6d7mIVhqqbtD0iQJ2Fg26vwh2JUfWeqe8dMbnAqJqT53YYzk4THiZJlb3fUdFchSyI2R KSmww5uWFuU7fjtVRNAfwLYl5x1ny5XXiRUHPTAG+7J6/66R6mZ/KWdFvhFS9ed+XnBw 2mjqHdEYPhMXtjYiSEkjfSK7ndTOywzenU2Fa3QK2m8K6r6Qnm+WctyW5c2u7UjIIyGc UL9g== X-Gm-Message-State: AAQBX9f1kjyfVAVS27zpP9SkwFfkV322q94p/4o3e5vG4sTQDFwD2PQk 3yzxwxX0nwI+TEJqivtqyBhFQBhcOF0= X-Google-Smtp-Source: AKy350ZZ9Icx+O5cAn8L7UL4LyCuWNAJhMF/AQzRrb3mRpbXzhEHNdWb1PPKet4jhSmTfS5WrLVoXSBCA6Y= X-Received: from drosen.mtv.corp.google.com ([2620:15c:211:201:e67a:98b0:942d:86aa]) (user=drosen job=sendgmr) by 2002:a25:d08d:0:b0:b7c:1144:a708 with SMTP id h135-20020a25d08d000000b00b7c1144a708mr10996656ybg.12.1681782084915; Mon, 17 Apr 2023 18:41:24 -0700 (PDT) Date: Mon, 17 Apr 2023 18:40:15 -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-16-drosen@google.com> Subject: [RFC PATCH v3 15/37] fuse-bpf: Support file/dir open/close 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 , Paul Lawrence 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 backing support for FUSE_OPEN, FUSE_OPENDIR, FUSE_CREATE, FUSE_RELEASE, and FUSE_RELEASEDIR Signed-off-by: Daniel Rosenberg Signed-off-by: Paul Lawrence --- fs/fuse/backing.c | 368 ++++++++++++++++++++++++++++++++++++++++++++++ fs/fuse/dir.c | 8 + fs/fuse/file.c | 7 + fs/fuse/fuse_i.h | 26 ++++ 4 files changed, 409 insertions(+) diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c index ee315598bc3f..d4a214cadc15 100644 --- a/fs/fuse/backing.c +++ b/fs/fuse/backing.c @@ -207,6 +207,374 @@ static void fuse_stat_to_attr(struct fuse_conn *fc, s= truct inode *inode, attr->blksize =3D 1 << blkbits; } =20 +struct fuse_open_args { + struct fuse_open_in in; + struct fuse_open_out out; +}; + +static int fuse_open_initialize_in(struct bpf_fuse_args *fa, struct fuse_o= pen_args *args, + struct inode *inode, struct file *file, bool isdir) +{ + args->in =3D (struct fuse_open_in) { + .flags =3D file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY), + }; + *fa =3D (struct bpf_fuse_args) { + .info =3D (struct bpf_fuse_meta_info) { + .nodeid =3D get_fuse_inode(inode)->nodeid, + .opcode =3D isdir ? FUSE_OPENDIR : FUSE_OPEN, + }, + .in_numargs =3D 1, + .in_args[0] =3D (struct bpf_fuse_arg) { + .size =3D sizeof(args->in), + .value =3D &args->in, + }, + }; + + return 0; +} + +static int fuse_open_initialize_out(struct bpf_fuse_args *fa, struct fuse_= open_args *args, + struct inode *inode, struct file *file, bool isdir) +{ + args->out =3D (struct fuse_open_out) { 0 }; + + fa->out_numargs =3D 1; + fa->out_args[0] =3D (struct bpf_fuse_arg) { + .size =3D sizeof(args->out), + .value =3D &args->out, + }; + + return 0; +} + +static int fuse_open_backing(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct file *file, bool isdir) +{ + struct fuse_mount *fm =3D get_fuse_mount(inode); + const struct fuse_open_in *foi =3D fa->in_args[0].value; + struct fuse_file *ff; + int mask; + struct fuse_dentry *fd =3D get_fuse_dentry(file->f_path.dentry); + struct file *backing_file; + + ff =3D fuse_file_alloc(fm); + if (!ff) + return -ENOMEM; + file->private_data =3D ff; + + switch (foi->flags & O_ACCMODE) { + case O_RDONLY: + mask =3D MAY_READ; + break; + + case O_WRONLY: + mask =3D MAY_WRITE; + break; + + case O_RDWR: + mask =3D MAY_READ | MAY_WRITE; + break; + + default: + return -EINVAL; + } + + *out =3D inode_permission(&nop_mnt_idmap, + get_fuse_inode(inode)->backing_inode, mask); + if (*out) + return *out; + + backing_file =3D + dentry_open(&fd->backing_path, foi->flags, current_cred()); + + if (IS_ERR(backing_file)) { + fuse_file_free(ff); + file->private_data =3D NULL; + return PTR_ERR(backing_file); + } + ff->backing_file =3D backing_file; + + *out =3D 0; + return 0; +} + +static int fuse_open_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct file *file, bool isdir) +{ + struct fuse_file *ff =3D file->private_data; + struct fuse_open_out *foo =3D fa->out_args[0].value; + + if (ff) { + ff->fh =3D foo->fh; + ff->nodeid =3D get_fuse_inode(inode)->nodeid; + } + return 0; +} + +int fuse_bpf_open(int *out, struct inode *inode, struct file *file, bool i= sdir) +{ + return bpf_fuse_backing(inode, struct fuse_open_args, out, + fuse_open_initialize_in, fuse_open_initialize_out, + fuse_open_backing, fuse_open_finalize, + inode, file, isdir); +} + +struct fuse_create_open_args { + struct fuse_create_in in; + struct fuse_buffer name; + struct fuse_entry_out entry_out; + struct fuse_open_out open_out; +}; + +static int fuse_create_open_initialize_in(struct bpf_fuse_args *fa, struct= fuse_create_open_args *args, + struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + args->in =3D (struct fuse_create_in) { + .flags =3D file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY), + .mode =3D mode, + }; + + args->name =3D (struct fuse_buffer) { + .data =3D (void *) entry->d_name.name, + .size =3D entry->d_name.len + 1, + .flags =3D BPF_FUSE_IMMUTABLE, + }; + + *fa =3D (struct bpf_fuse_args) { + .info =3D (struct bpf_fuse_meta_info) { + .nodeid =3D get_node_id(dir), + .opcode =3D FUSE_CREATE, + }, + .in_numargs =3D 2, + .in_args[0] =3D (struct bpf_fuse_arg) { + .size =3D sizeof(args->in), + .value =3D &args->in, + }, + .in_args[1] =3D (struct bpf_fuse_arg) { + .is_buffer =3D true, + .buffer =3D &args->name, + }, + }; + + return 0; +} + +static int fuse_create_open_initialize_out(struct bpf_fuse_args *fa, struc= t fuse_create_open_args *args, + struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + args->entry_out =3D (struct fuse_entry_out) { 0 }; + args->open_out =3D (struct fuse_open_out) { 0 }; + + fa->out_numargs =3D 2; + fa->out_args[0] =3D (struct bpf_fuse_arg) { + .size =3D sizeof(args->entry_out), + .value =3D &args->entry_out, + }; + fa->out_args[1] =3D (struct bpf_fuse_arg) { + .size =3D sizeof(args->open_out), + .value =3D &args->open_out, + }; + + return 0; +} + +static int fuse_open_file_backing(struct inode *inode, struct file *file) +{ + struct fuse_mount *fm =3D get_fuse_mount(inode); + struct dentry *entry =3D file->f_path.dentry; + struct fuse_dentry *fuse_dentry =3D get_fuse_dentry(entry); + struct fuse_file *fuse_file; + struct file *backing_file; + + fuse_file =3D fuse_file_alloc(fm); + if (!fuse_file) + return -ENOMEM; + file->private_data =3D fuse_file; + + backing_file =3D dentry_open(&fuse_dentry->backing_path, file->f_flags, + current_cred()); + if (IS_ERR(backing_file)) { + fuse_file_free(fuse_file); + file->private_data =3D NULL; + return PTR_ERR(backing_file); + } + fuse_file->backing_file =3D backing_file; + + return 0; +} + +static int fuse_create_open_backing(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + struct fuse_inode *dir_fuse_inode =3D get_fuse_inode(dir); + struct path backing_path; + struct inode *inode =3D NULL; + struct dentry *backing_parent; + struct dentry *newent; + const struct fuse_create_in *fci =3D fa->in_args[0].value; + + get_fuse_backing_path(entry, &backing_path); + if (!backing_path.dentry) + return -EBADF; + + if (IS_ERR(backing_path.dentry)) + return PTR_ERR(backing_path.dentry); + + if (d_really_is_positive(backing_path.dentry)) { + *out =3D -EIO; + goto out; + } + + backing_parent =3D dget_parent(backing_path.dentry); + inode_lock_nested(dir_fuse_inode->backing_inode, I_MUTEX_PARENT); + *out =3D vfs_create(&nop_mnt_idmap, d_inode(backing_parent), + backing_path.dentry, fci->mode, true); + inode_unlock(d_inode(backing_parent)); + dput(backing_parent); + if (*out) + goto out; + + inode =3D fuse_iget_backing(dir->i_sb, 0, backing_path.dentry->d_inode); + if (IS_ERR(inode)) { + *out =3D PTR_ERR(inode); + goto out; + } + + newent =3D d_splice_alias(inode, entry); + if (IS_ERR(newent)) { + *out =3D PTR_ERR(newent); + goto out; + } + + entry =3D newent ? newent : entry; + *out =3D finish_open(file, entry, fuse_open_file_backing); + +out: + path_put(&backing_path); + return *out; +} + +static int fuse_create_open_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + struct fuse_file *ff =3D file->private_data; + struct fuse_inode *fi =3D get_fuse_inode(file->f_inode); + struct fuse_entry_out *feo =3D fa->out_args[0].value; + struct fuse_open_out *foo =3D fa->out_args[1].value; + + if (fi) + fi->nodeid =3D feo->nodeid; + if (ff) + ff->fh =3D foo->fh; + return 0; +} + +int fuse_bpf_create_open(int *out, struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + return bpf_fuse_backing(dir, struct fuse_create_open_args, out, + fuse_create_open_initialize_in, + fuse_create_open_initialize_out, + fuse_create_open_backing, + fuse_create_open_finalize, + dir, entry, file, flags, mode); +} + +static int fuse_release_initialize_in(struct bpf_fuse_args *fa, struct fus= e_release_in *fri, + struct inode *inode, struct file *file) +{ + struct fuse_file *fuse_file =3D file->private_data; + + /* Always put backing file whatever bpf/userspace says */ + fput(fuse_file->backing_file); + + *fri =3D (struct fuse_release_in) { + .fh =3D ((struct fuse_file *)(file->private_data))->fh, + }; + + *fa =3D (struct bpf_fuse_args) { + .info =3D (struct bpf_fuse_meta_info) { + .nodeid =3D get_fuse_inode(inode)->nodeid, + .opcode =3D FUSE_RELEASE, + }, .in_numargs =3D 1, + .in_args[0].size =3D sizeof(*fri), + .in_args[0].value =3D fri, + }; + + return 0; +} + +static int fuse_release_initialize_out(struct bpf_fuse_args *fa, struct fu= se_release_in *fri, + struct inode *inode, struct file *file) +{ + return 0; +} + +static int fuse_releasedir_initialize_in(struct bpf_fuse_args *fa, + struct fuse_release_in *fri, + struct inode *inode, struct file *file) +{ + struct fuse_file *fuse_file =3D file->private_data; + + /* Always put backing file whatever bpf/userspace says */ + fput(fuse_file->backing_file); + + *fri =3D (struct fuse_release_in) { + .fh =3D ((struct fuse_file *)(file->private_data))->fh, + }; + + *fa =3D (struct bpf_fuse_args) { + .info =3D (struct bpf_fuse_meta_info) { + .nodeid =3D get_fuse_inode(inode)->nodeid, + .opcode =3D FUSE_RELEASEDIR, + }, .in_numargs =3D 1, + .in_args[0].size =3D sizeof(*fri), + .in_args[0].value =3D fri, + }; + + return 0; +} + +static int fuse_releasedir_initialize_out(struct bpf_fuse_args *fa, + struct fuse_release_in *fri, + struct inode *inode, struct file *file) +{ + return 0; +} + +static int fuse_release_backing(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct file *file) +{ + return 0; +} + +static int fuse_release_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct file *file) +{ + fuse_file_free(file->private_data); + *out =3D 0; + return 0; +} + +int fuse_bpf_release(int *out, struct inode *inode, struct file *file) +{ + return bpf_fuse_backing(inode, struct fuse_release_in, out, + fuse_release_initialize_in, fuse_release_initialize_out, + fuse_release_backing, fuse_release_finalize, + inode, file); +} + +int fuse_bpf_releasedir(int *out, struct inode *inode, struct file *file) +{ + return bpf_fuse_backing(inode, struct fuse_release_in, out, + fuse_releasedir_initialize_in, fuse_releasedir_initialize_out, + fuse_release_backing, fuse_release_finalize, inode, file); +} + struct fuse_lseek_args { struct fuse_lseek_in in; struct fuse_lseek_out out; diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c index 535e6cf9e970..1df2bbc72396 100644 --- a/fs/fuse/dir.c +++ b/fs/fuse/dir.c @@ -719,6 +719,9 @@ static int fuse_create_open(struct inode *dir, struct d= entry *entry, /* Userspace expects S_IFREG in create mode */ BUG_ON((mode & S_IFMT) !=3D S_IFREG); =20 + if (fuse_bpf_create_open(&err, dir, entry, file, flags, mode)) + return err; + forget =3D fuse_alloc_forget(); err =3D -ENOMEM; if (!forget) @@ -1629,6 +1632,11 @@ static int fuse_dir_open(struct inode *inode, struct= file *file) =20 static int fuse_dir_release(struct inode *inode, struct file *file) { + int err =3D 0; + + if (fuse_bpf_releasedir(&err, inode, file)) + return err; + fuse_release_common(file, true); =20 return 0; diff --git a/fs/fuse/file.c b/fs/fuse/file.c index 58cff04660db..1836d09d9ce3 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c @@ -243,6 +243,9 @@ int fuse_open_common(struct inode *inode, struct file *= file, bool isdir) if (err) return err; =20 + if (fuse_bpf_open(&err, inode, file, isdir)) + return err; + if (is_wb_truncate || dax_truncate) inode_lock(inode); =20 @@ -351,6 +354,10 @@ static int fuse_open(struct inode *inode, struct file = *file) static int fuse_release(struct inode *inode, struct file *file) { struct fuse_conn *fc =3D get_fuse_conn(inode); + int err; + + if (fuse_bpf_release(&err, inode, file)) + return err; =20 /* * Dirty pages might remain despite write_inode_now() call from diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h index 1dd9cc9720df..feecc1ebfdda 100644 --- a/fs/fuse/fuse_i.h +++ b/fs/fuse/fuse_i.h @@ -1405,6 +1405,11 @@ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe,= int num_entries); =20 #ifdef CONFIG_FUSE_BPF =20 +int fuse_bpf_open(int *err, struct inode *inode, struct file *file, bool i= sdir); +int fuse_bpf_create_open(int *out, struct inode *dir, struct dentry *entry, + struct file *file, unsigned int flags, umode_t mode); +int fuse_bpf_release(int *out, struct inode *inode, struct file *file); +int fuse_bpf_releasedir(int *out, struct inode *inode, struct file *file); int fuse_bpf_lseek(loff_t *out, struct inode *inode, struct file *file, lo= ff_t offset, int whence); int fuse_bpf_file_fallocate(int *out, struct inode *inode, struct file *fi= le, int mode, loff_t offset, loff_t length); int fuse_bpf_lookup(struct dentry **out, struct inode *dir, struct dentry = *entry, unsigned int flags); @@ -1412,6 +1417,27 @@ int fuse_bpf_access(int *out, struct inode *inode, i= nt mask); =20 #else =20 +static inline int fuse_bpf_open(int *err, struct inode *inode, struct file= *file, bool isdir) +{ + return 0; +} + +static inline int fuse_bpf_create_open(int *out, struct inode *dir, struct= dentry *entry, + struct file *file, unsigned int flags, umode_t mode) +{ + return 0; +} + +static inline int fuse_bpf_release(int *out, struct inode *inode, struct f= ile *file) +{ + return 0; +} + +static inline int fuse_bpf_releasedir(int *out, struct inode *inode, struc= t file *file) +{ + return 0; +} + static inline int fuse_bpf_lseek(loff_t *out, struct inode *inode, struct = file *file, loff_t offset, int whence) { return 0; --=20 2.40.0.634.g4ca3ef3211-goog