From nobody Wed Feb 11 23:47:59 2026 Received: from mail-yw1-f202.google.com (mail-yw1-f202.google.com [209.85.128.202]) (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 688E73FB93 for ; Fri, 29 Mar 2024 01:54:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711677266; cv=none; b=By8YfGiPlzdkiuQ3SiI92ydqXUvVzUuJvyo5KlGPwBQR7xH5V02ky5MSlKyYD+UJ8gst8GMBlVI1FQz5PUOa1WmVsFMQSBKf8WS6k3210jd8aJ/YlAd94iw4YNFHIG9yYjq1DHNms9/JY+XR5E52A9l7yvGDTw4z4M0wSUZQFos= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711677266; c=relaxed/simple; bh=Fkk92+rnt1CGnhyzsoVnRC9lfBnZyOPhYO5QkWWNTvQ=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=fJZEtCvpj5Q5+W64mgLWndS/WYOrMVoaOSDvvIqmAVxEaW9f9nFQ95BzLoBp2z7q6Sv9dY7neY3oBV3d1kCLYKvM2gssGj/pTNFOWAsiV/S+MgX4exGVYNXo8Yw+kkqoDfUWD8GXKxCb2yckmtswlidaDMSGSJHoY09yXCc9jks= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--drosen.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=IjaSbV0p; arc=none smtp.client-ip=209.85.128.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--drosen.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="IjaSbV0p" Received: by mail-yw1-f202.google.com with SMTP id 00721157ae682-60ccc3cfa39so27855717b3.2 for ; Thu, 28 Mar 2024 18:54:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1711677263; x=1712282063; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=MrUtVK6+k7+1QZ3C4cNIecBhDWMks4vBEWUta1bw0HE=; b=IjaSbV0pq+ZhIw2JDU9172KAypV2z/sAra6GyIXNHfPWa6tVO4zVGBqjrbOBbKPFSJ NRW0P9HACSxAwJbXWDFWirAtHpO80z7DRd8i/xYssYH1cINthA84h7Cq2dte/Oh2VTu0 5nrki2MngvFok2xGhao6GGN/nmLqvylB/AXRcSBJGYmnD7ofI20RcWR+pgvRMYqvWyGz zj//82gNuLlrf8M5r9rJb9dwXnBH9Vz4TEBTN2UmwWURCcNHKLIc6k2NxHqDKjKGSkiD IYz8CqtACNItAXKUGYH7AKJ71FyKfMCKpXQqmkCW+H2Tlo4FvwtZiOUYasyelJmIHRpB cZog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1711677263; x=1712282063; 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=MrUtVK6+k7+1QZ3C4cNIecBhDWMks4vBEWUta1bw0HE=; b=OF1EE2iUQvPgmUioXqyeyEJfySBbTvXsrpYX78REtRwRm6NgQ9fd1tNojaRBLPUmIG /SberKvmvrAOVOzK8Oxu36oamUeNlT3YPMdKrnB2qFoXYTNdfhCuYJra2cvsHQnke8lq SRaqyXGv8HpKzLJWGjh/xFwTfx4MkqikcWOJmb96HwINQ+hTPGhWvmsKBKdd5NT3cf7v M9DKd8LMhnMjgLIez4ucwgjkmAeJxVx19j20lIp6R5tDNse4lQE0NSNAVX+Izw/5eERR TELXoSeLOvVUjAH5PosaNIak+Mn5NNobkLHiMcbhhX/Zime04kHqHFzROboHpL4veYK+ imkg== X-Forwarded-Encrypted: i=1; AJvYcCU3Thpm3JfOhU528rCUjcQMUpAJX1l5mcMPv49INikte3w2FSf5BmVEND8sCGCRVKP5ecZk6jJ1kPMwJ+Fy+c1qiI0yMpGKjyeaoO+C X-Gm-Message-State: AOJu0Yzap93sOiy2T9xd4cbA+TxXoZKX3E5nxNnPIrloXs6k2O1xOVKi 9QC+hyOOfsrD/ugqUxWibsBoz0c8uTzjYcStUcY3RLnJff1QUdKdMwmARhKFZ0ix9TTqXTU585w ujg== X-Google-Smtp-Source: AGHT+IHUlRTQe/24H5Rd3XUF8D0L0jK5ORat1YiNu2Hnuiw60ohY9AVaFKP7PVzv+457HzOJe+gS/LwEsZk= X-Received: from drosen.mtv.corp.google.com ([2620:15c:211:201:fcce:d6ab:804c:b94b]) (user=drosen job=sendgmr) by 2002:a81:f910:0:b0:611:7166:1a4d with SMTP id x16-20020a81f910000000b0061171661a4dmr302696ywm.3.1711677263590; Thu, 28 Mar 2024 18:54:23 -0700 (PDT) Date: Thu, 28 Mar 2024 18:53:26 -0700 In-Reply-To: <20240329015351.624249-1-drosen@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20240329015351.624249-1-drosen@google.com> X-Mailer: git-send-email 2.44.0.478.gd926399ef9-goog Message-ID: <20240329015351.624249-12-drosen@google.com> Subject: [RFC PATCH v4 11/36] 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 , Eduard Zingerman , Yonghong Song , KP Singh , Stanislav Fomichev , Hao Luo , Jiri Olsa , Shuah Khan , Jonathan Corbet , Joanne Koong , Mykola Lysenko , Christian Brauner , kernel-team@android.com, Daniel Rosenberg , Paul Lawrence 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 | 336 ++++++++++++++++++++++++++++++++++++++++++++++ fs/fuse/dir.c | 3 + fs/fuse/file.c | 62 +++++---- fs/fuse/fuse_i.h | 26 ++++ 4 files changed, 404 insertions(+), 23 deletions(-) diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c index 4a22465ecdef..317a3adbbb3e 100644 --- a/fs/fuse/backing.c +++ b/fs/fuse/backing.c @@ -210,6 +210,342 @@ 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 (!inode) { + *out =3D -EIO; + goto out; + } + + newent =3D d_splice_alias(inode, entry); + if (IS_ERR(newent)) { + *out =3D PTR_ERR(newent); + goto out; + } + + inode =3D NULL; + entry =3D newent ? newent : entry; + *out =3D finish_open(file, entry, fuse_open_file_backing); + +out: + iput(inode); + 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 fuse_file *ff) +{ + /* Always put backing file whatever bpf/userspace says */ + fput(ff->backing_file); + + *fri =3D (struct fuse_release_in) { + .fh =3D ff->fh, + }; + + *fa =3D (struct bpf_fuse_args) { + .info =3D (struct bpf_fuse_meta_info) { + .nodeid =3D get_fuse_inode(inode)->nodeid, + .opcode =3D S_ISDIR(inode->i_mode) ? FUSE_RELEASEDIR + : 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 fuse_file *ff) +{ + return 0; +} + +static int fuse_release_backing(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct fuse_file *ff) +{ + return 0; +} + +static int fuse_release_finalize(struct bpf_fuse_args *fa, int *out, + struct inode *inode, struct fuse_file *ff) +{ + *out =3D 0; + return 0; +} + +int fuse_bpf_release(int *out, struct inode *inode, struct fuse_file *ff) +{ + 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, ff); +} + +int fuse_bpf_releasedir(int *out, struct inode *inode, struct fuse_file *f= f) +{ + 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, ff); +} + 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 8db6eb6a0848..09bb4c63fd71 100644 --- a/fs/fuse/dir.c +++ b/fs/fuse/dir.c @@ -736,6 +736,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) diff --git a/fs/fuse/file.c b/fs/fuse/file.c index 0ab882e1236a..c43f2d61c41a 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c @@ -106,25 +106,35 @@ static void fuse_release_end(struct fuse_mount *fm, s= truct fuse_args *args, kfree(ra); } =20 -static void fuse_file_put(struct fuse_file *ff, bool sync, bool isdir) +static void fuse_file_put(struct inode *inode, struct fuse_file *ff, + bool sync, bool isdir) { - if (refcount_dec_and_test(&ff->count)) { - struct fuse_args *args =3D &ff->release_args->args; + struct fuse_args *args =3D &ff->release_args->args; +#ifdef CONFIG_FUSE_BPF + int err; +#endif + if (!refcount_dec_and_test(&ff->count)) + return; =20 - if (isdir ? ff->fm->fc->no_opendir : ff->fm->fc->no_open) { - /* Do nothing when client does not implement 'open' */ - fuse_release_end(ff->fm, args, 0); - } else if (sync) { - fuse_simple_request(ff->fm, args); - fuse_release_end(ff->fm, args, 0); - } else { - args->end =3D fuse_release_end; - if (fuse_simple_background(ff->fm, args, - GFP_KERNEL | __GFP_NOFAIL)) - fuse_release_end(ff->fm, args, -ENOTCONN); - } - kfree(ff); +#ifdef CONFIG_FUSE_BPF + if (fuse_bpf_releasedir(&err, inode, ff)) { + fuse_release_end(ff->fm, args, 0); + } else +#endif + + if (isdir ? ff->fm->fc->no_opendir : ff->fm->fc->no_open) { + /* Do nothing when client does not implement 'open' */ + fuse_release_end(ff->fm, args, 0); + } else if (sync) { + fuse_simple_request(ff->fm, args); + fuse_release_end(ff->fm, args, 0); + } else { + args->end =3D fuse_release_end; + if (fuse_simple_background(ff->fm, args, + GFP_KERNEL | __GFP_NOFAIL)) + fuse_release_end(ff->fm, args, -ENOTCONN); } + kfree(ff); } =20 struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid, @@ -243,6 +253,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 @@ -334,7 +347,7 @@ void fuse_file_release(struct inode *inode, struct fuse= _file *ff, * synchronous RELEASE is allowed (and desirable) in this case * because the server can be trusted not to screw up. */ - fuse_file_put(ff, ff->fm->fc->destroy, isdir); + fuse_file_put(ra->inode, ff, ff->fm->fc->destroy, isdir); } =20 void fuse_release_common(struct file *file, bool isdir) @@ -374,7 +387,7 @@ void fuse_sync_release(struct fuse_inode *fi, struct fu= se_file *ff, * iput(NULL) is a no-op and since the refcount is 1 and everything's * synchronous, we are fine with not doing igrab() here" */ - fuse_file_put(ff, true, false); + fuse_file_put(&fi->inode, ff, true, false); } EXPORT_SYMBOL_GPL(fuse_sync_release); =20 @@ -930,8 +943,11 @@ static void fuse_readpages_end(struct fuse_mount *fm, = struct fuse_args *args, unlock_page(page); put_page(page); } - if (ia->ff) - fuse_file_put(ia->ff, false, false); + if (ia->ff) { + WARN_ON(!mapping); + fuse_file_put(mapping ? mapping->host : NULL, ia->ff, + false, false); + } =20 fuse_io_free(ia); } @@ -1673,7 +1689,7 @@ static void fuse_writepage_free(struct fuse_writepage= _args *wpa) __free_page(ap->pages[i]); =20 if (wpa->ia.ff) - fuse_file_put(wpa->ia.ff, false, false); + fuse_file_put(wpa->inode, wpa->ia.ff, false, false); =20 kfree(ap->pages); kfree(wpa); @@ -1928,7 +1944,7 @@ int fuse_write_inode(struct inode *inode, struct writ= eback_control *wbc) ff =3D __fuse_write_file_get(fi); err =3D fuse_flush_times(inode, ff); if (ff) - fuse_file_put(ff, false, false); + fuse_file_put(inode, ff, false, false); =20 return err; } @@ -2326,7 +2342,7 @@ static int fuse_writepages(struct address_space *mapp= ing, fuse_writepages_send(&data); } if (data.ff) - fuse_file_put(data.ff, false, false); + fuse_file_put(inode, data.ff, false, false); =20 kfree(data.orig_pages); out: diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h index 7a6cebecd00f..a133010fde1c 100644 --- a/fs/fuse/fuse_i.h +++ b/fs/fuse/fuse_i.h @@ -1438,6 +1438,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 fuse_file *ff); +int fuse_bpf_releasedir(int *out, struct inode *inode, struct fuse_file *f= f); 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); @@ -1445,6 +1450,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.44.0.478.gd926399ef9-goog