1 /*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
4
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7 */
8
9 #ifndef _FS_FUSE_I_H
10 #define _FS_FUSE_I_H
11
12 #ifndef pr_fmt
13 # define pr_fmt(fmt) "fuse: " fmt
14 #endif
15
16 #include <linux/fuse.h>
17 #include <linux/fs.h>
18 #include <linux/mount.h>
19 #include <linux/wait.h>
20 #include <linux/list.h>
21 #include <linux/spinlock.h>
22 #include <linux/mm.h>
23 #include <linux/backing-dev.h>
24 #include <linux/mutex.h>
25 #include <linux/rwsem.h>
26 #include <linux/rbtree.h>
27 #include <linux/poll.h>
28 #include <linux/workqueue.h>
29 #include <linux/kref.h>
30 #include <linux/xattr.h>
31 #include <linux/pid_namespace.h>
32 #include <linux/refcount.h>
33 #include <linux/user_namespace.h>
34
35 /** Default max number of pages that can be used in a single read request */
36 #define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
37
38 /** Bias for fi->writectr, meaning new writepages must not be sent */
39 #define FUSE_NOWRITE INT_MIN
40
41 /** Maximum length of a filename, not including terminating null */
42
43 /* maximum, small enough for FUSE_MIN_READ_BUFFER*/
44 #define FUSE_NAME_LOW_MAX 1024
45 /* maximum, but needs a request buffer > FUSE_MIN_READ_BUFFER */
46 #define FUSE_NAME_MAX (PATH_MAX - 1)
47
48 /** Number of dentries for each connection in the control filesystem */
49 #define FUSE_CTL_NUM_DENTRIES 5
50
51 /* Frequency (in seconds) of request timeout checks, if opted into */
52 #define FUSE_TIMEOUT_TIMER_FREQ 15
53
54 /** Frequency (in jiffies) of request timeout checks, if opted into */
55 extern const unsigned long fuse_timeout_timer_freq;
56
57 /** Maximum of max_pages received in init_out */
58 extern unsigned int fuse_max_pages_limit;
59 /*
60 * Default timeout (in seconds) for the server to reply to a request
61 * before the connection is aborted, if no timeout was specified on mount.
62 */
63 extern unsigned int fuse_default_req_timeout;
64 /*
65 * Max timeout (in seconds) for the server to reply to a request before
66 * the connection is aborted.
67 */
68 extern unsigned int fuse_max_req_timeout;
69
70 /** List of active connections */
71 extern struct list_head fuse_conn_list;
72
73 /** Global mutex protecting fuse_conn_list and the control filesystem */
74 extern struct mutex fuse_mutex;
75
76 /** Module parameters */
77 extern unsigned int max_user_bgreq;
78 extern unsigned int max_user_congthresh;
79
80 /* One forget request */
81 struct fuse_forget_link {
82 struct fuse_forget_one forget_one;
83 struct fuse_forget_link *next;
84 };
85
86 /* Submount lookup tracking */
87 struct fuse_submount_lookup {
88 /** Refcount */
89 refcount_t count;
90
91 /** Unique ID, which identifies the inode between userspace
92 * and kernel */
93 u64 nodeid;
94
95 /** The request used for sending the FORGET message */
96 struct fuse_forget_link *forget;
97 };
98
99 /** Container for data related to mapping to backing file */
100 struct fuse_backing {
101 struct file *file;
102 struct cred *cred;
103
104 /** refcount */
105 refcount_t count;
106 struct rcu_head rcu;
107 };
108
109 /** FUSE inode */
110 struct fuse_inode {
111 /** Inode data */
112 struct inode inode;
113
114 /** Unique ID, which identifies the inode between userspace
115 * and kernel */
116 u64 nodeid;
117
118 /** Number of lookups on this inode */
119 u64 nlookup;
120
121 /** The request used for sending the FORGET message */
122 struct fuse_forget_link *forget;
123
124 /** Time in jiffies until the file attributes are valid */
125 u64 i_time;
126
127 /* Which attributes are invalid */
128 u32 inval_mask;
129
130 /** The sticky bit in inode->i_mode may have been removed, so
131 preserve the original mode */
132 umode_t orig_i_mode;
133
134 /* Cache birthtime */
135 struct timespec64 i_btime;
136
137 /** 64 bit inode number */
138 u64 orig_ino;
139
140 /** Version of last attribute change */
141 u64 attr_version;
142
143 union {
144 /* read/write io cache (regular file only) */
145 struct {
146 /* Files usable in writepage. Protected by fi->lock */
147 struct list_head write_files;
148
149 /* Writepages pending on truncate or fsync */
150 struct list_head queued_writes;
151
152 /* Number of sent writes, a negative bias
153 * (FUSE_NOWRITE) means more writes are blocked */
154 int writectr;
155
156 /** Number of files/maps using page cache */
157 int iocachectr;
158
159 /* Waitq for writepage completion */
160 wait_queue_head_t page_waitq;
161
162 /* waitq for direct-io completion */
163 wait_queue_head_t direct_io_waitq;
164 };
165
166 /* readdir cache (directory only) */
167 struct {
168 /* true if fully cached */
169 bool cached;
170
171 /* size of cache */
172 loff_t size;
173
174 /* position at end of cache (position of next entry) */
175 loff_t pos;
176
177 /* version of the cache */
178 u64 version;
179
180 /* modification time of directory when cache was
181 * started */
182 struct timespec64 mtime;
183
184 /* iversion of directory when cache was started */
185 u64 iversion;
186
187 /* protects above fields */
188 spinlock_t lock;
189 } rdc;
190 };
191
192 /** Miscellaneous bits describing inode state */
193 unsigned long state;
194
195 /** Lock for serializing lookup and readdir for back compatibility*/
196 struct mutex mutex;
197
198 /** Lock to protect write related fields */
199 spinlock_t lock;
200
201 #ifdef CONFIG_FUSE_DAX
202 /*
203 * Dax specific inode data
204 */
205 struct fuse_inode_dax *dax;
206 #endif
207 /** Submount specific lookup tracking */
208 struct fuse_submount_lookup *submount_lookup;
209 #ifdef CONFIG_FUSE_PASSTHROUGH
210 /** Reference to backing file in passthrough mode */
211 struct fuse_backing *fb;
212 #endif
213
214 /*
215 * The underlying inode->i_blkbits value will not be modified,
216 * so preserve the blocksize specified by the server.
217 */
218 u8 cached_i_blkbits;
219 };
220
221 /** FUSE inode state bits */
222 enum {
223 /** Advise readdirplus */
224 FUSE_I_ADVISE_RDPLUS,
225 /** Initialized with readdirplus */
226 FUSE_I_INIT_RDPLUS,
227 /** An operation changing file size is in progress */
228 FUSE_I_SIZE_UNSTABLE,
229 /* Bad inode */
230 FUSE_I_BAD,
231 /* Has btime */
232 FUSE_I_BTIME,
233 /* Wants or already has page cache IO */
234 FUSE_I_CACHE_IO_MODE,
235 };
236
237 struct fuse_conn;
238 struct fuse_mount;
239 union fuse_file_args;
240
241 /** FUSE specific file data */
242 struct fuse_file {
243 /** Fuse connection for this file */
244 struct fuse_mount *fm;
245
246 /* Argument space reserved for open/release */
247 union fuse_file_args *args;
248
249 /** Kernel file handle guaranteed to be unique */
250 u64 kh;
251
252 /** File handle used by userspace */
253 u64 fh;
254
255 /** Node id of this file */
256 u64 nodeid;
257
258 /** Refcount */
259 refcount_t count;
260
261 /** FOPEN_* flags returned by open */
262 u32 open_flags;
263
264 /** Entry on inode's write_files list */
265 struct list_head write_entry;
266
267 /* Readdir related */
268 struct {
269 /* Dir stream position */
270 loff_t pos;
271
272 /* Offset in cache */
273 loff_t cache_off;
274
275 /* Version of cache we are reading */
276 u64 version;
277
278 } readdir;
279
280 /** RB node to be linked on fuse_conn->polled_files */
281 struct rb_node polled_node;
282
283 /** Wait queue head for poll */
284 wait_queue_head_t poll_wait;
285
286 /** Does file hold a fi->iocachectr refcount? */
287 enum { IOM_NONE, IOM_CACHED, IOM_UNCACHED } iomode;
288
289 #ifdef CONFIG_FUSE_PASSTHROUGH
290 /** Reference to backing file in passthrough mode */
291 struct file *passthrough;
292 const struct cred *cred;
293 #endif
294
295 /** Has flock been performed on this file? */
296 bool flock:1;
297 };
298
299 /** One input argument of a request */
300 struct fuse_in_arg {
301 unsigned size;
302 const void *value;
303 };
304
305 /** One output argument of a request */
306 struct fuse_arg {
307 unsigned size;
308 void *value;
309 };
310
311 /** FUSE folio descriptor */
312 struct fuse_folio_desc {
313 unsigned int length;
314 unsigned int offset;
315 };
316
317 struct fuse_args {
318 uint64_t nodeid;
319 uint32_t opcode;
320 uint8_t in_numargs;
321 uint8_t out_numargs;
322 uint8_t ext_idx;
323 bool force:1;
324 bool noreply:1;
325 bool nocreds:1;
326 bool in_pages:1;
327 bool out_pages:1;
328 bool user_pages:1;
329 bool out_argvar:1;
330 bool page_zeroing:1;
331 bool page_replace:1;
332 bool may_block:1;
333 bool is_ext:1;
334 bool is_pinned:1;
335 bool invalidate_vmap:1;
336 struct fuse_in_arg in_args[4];
337 struct fuse_arg out_args[2];
338 void (*end)(struct fuse_mount *fm, struct fuse_args *args, int error);
339 /* Used for kvec iter backed by vmalloc address */
340 void *vmap_base;
341 };
342
343 struct fuse_args_pages {
344 struct fuse_args args;
345 struct folio **folios;
346 struct fuse_folio_desc *descs;
347 unsigned int num_folios;
348 };
349
350 struct fuse_release_args {
351 struct fuse_args args;
352 struct fuse_release_in inarg;
353 struct inode *inode;
354 };
355
356 union fuse_file_args {
357 /* Used during open() */
358 struct fuse_open_out open_outarg;
359 /* Used during release() */
360 struct fuse_release_args release_args;
361 };
362
363 #define FUSE_ARGS(args) struct fuse_args args = {}
364
365 /** The request IO state (for asynchronous processing) */
366 struct fuse_io_priv {
367 struct kref refcnt;
368 int async;
369 spinlock_t lock;
370 unsigned reqs;
371 ssize_t bytes;
372 size_t size;
373 __u64 offset;
374 bool write;
375 bool should_dirty;
376 int err;
377 struct kiocb *iocb;
378 struct completion *done;
379 bool blocking;
380 };
381
382 #define FUSE_IO_PRIV_SYNC(i) \
383 { \
384 .refcnt = KREF_INIT(1), \
385 .async = 0, \
386 .iocb = i, \
387 }
388
389 /**
390 * Request flags
391 *
392 * FR_ISREPLY: set if the request has reply
393 * FR_FORCE: force sending of the request even if interrupted
394 * FR_BACKGROUND: request is sent in the background
395 * FR_WAITING: request is counted as "waiting"
396 * FR_ABORTED: the request was aborted
397 * FR_INTERRUPTED: the request has been interrupted
398 * FR_LOCKED: data is being copied to/from the request
399 * FR_PENDING: request is not yet in userspace
400 * FR_SENT: request is in userspace, waiting for an answer
401 * FR_FINISHED: request is finished
402 * FR_PRIVATE: request is on private list
403 * FR_ASYNC: request is asynchronous
404 * FR_URING: request is handled through fuse-io-uring
405 */
406 enum fuse_req_flag {
407 FR_ISREPLY,
408 FR_FORCE,
409 FR_BACKGROUND,
410 FR_WAITING,
411 FR_ABORTED,
412 FR_INTERRUPTED,
413 FR_LOCKED,
414 FR_PENDING,
415 FR_SENT,
416 FR_FINISHED,
417 FR_PRIVATE,
418 FR_ASYNC,
419 FR_URING,
420 };
421
422 /**
423 * A request to the client
424 *
425 * .waitq.lock protects the following fields:
426 * - FR_ABORTED
427 * - FR_LOCKED (may also be modified under fc->lock, tested under both)
428 */
429 struct fuse_req {
430 /** This can be on either pending processing or io lists in
431 fuse_conn */
432 struct list_head list;
433
434 /** Entry on the interrupts list */
435 struct list_head intr_entry;
436
437 /* Input/output arguments */
438 struct fuse_args *args;
439
440 /** refcount */
441 refcount_t count;
442
443 /* Request flags, updated with test/set/clear_bit() */
444 unsigned long flags;
445
446 /* The request input header */
447 struct {
448 struct fuse_in_header h;
449 } in;
450
451 /* The request output header */
452 struct {
453 struct fuse_out_header h;
454 } out;
455
456 /** Used to wake up the task waiting for completion of request*/
457 wait_queue_head_t waitq;
458
459 #if IS_ENABLED(CONFIG_VIRTIO_FS)
460 /** virtio-fs's physically contiguous buffer for in and out args */
461 void *argbuf;
462 #endif
463
464 /** fuse_mount this request belongs to */
465 struct fuse_mount *fm;
466
467 #ifdef CONFIG_FUSE_IO_URING
468 void *ring_entry;
469 void *ring_queue;
470 #endif
471 /** When (in jiffies) the request was created */
472 unsigned long create_time;
473 };
474
475 struct fuse_iqueue;
476
477 /**
478 * Input queue callbacks
479 *
480 * Input queue signalling is device-specific. For example, the /dev/fuse file
481 * uses fiq->waitq and fasync to wake processes that are waiting on queue
482 * readiness. These callbacks allow other device types to respond to input
483 * queue activity.
484 */
485 struct fuse_iqueue_ops {
486 /**
487 * Send one forget
488 */
489 void (*send_forget)(struct fuse_iqueue *fiq, struct fuse_forget_link *link);
490
491 /**
492 * Send interrupt for request
493 */
494 void (*send_interrupt)(struct fuse_iqueue *fiq, struct fuse_req *req);
495
496 /**
497 * Send one request
498 */
499 void (*send_req)(struct fuse_iqueue *fiq, struct fuse_req *req);
500
501 /**
502 * Clean up when fuse_iqueue is destroyed
503 */
504 void (*release)(struct fuse_iqueue *fiq);
505 };
506
507 /** /dev/fuse input queue operations */
508 extern const struct fuse_iqueue_ops fuse_dev_fiq_ops;
509
510 struct fuse_iqueue {
511 /** Connection established */
512 unsigned connected;
513
514 /** Lock protecting accesses to members of this structure */
515 spinlock_t lock;
516
517 /** Readers of the connection are waiting on this */
518 wait_queue_head_t waitq;
519
520 /** The next unique request id */
521 u64 reqctr;
522
523 /** The list of pending requests */
524 struct list_head pending;
525
526 /** Pending interrupts */
527 struct list_head interrupts;
528
529 /** Queue of pending forgets */
530 struct fuse_forget_link forget_list_head;
531 struct fuse_forget_link *forget_list_tail;
532
533 /** Batching of FORGET requests (positive indicates FORGET batch) */
534 int forget_batch;
535
536 /** O_ASYNC requests */
537 struct fasync_struct *fasync;
538
539 /** Device-specific callbacks */
540 const struct fuse_iqueue_ops *ops;
541
542 /** Device-specific state */
543 void *priv;
544 };
545
546 #define FUSE_PQ_HASH_BITS 8
547 #define FUSE_PQ_HASH_SIZE (1 << FUSE_PQ_HASH_BITS)
548
549 struct fuse_pqueue {
550 /** Connection established */
551 unsigned connected;
552
553 /** Lock protecting accessess to members of this structure */
554 spinlock_t lock;
555
556 /** Hash table of requests being processed */
557 struct list_head *processing;
558
559 /** The list of requests under I/O */
560 struct list_head io;
561 };
562
563 /**
564 * Fuse device instance
565 */
566 struct fuse_dev {
567 /** Fuse connection for this device */
568 struct fuse_conn *fc;
569
570 /** Processing queue */
571 struct fuse_pqueue pq;
572
573 /** list entry on fc->devices */
574 struct list_head entry;
575 };
576
577 enum fuse_dax_mode {
578 FUSE_DAX_INODE_DEFAULT, /* default */
579 FUSE_DAX_ALWAYS, /* "-o dax=always" */
580 FUSE_DAX_NEVER, /* "-o dax=never" */
581 FUSE_DAX_INODE_USER, /* "-o dax=inode" */
582 };
583
fuse_is_inode_dax_mode(enum fuse_dax_mode mode)584 static inline bool fuse_is_inode_dax_mode(enum fuse_dax_mode mode)
585 {
586 return mode == FUSE_DAX_INODE_DEFAULT || mode == FUSE_DAX_INODE_USER;
587 }
588
589 struct fuse_fs_context {
590 int fd;
591 struct file *file;
592 unsigned int rootmode;
593 kuid_t user_id;
594 kgid_t group_id;
595 bool is_bdev:1;
596 bool fd_present:1;
597 bool rootmode_present:1;
598 bool user_id_present:1;
599 bool group_id_present:1;
600 bool default_permissions:1;
601 bool allow_other:1;
602 bool destroy:1;
603 bool no_control:1;
604 bool no_force_umount:1;
605 bool legacy_opts_show:1;
606 enum fuse_dax_mode dax_mode;
607 unsigned int max_read;
608 unsigned int blksize;
609 const char *subtype;
610
611 /* DAX device, may be NULL */
612 struct dax_device *dax_dev;
613
614 /* fuse_dev pointer to fill in, should contain NULL on entry */
615 void **fudptr;
616 };
617
618 struct fuse_sync_bucket {
619 /* count is a possible scalability bottleneck */
620 atomic_t count;
621 wait_queue_head_t waitq;
622 struct rcu_head rcu;
623 };
624
625 /**
626 * A Fuse connection.
627 *
628 * This structure is created, when the root filesystem is mounted, and
629 * is destroyed, when the client device is closed and the last
630 * fuse_mount is destroyed.
631 */
632 struct fuse_conn {
633 /** Lock protecting accessess to members of this structure */
634 spinlock_t lock;
635
636 /** Refcount */
637 refcount_t count;
638
639 /** Number of fuse_dev's */
640 atomic_t dev_count;
641
642 /** Current epoch for up-to-date dentries */
643 atomic_t epoch;
644
645 struct rcu_head rcu;
646
647 /** The user id for this mount */
648 kuid_t user_id;
649
650 /** The group id for this mount */
651 kgid_t group_id;
652
653 /** The pid namespace for this mount */
654 struct pid_namespace *pid_ns;
655
656 /** The user namespace for this mount */
657 struct user_namespace *user_ns;
658
659 /** Maximum read size */
660 unsigned max_read;
661
662 /** Maximum write size */
663 unsigned max_write;
664
665 /** Maximum number of pages that can be used in a single request */
666 unsigned int max_pages;
667
668 /** Constrain ->max_pages to this value during feature negotiation */
669 unsigned int max_pages_limit;
670
671 /** Input queue */
672 struct fuse_iqueue iq;
673
674 /** The next unique kernel file handle */
675 atomic64_t khctr;
676
677 /** rbtree of fuse_files waiting for poll events indexed by ph */
678 struct rb_root polled_files;
679
680 /** Maximum number of outstanding background requests */
681 unsigned max_background;
682
683 /** Number of background requests at which congestion starts */
684 unsigned congestion_threshold;
685
686 /** Number of requests currently in the background */
687 unsigned num_background;
688
689 /** Number of background requests currently queued for userspace */
690 unsigned active_background;
691
692 /** The list of background requests set aside for later queuing */
693 struct list_head bg_queue;
694
695 /** Protects: max_background, congestion_threshold, num_background,
696 * active_background, bg_queue, blocked */
697 spinlock_t bg_lock;
698
699 /** Flag indicating that INIT reply has been received. Allocating
700 * any fuse request will be suspended until the flag is set */
701 int initialized;
702
703 /** Flag indicating if connection is blocked. This will be
704 the case before the INIT reply is received, and if there
705 are too many outstading backgrounds requests */
706 int blocked;
707
708 /** waitq for blocked connection */
709 wait_queue_head_t blocked_waitq;
710
711 /** Connection established, cleared on umount, connection
712 abort and device release */
713 unsigned connected;
714
715 /** Connection aborted via sysfs */
716 bool aborted;
717
718 /** Connection failed (version mismatch). Cannot race with
719 setting other bitfields since it is only set once in INIT
720 reply, before any other request, and never cleared */
721 unsigned conn_error:1;
722
723 /** Connection successful. Only set in INIT */
724 unsigned conn_init:1;
725
726 /** Do readahead asynchronously? Only set in INIT */
727 unsigned async_read:1;
728
729 /** Return an unique read error after abort. Only set in INIT */
730 unsigned abort_err:1;
731
732 /** Do not send separate SETATTR request before open(O_TRUNC) */
733 unsigned atomic_o_trunc:1;
734
735 /** Filesystem supports NFS exporting. Only set in INIT */
736 unsigned export_support:1;
737
738 /** write-back cache policy (default is write-through) */
739 unsigned writeback_cache:1;
740
741 /** allow parallel lookups and readdir (default is serialized) */
742 unsigned parallel_dirops:1;
743
744 /** handle fs handles killing suid/sgid/cap on write/chown/trunc */
745 unsigned handle_killpriv:1;
746
747 /** cache READLINK responses in page cache */
748 unsigned cache_symlinks:1;
749
750 /* show legacy mount options */
751 unsigned int legacy_opts_show:1;
752
753 /*
754 * fs kills suid/sgid/cap on write/chown/trunc. suid is killed on
755 * write/trunc only if caller did not have CAP_FSETID. sgid is killed
756 * on write/truncate only if caller did not have CAP_FSETID as well as
757 * file has group execute permission.
758 */
759 unsigned handle_killpriv_v2:1;
760
761 /*
762 * The following bitfields are only for optimization purposes
763 * and hence races in setting them will not cause malfunction
764 */
765
766 /** Is open/release not implemented by fs? */
767 unsigned no_open:1;
768
769 /** Is opendir/releasedir not implemented by fs? */
770 unsigned no_opendir:1;
771
772 /** Is fsync not implemented by fs? */
773 unsigned no_fsync:1;
774
775 /** Is fsyncdir not implemented by fs? */
776 unsigned no_fsyncdir:1;
777
778 /** Is flush not implemented by fs? */
779 unsigned no_flush:1;
780
781 /** Is setxattr not implemented by fs? */
782 unsigned no_setxattr:1;
783
784 /** Does file server support extended setxattr */
785 unsigned setxattr_ext:1;
786
787 /** Is getxattr not implemented by fs? */
788 unsigned no_getxattr:1;
789
790 /** Is listxattr not implemented by fs? */
791 unsigned no_listxattr:1;
792
793 /** Is removexattr not implemented by fs? */
794 unsigned no_removexattr:1;
795
796 /** Are posix file locking primitives not implemented by fs? */
797 unsigned no_lock:1;
798
799 /** Is access not implemented by fs? */
800 unsigned no_access:1;
801
802 /** Is create not implemented by fs? */
803 unsigned no_create:1;
804
805 /** Is interrupt not implemented by fs? */
806 unsigned no_interrupt:1;
807
808 /** Is bmap not implemented by fs? */
809 unsigned no_bmap:1;
810
811 /** Is poll not implemented by fs? */
812 unsigned no_poll:1;
813
814 /** Do multi-page cached writes */
815 unsigned big_writes:1;
816
817 /** Don't apply umask to creation modes */
818 unsigned dont_mask:1;
819
820 /** Are BSD file locking primitives not implemented by fs? */
821 unsigned no_flock:1;
822
823 /** Is fallocate not implemented by fs? */
824 unsigned no_fallocate:1;
825
826 /** Is rename with flags implemented by fs? */
827 unsigned no_rename2:1;
828
829 /** Use enhanced/automatic page cache invalidation. */
830 unsigned auto_inval_data:1;
831
832 /** Filesystem is fully responsible for page cache invalidation. */
833 unsigned explicit_inval_data:1;
834
835 /** Does the filesystem support readdirplus? */
836 unsigned do_readdirplus:1;
837
838 /** Does the filesystem want adaptive readdirplus? */
839 unsigned readdirplus_auto:1;
840
841 /** Does the filesystem support asynchronous direct-IO submission? */
842 unsigned async_dio:1;
843
844 /** Is lseek not implemented by fs? */
845 unsigned no_lseek:1;
846
847 /** Does the filesystem support posix acls? */
848 unsigned posix_acl:1;
849
850 /** Check permissions based on the file mode or not? */
851 unsigned default_permissions:1;
852
853 /** Allow other than the mounter user to access the filesystem ? */
854 unsigned allow_other:1;
855
856 /** Does the filesystem support copy_file_range? */
857 unsigned no_copy_file_range:1;
858
859 /* Send DESTROY request */
860 unsigned int destroy:1;
861
862 /* Delete dentries that have gone stale */
863 unsigned int delete_stale:1;
864
865 /** Do not create entry in fusectl fs */
866 unsigned int no_control:1;
867
868 /** Do not allow MNT_FORCE umount */
869 unsigned int no_force_umount:1;
870
871 /* Auto-mount submounts announced by the server */
872 unsigned int auto_submounts:1;
873
874 /* Propagate syncfs() to server */
875 unsigned int sync_fs:1;
876
877 /* Initialize security xattrs when creating a new inode */
878 unsigned int init_security:1;
879
880 /* Add supplementary group info when creating a new inode */
881 unsigned int create_supp_group:1;
882
883 /* Does the filesystem support per inode DAX? */
884 unsigned int inode_dax:1;
885
886 /* Is tmpfile not implemented by fs? */
887 unsigned int no_tmpfile:1;
888
889 /* Relax restrictions to allow shared mmap in FOPEN_DIRECT_IO mode */
890 unsigned int direct_io_allow_mmap:1;
891
892 /* Is statx not implemented by fs? */
893 unsigned int no_statx:1;
894
895 /** Passthrough support for read/write IO */
896 unsigned int passthrough:1;
897
898 /* Use pages instead of pointer for kernel I/O */
899 unsigned int use_pages_for_kvec_io:1;
900
901 /* Is link not implemented by fs? */
902 unsigned int no_link:1;
903
904 /* Use io_uring for communication */
905 unsigned int io_uring;
906
907 /** Maximum stack depth for passthrough backing files */
908 int max_stack_depth;
909
910 /** The number of requests waiting for completion */
911 atomic_t num_waiting;
912
913 /** Negotiated minor version */
914 unsigned minor;
915
916 /** Entry on the fuse_conn_list */
917 struct list_head entry;
918
919 /** Device ID from the root super block */
920 dev_t dev;
921
922 /** Key for lock owner ID scrambling */
923 u32 scramble_key[4];
924
925 /** Version counter for attribute changes */
926 atomic64_t attr_version;
927
928 /** Version counter for evict inode */
929 atomic64_t evict_ctr;
930
931 /* maximum file name length */
932 u32 name_max;
933
934 /** Called on final put */
935 void (*release)(struct fuse_conn *);
936
937 /**
938 * Read/write semaphore to hold when accessing the sb of any
939 * fuse_mount belonging to this connection
940 */
941 struct rw_semaphore killsb;
942
943 /** List of device instances belonging to this connection */
944 struct list_head devices;
945
946 #ifdef CONFIG_FUSE_DAX
947 /* Dax mode */
948 enum fuse_dax_mode dax_mode;
949
950 /* Dax specific conn data, non-NULL if DAX is enabled */
951 struct fuse_conn_dax *dax;
952 #endif
953
954 /** List of filesystems using this connection */
955 struct list_head mounts;
956
957 /* New writepages go into this bucket */
958 struct fuse_sync_bucket __rcu *curr_bucket;
959
960 #ifdef CONFIG_FUSE_PASSTHROUGH
961 /** IDR for backing files ids */
962 struct idr backing_files_map;
963 #endif
964
965 #ifdef CONFIG_FUSE_IO_URING
966 /** uring connection information*/
967 struct fuse_ring *ring;
968 #endif
969
970 /** Only used if the connection opts into request timeouts */
971 struct {
972 /* Worker for checking if any requests have timed out */
973 struct delayed_work work;
974
975 /* Request timeout (in jiffies). 0 = no timeout */
976 unsigned int req_timeout;
977 } timeout;
978
979 /*
980 * This is a workaround until fuse uses iomap for reads.
981 * For fuseblk servers, this represents the blocksize passed in at
982 * mount time and for regular fuse servers, this is equivalent to
983 * inode->i_blkbits.
984 */
985 u8 blkbits;
986 };
987
988 /*
989 * Represents a mounted filesystem, potentially a submount.
990 *
991 * This object allows sharing a fuse_conn between separate mounts to
992 * allow submounts with dedicated superblocks and thus separate device
993 * IDs.
994 */
995 struct fuse_mount {
996 /* Underlying (potentially shared) connection to the FUSE server */
997 struct fuse_conn *fc;
998
999 /*
1000 * Super block for this connection (fc->killsb must be held when
1001 * accessing this).
1002 */
1003 struct super_block *sb;
1004
1005 /* Entry on fc->mounts */
1006 struct list_head fc_entry;
1007 struct rcu_head rcu;
1008 };
1009
1010 /*
1011 * Empty header for FUSE opcodes without specific header needs.
1012 * Used as a placeholder in args->in_args[0] for consistency
1013 * across all FUSE operations, simplifying request handling.
1014 */
1015 struct fuse_zero_header {};
1016
fuse_set_zero_arg0(struct fuse_args * args)1017 static inline void fuse_set_zero_arg0(struct fuse_args *args)
1018 {
1019 args->in_args[0].size = sizeof(struct fuse_zero_header);
1020 args->in_args[0].value = NULL;
1021 }
1022
get_fuse_mount_super(struct super_block * sb)1023 static inline struct fuse_mount *get_fuse_mount_super(struct super_block *sb)
1024 {
1025 return sb->s_fs_info;
1026 }
1027
get_fuse_conn_super(struct super_block * sb)1028 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
1029 {
1030 return get_fuse_mount_super(sb)->fc;
1031 }
1032
get_fuse_mount(struct inode * inode)1033 static inline struct fuse_mount *get_fuse_mount(struct inode *inode)
1034 {
1035 return get_fuse_mount_super(inode->i_sb);
1036 }
1037
get_fuse_conn(struct inode * inode)1038 static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
1039 {
1040 return get_fuse_mount_super(inode->i_sb)->fc;
1041 }
1042
get_fuse_inode(struct inode * inode)1043 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
1044 {
1045 return container_of(inode, struct fuse_inode, inode);
1046 }
1047
get_node_id(struct inode * inode)1048 static inline u64 get_node_id(struct inode *inode)
1049 {
1050 return get_fuse_inode(inode)->nodeid;
1051 }
1052
invalid_nodeid(u64 nodeid)1053 static inline int invalid_nodeid(u64 nodeid)
1054 {
1055 return !nodeid || nodeid == FUSE_ROOT_ID;
1056 }
1057
fuse_get_attr_version(struct fuse_conn * fc)1058 static inline u64 fuse_get_attr_version(struct fuse_conn *fc)
1059 {
1060 return atomic64_read(&fc->attr_version);
1061 }
1062
fuse_get_evict_ctr(struct fuse_conn * fc)1063 static inline u64 fuse_get_evict_ctr(struct fuse_conn *fc)
1064 {
1065 return atomic64_read(&fc->evict_ctr);
1066 }
1067
fuse_stale_inode(const struct inode * inode,int generation,struct fuse_attr * attr)1068 static inline bool fuse_stale_inode(const struct inode *inode, int generation,
1069 struct fuse_attr *attr)
1070 {
1071 return inode->i_generation != generation ||
1072 inode_wrong_type(inode, attr->mode);
1073 }
1074
fuse_make_bad(struct inode * inode)1075 static inline void fuse_make_bad(struct inode *inode)
1076 {
1077 set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);
1078 }
1079
fuse_is_bad(struct inode * inode)1080 static inline bool fuse_is_bad(struct inode *inode)
1081 {
1082 return unlikely(test_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state));
1083 }
1084
fuse_folios_alloc(unsigned int nfolios,gfp_t flags,struct fuse_folio_desc ** desc)1085 static inline struct folio **fuse_folios_alloc(unsigned int nfolios, gfp_t flags,
1086 struct fuse_folio_desc **desc)
1087 {
1088 struct folio **folios;
1089
1090 folios = kzalloc(nfolios * (sizeof(struct folio *) +
1091 sizeof(struct fuse_folio_desc)), flags);
1092 *desc = (void *) (folios + nfolios);
1093
1094 return folios;
1095 }
1096
fuse_folio_descs_length_init(struct fuse_folio_desc * descs,unsigned int index,unsigned int nr_folios)1097 static inline void fuse_folio_descs_length_init(struct fuse_folio_desc *descs,
1098 unsigned int index,
1099 unsigned int nr_folios)
1100 {
1101 int i;
1102
1103 for (i = index; i < index + nr_folios; i++)
1104 descs[i].length = PAGE_SIZE - descs[i].offset;
1105 }
1106
fuse_sync_bucket_dec(struct fuse_sync_bucket * bucket)1107 static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)
1108 {
1109 /* Need RCU protection to prevent use after free after the decrement */
1110 rcu_read_lock();
1111 if (atomic_dec_and_test(&bucket->count))
1112 wake_up(&bucket->waitq);
1113 rcu_read_unlock();
1114 }
1115
1116 /** Device operations */
1117 extern const struct file_operations fuse_dev_operations;
1118
1119 extern const struct dentry_operations fuse_dentry_operations;
1120
1121 /**
1122 * Get a filled in inode
1123 */
1124 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
1125 int generation, struct fuse_attr *attr,
1126 u64 attr_valid, u64 attr_version,
1127 u64 evict_ctr);
1128
1129 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
1130 struct fuse_entry_out *outarg, struct inode **inode);
1131
1132 /**
1133 * Send FORGET command
1134 */
1135 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
1136 u64 nodeid, u64 nlookup);
1137
1138 struct fuse_forget_link *fuse_alloc_forget(void);
1139
1140 /*
1141 * Initialize READ or READDIR request
1142 */
1143 struct fuse_io_args {
1144 union {
1145 struct {
1146 struct fuse_read_in in;
1147 u64 attr_ver;
1148 } read;
1149 struct {
1150 struct fuse_write_in in;
1151 struct fuse_write_out out;
1152 bool folio_locked;
1153 } write;
1154 };
1155 struct fuse_args_pages ap;
1156 struct fuse_io_priv *io;
1157 struct fuse_file *ff;
1158 };
1159
1160 void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos,
1161 size_t count, int opcode);
1162
1163
1164 struct fuse_file *fuse_file_alloc(struct fuse_mount *fm, bool release);
1165 void fuse_file_free(struct fuse_file *ff);
1166 int fuse_finish_open(struct inode *inode, struct file *file);
1167
1168 void fuse_sync_release(struct fuse_inode *fi, struct fuse_file *ff,
1169 unsigned int flags);
1170
1171 /**
1172 * Send RELEASE or RELEASEDIR request
1173 */
1174 void fuse_release_common(struct file *file, bool isdir);
1175
1176 /**
1177 * Send FSYNC or FSYNCDIR request
1178 */
1179 int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
1180 int datasync, int opcode);
1181
1182 /**
1183 * Notify poll wakeup
1184 */
1185 int fuse_notify_poll_wakeup(struct fuse_conn *fc,
1186 struct fuse_notify_poll_wakeup_out *outarg);
1187
1188 /**
1189 * Initialize file operations on a regular file
1190 */
1191 void fuse_init_file_inode(struct inode *inode, unsigned int flags);
1192
1193 /**
1194 * Initialize inode operations on regular files and special files
1195 */
1196 void fuse_init_common(struct inode *inode);
1197
1198 /**
1199 * Initialize inode and file operations on a directory
1200 */
1201 void fuse_init_dir(struct inode *inode);
1202
1203 /**
1204 * Initialize inode operations on a symlink
1205 */
1206 void fuse_init_symlink(struct inode *inode);
1207
1208 /**
1209 * Change attributes of an inode
1210 */
1211 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
1212 struct fuse_statx *sx,
1213 u64 attr_valid, u64 attr_version);
1214
1215 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
1216 struct fuse_statx *sx,
1217 u64 attr_valid, u32 cache_mask,
1218 u64 evict_ctr);
1219
1220 u32 fuse_get_cache_mask(struct inode *inode);
1221
1222 /**
1223 * Initialize the client device
1224 */
1225 int fuse_dev_init(void);
1226
1227 /**
1228 * Cleanup the client device
1229 */
1230 void fuse_dev_cleanup(void);
1231
1232 int fuse_ctl_init(void);
1233 void __exit fuse_ctl_cleanup(void);
1234
1235 /**
1236 * Simple request sending that does request allocation and freeing
1237 */
1238 ssize_t __fuse_simple_request(struct mnt_idmap *idmap,
1239 struct fuse_mount *fm,
1240 struct fuse_args *args);
1241
fuse_simple_request(struct fuse_mount * fm,struct fuse_args * args)1242 static inline ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args)
1243 {
1244 return __fuse_simple_request(&invalid_mnt_idmap, fm, args);
1245 }
1246
fuse_simple_idmap_request(struct mnt_idmap * idmap,struct fuse_mount * fm,struct fuse_args * args)1247 static inline ssize_t fuse_simple_idmap_request(struct mnt_idmap *idmap,
1248 struct fuse_mount *fm,
1249 struct fuse_args *args)
1250 {
1251 return __fuse_simple_request(idmap, fm, args);
1252 }
1253
1254 int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args,
1255 gfp_t gfp_flags);
1256
1257 /**
1258 * End a finished request
1259 */
1260 void fuse_request_end(struct fuse_req *req);
1261
1262 /* Abort all requests */
1263 void fuse_abort_conn(struct fuse_conn *fc);
1264 void fuse_wait_aborted(struct fuse_conn *fc);
1265
1266 /* Check if any requests timed out */
1267 void fuse_check_timeout(struct work_struct *work);
1268
1269 /**
1270 * Invalidate inode attributes
1271 */
1272
1273 /* Attributes possibly changed on data modification */
1274 #define FUSE_STATX_MODIFY (STATX_MTIME | STATX_CTIME | STATX_BLOCKS)
1275
1276 /* Attributes possibly changed on data and/or size modification */
1277 #define FUSE_STATX_MODSIZE (FUSE_STATX_MODIFY | STATX_SIZE)
1278
1279 void fuse_invalidate_attr(struct inode *inode);
1280 void fuse_invalidate_attr_mask(struct inode *inode, u32 mask);
1281
1282 void fuse_invalidate_entry_cache(struct dentry *entry);
1283
1284 void fuse_invalidate_atime(struct inode *inode);
1285
1286 u64 fuse_time_to_jiffies(u64 sec, u32 nsec);
1287 #define ATTR_TIMEOUT(o) \
1288 fuse_time_to_jiffies((o)->attr_valid, (o)->attr_valid_nsec)
1289
1290 void fuse_change_entry_timeout(struct dentry *entry, struct fuse_entry_out *o);
1291
1292 /**
1293 * Acquire reference to fuse_conn
1294 */
1295 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
1296
1297 /**
1298 * Initialize the fuse processing queue
1299 */
1300 void fuse_pqueue_init(struct fuse_pqueue *fpq);
1301
1302 /**
1303 * Initialize fuse_conn
1304 */
1305 void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
1306 struct user_namespace *user_ns,
1307 const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv);
1308
1309 /**
1310 * Release reference to fuse_conn
1311 */
1312 void fuse_conn_put(struct fuse_conn *fc);
1313
1314 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc);
1315 struct fuse_dev *fuse_dev_alloc(void);
1316 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc);
1317 void fuse_dev_free(struct fuse_dev *fud);
1318 void fuse_send_init(struct fuse_mount *fm);
1319
1320 /**
1321 * Fill in superblock and initialize fuse connection
1322 * @sb: partially-initialized superblock to fill in
1323 * @ctx: mount context
1324 */
1325 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx);
1326
1327 /*
1328 * Remove the mount from the connection
1329 *
1330 * Returns whether this was the last mount
1331 */
1332 bool fuse_mount_remove(struct fuse_mount *fm);
1333
1334 /*
1335 * Setup context ops for submounts
1336 */
1337 int fuse_init_fs_context_submount(struct fs_context *fsc);
1338
1339 /*
1340 * Shut down the connection (possibly sending DESTROY request).
1341 */
1342 void fuse_conn_destroy(struct fuse_mount *fm);
1343
1344 /* Drop the connection and free the fuse mount */
1345 void fuse_mount_destroy(struct fuse_mount *fm);
1346
1347 /**
1348 * Add connection to control filesystem
1349 */
1350 int fuse_ctl_add_conn(struct fuse_conn *fc);
1351
1352 /**
1353 * Remove connection from control filesystem
1354 */
1355 void fuse_ctl_remove_conn(struct fuse_conn *fc);
1356
1357 /**
1358 * Is file type valid?
1359 */
1360 int fuse_valid_type(int m);
1361
1362 bool fuse_invalid_attr(struct fuse_attr *attr);
1363
1364 /**
1365 * Is current process allowed to perform filesystem operation?
1366 */
1367 bool fuse_allow_current_process(struct fuse_conn *fc);
1368
1369 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
1370
1371 void fuse_flush_time_update(struct inode *inode);
1372 void fuse_update_ctime(struct inode *inode);
1373
1374 int fuse_update_attributes(struct inode *inode, struct file *file, u32 mask);
1375
1376 void fuse_flush_writepages(struct inode *inode);
1377
1378 void fuse_set_nowrite(struct inode *inode);
1379 void fuse_release_nowrite(struct inode *inode);
1380
1381 /**
1382 * Scan all fuse_mounts belonging to fc to find the first where
1383 * ilookup5() returns a result. Return that result and the
1384 * respective fuse_mount in *fm (unless fm is NULL).
1385 *
1386 * The caller must hold fc->killsb.
1387 */
1388 struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
1389 struct fuse_mount **fm);
1390
1391 /**
1392 * File-system tells the kernel to invalidate cache for the given node id.
1393 */
1394 int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
1395 loff_t offset, loff_t len);
1396
1397 /**
1398 * File-system tells the kernel to invalidate parent attributes and
1399 * the dentry matching parent/name.
1400 *
1401 * If the child_nodeid is non-zero and:
1402 * - matches the inode number for the dentry matching parent/name,
1403 * - is not a mount point
1404 * - is a file or oan empty directory
1405 * then the dentry is unhashed (d_delete()).
1406 */
1407 int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
1408 u64 child_nodeid, struct qstr *name, u32 flags);
1409
1410 int fuse_do_open(struct fuse_mount *fm, u64 nodeid, struct file *file,
1411 bool isdir);
1412
1413 /**
1414 * fuse_direct_io() flags
1415 */
1416
1417 /** If set, it is WRITE; otherwise - READ */
1418 #define FUSE_DIO_WRITE (1 << 0)
1419
1420 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */
1421 #define FUSE_DIO_CUSE (1 << 1)
1422
1423 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
1424 loff_t *ppos, int flags);
1425 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
1426 unsigned int flags);
1427 long fuse_ioctl_common(struct file *file, unsigned int cmd,
1428 unsigned long arg, unsigned int flags);
1429 __poll_t fuse_file_poll(struct file *file, poll_table *wait);
1430 int fuse_dev_release(struct inode *inode, struct file *file);
1431
1432 bool fuse_write_update_attr(struct inode *inode, loff_t pos, ssize_t written);
1433
1434 int fuse_flush_times(struct inode *inode, struct fuse_file *ff);
1435 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc);
1436
1437 int fuse_do_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
1438 struct iattr *attr, struct file *file);
1439
1440 void fuse_set_initialized(struct fuse_conn *fc);
1441
1442 void fuse_unlock_inode(struct inode *inode, bool locked);
1443 bool fuse_lock_inode(struct inode *inode);
1444
1445 int fuse_setxattr(struct inode *inode, const char *name, const void *value,
1446 size_t size, int flags, unsigned int extra_flags);
1447 ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
1448 size_t size);
1449 ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size);
1450 int fuse_removexattr(struct inode *inode, const char *name);
1451 extern const struct xattr_handler * const fuse_xattr_handlers[];
1452
1453 struct posix_acl;
1454 struct posix_acl *fuse_get_inode_acl(struct inode *inode, int type, bool rcu);
1455 struct posix_acl *fuse_get_acl(struct mnt_idmap *idmap,
1456 struct dentry *dentry, int type);
1457 int fuse_set_acl(struct mnt_idmap *, struct dentry *dentry,
1458 struct posix_acl *acl, int type);
1459
1460 /* readdir.c */
1461 int fuse_readdir(struct file *file, struct dir_context *ctx);
1462
1463 /**
1464 * Return the number of bytes in an arguments list
1465 */
1466 unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args);
1467
1468 /**
1469 * Get the next unique ID for a request
1470 */
1471 u64 fuse_get_unique(struct fuse_iqueue *fiq);
1472 void fuse_free_conn(struct fuse_conn *fc);
1473
1474 /* dax.c */
1475
1476 #define FUSE_IS_DAX(inode) (IS_ENABLED(CONFIG_FUSE_DAX) && IS_DAX(inode))
1477
1478 ssize_t fuse_dax_read_iter(struct kiocb *iocb, struct iov_iter *to);
1479 ssize_t fuse_dax_write_iter(struct kiocb *iocb, struct iov_iter *from);
1480 int fuse_dax_mmap(struct file *file, struct vm_area_struct *vma);
1481 int fuse_dax_break_layouts(struct inode *inode, u64 dmap_start, u64 dmap_end);
1482 int fuse_dax_conn_alloc(struct fuse_conn *fc, enum fuse_dax_mode mode,
1483 struct dax_device *dax_dev);
1484 void fuse_dax_conn_free(struct fuse_conn *fc);
1485 bool fuse_dax_inode_alloc(struct super_block *sb, struct fuse_inode *fi);
1486 void fuse_dax_inode_init(struct inode *inode, unsigned int flags);
1487 void fuse_dax_inode_cleanup(struct inode *inode);
1488 void fuse_dax_dontcache(struct inode *inode, unsigned int flags);
1489 bool fuse_dax_check_alignment(struct fuse_conn *fc, unsigned int map_alignment);
1490 void fuse_dax_cancel_work(struct fuse_conn *fc);
1491
1492 /* ioctl.c */
1493 long fuse_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1494 long fuse_file_compat_ioctl(struct file *file, unsigned int cmd,
1495 unsigned long arg);
1496 int fuse_fileattr_get(struct dentry *dentry, struct file_kattr *fa);
1497 int fuse_fileattr_set(struct mnt_idmap *idmap,
1498 struct dentry *dentry, struct file_kattr *fa);
1499
1500 /* iomode.c */
1501 int fuse_file_cached_io_open(struct inode *inode, struct fuse_file *ff);
1502 int fuse_inode_uncached_io_start(struct fuse_inode *fi,
1503 struct fuse_backing *fb);
1504 void fuse_inode_uncached_io_end(struct fuse_inode *fi);
1505
1506 int fuse_file_io_open(struct file *file, struct inode *inode);
1507 void fuse_file_io_release(struct fuse_file *ff, struct inode *inode);
1508
1509 /* file.c */
1510 struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid,
1511 unsigned int open_flags, bool isdir);
1512 void fuse_file_release(struct inode *inode, struct fuse_file *ff,
1513 unsigned int open_flags, fl_owner_t id, bool isdir);
1514
1515 /* passthrough.c */
fuse_inode_backing(struct fuse_inode * fi)1516 static inline struct fuse_backing *fuse_inode_backing(struct fuse_inode *fi)
1517 {
1518 #ifdef CONFIG_FUSE_PASSTHROUGH
1519 return READ_ONCE(fi->fb);
1520 #else
1521 return NULL;
1522 #endif
1523 }
1524
fuse_inode_backing_set(struct fuse_inode * fi,struct fuse_backing * fb)1525 static inline struct fuse_backing *fuse_inode_backing_set(struct fuse_inode *fi,
1526 struct fuse_backing *fb)
1527 {
1528 #ifdef CONFIG_FUSE_PASSTHROUGH
1529 return xchg(&fi->fb, fb);
1530 #else
1531 return NULL;
1532 #endif
1533 }
1534
1535 #ifdef CONFIG_FUSE_PASSTHROUGH
1536 struct fuse_backing *fuse_backing_get(struct fuse_backing *fb);
1537 void fuse_backing_put(struct fuse_backing *fb);
1538 #else
1539
fuse_backing_get(struct fuse_backing * fb)1540 static inline struct fuse_backing *fuse_backing_get(struct fuse_backing *fb)
1541 {
1542 return NULL;
1543 }
1544
fuse_backing_put(struct fuse_backing * fb)1545 static inline void fuse_backing_put(struct fuse_backing *fb)
1546 {
1547 }
1548 #endif
1549
1550 void fuse_backing_files_init(struct fuse_conn *fc);
1551 void fuse_backing_files_free(struct fuse_conn *fc);
1552 int fuse_backing_open(struct fuse_conn *fc, struct fuse_backing_map *map);
1553 int fuse_backing_close(struct fuse_conn *fc, int backing_id);
1554
1555 struct fuse_backing *fuse_passthrough_open(struct file *file,
1556 struct inode *inode,
1557 int backing_id);
1558 void fuse_passthrough_release(struct fuse_file *ff, struct fuse_backing *fb);
1559
fuse_file_passthrough(struct fuse_file * ff)1560 static inline struct file *fuse_file_passthrough(struct fuse_file *ff)
1561 {
1562 #ifdef CONFIG_FUSE_PASSTHROUGH
1563 return ff->passthrough;
1564 #else
1565 return NULL;
1566 #endif
1567 }
1568
1569 ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter);
1570 ssize_t fuse_passthrough_write_iter(struct kiocb *iocb, struct iov_iter *iter);
1571 ssize_t fuse_passthrough_splice_read(struct file *in, loff_t *ppos,
1572 struct pipe_inode_info *pipe,
1573 size_t len, unsigned int flags);
1574 ssize_t fuse_passthrough_splice_write(struct pipe_inode_info *pipe,
1575 struct file *out, loff_t *ppos,
1576 size_t len, unsigned int flags);
1577 ssize_t fuse_passthrough_mmap(struct file *file, struct vm_area_struct *vma);
1578
1579 #ifdef CONFIG_SYSCTL
1580 extern int fuse_sysctl_register(void);
1581 extern void fuse_sysctl_unregister(void);
1582 #else
1583 #define fuse_sysctl_register() (0)
1584 #define fuse_sysctl_unregister() do { } while (0)
1585 #endif /* CONFIG_SYSCTL */
1586
1587 #endif /* _FS_FUSE_I_H */
1588