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