xref: /openbmc/linux/fs/fuse/fuse_i.h (revision 535e9bd0)
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 	struct rcu_head rcu;
892 };
893 
get_fuse_mount_super(struct super_block * sb)894 static inline struct fuse_mount *get_fuse_mount_super(struct super_block *sb)
895 {
896 	return sb->s_fs_info;
897 }
898 
get_fuse_conn_super(struct super_block * sb)899 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
900 {
901 	return get_fuse_mount_super(sb)->fc;
902 }
903 
get_fuse_mount(struct inode * inode)904 static inline struct fuse_mount *get_fuse_mount(struct inode *inode)
905 {
906 	return get_fuse_mount_super(inode->i_sb);
907 }
908 
get_fuse_conn(struct inode * inode)909 static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
910 {
911 	return get_fuse_mount_super(inode->i_sb)->fc;
912 }
913 
get_fuse_inode(struct inode * inode)914 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
915 {
916 	return container_of(inode, struct fuse_inode, inode);
917 }
918 
get_node_id(struct inode * inode)919 static inline u64 get_node_id(struct inode *inode)
920 {
921 	return get_fuse_inode(inode)->nodeid;
922 }
923 
invalid_nodeid(u64 nodeid)924 static inline int invalid_nodeid(u64 nodeid)
925 {
926 	return !nodeid || nodeid == FUSE_ROOT_ID;
927 }
928 
fuse_get_attr_version(struct fuse_conn * fc)929 static inline u64 fuse_get_attr_version(struct fuse_conn *fc)
930 {
931 	return atomic64_read(&fc->attr_version);
932 }
933 
fuse_stale_inode(const struct inode * inode,int generation,struct fuse_attr * attr)934 static inline bool fuse_stale_inode(const struct inode *inode, int generation,
935 				    struct fuse_attr *attr)
936 {
937 	return inode->i_generation != generation ||
938 		inode_wrong_type(inode, attr->mode);
939 }
940 
fuse_make_bad(struct inode * inode)941 static inline void fuse_make_bad(struct inode *inode)
942 {
943 	set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state);
944 }
945 
fuse_is_bad(struct inode * inode)946 static inline bool fuse_is_bad(struct inode *inode)
947 {
948 	return unlikely(test_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state));
949 }
950 
fuse_pages_alloc(unsigned int npages,gfp_t flags,struct fuse_page_desc ** desc)951 static inline struct page **fuse_pages_alloc(unsigned int npages, gfp_t flags,
952 					     struct fuse_page_desc **desc)
953 {
954 	struct page **pages;
955 
956 	pages = kzalloc(npages * (sizeof(struct page *) +
957 				  sizeof(struct fuse_page_desc)), flags);
958 	*desc = (void *) (pages + npages);
959 
960 	return pages;
961 }
962 
fuse_page_descs_length_init(struct fuse_page_desc * descs,unsigned int index,unsigned int nr_pages)963 static inline void fuse_page_descs_length_init(struct fuse_page_desc *descs,
964 					       unsigned int index,
965 					       unsigned int nr_pages)
966 {
967 	int i;
968 
969 	for (i = index; i < index + nr_pages; i++)
970 		descs[i].length = PAGE_SIZE - descs[i].offset;
971 }
972 
fuse_sync_bucket_dec(struct fuse_sync_bucket * bucket)973 static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket)
974 {
975 	/* Need RCU protection to prevent use after free after the decrement */
976 	rcu_read_lock();
977 	if (atomic_dec_and_test(&bucket->count))
978 		wake_up(&bucket->waitq);
979 	rcu_read_unlock();
980 }
981 
982 /** Device operations */
983 extern const struct file_operations fuse_dev_operations;
984 
985 extern const struct dentry_operations fuse_dentry_operations;
986 extern const struct dentry_operations fuse_root_dentry_operations;
987 
988 /**
989  * Get a filled in inode
990  */
991 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
992 			int generation, struct fuse_attr *attr,
993 			u64 attr_valid, u64 attr_version);
994 
995 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
996 		     struct fuse_entry_out *outarg, struct inode **inode);
997 
998 /**
999  * Send FORGET command
1000  */
1001 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
1002 		       u64 nodeid, u64 nlookup);
1003 
1004 struct fuse_forget_link *fuse_alloc_forget(void);
1005 
1006 struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq,
1007 					     unsigned int max,
1008 					     unsigned int *countp);
1009 
1010 /*
1011  * Initialize READ or READDIR request
1012  */
1013 struct fuse_io_args {
1014 	union {
1015 		struct {
1016 			struct fuse_read_in in;
1017 			u64 attr_ver;
1018 		} read;
1019 		struct {
1020 			struct fuse_write_in in;
1021 			struct fuse_write_out out;
1022 			bool page_locked;
1023 		} write;
1024 	};
1025 	struct fuse_args_pages ap;
1026 	struct fuse_io_priv *io;
1027 	struct fuse_file *ff;
1028 };
1029 
1030 void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos,
1031 			 size_t count, int opcode);
1032 
1033 
1034 /**
1035  * Send OPEN or OPENDIR request
1036  */
1037 int fuse_open_common(struct inode *inode, struct file *file, bool isdir);
1038 
1039 struct fuse_file *fuse_file_alloc(struct fuse_mount *fm);
1040 void fuse_file_free(struct fuse_file *ff);
1041 void fuse_finish_open(struct inode *inode, struct file *file);
1042 
1043 void fuse_sync_release(struct fuse_inode *fi, struct fuse_file *ff,
1044 		       unsigned int flags);
1045 
1046 /**
1047  * Send RELEASE or RELEASEDIR request
1048  */
1049 void fuse_release_common(struct file *file, bool isdir);
1050 
1051 /**
1052  * Send FSYNC or FSYNCDIR request
1053  */
1054 int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
1055 		      int datasync, int opcode);
1056 
1057 /**
1058  * Notify poll wakeup
1059  */
1060 int fuse_notify_poll_wakeup(struct fuse_conn *fc,
1061 			    struct fuse_notify_poll_wakeup_out *outarg);
1062 
1063 /**
1064  * Initialize file operations on a regular file
1065  */
1066 void fuse_init_file_inode(struct inode *inode, unsigned int flags);
1067 
1068 /**
1069  * Initialize inode operations on regular files and special files
1070  */
1071 void fuse_init_common(struct inode *inode);
1072 
1073 /**
1074  * Initialize inode and file operations on a directory
1075  */
1076 void fuse_init_dir(struct inode *inode);
1077 
1078 /**
1079  * Initialize inode operations on a symlink
1080  */
1081 void fuse_init_symlink(struct inode *inode);
1082 
1083 /**
1084  * Change attributes of an inode
1085  */
1086 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
1087 			    struct fuse_statx *sx,
1088 			    u64 attr_valid, u64 attr_version);
1089 
1090 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
1091 				   struct fuse_statx *sx,
1092 				   u64 attr_valid, u32 cache_mask);
1093 
1094 u32 fuse_get_cache_mask(struct inode *inode);
1095 
1096 /**
1097  * Initialize the client device
1098  */
1099 int fuse_dev_init(void);
1100 
1101 /**
1102  * Cleanup the client device
1103  */
1104 void fuse_dev_cleanup(void);
1105 
1106 int fuse_ctl_init(void);
1107 void __exit fuse_ctl_cleanup(void);
1108 
1109 /**
1110  * Simple request sending that does request allocation and freeing
1111  */
1112 ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args);
1113 int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args,
1114 			   gfp_t gfp_flags);
1115 
1116 /**
1117  * End a finished request
1118  */
1119 void fuse_request_end(struct fuse_req *req);
1120 
1121 /* Abort all requests */
1122 void fuse_abort_conn(struct fuse_conn *fc);
1123 void fuse_wait_aborted(struct fuse_conn *fc);
1124 
1125 /**
1126  * Invalidate inode attributes
1127  */
1128 
1129 /* Attributes possibly changed on data modification */
1130 #define FUSE_STATX_MODIFY	(STATX_MTIME | STATX_CTIME | STATX_BLOCKS)
1131 
1132 /* Attributes possibly changed on data and/or size modification */
1133 #define FUSE_STATX_MODSIZE	(FUSE_STATX_MODIFY | STATX_SIZE)
1134 
1135 void fuse_invalidate_attr(struct inode *inode);
1136 void fuse_invalidate_attr_mask(struct inode *inode, u32 mask);
1137 
1138 void fuse_invalidate_entry_cache(struct dentry *entry);
1139 
1140 void fuse_invalidate_atime(struct inode *inode);
1141 
1142 u64 fuse_time_to_jiffies(u64 sec, u32 nsec);
1143 #define ATTR_TIMEOUT(o) \
1144 	fuse_time_to_jiffies((o)->attr_valid, (o)->attr_valid_nsec)
1145 
1146 void fuse_change_entry_timeout(struct dentry *entry, struct fuse_entry_out *o);
1147 
1148 /**
1149  * Acquire reference to fuse_conn
1150  */
1151 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
1152 
1153 /**
1154  * Initialize fuse_conn
1155  */
1156 void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm,
1157 		    struct user_namespace *user_ns,
1158 		    const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv);
1159 
1160 /**
1161  * Release reference to fuse_conn
1162  */
1163 void fuse_conn_put(struct fuse_conn *fc);
1164 
1165 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc);
1166 struct fuse_dev *fuse_dev_alloc(void);
1167 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc);
1168 void fuse_dev_free(struct fuse_dev *fud);
1169 void fuse_send_init(struct fuse_mount *fm);
1170 
1171 /**
1172  * Fill in superblock and initialize fuse connection
1173  * @sb: partially-initialized superblock to fill in
1174  * @ctx: mount context
1175  */
1176 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx);
1177 
1178 /*
1179  * Remove the mount from the connection
1180  *
1181  * Returns whether this was the last mount
1182  */
1183 bool fuse_mount_remove(struct fuse_mount *fm);
1184 
1185 /*
1186  * Setup context ops for submounts
1187  */
1188 int fuse_init_fs_context_submount(struct fs_context *fsc);
1189 
1190 /*
1191  * Shut down the connection (possibly sending DESTROY request).
1192  */
1193 void fuse_conn_destroy(struct fuse_mount *fm);
1194 
1195 /* Drop the connection and free the fuse mount */
1196 void fuse_mount_destroy(struct fuse_mount *fm);
1197 
1198 /**
1199  * Add connection to control filesystem
1200  */
1201 int fuse_ctl_add_conn(struct fuse_conn *fc);
1202 
1203 /**
1204  * Remove connection from control filesystem
1205  */
1206 void fuse_ctl_remove_conn(struct fuse_conn *fc);
1207 
1208 /**
1209  * Is file type valid?
1210  */
1211 int fuse_valid_type(int m);
1212 
1213 bool fuse_invalid_attr(struct fuse_attr *attr);
1214 
1215 /**
1216  * Is current process allowed to perform filesystem operation?
1217  */
1218 bool fuse_allow_current_process(struct fuse_conn *fc);
1219 
1220 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
1221 
1222 void fuse_flush_time_update(struct inode *inode);
1223 void fuse_update_ctime(struct inode *inode);
1224 
1225 int fuse_update_attributes(struct inode *inode, struct file *file, u32 mask);
1226 
1227 void fuse_flush_writepages(struct inode *inode);
1228 
1229 void fuse_set_nowrite(struct inode *inode);
1230 void fuse_release_nowrite(struct inode *inode);
1231 
1232 /**
1233  * Scan all fuse_mounts belonging to fc to find the first where
1234  * ilookup5() returns a result.  Return that result and the
1235  * respective fuse_mount in *fm (unless fm is NULL).
1236  *
1237  * The caller must hold fc->killsb.
1238  */
1239 struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid,
1240 			   struct fuse_mount **fm);
1241 
1242 /**
1243  * File-system tells the kernel to invalidate cache for the given node id.
1244  */
1245 int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid,
1246 			     loff_t offset, loff_t len);
1247 
1248 /**
1249  * File-system tells the kernel to invalidate parent attributes and
1250  * the dentry matching parent/name.
1251  *
1252  * If the child_nodeid is non-zero and:
1253  *    - matches the inode number for the dentry matching parent/name,
1254  *    - is not a mount point
1255  *    - is a file or oan empty directory
1256  * then the dentry is unhashed (d_delete()).
1257  */
1258 int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
1259 			     u64 child_nodeid, struct qstr *name, u32 flags);
1260 
1261 int fuse_do_open(struct fuse_mount *fm, u64 nodeid, struct file *file,
1262 		 bool isdir);
1263 
1264 /**
1265  * fuse_direct_io() flags
1266  */
1267 
1268 /** If set, it is WRITE; otherwise - READ */
1269 #define FUSE_DIO_WRITE (1 << 0)
1270 
1271 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */
1272 #define FUSE_DIO_CUSE  (1 << 1)
1273 
1274 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter,
1275 		       loff_t *ppos, int flags);
1276 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
1277 		   unsigned int flags);
1278 long fuse_ioctl_common(struct file *file, unsigned int cmd,
1279 		       unsigned long arg, unsigned int flags);
1280 __poll_t fuse_file_poll(struct file *file, poll_table *wait);
1281 int fuse_dev_release(struct inode *inode, struct file *file);
1282 
1283 bool fuse_write_update_attr(struct inode *inode, loff_t pos, ssize_t written);
1284 
1285 int fuse_flush_times(struct inode *inode, struct fuse_file *ff);
1286 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc);
1287 
1288 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
1289 		    struct file *file);
1290 
1291 void fuse_set_initialized(struct fuse_conn *fc);
1292 
1293 void fuse_unlock_inode(struct inode *inode, bool locked);
1294 bool fuse_lock_inode(struct inode *inode);
1295 
1296 int fuse_setxattr(struct inode *inode, const char *name, const void *value,
1297 		  size_t size, int flags, unsigned int extra_flags);
1298 ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
1299 		      size_t size);
1300 ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size);
1301 int fuse_removexattr(struct inode *inode, const char *name);
1302 extern const struct xattr_handler *fuse_xattr_handlers[];
1303 
1304 struct posix_acl;
1305 struct posix_acl *fuse_get_inode_acl(struct inode *inode, int type, bool rcu);
1306 struct posix_acl *fuse_get_acl(struct mnt_idmap *idmap,
1307 			       struct dentry *dentry, int type);
1308 int fuse_set_acl(struct mnt_idmap *, struct dentry *dentry,
1309 		 struct posix_acl *acl, int type);
1310 
1311 /* readdir.c */
1312 int fuse_readdir(struct file *file, struct dir_context *ctx);
1313 
1314 /**
1315  * Return the number of bytes in an arguments list
1316  */
1317 unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args);
1318 
1319 /**
1320  * Get the next unique ID for a request
1321  */
1322 u64 fuse_get_unique(struct fuse_iqueue *fiq);
1323 void fuse_free_conn(struct fuse_conn *fc);
1324 
1325 /* dax.c */
1326 
1327 #define FUSE_IS_DAX(inode) (IS_ENABLED(CONFIG_FUSE_DAX) && IS_DAX(inode))
1328 
1329 ssize_t fuse_dax_read_iter(struct kiocb *iocb, struct iov_iter *to);
1330 ssize_t fuse_dax_write_iter(struct kiocb *iocb, struct iov_iter *from);
1331 int fuse_dax_mmap(struct file *file, struct vm_area_struct *vma);
1332 int fuse_dax_break_layouts(struct inode *inode, u64 dmap_start, u64 dmap_end);
1333 int fuse_dax_conn_alloc(struct fuse_conn *fc, enum fuse_dax_mode mode,
1334 			struct dax_device *dax_dev);
1335 void fuse_dax_conn_free(struct fuse_conn *fc);
1336 bool fuse_dax_inode_alloc(struct super_block *sb, struct fuse_inode *fi);
1337 void fuse_dax_inode_init(struct inode *inode, unsigned int flags);
1338 void fuse_dax_inode_cleanup(struct inode *inode);
1339 void fuse_dax_dontcache(struct inode *inode, unsigned int flags);
1340 bool fuse_dax_check_alignment(struct fuse_conn *fc, unsigned int map_alignment);
1341 void fuse_dax_cancel_work(struct fuse_conn *fc);
1342 
1343 /* ioctl.c */
1344 long fuse_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1345 long fuse_file_compat_ioctl(struct file *file, unsigned int cmd,
1346 			    unsigned long arg);
1347 int fuse_fileattr_get(struct dentry *dentry, struct fileattr *fa);
1348 int fuse_fileattr_set(struct mnt_idmap *idmap,
1349 		      struct dentry *dentry, struct fileattr *fa);
1350 
1351 /* file.c */
1352 
1353 struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid,
1354 				 unsigned int open_flags, bool isdir);
1355 void fuse_file_release(struct inode *inode, struct fuse_file *ff,
1356 		       unsigned int open_flags, fl_owner_t id, bool isdir);
1357 
1358 #endif /* _FS_FUSE_I_H */
1359