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#include <linux/fuse.h>
13#include <linux/fs.h>
14#include <linux/mount.h>
15#include <linux/wait.h>
16#include <linux/list.h>
17#include <linux/spinlock.h>
18#include <linux/mm.h>
19#include <linux/backing-dev.h>
20#include <linux/mutex.h>
21#include <linux/rwsem.h>
22#include <linux/rbtree.h>
23#include <linux/poll.h>
24
25/** Max number of pages that can be used in a single read request */
26#define FUSE_MAX_PAGES_PER_REQ 32
27
28/** Bias for fi->writectr, meaning new writepages must not be sent */
29#define FUSE_NOWRITE INT_MIN
30
31/** It could be as large as PATH_MAX, but would that have any uses? */
32#define FUSE_NAME_MAX 1024
33
34/** Number of dentries for each connection in the control filesystem */
35#define FUSE_CTL_NUM_DENTRIES 5
36
37/** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
38    module will check permissions based on the file mode.  Otherwise no
39    permission checking is done in the kernel */
40#define FUSE_DEFAULT_PERMISSIONS (1 << 0)
41
42/** If the FUSE_ALLOW_OTHER flag is given, then not only the user
43    doing the mount will be allowed to access the filesystem */
44#define FUSE_ALLOW_OTHER         (1 << 1)
45
46/** List of active connections */
47extern struct list_head fuse_conn_list;
48
49/** Global mutex protecting fuse_conn_list and the control filesystem */
50extern struct mutex fuse_mutex;
51
52/** Module parameters */
53extern unsigned max_user_bgreq;
54extern unsigned max_user_congthresh;
55
56/** FUSE inode */
57struct fuse_inode {
58	/** Inode data */
59	struct inode inode;
60
61	/** Unique ID, which identifies the inode between userspace
62	 * and kernel */
63	u64 nodeid;
64
65	/** Number of lookups on this inode */
66	u64 nlookup;
67
68	/** The request used for sending the FORGET message */
69	struct fuse_req *forget_req;
70
71	/** Time in jiffies until the file attributes are valid */
72	u64 i_time;
73
74	/** The sticky bit in inode->i_mode may have been removed, so
75	    preserve the original mode */
76	mode_t orig_i_mode;
77
78	/** Version of last attribute change */
79	u64 attr_version;
80
81	/** Files usable in writepage.  Protected by fc->lock */
82	struct list_head write_files;
83
84	/** Writepages pending on truncate or fsync */
85	struct list_head queued_writes;
86
87	/** Number of sent writes, a negative bias (FUSE_NOWRITE)
88	 * means more writes are blocked */
89	int writectr;
90
91	/** Waitq for writepage completion */
92	wait_queue_head_t page_waitq;
93
94	/** List of writepage requestst (pending or sent) */
95	struct list_head writepages;
96};
97
98struct fuse_conn;
99
100/** FUSE specific file data */
101struct fuse_file {
102	/** Fuse connection for this file */
103	struct fuse_conn *fc;
104
105	/** Request reserved for flush and release */
106	struct fuse_req *reserved_req;
107
108	/** Kernel file handle guaranteed to be unique */
109	u64 kh;
110
111	/** File handle used by userspace */
112	u64 fh;
113
114	/** Node id of this file */
115	u64 nodeid;
116
117	/** Refcount */
118	atomic_t count;
119
120	/** FOPEN_* flags returned by open */
121	u32 open_flags;
122
123	/** Entry on inode's write_files list */
124	struct list_head write_entry;
125
126	/** RB node to be linked on fuse_conn->polled_files */
127	struct rb_node polled_node;
128
129	/** Wait queue head for poll */
130	wait_queue_head_t poll_wait;
131};
132
133/** One input argument of a request */
134struct fuse_in_arg {
135	unsigned size;
136	const void *value;
137};
138
139/** The request input */
140struct fuse_in {
141	/** The request header */
142	struct fuse_in_header h;
143
144	/** True if the data for the last argument is in req->pages */
145	unsigned argpages:1;
146
147	/** Number of arguments */
148	unsigned numargs;
149
150	/** Array of arguments */
151	struct fuse_in_arg args[3];
152};
153
154/** One output argument of a request */
155struct fuse_arg {
156	unsigned size;
157	void *value;
158};
159
160/** The request output */
161struct fuse_out {
162	/** Header returned from userspace */
163	struct fuse_out_header h;
164
165	/*
166	 * The following bitfields are not changed during the request
167	 * processing
168	 */
169
170	/** Last argument is variable length (can be shorter than
171	    arg->size) */
172	unsigned argvar:1;
173
174	/** Last argument is a list of pages to copy data to */
175	unsigned argpages:1;
176
177	/** Zero partially or not copied pages */
178	unsigned page_zeroing:1;
179
180	/** Pages may be replaced with new ones */
181	unsigned page_replace:1;
182
183	/** Number or arguments */
184	unsigned numargs;
185
186	/** Array of arguments */
187	struct fuse_arg args[3];
188};
189
190/** The request state */
191enum fuse_req_state {
192	FUSE_REQ_INIT = 0,
193	FUSE_REQ_PENDING,
194	FUSE_REQ_READING,
195	FUSE_REQ_SENT,
196	FUSE_REQ_WRITING,
197	FUSE_REQ_FINISHED
198};
199
200/**
201 * A request to the client
202 */
203struct fuse_req {
204	/** This can be on either pending processing or io lists in
205	    fuse_conn */
206	struct list_head list;
207
208	/** Entry on the interrupts list  */
209	struct list_head intr_entry;
210
211	/** refcount */
212	atomic_t count;
213
214	/** Unique ID for the interrupt request */
215	u64 intr_unique;
216
217	/*
218	 * The following bitfields are either set once before the
219	 * request is queued or setting/clearing them is protected by
220	 * fuse_conn->lock
221	 */
222
223	/** True if the request has reply */
224	unsigned isreply:1;
225
226	/** Force sending of the request even if interrupted */
227	unsigned force:1;
228
229	/** The request was aborted */
230	unsigned aborted:1;
231
232	/** Request is sent in the background */
233	unsigned background:1;
234
235	/** The request has been interrupted */
236	unsigned interrupted:1;
237
238	/** Data is being copied to/from the request */
239	unsigned locked:1;
240
241	/** Request is counted as "waiting" */
242	unsigned waiting:1;
243
244	/** State of the request */
245	enum fuse_req_state state;
246
247	/** The request input */
248	struct fuse_in in;
249
250	/** The request output */
251	struct fuse_out out;
252
253	/** Used to wake up the task waiting for completion of request*/
254	wait_queue_head_t waitq;
255
256	/** Data for asynchronous requests */
257	union {
258		struct fuse_forget_in forget_in;
259		struct {
260			struct fuse_release_in in;
261			struct path path;
262		} release;
263		struct fuse_init_in init_in;
264		struct fuse_init_out init_out;
265		struct cuse_init_in cuse_init_in;
266		struct cuse_init_out cuse_init_out;
267		struct {
268			struct fuse_read_in in;
269			u64 attr_ver;
270		} read;
271		struct {
272			struct fuse_write_in in;
273			struct fuse_write_out out;
274		} write;
275		struct fuse_notify_retrieve_in retrieve_in;
276		struct fuse_lk_in lk_in;
277	} misc;
278
279	/** page vector */
280	struct page *pages[FUSE_MAX_PAGES_PER_REQ];
281
282	/** number of pages in vector */
283	unsigned num_pages;
284
285	/** offset of data on first page */
286	unsigned page_offset;
287
288	/** File used in the request (or NULL) */
289	struct fuse_file *ff;
290
291	/** Inode used in the request or NULL */
292	struct inode *inode;
293
294	/** Link on fi->writepages */
295	struct list_head writepages_entry;
296
297	/** Request completion callback */
298	void (*end)(struct fuse_conn *, struct fuse_req *);
299
300	/** Request is stolen from fuse_file->reserved_req */
301	struct file *stolen_file;
302};
303
304/**
305 * A Fuse connection.
306 *
307 * This structure is created, when the filesystem is mounted, and is
308 * destroyed, when the client device is closed and the filesystem is
309 * unmounted.
310 */
311struct fuse_conn {
312	/** Lock protecting accessess to  members of this structure */
313	spinlock_t lock;
314
315	/** Mutex protecting against directory alias creation */
316	struct mutex inst_mutex;
317
318	/** Refcount */
319	atomic_t count;
320
321	/** The user id for this mount */
322	uid_t user_id;
323
324	/** The group id for this mount */
325	gid_t group_id;
326
327	/** The fuse mount flags for this mount */
328	unsigned flags;
329
330	/** Maximum read size */
331	unsigned max_read;
332
333	/** Maximum write size */
334	unsigned max_write;
335
336	/** Readers of the connection are waiting on this */
337	wait_queue_head_t waitq;
338
339	/** The list of pending requests */
340	struct list_head pending;
341
342	/** The list of requests being processed */
343	struct list_head processing;
344
345	/** The list of requests under I/O */
346	struct list_head io;
347
348	/** The next unique kernel file handle */
349	u64 khctr;
350
351	/** rbtree of fuse_files waiting for poll events indexed by ph */
352	struct rb_root polled_files;
353
354	/** Maximum number of outstanding background requests */
355	unsigned max_background;
356
357	/** Number of background requests at which congestion starts */
358	unsigned congestion_threshold;
359
360	/** Number of requests currently in the background */
361	unsigned num_background;
362
363	/** Number of background requests currently queued for userspace */
364	unsigned active_background;
365
366	/** The list of background requests set aside for later queuing */
367	struct list_head bg_queue;
368
369	/** Pending interrupts */
370	struct list_head interrupts;
371
372	/** Flag indicating if connection is blocked.  This will be
373	    the case before the INIT reply is received, and if there
374	    are too many outstading backgrounds requests */
375	int blocked;
376
377	/** waitq for blocked connection */
378	wait_queue_head_t blocked_waitq;
379
380	/** waitq for reserved requests */
381	wait_queue_head_t reserved_req_waitq;
382
383	/** The next unique request id */
384	u64 reqctr;
385
386	/** Connection established, cleared on umount, connection
387	    abort and device release */
388	unsigned connected;
389
390	/** Connection failed (version mismatch).  Cannot race with
391	    setting other bitfields since it is only set once in INIT
392	    reply, before any other request, and never cleared */
393	unsigned conn_error:1;
394
395	/** Connection successful.  Only set in INIT */
396	unsigned conn_init:1;
397
398	/** Do readpages asynchronously?  Only set in INIT */
399	unsigned async_read:1;
400
401	/** Do not send separate SETATTR request before open(O_TRUNC)  */
402	unsigned atomic_o_trunc:1;
403
404	/** Filesystem supports NFS exporting.  Only set in INIT */
405	unsigned export_support:1;
406
407	/** Set if bdi is valid */
408	unsigned bdi_initialized:1;
409
410	/*
411	 * The following bitfields are only for optimization purposes
412	 * and hence races in setting them will not cause malfunction
413	 */
414
415	/** Is fsync not implemented by fs? */
416	unsigned no_fsync:1;
417
418	/** Is fsyncdir not implemented by fs? */
419	unsigned no_fsyncdir:1;
420
421	/** Is flush not implemented by fs? */
422	unsigned no_flush:1;
423
424	/** Is setxattr not implemented by fs? */
425	unsigned no_setxattr:1;
426
427	/** Is getxattr not implemented by fs? */
428	unsigned no_getxattr:1;
429
430	/** Is listxattr not implemented by fs? */
431	unsigned no_listxattr:1;
432
433	/** Is removexattr not implemented by fs? */
434	unsigned no_removexattr:1;
435
436	/** Are file locking primitives not implemented by fs? */
437	unsigned no_lock:1;
438
439	/** Is access not implemented by fs? */
440	unsigned no_access:1;
441
442	/** Is create not implemented by fs? */
443	unsigned no_create:1;
444
445	/** Is interrupt not implemented by fs? */
446	unsigned no_interrupt:1;
447
448	/** Is bmap not implemented by fs? */
449	unsigned no_bmap:1;
450
451	/** Is poll not implemented by fs? */
452	unsigned no_poll:1;
453
454	/** Do multi-page cached writes */
455	unsigned big_writes:1;
456
457	/** Don't apply umask to creation modes */
458	unsigned dont_mask:1;
459
460	/** The number of requests waiting for completion */
461	atomic_t num_waiting;
462
463	/** Negotiated minor version */
464	unsigned minor;
465
466	/** Backing dev info */
467	struct backing_dev_info bdi;
468
469	/** Entry on the fuse_conn_list */
470	struct list_head entry;
471
472	/** Device ID from super block */
473	dev_t dev;
474
475	/** Dentries in the control filesystem */
476	struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES];
477
478	/** number of dentries used in the above array */
479	int ctl_ndents;
480
481	/** O_ASYNC requests */
482	struct fasync_struct *fasync;
483
484	/** Key for lock owner ID scrambling */
485	u32 scramble_key[4];
486
487	/** Reserved request for the DESTROY message */
488	struct fuse_req *destroy_req;
489
490	/** Version counter for attribute changes */
491	u64 attr_version;
492
493	/** Called on final put */
494	void (*release)(struct fuse_conn *);
495
496	/** Super block for this connection. */
497	struct super_block *sb;
498
499	/** Read/write semaphore to hold when accessing sb. */
500	struct rw_semaphore killsb;
501};
502
503static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
504{
505	return sb->s_fs_info;
506}
507
508static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
509{
510	return get_fuse_conn_super(inode->i_sb);
511}
512
513static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
514{
515	return container_of(inode, struct fuse_inode, inode);
516}
517
518static inline u64 get_node_id(struct inode *inode)
519{
520	return get_fuse_inode(inode)->nodeid;
521}
522
523/** Device operations */
524extern const struct file_operations fuse_dev_operations;
525
526extern const struct dentry_operations fuse_dentry_operations;
527
528/**
529 * Inode to nodeid comparison.
530 */
531int fuse_inode_eq(struct inode *inode, void *_nodeidp);
532
533/**
534 * Get a filled in inode
535 */
536struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
537			int generation, struct fuse_attr *attr,
538			u64 attr_valid, u64 attr_version);
539
540int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
541		     struct fuse_entry_out *outarg, struct inode **inode);
542
543/**
544 * Send FORGET command
545 */
546void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
547		      u64 nodeid, u64 nlookup);
548
549/**
550 * Initialize READ or READDIR request
551 */
552void fuse_read_fill(struct fuse_req *req, struct file *file,
553		    loff_t pos, size_t count, int opcode);
554
555/**
556 * Send OPEN or OPENDIR request
557 */
558int fuse_open_common(struct inode *inode, struct file *file, bool isdir);
559
560struct fuse_file *fuse_file_alloc(struct fuse_conn *fc);
561struct fuse_file *fuse_file_get(struct fuse_file *ff);
562void fuse_file_free(struct fuse_file *ff);
563void fuse_finish_open(struct inode *inode, struct file *file);
564
565void fuse_sync_release(struct fuse_file *ff, int flags);
566
567/**
568 * Send RELEASE or RELEASEDIR request
569 */
570void fuse_release_common(struct file *file, int opcode);
571
572/**
573 * Send FSYNC or FSYNCDIR request
574 */
575int fuse_fsync_common(struct file *file, int datasync, int isdir);
576
577/**
578 * Notify poll wakeup
579 */
580int fuse_notify_poll_wakeup(struct fuse_conn *fc,
581			    struct fuse_notify_poll_wakeup_out *outarg);
582
583/**
584 * Initialize file operations on a regular file
585 */
586void fuse_init_file_inode(struct inode *inode);
587
588/**
589 * Initialize inode operations on regular files and special files
590 */
591void fuse_init_common(struct inode *inode);
592
593/**
594 * Initialize inode and file operations on a directory
595 */
596void fuse_init_dir(struct inode *inode);
597
598/**
599 * Initialize inode operations on a symlink
600 */
601void fuse_init_symlink(struct inode *inode);
602
603/**
604 * Change attributes of an inode
605 */
606void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
607			    u64 attr_valid, u64 attr_version);
608
609void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
610				   u64 attr_valid);
611
612/**
613 * Initialize the client device
614 */
615int fuse_dev_init(void);
616
617/**
618 * Cleanup the client device
619 */
620void fuse_dev_cleanup(void);
621
622int fuse_ctl_init(void);
623void fuse_ctl_cleanup(void);
624
625/**
626 * Allocate a request
627 */
628struct fuse_req *fuse_request_alloc(void);
629
630struct fuse_req *fuse_request_alloc_nofs(void);
631
632/**
633 * Free a request
634 */
635void fuse_request_free(struct fuse_req *req);
636
637/**
638 * Get a request, may fail with -ENOMEM
639 */
640struct fuse_req *fuse_get_req(struct fuse_conn *fc);
641
642/**
643 * Gets a requests for a file operation, always succeeds
644 */
645struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file);
646
647/**
648 * Decrement reference count of a request.  If count goes to zero free
649 * the request.
650 */
651void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);
652
653/**
654 * Send a request (synchronous)
655 */
656void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req);
657
658/**
659 * Send a request with no reply
660 */
661void fuse_request_send_noreply(struct fuse_conn *fc, struct fuse_req *req);
662
663/**
664 * Send a request in the background
665 */
666void fuse_request_send_background(struct fuse_conn *fc, struct fuse_req *req);
667
668void fuse_request_send_background_locked(struct fuse_conn *fc,
669					 struct fuse_req *req);
670
671/* Abort all requests */
672void fuse_abort_conn(struct fuse_conn *fc);
673
674/**
675 * Invalidate inode attributes
676 */
677void fuse_invalidate_attr(struct inode *inode);
678
679void fuse_invalidate_entry_cache(struct dentry *entry);
680
681/**
682 * Acquire reference to fuse_conn
683 */
684struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
685
686void fuse_conn_kill(struct fuse_conn *fc);
687
688/**
689 * Initialize fuse_conn
690 */
691void fuse_conn_init(struct fuse_conn *fc);
692
693/**
694 * Release reference to fuse_conn
695 */
696void fuse_conn_put(struct fuse_conn *fc);
697
698/**
699 * Add connection to control filesystem
700 */
701int fuse_ctl_add_conn(struct fuse_conn *fc);
702
703/**
704 * Remove connection from control filesystem
705 */
706void fuse_ctl_remove_conn(struct fuse_conn *fc);
707
708/**
709 * Is file type valid?
710 */
711int fuse_valid_type(int m);
712
713/**
714 * Is task allowed to perform filesystem operation?
715 */
716int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task);
717
718u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
719
720int fuse_update_attributes(struct inode *inode, struct kstat *stat,
721			   struct file *file, bool *refreshed);
722
723void fuse_flush_writepages(struct inode *inode);
724
725void fuse_set_nowrite(struct inode *inode);
726void fuse_release_nowrite(struct inode *inode);
727
728u64 fuse_get_attr_version(struct fuse_conn *fc);
729
730/**
731 * File-system tells the kernel to invalidate cache for the given node id.
732 */
733int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
734			     loff_t offset, loff_t len);
735
736/**
737 * File-system tells the kernel to invalidate parent attributes and
738 * the dentry matching parent/name.
739 */
740int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
741			     struct qstr *name);
742
743int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file,
744		 bool isdir);
745ssize_t fuse_direct_io(struct file *file, const char __user *buf,
746		       size_t count, loff_t *ppos, int write);
747long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg,
748		   unsigned int flags);
749unsigned fuse_file_poll(struct file *file, poll_table *wait);
750int fuse_dev_release(struct inode *inode, struct file *file);
751
752void fuse_write_update_size(struct inode *inode, loff_t pos);
753
754#endif /* _FS_FUSE_I_H */
755