projects/linux·blob master · refs

427 lines · 10.7 KiB

1/* SPDX-License-Identifier: GPL-2.0
2 *
3 * FUSE: Filesystem in Userspace
4 * Copyright (C) 2001-2008 Miklos Szeredi <[email protected]>
5 */
6#ifndef _FS_FUSE_DEV_I_H
7#define _FS_FUSE_DEV_I_H
8
9#include <linux/fuse.h>
10#include <linux/types.h>
11#include <linux/refcount.h>
12#include <linux/wait.h>
13#include <linux/workqueue.h>
14#include <linux/fs.h>
15
16/* Ordinary requests have even IDs, while interrupts IDs are odd */
17#define FUSE_INT_REQ_BIT (1ULL << 0)
18#define FUSE_REQ_ID_STEP (1ULL << 1)
19
20struct fuse_arg;
21struct fuse_args;
22struct fuse_pqueue;
23struct fuse_iqueue;
24
25/**
26 * enum fuse_req_flag - Request flags
27 *
28 * @FR_ISREPLY: set if the request has reply
29 * @FR_FORCE: force sending of the request even if interrupted
30 * @FR_BACKGROUND: request is sent in the background
31 * @FR_WAITING: request is counted as "waiting"
32 * @FR_ABORTED: the request was aborted
33 * @FR_INTERRUPTED: the request has been interrupted
34 * @FR_LOCKED: data is being copied to/from the request
35 * @FR_PENDING: request is not yet in userspace
36 * @FR_SENT: request is in userspace, waiting for an answer
37 * @FR_FINISHED: request is finished
38 * @FR_PRIVATE: request is on private list
39 * @FR_ASYNC: request is asynchronous
40 * @FR_URING: request is handled through fuse-io-uring
41 * @FR_SYNC_WAKEUP: use synchronous wakeup when queueing this request to
42 * give the scheduler a hint about the waker task
43 */
44enum fuse_req_flag {
45 FR_ISREPLY,
46 FR_FORCE,
47 FR_BACKGROUND,
48 FR_WAITING,
49 FR_ABORTED,
50 FR_INTERRUPTED,
51 FR_LOCKED,
52 FR_PENDING,
53 FR_SENT,
54 FR_FINISHED,
55 FR_PRIVATE,
56 FR_ASYNC,
57 FR_URING,
58 FR_SYNC_WAKEUP,
59};
60
61/**
62 * struct fuse_req - A request to the client
63 *
64 * .waitq.lock protects the following fields:
65 * - FR_ABORTED
66 * - FR_LOCKED (may also be modified under fpq->lock, tested under both)
67 */
68struct fuse_req {
69 /**
70 * @list: This can be on either pending processing or io lists in
71 * fuse_conn
72 */
73 struct list_head list;
74
75 /** @intr_entry: Entry on the interrupts list */
76 struct list_head intr_entry;
77
78 /** @args: Input/output arguments */
79 struct fuse_args *args;
80
81 /** @count: refcount */
82 refcount_t count;
83
84 /** @flags: Request flags, updated with test/set/clear_bit() */
85 unsigned long flags;
86
87 /** @in: The request input header */
88 struct {
89 /** @in.h: The request input header */
90 struct fuse_in_header h;
91 } in;
92
93 /** @out: The request output header */
94 struct {
95 /** @out.h: The request output header */
96 struct fuse_out_header h;
97 } out;
98
99 /** @waitq: Used to wake up the task waiting for completion of request */
100 wait_queue_head_t waitq;
101
102#if IS_ENABLED(CONFIG_VIRTIO_FS)
103 /**
104 * @argbuf: virtio-fs's physically contiguous buffer for in and out
105 * args
106 */
107 void *argbuf;
108#endif
109
110 /** @chan: fuse_chan this request belongs to */
111 struct fuse_chan *chan;
112
113#ifdef CONFIG_FUSE_IO_URING
114 void *ring_entry;
115 void *ring_queue;
116#endif
117 /** @create_time: When (in jiffies) the request was created */
118 unsigned long create_time;
119};
120
121/* One forget request */
122struct fuse_forget_link {
123 struct fuse_forget_one forget_one;
124 struct fuse_forget_link *next;
125};
126
127/**
128 * struct fuse_iqueue_ops - Input queue callbacks
129 *
130 * Input queue signalling is device-specific. For example, the /dev/fuse file
131 * uses fiq->waitq and fasync to wake processes that are waiting on queue
132 * readiness. These callbacks allow other device types to respond to input
133 * queue activity.
134 */
135struct fuse_iqueue_ops {
136 /**
137 * @send_forget: Send one forget
138 */
139 void (*send_forget)(struct fuse_iqueue *fiq, struct fuse_forget_link *link);
140
141 /**
142 * @send_interrupt: Send interrupt for request
143 */
144 void (*send_interrupt)(struct fuse_iqueue *fiq, struct fuse_req *req);
145
146 /**
147 * @send_req: Send one request
148 */
149 void (*send_req)(struct fuse_iqueue *fiq, struct fuse_req *req);
150
151 /**
152 * @release: Clean up when fuse_iqueue is destroyed
153 */
154 void (*release)(struct fuse_iqueue *fiq);
155};
156
157struct fuse_iqueue {
158 /** Connection established */
159 unsigned connected;
160
161 /** Lock protecting accesses to members of this structure */
162 spinlock_t lock;
163
164 /** Readers of the connection are waiting on this */
165 wait_queue_head_t waitq;
166
167 /** The next unique request id */
168 u64 reqctr;
169
170 /** The list of pending requests */
171 struct list_head pending;
172
173 /** Pending interrupts */
174 struct list_head interrupts;
175
176 /** Queue of pending forgets */
177 struct fuse_forget_link forget_list_head;
178 struct fuse_forget_link *forget_list_tail;
179
180 /** Batching of FORGET requests (positive indicates FORGET batch) */
181 int forget_batch;
182
183 /** O_ASYNC requests */
184 struct fasync_struct *fasync;
185
186 /** Device-specific callbacks */
187 const struct fuse_iqueue_ops *ops;
188
189 /** Device-specific state */
190 void *priv;
191};
192
193struct fuse_chan {
194 /** Lock protecting:
195 - devices
196 - connected
197 - ring
198 - ring->queues[qid]
199 */
200 spinlock_t lock;
201
202 /* back pointer: fc->chan->conn == fc */
203 struct fuse_conn *conn;
204
205 /** Input queue */
206 struct fuse_iqueue iq;
207
208 /** List of device instances belonging to this connection */
209 struct list_head devices;
210
211 /** Maximum number of outstanding background requests */
212 unsigned max_background;
213
214 /** Number of requests currently in the background */
215 unsigned num_background;
216
217 /** Number of background requests currently queued for userspace */
218 unsigned active_background;
219
220 /** The list of background requests set aside for later queuing */
221 struct list_head bg_queue;
222
223 /** Protects: max_background, num_background, active_background, bg_queue, blocked */
224 spinlock_t bg_lock;
225
226 /** Flag indicating that INIT reply has been received. Allocating
227 * any fuse request will be suspended until the flag is set */
228 int initialized;
229
230 /** Flag indicating if connection is blocked. This will be
231 the case before the INIT reply is received, and if there
232 are too many outstading backgrounds requests */
233 int blocked;
234
235 /** waitq for blocked connection */
236 wait_queue_head_t blocked_waitq;
237
238 /** Connection established, cleared on umount, connection
239 abort and device release */
240 unsigned connected;
241
242 /** The number of requests waiting for completion */
243 atomic_t num_waiting;
244
245 /** Is interrupt not implemented by fs? */
246 bool no_interrupt;
247
248 /* Use io_uring for communication */
249 unsigned int io_uring;
250
251 /* Negotiated minor version */
252 unsigned int minor;
253
254 /* Maximum write size */
255 unsigned int max_write;
256
257 /* Maximum number of pages that can be used in a single request */
258 unsigned int max_pages;
259
260 /* Before being installed into fud, contains the preallocated pq array*/
261 struct list_head *pq_prealloc;
262
263 /** Connection aborted via sysfs, respond with ECONNABORTED on device I/O */
264 bool abort_with_err;
265
266#ifdef CONFIG_FUSE_IO_URING
267 /** uring connection information*/
268 struct fuse_ring *ring;
269#endif
270
271 /** Only used if the connection opts into request timeouts */
272 struct {
273 /* Worker for checking if any requests have timed out */
274 struct delayed_work work;
275
276 /* Request timeout (in jiffies). 0 = no timeout */
277 unsigned int req_timeout;
278 } timeout;
279};
280
281#define FUSE_PQ_HASH_BITS 8
282#define FUSE_PQ_HASH_SIZE (1 << FUSE_PQ_HASH_BITS)
283
284struct fuse_pqueue {
285 /** Connection established */
286 unsigned connected;
287
288 /** Lock protecting accessess to members of this structure */
289 spinlock_t lock;
290
291 /** Hash table of requests being processed */
292 struct list_head *processing;
293
294 /** The list of requests under I/O */
295 struct list_head io;
296};
297
298/**
299 * struct fuse_dev - Fuse device instance
300 */
301struct fuse_dev {
302 /** @ref: Reference count of this object */
303 refcount_t ref;
304
305 /** @sync_init: Issue FUSE_INIT synchronously */
306 bool sync_init;
307
308 /** @chan: Fuse channel for this device */
309 struct fuse_chan *chan;
310
311 /** @pq: Processing queue */
312 struct fuse_pqueue pq;
313
314 /** @entry: list entry on fch->devices */
315 struct list_head entry;
316};
317
318struct fuse_copy_state {
319 struct fuse_req *req;
320 struct iov_iter *iter;
321 struct pipe_buffer *pipebufs;
322 struct pipe_buffer *currbuf;
323 struct pipe_inode_info *pipe;
324 unsigned long nr_segs;
325 struct page *pg;
326 unsigned int len;
327 unsigned int offset;
328 bool write:1;
329 bool move_folios:1;
330 bool is_uring:1;
331 /* set when the payload is zero-copied. folios are filled in place */
332 bool skip_folio_copy:1;
333 struct {
334 unsigned int copied_sz; /* copied size into the user buffer */
335 } ring;
336};
337
338/* fud->chan gets assigned to this value when /dev/fuse is closed */
339#define FUSE_DEV_CHAN_DISCONNECTED ((struct fuse_chan *) 1)
340
341/*
342 * Lockless access is OK, because fud->chan is set once during mount and is valid
343 * until the file is released.
344 *
345 * fud->chan is set to FUSE_DEV_CHAN_DISCONNECTED only after the containing file is
346 * released, so result is safe to dereference in most cases. Exceptions are:
347 * fuse_dev_put() and fuse_fill_super_common().
348 */
349static inline struct fuse_chan *fuse_dev_chan_get(struct fuse_dev *fud)
350{
351 /* Pairs with xchg() in fuse_dev_install() */
352 return smp_load_acquire(&fud->chan);
353}
354
355static inline struct fuse_dev *fuse_file_to_fud(struct file *file)
356{
357 return file->private_data;
358}
359
360static inline struct fuse_dev *__fuse_get_dev(struct file *file)
361{
362 struct fuse_dev *fud = fuse_file_to_fud(file);
363
364 if (!fuse_dev_chan_get(fud))
365 return NULL;
366
367 return fud;
368}
369
370void fuse_iqueue_init(struct fuse_iqueue *fiq, const struct fuse_iqueue_ops *ops, void *priv);
371
372struct fuse_dev *fuse_get_dev(struct file *file);
373
374unsigned int fuse_req_hash(u64 unique);
375struct fuse_req *fuse_request_find(struct fuse_pqueue *fpq, u64 unique);
376
377void fuse_dev_end_requests(struct list_head *head);
378void fuse_request_bg_finish(struct fuse_chan *fch, struct fuse_req *req);
379
380void fuse_copy_init(struct fuse_copy_state *cs, bool write,
381 struct iov_iter *iter);
382/*
383 * Return the number of bytes in an arguments list
384 */
385unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args);
386
387int fuse_copy_args(struct fuse_copy_state *cs, unsigned int numargs,
388 unsigned int argpages, struct fuse_arg *args,
389 int zeroing);
390int fuse_copy_out_args(struct fuse_copy_state *cs, struct fuse_args *args,
391 unsigned int nbytes);
392void fuse_dev_queue_forget(struct fuse_iqueue *fiq,
393 struct fuse_forget_link *forget);
394void fuse_dev_queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req);
395bool fuse_remove_pending_req(struct fuse_req *req, spinlock_t *lock);
396
397bool fuse_request_expired(struct fuse_chan *fch, struct list_head *list);
398
399/*
400 * Assign a unique id to a fuse request
401 */
402void fuse_request_assign_unique(struct fuse_iqueue *fiq, struct fuse_req *req);
403
404/*
405 * Get the next unique ID for a request
406 */
407u64 fuse_get_unique(struct fuse_iqueue *fiq);
408
409struct fuse_dev *fuse_dev_alloc_install(struct fuse_chan *fch);
410struct fuse_dev *fuse_dev_alloc(void);
411
412int fuse_dev_release(struct inode *inode, struct file *file);
413
414struct list_head *fuse_pqueue_alloc(void);
415
416/*
417 * Initialize the fuse processing queue
418 */
419void fuse_pqueue_init(struct fuse_pqueue *fpq);
420
421/*
422 * End a finished request
423 */
424void fuse_request_end(struct fuse_req *req);
425
426#endif
427