1// SPDX-License-Identifier: GPL-2.0
2/*
3 * FUSE passthrough to backing file.
4 *
5 * Copyright (c) 2023 CTERA Networks.
6 */
7
8#include "fuse_i.h"
9
10#include <linux/file.h>
11#include <linux/backing-file.h>
12#include <linux/splice.h>
13
14static void fuse_file_accessed(struct file *file)
15{
16 struct inode *inode = file_inode(f: file);
17
18 fuse_invalidate_atime(inode);
19}
20
21static void fuse_passthrough_end_write(struct kiocb *iocb, ssize_t ret)
22{
23 struct inode *inode = file_inode(f: iocb->ki_filp);
24
25 fuse_write_update_attr(inode, pos: iocb->ki_pos, written: ret);
26}
27
28ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter)
29{
30 struct file *file = iocb->ki_filp;
31 struct fuse_file *ff = file->private_data;
32 struct file *backing_file = fuse_file_passthrough(ff);
33 size_t count = iov_iter_count(i: iter);
34 ssize_t ret;
35 struct backing_file_ctx ctx = {
36 .cred = ff->cred,
37 .accessed = fuse_file_accessed,
38 };
39
40
41 pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu\n", __func__,
42 backing_file, iocb->ki_pos, count);
43
44 if (!count)
45 return 0;
46
47 ret = backing_file_read_iter(file: backing_file, iter, iocb, flags: iocb->ki_flags,
48 ctx: &ctx);
49
50 return ret;
51}
52
53ssize_t fuse_passthrough_write_iter(struct kiocb *iocb,
54 struct iov_iter *iter)
55{
56 struct file *file = iocb->ki_filp;
57 struct inode *inode = file_inode(f: file);
58 struct fuse_file *ff = file->private_data;
59 struct file *backing_file = fuse_file_passthrough(ff);
60 size_t count = iov_iter_count(i: iter);
61 ssize_t ret;
62 struct backing_file_ctx ctx = {
63 .cred = ff->cred,
64 .end_write = fuse_passthrough_end_write,
65 };
66
67 pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu\n", __func__,
68 backing_file, iocb->ki_pos, count);
69
70 if (!count)
71 return 0;
72
73 inode_lock(inode);
74 ret = backing_file_write_iter(file: backing_file, iter, iocb, flags: iocb->ki_flags,
75 ctx: &ctx);
76 inode_unlock(inode);
77
78 return ret;
79}
80
81ssize_t fuse_passthrough_splice_read(struct file *in, loff_t *ppos,
82 struct pipe_inode_info *pipe,
83 size_t len, unsigned int flags)
84{
85 struct fuse_file *ff = in->private_data;
86 struct file *backing_file = fuse_file_passthrough(ff);
87 struct backing_file_ctx ctx = {
88 .cred = ff->cred,
89 .accessed = fuse_file_accessed,
90 };
91 struct kiocb iocb;
92 ssize_t ret;
93
94 pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu, flags=0x%x\n", __func__,
95 backing_file, *ppos, len, flags);
96
97 init_sync_kiocb(kiocb: &iocb, filp: in);
98 iocb.ki_pos = *ppos;
99 ret = backing_file_splice_read(in: backing_file, iocb: &iocb, pipe, len, flags, ctx: &ctx);
100 *ppos = iocb.ki_pos;
101
102 return ret;
103}
104
105ssize_t fuse_passthrough_splice_write(struct pipe_inode_info *pipe,
106 struct file *out, loff_t *ppos,
107 size_t len, unsigned int flags)
108{
109 struct fuse_file *ff = out->private_data;
110 struct file *backing_file = fuse_file_passthrough(ff);
111 struct inode *inode = file_inode(f: out);
112 ssize_t ret;
113 struct backing_file_ctx ctx = {
114 .cred = ff->cred,
115 .end_write = fuse_passthrough_end_write,
116 };
117 struct kiocb iocb;
118
119 pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu, flags=0x%x\n", __func__,
120 backing_file, *ppos, len, flags);
121
122 inode_lock(inode);
123 init_sync_kiocb(kiocb: &iocb, filp: out);
124 iocb.ki_pos = *ppos;
125 ret = backing_file_splice_write(pipe, out: backing_file, iocb: &iocb, len, flags, ctx: &ctx);
126 *ppos = iocb.ki_pos;
127 inode_unlock(inode);
128
129 return ret;
130}
131
132ssize_t fuse_passthrough_mmap(struct file *file, struct vm_area_struct *vma)
133{
134 struct fuse_file *ff = file->private_data;
135 struct file *backing_file = fuse_file_passthrough(ff);
136 struct backing_file_ctx ctx = {
137 .cred = ff->cred,
138 .accessed = fuse_file_accessed,
139 };
140
141 pr_debug("%s: backing_file=0x%p, start=%lu, end=%lu\n", __func__,
142 backing_file, vma->vm_start, vma->vm_end);
143
144 return backing_file_mmap(file: backing_file, vma, ctx: &ctx);
145}
146
147/*
148 * Setup passthrough to a backing file.
149 *
150 * Returns an fb object with elevated refcount to be stored in fuse inode.
151 */
152struct fuse_backing *fuse_passthrough_open(struct file *file, int backing_id)
153{
154 struct fuse_file *ff = file->private_data;
155 struct fuse_conn *fc = ff->fm->fc;
156 struct fuse_backing *fb = NULL;
157 struct file *backing_file;
158 int err;
159
160 err = -EINVAL;
161 if (backing_id <= 0)
162 goto out;
163
164 err = -ENOENT;
165 fb = fuse_backing_lookup(fc, backing_id);
166 if (!fb)
167 goto out;
168
169 /* Allocate backing file per fuse file to store fuse path */
170 backing_file = backing_file_open(user_path: &file->f_path, flags: file->f_flags,
171 real_path: &fb->file->f_path, cred: fb->cred);
172 err = PTR_ERR(ptr: backing_file);
173 if (IS_ERR(ptr: backing_file)) {
174 fuse_backing_put(fb);
175 goto out;
176 }
177
178 err = 0;
179 ff->passthrough = backing_file;
180 ff->cred = get_cred(cred: fb->cred);
181out:
182 pr_debug("%s: backing_id=%d, fb=0x%p, backing_file=0x%p, err=%i\n", __func__,
183 backing_id, fb, ff->passthrough, err);
184
185 return err ? ERR_PTR(error: err) : fb;
186}
187
188void fuse_passthrough_release(struct fuse_file *ff, struct fuse_backing *fb)
189{
190 pr_debug("%s: fb=0x%p, backing_file=0x%p\n", __func__,
191 fb, ff->passthrough);
192
193 fput(ff->passthrough);
194 ff->passthrough = NULL;
195 put_cred(cred: ff->cred);
196 ff->cred = NULL;
197}
198

source code of linux/fs/fuse/passthrough.c