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 A7978C77B75 for ; Tue, 18 Apr 2023 01:43:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229510AbjDRBnW (ORCPT ); Mon, 17 Apr 2023 21:43:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53878 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230331AbjDRBma (ORCPT ); Mon, 17 Apr 2023 21:42:30 -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 A0F067EF2 for ; Mon, 17 Apr 2023 18:41:34 -0700 (PDT) Received: by mail-yb1-xb4a.google.com with SMTP id d132-20020a254f8a000000b00b868826cdfeso2898062ybb.0 for ; Mon, 17 Apr 2023 18:41:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1681782087; x=1684374087; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=NDDGgrzSklW9PeQhCnnSrKGQK+GKlru6fDSS3O5BjmA=; b=ZH5Or0LVxK0ACl0MYkteAzESD99/7Y6eEY7bCBEA2/UuGiSKlZfZQrdX8//nPc5nnK aJRB9zReYRfrzP6d9Tm5nolDNIPFi0ZArQix6zL92mKogJZGyyJ4PoxLe7+MZrdvb9wO kQzhsjswf9u1btEBhZRZNqtsp1rTkCG+uQxMOSb7QE3FpkXqeV2NOwqoXk4OAg1om9pg xbA94KAfpNG9a0xgBppvH0P/oMFCe049pKZOYRMru06j+Wx//wEy38p0FUuAuX2U+8I7 MW5H+7BpQvPjjs+oyFzPJ+0Ar9sgfNJqCfxtarg9uNdtUS4R8CyMoCC4J77InmpYcLjF bTpA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1681782087; x=1684374087; 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=NDDGgrzSklW9PeQhCnnSrKGQK+GKlru6fDSS3O5BjmA=; b=jvaYPEkWtl10HP/9VT4vGa3P1eDyRLs/73jmpBDwpEAqVnCUQ3tpPFpBtfGU6hJxqo la94Q6BgTKoUL/jx6MTxBFcgjDfk/DA8SKxymh1JqXo/htGeTcgPgz6WIFeFqa081W0G /vwVDtMNMTylgE5DreAo4H5T36zlX0Tx68ZkO8D2X51oGqWkfcCXGTOqf4fkqUnF+g2g YrStMrbnXBGKjOQRyFoIkwFMFeIWUYcXaCaS5QvDloleaUeM7iR8rfYBQldHXab2Nzdw 9NVzJxY2R3rYhDGFZ+Xiq5MdQpRU+uh0RrFCPnEiCmwtfeeusZZXFZ+KTIEGg6uqnDAU vh+g== X-Gm-Message-State: AAQBX9dRfmOXR1BkfRG7wR3hiSCctlocmStsg5feQIa4Q5xXtous3MWW m6z/KPWZ3t6cuFt101NwHuyZsrGSAx0= X-Google-Smtp-Source: AKy350b2QTc7qTknU5iRQ/AMnSRDgnYtVdT/oLHx5r2YmfDH4vM6DkZ756se8OX1GhvWk/AZEjOfYn0mUv0= X-Received: from drosen.mtv.corp.google.com ([2620:15c:211:201:e67a:98b0:942d:86aa]) (user=drosen job=sendgmr) by 2002:a25:d8c1:0:b0:b8b:f594:d512 with SMTP id p184-20020a25d8c1000000b00b8bf594d512mr8744186ybg.13.1681782087328; Mon, 17 Apr 2023 18:41:27 -0700 (PDT) Date: Mon, 17 Apr 2023 18:40:16 -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-17-drosen@google.com> Subject: [RFC PATCH v3 16/37] fuse-bpf: Support mknod/unlink/mkdir/rmdir 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_MKNOD, FUSE_MKDIR, FUSE_RMDIR, and FUSE_UNLINK Signed-off-by: Daniel Rosenberg Signed-off-by: Paul Lawrence --- fs/fuse/backing.c | 342 ++++++++++++++++++++++++++++++++++++++++++++++ fs/fuse/dir.c | 14 ++ fs/fuse/fuse_i.h | 24 ++++ 3 files changed, 380 insertions(+) diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c index d4a214cadc15..c6ef10aeec15 100644 --- a/fs/fuse/backing.c +++ b/fs/fuse/backing.c @@ -972,6 +972,348 @@ int fuse_revalidate_backing(struct dentry *entry, uns= igned int flags) return 1; } =20 +struct fuse_mknod_args { + struct fuse_mknod_in in; + struct fuse_buffer name; +}; + +static int fuse_mknod_initialize_in(struct bpf_fuse_args *fa, struct fuse_= mknod_args *args, + struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) +{ + *args =3D (struct fuse_mknod_args) { + .in =3D (struct fuse_mknod_in) { + .mode =3D mode, + .rdev =3D new_encode_dev(rdev), + .umask =3D current_umask(), + }, + .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_MKNOD, + }, + .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_mknod_initialize_out(struct bpf_fuse_args *fa, struct fuse= _mknod_args *args, + struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) +{ + return 0; +} + +static int fuse_mknod_backing(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, umode_t mode, dev_t rdev) +{ + const struct fuse_mknod_in *fmi =3D fa->in_args[0].value; + struct fuse_inode *fuse_inode =3D get_fuse_inode(dir); + struct inode *backing_inode =3D fuse_inode->backing_inode; + struct path backing_path; + struct inode *inode =3D NULL; + + get_fuse_backing_path(entry, &backing_path); + if (!backing_path.dentry) + return -EBADF; + + inode_lock_nested(backing_inode, I_MUTEX_PARENT); + mode =3D fmi->mode; + if (!IS_POSIXACL(backing_inode)) + mode &=3D ~fmi->umask; + *out =3D vfs_mknod(&nop_mnt_idmap, backing_inode, backing_path.dentry, mo= de, + new_decode_dev(fmi->rdev)); + inode_unlock(backing_inode); + if (*out) + goto out; + if (d_really_is_negative(backing_path.dentry) || + unlikely(d_unhashed(backing_path.dentry))) { + *out =3D -EINVAL; + /** + * TODO: overlayfs responds to this situation with a + * lookupOneLen. Should we do that too? + */ + goto out; + } + inode =3D fuse_iget_backing(dir->i_sb, fuse_inode->nodeid, backing_inode); + if (IS_ERR(inode)) { + *out =3D PTR_ERR(inode); + goto out; + } + d_instantiate(entry, inode); +out: + path_put(&backing_path); + return *out; +} + +static int fuse_mknod_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, umode_t mode, dev_t rde= v) +{ + return 0; +} + +int fuse_bpf_mknod(int *out, struct inode *dir, struct dentry *entry, umod= e_t mode, dev_t rdev) +{ + return bpf_fuse_backing(dir, struct fuse_mknod_args, out, + fuse_mknod_initialize_in, fuse_mknod_initialize_out, + fuse_mknod_backing, fuse_mknod_finalize, + dir, entry, mode, rdev); +} + +struct fuse_mkdir_args { + struct fuse_mkdir_in in; + struct fuse_buffer name; +}; + +static int fuse_mkdir_initialize_in(struct bpf_fuse_args *fa, struct fuse_= mkdir_args *args, + struct inode *dir, struct dentry *entry, umode_t mode) +{ + *args =3D (struct fuse_mkdir_args) { + .in =3D (struct fuse_mkdir_in) { + .mode =3D mode, + .umask =3D current_umask(), + }, + .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_MKDIR, + }, + .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) { + .value =3D &args->name, + .is_buffer =3D true, + }, + }; + + return 0; +} + +static int fuse_mkdir_initialize_out(struct bpf_fuse_args *fa, struct fuse= _mkdir_args *args, + struct inode *dir, struct dentry *entry, umode_t mode) +{ + return 0; +} + +static int fuse_mkdir_backing(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, umode_t mode) +{ + const struct fuse_mkdir_in *fmi =3D fa->in_args[0].value; + struct fuse_inode *fuse_inode =3D get_fuse_inode(dir); + struct inode *backing_inode =3D fuse_inode->backing_inode; + struct path backing_path; + struct inode *inode =3D NULL; + struct dentry *d; + + get_fuse_backing_path(entry, &backing_path); + if (!backing_path.dentry) + return -EBADF; + + inode_lock_nested(backing_inode, I_MUTEX_PARENT); + mode =3D fmi->mode; + if (!IS_POSIXACL(backing_inode)) + mode &=3D ~fmi->umask; + *out =3D vfs_mkdir(&nop_mnt_idmap, backing_inode, backing_path.dentry, + mode); + if (*out) + goto out; + if (d_really_is_negative(backing_path.dentry) || + unlikely(d_unhashed(backing_path.dentry))) { + d =3D lookup_one_len(entry->d_name.name, + backing_path.dentry->d_parent, + entry->d_name.len); + if (IS_ERR(d)) { + *out =3D PTR_ERR(d); + goto out; + } + dput(backing_path.dentry); + backing_path.dentry =3D d; + } + inode =3D fuse_iget_backing(dir->i_sb, fuse_inode->nodeid, backing_inode); + if (IS_ERR(inode)) { + *out =3D PTR_ERR(inode); + goto out; + } + d_instantiate(entry, inode); +out: + inode_unlock(backing_inode); + path_put(&backing_path); + return *out; +} + +static int fuse_mkdir_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry, umode_t mode) +{ + return 0; +} + +int fuse_bpf_mkdir(int *out, struct inode *dir, struct dentry *entry, umod= e_t mode) +{ + return bpf_fuse_backing(dir, struct fuse_mkdir_args, out, + fuse_mkdir_initialize_in, fuse_mkdir_initialize_out, + fuse_mkdir_backing, fuse_mkdir_finalize, + dir, entry, mode); +} + +static int fuse_rmdir_initialize_in(struct bpf_fuse_args *fa, struct fuse_= buffer *name, + struct inode *dir, struct dentry *entry) +{ + *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_RMDIR, + }, + .in_numargs =3D 1, + .in_args[0] =3D (struct bpf_fuse_arg) { + .is_buffer =3D true, + .buffer =3D name, + }, + }; + + return 0; +} + +static int fuse_rmdir_initialize_out(struct bpf_fuse_args *fa, struct fuse= _buffer *name, + struct inode *dir, struct dentry *entry) +{ + return 0; +} + +static int fuse_rmdir_backing(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry) +{ + struct path backing_path; + struct dentry *backing_parent_dentry; + struct inode *backing_inode; + + get_fuse_backing_path(entry, &backing_path); + if (!backing_path.dentry) + return -EBADF; + + backing_parent_dentry =3D dget_parent(backing_path.dentry); + backing_inode =3D d_inode(backing_parent_dentry); + + inode_lock_nested(backing_inode, I_MUTEX_PARENT); + *out =3D vfs_rmdir(&nop_mnt_idmap, backing_inode, backing_path.dentry); + inode_unlock(backing_inode); + + dput(backing_parent_dentry); + if (!*out) + d_drop(entry); + path_put(&backing_path); + return *out; +} + +static int fuse_rmdir_finalize(struct bpf_fuse_args *fa, int *out, struct = inode *dir, struct dentry *entry) +{ + return 0; +} + +int fuse_bpf_rmdir(int *out, struct inode *dir, struct dentry *entry) +{ + return bpf_fuse_backing(dir, struct fuse_buffer, out, + fuse_rmdir_initialize_in, fuse_rmdir_initialize_out, + fuse_rmdir_backing, fuse_rmdir_finalize, + dir, entry); +} + +static int fuse_unlink_initialize_in(struct bpf_fuse_args *fa, struct fuse= _buffer *name, + struct inode *dir, struct dentry *entry) +{ + *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_UNLINK, + }, + .in_numargs =3D 1, + .in_args[0] =3D (struct bpf_fuse_arg) { + .is_buffer =3D true, + .buffer =3D name, + }, + }; + + return 0; +} + +static int fuse_unlink_initialize_out(struct bpf_fuse_args *fa, struct fus= e_buffer *name, + struct inode *dir, struct dentry *entry) +{ + return 0; +} + +static int fuse_unlink_backing(struct bpf_fuse_args *fa, int *out, struct = inode *dir, struct dentry *entry) +{ + struct path backing_path; + struct dentry *backing_parent_dentry; + struct inode *backing_inode; + + get_fuse_backing_path(entry, &backing_path); + if (!backing_path.dentry) + return -EBADF; + + /* TODO Not sure if we should reverify like overlayfs, or get inode from = d_parent */ + backing_parent_dentry =3D dget_parent(backing_path.dentry); + backing_inode =3D d_inode(backing_parent_dentry); + + inode_lock_nested(backing_inode, I_MUTEX_PARENT); + *out =3D vfs_unlink(&nop_mnt_idmap, backing_inode, backing_path.dentry, + NULL); + inode_unlock(backing_inode); + + dput(backing_parent_dentry); + if (!*out) + d_drop(entry); + path_put(&backing_path); + return *out; +} + +static int fuse_unlink_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *dir, struct dentry *entry) +{ + return 0; +} + +int fuse_bpf_unlink(int *out, struct inode *dir, struct dentry *entry) +{ + return bpf_fuse_backing(dir, struct fuse_buffer, out, + fuse_unlink_initialize_in, fuse_unlink_initialize_out, + fuse_unlink_backing, fuse_unlink_finalize, + dir, entry); +} + static int fuse_access_initialize_in(struct bpf_fuse_args *fa, struct fuse= _access_in *in, struct inode *inode, int mask) { diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c index 1df2bbc72396..a763a45fa973 100644 --- a/fs/fuse/dir.c +++ b/fs/fuse/dir.c @@ -937,6 +937,10 @@ static int fuse_mknod(struct mnt_idmap *idmap, struct = inode *dir, struct fuse_mknod_in inarg; struct fuse_mount *fm =3D get_fuse_mount(dir); FUSE_ARGS(args); + int err; + + if (fuse_bpf_mknod(&err, dir, entry, mode, rdev)) + return err; =20 if (!fm->fc->dont_mask) mode &=3D ~current_umask(); @@ -983,6 +987,10 @@ static int fuse_mkdir(struct mnt_idmap *idmap, struct = inode *dir, struct fuse_mkdir_in inarg; struct fuse_mount *fm =3D get_fuse_mount(dir); FUSE_ARGS(args); + int err; + + if (fuse_bpf_mkdir(&err, dir, entry, mode)) + return err; =20 if (!fm->fc->dont_mask) mode &=3D ~current_umask(); @@ -1069,6 +1077,9 @@ static int fuse_unlink(struct inode *dir, struct dent= ry *entry) if (fuse_is_bad(dir)) return -EIO; =20 + if (fuse_bpf_unlink(&err, dir, entry)) + return err; + args.opcode =3D FUSE_UNLINK; args.nodeid =3D get_node_id(dir); args.in_numargs =3D 1; @@ -1092,6 +1103,9 @@ static int fuse_rmdir(struct inode *dir, struct dentr= y *entry) if (fuse_is_bad(dir)) return -EIO; =20 + if (fuse_bpf_rmdir(&err, dir, entry)) + return err; + args.opcode =3D FUSE_RMDIR; args.nodeid =3D get_node_id(dir); args.in_numargs =3D 1; diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h index feecc1ebfdda..2cbe232c1048 100644 --- a/fs/fuse/fuse_i.h +++ b/fs/fuse/fuse_i.h @@ -1408,6 +1408,10 @@ int parse_fuse_bpf_entry(struct fuse_bpf_entry *fbe,= int num_entries); 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_mknod(int *out, struct inode *dir, struct dentry *entry, umod= e_t mode, dev_t rdev); +int fuse_bpf_mkdir(int *out, struct inode *dir, struct dentry *entry, umod= e_t mode); +int fuse_bpf_rmdir(int *out, struct inode *dir, struct dentry *entry); +int fuse_bpf_unlink(int *out, struct inode *dir, struct dentry *entry); 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); @@ -1428,6 +1432,26 @@ static inline int fuse_bpf_create_open(int *out, str= uct inode *dir, struct dentr return 0; } =20 +static inline int fuse_bpf_mknod(int *out, struct inode *dir, struct dentr= y *entry, umode_t mode, dev_t rdev) +{ + return 0; +} + +static inline int fuse_bpf_mkdir(int *out, struct inode *dir, struct dentr= y *entry, umode_t mode) +{ + return 0; +} + +static inline int fuse_bpf_rmdir(int *out, struct inode *dir, struct dentr= y *entry) +{ + return 0; +} + +static inline int fuse_bpf_unlink(int *out, struct inode *dir, struct dent= ry *entry) +{ + return 0; +} + static inline int fuse_bpf_release(int *out, struct inode *inode, struct f= ile *file) { return 0; --=20 2.40.0.634.g4ca3ef3211-goog