1 // SPDX-License-Identifier: GPL-2.0
2
3 #include "fuse_i.h"
4
5 #include <linux/fuse.h>
6 #include <linux/idr.h>
7 #include <linux/uio.h>
8
9 #define PASSTHROUGH_IOCB_MASK \
10 (IOCB_APPEND | IOCB_DSYNC | IOCB_HIPRI | IOCB_NOWAIT | IOCB_SYNC)
11
12 struct fuse_aio_req {
13 struct kiocb iocb;
14 struct kiocb *iocb_fuse;
15 };
16
fuse_file_accessed(struct file * dst_file,struct file * src_file)17 static void fuse_file_accessed(struct file *dst_file, struct file *src_file)
18 {
19 struct inode *dst_inode;
20 struct inode *src_inode;
21
22 if (dst_file->f_flags & O_NOATIME)
23 return;
24
25 dst_inode = file_inode(dst_file);
26 src_inode = file_inode(src_file);
27
28 if ((!timespec64_equal(&dst_inode->i_mtime, &src_inode->i_mtime) ||
29 !timespec64_equal(&dst_inode->i_ctime, &src_inode->i_ctime))) {
30 dst_inode->i_mtime = src_inode->i_mtime;
31 dst_inode->i_ctime = src_inode->i_ctime;
32 }
33
34 touch_atime(&dst_file->f_path);
35 }
36
fuse_copyattr(struct file * dst_file,struct file * src_file)37 void fuse_copyattr(struct file *dst_file, struct file *src_file)
38 {
39 struct inode *dst = file_inode(dst_file);
40 struct inode *src = file_inode(src_file);
41
42 dst->i_atime = src->i_atime;
43 dst->i_mtime = src->i_mtime;
44 dst->i_ctime = src->i_ctime;
45 i_size_write(dst, i_size_read(src));
46 }
47
fuse_aio_cleanup_handler(struct fuse_aio_req * aio_req)48 static void fuse_aio_cleanup_handler(struct fuse_aio_req *aio_req)
49 {
50 struct kiocb *iocb = &aio_req->iocb;
51 struct kiocb *iocb_fuse = aio_req->iocb_fuse;
52
53 if (iocb->ki_flags & IOCB_WRITE) {
54 __sb_writers_acquired(file_inode(iocb->ki_filp)->i_sb,
55 SB_FREEZE_WRITE);
56 file_end_write(iocb->ki_filp);
57 fuse_copyattr(iocb_fuse->ki_filp, iocb->ki_filp);
58 }
59
60 iocb_fuse->ki_pos = iocb->ki_pos;
61 kfree(aio_req);
62 }
63
fuse_aio_rw_complete(struct kiocb * iocb,long res,long res2)64 static void fuse_aio_rw_complete(struct kiocb *iocb, long res, long res2)
65 {
66 struct fuse_aio_req *aio_req =
67 container_of(iocb, struct fuse_aio_req, iocb);
68 struct kiocb *iocb_fuse = aio_req->iocb_fuse;
69
70 fuse_aio_cleanup_handler(aio_req);
71 iocb_fuse->ki_complete(iocb_fuse, res, res2);
72 }
73
fuse_passthrough_read_iter(struct kiocb * iocb_fuse,struct iov_iter * iter)74 ssize_t fuse_passthrough_read_iter(struct kiocb *iocb_fuse,
75 struct iov_iter *iter)
76 {
77 ssize_t ret;
78 const struct cred *old_cred;
79 struct file *fuse_filp = iocb_fuse->ki_filp;
80 struct fuse_file *ff = fuse_filp->private_data;
81 struct file *passthrough_filp = ff->passthrough.filp;
82
83 if (!iov_iter_count(iter))
84 return 0;
85
86 old_cred = override_creds(ff->passthrough.cred);
87 if (is_sync_kiocb(iocb_fuse)) {
88 ret = vfs_iter_read(passthrough_filp, iter, &iocb_fuse->ki_pos,
89 iocb_to_rw_flags(iocb_fuse->ki_flags,
90 PASSTHROUGH_IOCB_MASK));
91 } else {
92 struct fuse_aio_req *aio_req;
93
94 aio_req = kmalloc(sizeof(struct fuse_aio_req), GFP_KERNEL);
95 if (!aio_req) {
96 ret = -ENOMEM;
97 goto out;
98 }
99
100 aio_req->iocb_fuse = iocb_fuse;
101 kiocb_clone(&aio_req->iocb, iocb_fuse, passthrough_filp);
102 aio_req->iocb.ki_complete = fuse_aio_rw_complete;
103 ret = call_read_iter(passthrough_filp, &aio_req->iocb, iter);
104 if (ret != -EIOCBQUEUED)
105 fuse_aio_cleanup_handler(aio_req);
106 }
107 out:
108 revert_creds(old_cred);
109
110 fuse_file_accessed(fuse_filp, passthrough_filp);
111
112 return ret;
113 }
114
fuse_passthrough_write_iter(struct kiocb * iocb_fuse,struct iov_iter * iter)115 ssize_t fuse_passthrough_write_iter(struct kiocb *iocb_fuse,
116 struct iov_iter *iter)
117 {
118 ssize_t ret;
119 const struct cred *old_cred;
120 struct file *fuse_filp = iocb_fuse->ki_filp;
121 struct fuse_file *ff = fuse_filp->private_data;
122 struct inode *fuse_inode = file_inode(fuse_filp);
123 struct file *passthrough_filp = ff->passthrough.filp;
124 struct inode *passthrough_inode = file_inode(passthrough_filp);
125
126 if (!iov_iter_count(iter))
127 return 0;
128
129 inode_lock(fuse_inode);
130
131 fuse_copyattr(fuse_filp, passthrough_filp);
132
133 old_cred = override_creds(ff->passthrough.cred);
134 if (is_sync_kiocb(iocb_fuse)) {
135 file_start_write(passthrough_filp);
136 ret = vfs_iter_write(passthrough_filp, iter, &iocb_fuse->ki_pos,
137 iocb_to_rw_flags(iocb_fuse->ki_flags,
138 PASSTHROUGH_IOCB_MASK));
139 file_end_write(passthrough_filp);
140 if (ret > 0)
141 fuse_copyattr(fuse_filp, passthrough_filp);
142 } else {
143 struct fuse_aio_req *aio_req;
144
145 aio_req = kmalloc(sizeof(struct fuse_aio_req), GFP_KERNEL);
146 if (!aio_req) {
147 ret = -ENOMEM;
148 goto out;
149 }
150
151 file_start_write(passthrough_filp);
152 __sb_writers_release(passthrough_inode->i_sb, SB_FREEZE_WRITE);
153
154 aio_req->iocb_fuse = iocb_fuse;
155 kiocb_clone(&aio_req->iocb, iocb_fuse, passthrough_filp);
156 aio_req->iocb.ki_complete = fuse_aio_rw_complete;
157 ret = call_write_iter(passthrough_filp, &aio_req->iocb, iter);
158 if (ret != -EIOCBQUEUED)
159 fuse_aio_cleanup_handler(aio_req);
160 }
161 out:
162 revert_creds(old_cred);
163 inode_unlock(fuse_inode);
164
165 return ret;
166 }
167
fuse_passthrough_mmap(struct file * file,struct vm_area_struct * vma)168 ssize_t fuse_passthrough_mmap(struct file *file, struct vm_area_struct *vma)
169 {
170 int ret;
171 const struct cred *old_cred;
172 struct fuse_file *ff = file->private_data;
173 struct file *passthrough_filp = ff->passthrough.filp;
174
175 if (!passthrough_filp->f_op->mmap)
176 return -ENODEV;
177
178 if (WARN_ON(file != vma->vm_file))
179 return -EIO;
180
181 vma->vm_file = get_file(passthrough_filp);
182
183 old_cred = override_creds(ff->passthrough.cred);
184 ret = call_mmap(vma->vm_file, vma);
185 revert_creds(old_cred);
186
187 if (ret)
188 fput(passthrough_filp);
189 else
190 fput(file);
191
192 fuse_file_accessed(file, passthrough_filp);
193
194 return ret;
195 }
196
fuse_passthrough_open(struct fuse_dev * fud,u32 lower_fd)197 int fuse_passthrough_open(struct fuse_dev *fud, u32 lower_fd)
198 {
199 int res;
200 struct file *passthrough_filp;
201 struct fuse_conn *fc = fud->fc;
202 struct inode *passthrough_inode;
203 struct super_block *passthrough_sb;
204 struct fuse_passthrough *passthrough;
205
206 if (!fc->passthrough)
207 return -EPERM;
208
209 passthrough_filp = fget(lower_fd);
210 if (!passthrough_filp) {
211 pr_err("FUSE: invalid file descriptor for passthrough.\n");
212 return -EBADF;
213 }
214
215 if (!passthrough_filp->f_op->read_iter ||
216 !((passthrough_filp->f_path.mnt->mnt_flags | MNT_READONLY) ||
217 passthrough_filp->f_op->write_iter)) {
218 pr_err("FUSE: passthrough file misses file operations.\n");
219 res = -EBADF;
220 goto err_free_file;
221 }
222
223 passthrough_inode = file_inode(passthrough_filp);
224 passthrough_sb = passthrough_inode->i_sb;
225 if (passthrough_sb->s_stack_depth >= FILESYSTEM_MAX_STACK_DEPTH) {
226 pr_err("FUSE: fs stacking depth exceeded for passthrough\n");
227 res = -EINVAL;
228 goto err_free_file;
229 }
230
231 passthrough = kmalloc(sizeof(struct fuse_passthrough), GFP_KERNEL);
232 if (!passthrough) {
233 res = -ENOMEM;
234 goto err_free_file;
235 }
236
237 passthrough->filp = passthrough_filp;
238 passthrough->cred = prepare_creds();
239
240 idr_preload(GFP_KERNEL);
241 spin_lock(&fc->passthrough_req_lock);
242 res = idr_alloc(&fc->passthrough_req, passthrough, 1, 0, GFP_ATOMIC);
243 spin_unlock(&fc->passthrough_req_lock);
244 idr_preload_end();
245
246 if (res > 0)
247 return res;
248
249 fuse_passthrough_release(passthrough);
250 kfree(passthrough);
251
252 err_free_file:
253 fput(passthrough_filp);
254
255 return res;
256 }
257
fuse_passthrough_setup(struct fuse_conn * fc,struct fuse_file * ff,struct fuse_open_out * openarg)258 int fuse_passthrough_setup(struct fuse_conn *fc, struct fuse_file *ff,
259 struct fuse_open_out *openarg)
260 {
261 struct fuse_passthrough *passthrough;
262 int passthrough_fh = openarg->passthrough_fh;
263
264 if (!fc->passthrough)
265 return -EPERM;
266
267 /* Default case, passthrough is not requested */
268 if (passthrough_fh <= 0)
269 return -EINVAL;
270
271 spin_lock(&fc->passthrough_req_lock);
272 passthrough = idr_remove(&fc->passthrough_req, passthrough_fh);
273 spin_unlock(&fc->passthrough_req_lock);
274
275 if (!passthrough)
276 return -EINVAL;
277
278 ff->passthrough = *passthrough;
279 kfree(passthrough);
280
281 return 0;
282 }
283
fuse_passthrough_release(struct fuse_passthrough * passthrough)284 void fuse_passthrough_release(struct fuse_passthrough *passthrough)
285 {
286 if (passthrough->filp) {
287 fput(passthrough->filp);
288 passthrough->filp = NULL;
289 }
290 if (passthrough->cred) {
291 put_cred(passthrough->cred);
292 passthrough->cred = NULL;
293 }
294 }
295