projects/linux·blob master · refs

275 lines · 7.0 KiB

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 */
18static 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 */
30int 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
71static 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 */
85int 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 }
110unlock:
111 spin_unlock(&fi->lock);
112 return err;
113}
114
115/* Takes uncached_io inode mode reference to be dropped on file release */
116static 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
132void 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 */
149static 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
168static 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, ff->args->open_outarg.backing_id);
181 if (IS_ERR(fb))
182 return PTR_ERR(fb);
183
184 /* First passthrough file open denies caching inode io mode */
185 err = fuse_file_uncached_io_open(inode, ff, fb);
186 if (!err)
187 return 0;
188
189 fuse_passthrough_release(ff, fb);
190 fuse_backing_put(fb);
191
192 return err;
193}
194
195/* Request access to submit new io to inode via open file */
196int fuse_file_io_open(struct file *file, struct inode *inode)
197{
198 struct fuse_file *ff = file->private_data;
199 struct fuse_inode *fi = get_fuse_inode(inode);
200 int err;
201
202 /*
203 * io modes are not relevant with DAX and with server that does not
204 * implement open.
205 */
206 if (FUSE_IS_DAX(inode) || !ff->args)
207 return 0;
208
209 /*
210 * Server is expected to use FOPEN_PASSTHROUGH for all opens of an inode
211 * which is already open for passthrough.
212 */
213 err = -EINVAL;
214 if (fuse_inode_backing(fi) && !(ff->open_flags & FOPEN_PASSTHROUGH))
215 goto fail;
216
217 /*
218 * FOPEN_PARALLEL_DIRECT_WRITES requires FOPEN_DIRECT_IO.
219 */
220 if (!(ff->open_flags & FOPEN_DIRECT_IO))
221 ff->open_flags &= ~FOPEN_PARALLEL_DIRECT_WRITES;
222
223 /*
224 * First passthrough file open denies caching inode io mode.
225 * First caching file open enters caching inode io mode.
226 *
227 * Note that if user opens a file open with O_DIRECT, but server did
228 * not specify FOPEN_DIRECT_IO, a later fcntl() could remove O_DIRECT,
229 * so we put the inode in caching mode to prevent parallel dio.
230 */
231 if ((ff->open_flags & FOPEN_DIRECT_IO) &&
232 !(ff->open_flags & FOPEN_PASSTHROUGH))
233 return 0;
234
235 if (ff->open_flags & FOPEN_PASSTHROUGH)
236 err = fuse_file_passthrough_open(inode, file);
237 else
238 err = fuse_file_cached_io_open(inode, ff);
239 if (err)
240 goto fail;
241
242 return 0;
243
244fail:
245 pr_debug("failed to open file in requested io mode (open_flags=0x%x, err=%i).\n",
246 ff->open_flags, err);
247 /*
248 * The file open mode determines the inode io mode.
249 * Using incorrect open mode is a server mistake, which results in
250 * user visible failure of open() with EIO error.
251 */
252 return -EIO;
253}
254
255/* No more pending io and no new io possible to inode via open/mmapped file */
256void fuse_file_io_release(struct fuse_file *ff, struct inode *inode)
257{
258 struct fuse_inode *fi = get_fuse_inode(inode);
259
260 /*
261 * Last passthrough file close allows caching inode io mode.
262 * Last caching file close exits caching inode io mode.
263 */
264 switch (ff->iomode) {
265 case IOM_NONE:
266 /* Nothing to do */
267 break;
268 case IOM_UNCACHED:
269 fuse_file_uncached_io_release(ff, fi);
270 break;
271 case IOM_CACHED:
272 fuse_file_cached_io_release(ff, fi);
273 break;
274 }
275}