1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * FUSE inode io modes.
4 *
5 * Copyright (c) 2024 CTERA Networks.
6 */
7
8 #include "fuse_i.h"
9
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/file.h>
13 #include <linux/fs.h>
14
15 /*
16 * Return true if need to wait for new opens in caching mode.
17 */
18 static inline bool fuse_is_io_cache_wait(struct fuse_inode *fi)
19 {
20 return READ_ONCE(fi->iocachectr) < 0 && !fuse_inode_backing(fi);
21 }
22
23 /*
24 * Called on cached file open() and on first mmap() of direct_io file.
25 * Takes cached_io inode mode reference to be dropped on file release.
26 *
27 * Blocks new parallel dio writes and waits for the in-progress parallel dio
28 * writes to complete.
29 */
30 int fuse_file_cached_io_open(struct inode *inode, struct fuse_file *ff)
31 {
32 struct fuse_inode *fi = get_fuse_inode(inode);
33
34 /* There are no io modes if server does not implement open */
35 if (!ff->args)
36 return 0;
37
38 spin_lock(&fi->lock);
39 /*
40 * Setting the bit advises new direct-io writes to use an exclusive
41 * lock - without it the wait below might be forever.
42 */
43 while (fuse_is_io_cache_wait(fi)) {
44 set_bit(FUSE_I_CACHE_IO_MODE, &fi->state);
45 spin_unlock(&fi->lock);
46 wait_event(fi->direct_io_waitq, !fuse_is_io_cache_wait(fi));
47 spin_lock(&fi->lock);
48 }
49
50 /*
51 * Check if inode entered passthrough io mode while waiting for parallel
52 * dio write completion.
53 */
54 if (fuse_inode_backing(fi)) {
55 clear_bit(FUSE_I_CACHE_IO_MODE, &fi->state);
56 spin_unlock(&fi->lock);
57 return -ETXTBSY;
58 }
59
60 WARN_ON(ff->iomode == IOM_UNCACHED);
61 if (ff->iomode == IOM_NONE) {
62 ff->iomode = IOM_CACHED;
63 if (fi->iocachectr == 0)
64 set_bit(FUSE_I_CACHE_IO_MODE, &fi->state);
65 fi->iocachectr++;
66 }
67 spin_unlock(&fi->lock);
68 return 0;
69 }
70
71 static void fuse_file_cached_io_release(struct fuse_file *ff,
72 struct fuse_inode *fi)
73 {
74 spin_lock(&fi->lock);
75 WARN_ON(fi->iocachectr <= 0);
76 WARN_ON(ff->iomode != IOM_CACHED);
77 ff->iomode = IOM_NONE;
78 fi->iocachectr--;
79 if (fi->iocachectr == 0)
80 clear_bit(FUSE_I_CACHE_IO_MODE, &fi->state);
81 spin_unlock(&fi->lock);
82 }
83
84 /* Start strictly uncached io mode where cache access is not allowed */
85 int fuse_inode_uncached_io_start(struct fuse_inode *fi, struct fuse_backing *fb)
86 {
87 struct fuse_backing *oldfb;
88 int err = 0;
89
90 spin_lock(&fi->lock);
91 /* deny conflicting backing files on same fuse inode */
92 oldfb = fuse_inode_backing(fi);
93 if (fb && oldfb && oldfb != fb) {
94 err = -EBUSY;
95 goto unlock;
96 }
97 if (fi->iocachectr > 0) {
98 err = -ETXTBSY;
99 goto unlock;
100 }
101 fi->iocachectr--;
102
103 /* fuse inode holds a single refcount of backing file */
104 if (fb && !oldfb) {
105 oldfb = fuse_inode_backing_set(fi, fb);
106 WARN_ON_ONCE(oldfb != NULL);
107 } else {
108 fuse_backing_put(fb);
109 }
110 unlock:
111 spin_unlock(&fi->lock);
112 return err;
113 }
114
115 /* Takes uncached_io inode mode reference to be dropped on file release */
116 static int fuse_file_uncached_io_open(struct inode *inode,
117 struct fuse_file *ff,
118 struct fuse_backing *fb)
119 {
120 struct fuse_inode *fi = get_fuse_inode(inode);
121 int err;
122
123 err = fuse_inode_uncached_io_start(fi, fb);
124 if (err)
125 return err;
126
127 WARN_ON(ff->iomode != IOM_NONE);
128 ff->iomode = IOM_UNCACHED;
129 return 0;
130 }
131
132 void fuse_inode_uncached_io_end(struct fuse_inode *fi)
133 {
134 struct fuse_backing *oldfb = NULL;
135
136 spin_lock(&fi->lock);
137 WARN_ON(fi->iocachectr >= 0);
138 fi->iocachectr++;
139 if (!fi->iocachectr) {
140 wake_up(&fi->direct_io_waitq);
141 oldfb = fuse_inode_backing_set(fi, NULL);
142 }
143 spin_unlock(&fi->lock);
144 if (oldfb)
145 fuse_backing_put(oldfb);
146 }
147
148 /* Drop uncached_io reference from passthrough open */
149 static void fuse_file_uncached_io_release(struct fuse_file *ff,
150 struct fuse_inode *fi)
151 {
152 WARN_ON(ff->iomode != IOM_UNCACHED);
153 ff->iomode = IOM_NONE;
154 fuse_inode_uncached_io_end(fi);
155 }
156
157 /*
158 * Open flags that are allowed in combination with FOPEN_PASSTHROUGH.
159 * A combination of FOPEN_PASSTHROUGH and FOPEN_DIRECT_IO means that read/write
160 * operations go directly to the server, but mmap is done on the backing file.
161 * FOPEN_PASSTHROUGH mode should not co-exist with any users of the fuse inode
162 * page cache, so FOPEN_KEEP_CACHE is a strange and undesired combination.
163 */
164 #define FOPEN_PASSTHROUGH_MASK \
165 (FOPEN_PASSTHROUGH | FOPEN_DIRECT_IO | FOPEN_PARALLEL_DIRECT_WRITES | \
166 FOPEN_NOFLUSH)
167
168 static int fuse_file_passthrough_open(struct inode *inode, struct file *file)
169 {
170 struct fuse_file *ff = file->private_data;
171 struct fuse_conn *fc = get_fuse_conn(inode);
172 struct fuse_backing *fb;
173 int err;
174
175 /* Check allowed conditions for file open in passthrough mode */
176 if (!IS_ENABLED(CONFIG_FUSE_PASSTHROUGH) || !fc->passthrough ||
177 (ff->open_flags & ~FOPEN_PASSTHROUGH_MASK))
178 return -EINVAL;
179
180 fb = fuse_passthrough_open(file, inode,
181 ff->args->open_outarg.backing_id);
182 if (IS_ERR(fb))
183 return PTR_ERR(fb);
184
185 /* First passthrough file open denies caching inode io mode */
186 err = fuse_file_uncached_io_open(inode, ff, fb);
187 if (!err)
188 return 0;
189
190 fuse_passthrough_release(ff, fb);
191 fuse_backing_put(fb);
192
193 return err;
194 }
195
196 /* Request access to submit new io to inode via open file */
197 int fuse_file_io_open(struct file *file, struct inode *inode)
198 {
199 struct fuse_file *ff = file->private_data;
200 struct fuse_inode *fi = get_fuse_inode(inode);
201 int err;
202
203 /*
204 * io modes are not relevant with DAX and with server that does not
205 * implement open.
206 */
207 if (FUSE_IS_DAX(inode) || !ff->args)
208 return 0;
209
210 /*
211 * Server is expected to use FOPEN_PASSTHROUGH for all opens of an inode
212 * which is already open for passthrough.
213 */
214 err = -EINVAL;
215 if (fuse_inode_backing(fi) && !(ff->open_flags & FOPEN_PASSTHROUGH))
216 goto fail;
217
218 /*
219 * FOPEN_PARALLEL_DIRECT_WRITES requires FOPEN_DIRECT_IO.
220 */
221 if (!(ff->open_flags & FOPEN_DIRECT_IO))
222 ff->open_flags &= ~FOPEN_PARALLEL_DIRECT_WRITES;
223
224 /*
225 * First passthrough file open denies caching inode io mode.
226 * First caching file open enters caching inode io mode.
227 *
228 * Note that if user opens a file open with O_DIRECT, but server did
229 * not specify FOPEN_DIRECT_IO, a later fcntl() could remove O_DIRECT,
230 * so we put the inode in caching mode to prevent parallel dio.
231 */
232 if ((ff->open_flags & FOPEN_DIRECT_IO) &&
233 !(ff->open_flags & FOPEN_PASSTHROUGH))
234 return 0;
235
236 if (ff->open_flags & FOPEN_PASSTHROUGH)
237 err = fuse_file_passthrough_open(inode, file);
238 else
239 err = fuse_file_cached_io_open(inode, ff);
240 if (err)
241 goto fail;
242
243 return 0;
244
245 fail:
246 pr_debug("failed to open file in requested io mode (open_flags=0x%x, err=%i).\n",
247 ff->open_flags, err);
248 /*
249 * The file open mode determines the inode io mode.
250 * Using incorrect open mode is a server mistake, which results in
251 * user visible failure of open() with EIO error.
252 */
253 return -EIO;
254 }
255
256 /* No more pending io and no new io possible to inode via open/mmapped file */
257 void fuse_file_io_release(struct fuse_file *ff, struct inode *inode)
258 {
259 struct fuse_inode *fi = get_fuse_inode(inode);
260
261 /*
262 * Last passthrough file close allows caching inode io mode.
263 * Last caching file close exits caching inode io mode.
264 */
265 switch (ff->iomode) {
266 case IOM_NONE:
267 /* Nothing to do */
268 break;
269 case IOM_UNCACHED:
270 fuse_file_uncached_io_release(ff, fi);
271 break;
272 case IOM_CACHED:
273 fuse_file_cached_io_release(ff, fi);
274 break;
275 }
276 }
277
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.