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