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