2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
5 This program can be distributed under the terms of the GNU GPL.
12 #include <linux/fuse.h>
14 #include <linux/mount.h>
15 #include <linux/wait.h>
16 #include <linux/list.h>
17 #include <linux/spinlock.h>
19 #include <linux/backing-dev.h>
20 #include <linux/mutex.h>
21 #include <linux/rwsem.h>
23 /** Max number of pages that can be used in a single read request */
24 #define FUSE_MAX_PAGES_PER_REQ 32
26 /** Maximum number of outstanding background requests */
27 #define FUSE_MAX_BACKGROUND 12
29 /** Congestion starts at 75% of maximum */
30 #define FUSE_CONGESTION_THRESHOLD (FUSE_MAX_BACKGROUND * 75 / 100)
32 /** Bias for fi->writectr, meaning new writepages must not be sent */
33 #define FUSE_NOWRITE INT_MIN
35 /** It could be as large as PATH_MAX, but would that have any uses? */
36 #define FUSE_NAME_MAX 1024
38 /** Number of dentries for each connection in the control filesystem */
39 #define FUSE_CTL_NUM_DENTRIES 3
41 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
42 module will check permissions based on the file mode. Otherwise no
43 permission checking is done in the kernel */
44 #define FUSE_DEFAULT_PERMISSIONS (1 << 0)
46 /** If the FUSE_ALLOW_OTHER flag is given, then not only the user
47 doing the mount will be allowed to access the filesystem */
48 #define FUSE_ALLOW_OTHER (1 << 1)
50 /** List of active connections */
51 extern struct list_head fuse_conn_list;
53 /** Global mutex protecting fuse_conn_list and the control filesystem */
54 extern struct mutex fuse_mutex;
61 /** Unique ID, which identifies the inode between userspace
65 /** Number of lookups on this inode */
68 /** The request used for sending the FORGET message */
69 struct fuse_req *forget_req;
71 /** Time in jiffies until the file attributes are valid */
74 /** The sticky bit in inode->i_mode may have been removed, so
75 preserve the original mode */
78 /** Version of last attribute change */
81 /** Files usable in writepage. Protected by fc->lock */
82 struct list_head write_files;
84 /** Writepages pending on truncate or fsync */
85 struct list_head queued_writes;
87 /** Number of sent writes, a negative bias (FUSE_NOWRITE)
88 * means more writes are blocked */
91 /** Waitq for writepage completion */
92 wait_queue_head_t page_waitq;
94 /** List of writepage requestst (pending or sent) */
95 struct list_head writepages;
98 /** FUSE specific file data */
100 /** Request reserved for flush and release */
101 struct fuse_req *reserved_req;
103 /** Kernel file handle guaranteed to be unique */
106 /** File handle used by userspace */
112 /** Entry on inode's write_files list */
113 struct list_head write_entry;
116 /** One input argument of a request */
122 /** The request input */
124 /** The request header */
125 struct fuse_in_header h;
127 /** True if the data for the last argument is in req->pages */
130 /** Number of arguments */
133 /** Array of arguments */
134 struct fuse_in_arg args[3];
137 /** One output argument of a request */
143 /** The request output */
145 /** Header returned from userspace */
146 struct fuse_out_header h;
149 * The following bitfields are not changed during the request
153 /** Last argument is variable length (can be shorter than
157 /** Last argument is a list of pages to copy data to */
160 /** Zero partially or not copied pages */
161 unsigned page_zeroing:1;
163 /** Number or arguments */
166 /** Array of arguments */
167 struct fuse_arg args[3];
170 /** The request state */
171 enum fuse_req_state {
183 * A request to the client
186 /** This can be on either pending processing or io lists in
188 struct list_head list;
190 /** Entry on the interrupts list */
191 struct list_head intr_entry;
196 /** Unique ID for the interrupt request */
200 * The following bitfields are either set once before the
201 * request is queued or setting/clearing them is protected by
205 /** True if the request has reply */
208 /** Force sending of the request even if interrupted */
211 /** The request was aborted */
214 /** Request is sent in the background */
215 unsigned background:1;
217 /** The request has been interrupted */
218 unsigned interrupted:1;
220 /** Data is being copied to/from the request */
223 /** Request is counted as "waiting" */
226 /** State of the request */
227 enum fuse_req_state state;
229 /** The request input */
232 /** The request output */
235 /** Used to wake up the task waiting for completion of request*/
236 wait_queue_head_t waitq;
238 /** Data for asynchronous requests */
240 struct fuse_forget_in forget_in;
242 struct fuse_release_in in;
243 struct vfsmount *vfsmount;
244 struct dentry *dentry;
246 struct fuse_init_in init_in;
247 struct fuse_init_out init_out;
249 struct fuse_read_in in;
253 struct fuse_write_in in;
254 struct fuse_write_out out;
256 struct fuse_lk_in lk_in;
260 struct page *pages[FUSE_MAX_PAGES_PER_REQ];
262 /** number of pages in vector */
265 /** offset of data on first page */
266 unsigned page_offset;
268 /** File used in the request (or NULL) */
269 struct fuse_file *ff;
271 /** Inode used in the request or NULL */
274 /** Link on fi->writepages */
275 struct list_head writepages_entry;
277 /** Request completion callback */
278 void (*end)(struct fuse_conn *, struct fuse_req *);
280 /** Request is stolen from fuse_file->reserved_req */
281 struct file *stolen_file;
287 * This structure is created, when the filesystem is mounted, and is
288 * destroyed, when the client device is closed and the filesystem is
292 /** Lock protecting accessess to members of this structure */
295 /** Mutex protecting against directory alias creation */
296 struct mutex inst_mutex;
301 /** The user id for this mount */
304 /** The group id for this mount */
307 /** The fuse mount flags for this mount */
310 /** Maximum read size */
313 /** Maximum write size */
316 /** Readers of the connection are waiting on this */
317 wait_queue_head_t waitq;
319 /** The list of pending requests */
320 struct list_head pending;
322 /** The list of requests being processed */
323 struct list_head processing;
325 /** The list of requests under I/O */
328 /** The next unique kernel file handle */
331 /** Number of requests currently in the background */
332 unsigned num_background;
334 /** Number of background requests currently queued for userspace */
335 unsigned active_background;
337 /** The list of background requests set aside for later queuing */
338 struct list_head bg_queue;
340 /** Pending interrupts */
341 struct list_head interrupts;
343 /** Flag indicating if connection is blocked. This will be
344 the case before the INIT reply is received, and if there
345 are too many outstading backgrounds requests */
348 /** waitq for blocked connection */
349 wait_queue_head_t blocked_waitq;
351 /** waitq for reserved requests */
352 wait_queue_head_t reserved_req_waitq;
354 /** The next unique request id */
357 /** Connection established, cleared on umount, connection
358 abort and device release */
361 /** Connection failed (version mismatch). Cannot race with
362 setting other bitfields since it is only set once in INIT
363 reply, before any other request, and never cleared */
364 unsigned conn_error:1;
366 /** Connection successful. Only set in INIT */
367 unsigned conn_init:1;
369 /** Do readpages asynchronously? Only set in INIT */
370 unsigned async_read:1;
372 /** Do not send separate SETATTR request before open(O_TRUNC) */
373 unsigned atomic_o_trunc:1;
375 /** Filesystem supports NFS exporting. Only set in INIT */
376 unsigned export_support:1;
379 * The following bitfields are only for optimization purposes
380 * and hence races in setting them will not cause malfunction
383 /** Is fsync not implemented by fs? */
386 /** Is fsyncdir not implemented by fs? */
387 unsigned no_fsyncdir:1;
389 /** Is flush not implemented by fs? */
392 /** Is setxattr not implemented by fs? */
393 unsigned no_setxattr:1;
395 /** Is getxattr not implemented by fs? */
396 unsigned no_getxattr:1;
398 /** Is listxattr not implemented by fs? */
399 unsigned no_listxattr:1;
401 /** Is removexattr not implemented by fs? */
402 unsigned no_removexattr:1;
404 /** Are file locking primitives not implemented by fs? */
407 /** Is access not implemented by fs? */
408 unsigned no_access:1;
410 /** Is create not implemented by fs? */
411 unsigned no_create:1;
413 /** Is interrupt not implemented by fs? */
414 unsigned no_interrupt:1;
416 /** Is bmap not implemented by fs? */
419 /** Do multi-page cached writes */
420 unsigned big_writes:1;
422 /** The number of requests waiting for completion */
423 atomic_t num_waiting;
425 /** Negotiated minor version */
428 /** Backing dev info */
429 struct backing_dev_info bdi;
431 /** Entry on the fuse_conn_list */
432 struct list_head entry;
434 /** Device ID from super block */
437 /** Dentries in the control filesystem */
438 struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES];
440 /** number of dentries used in the above array */
443 /** O_ASYNC requests */
444 struct fasync_struct *fasync;
446 /** Key for lock owner ID scrambling */
449 /** Reserved request for the DESTROY message */
450 struct fuse_req *destroy_req;
452 /** Version counter for attribute changes */
456 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
458 return sb->s_fs_info;
461 static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
463 return get_fuse_conn_super(inode->i_sb);
466 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
468 return container_of(inode, struct fuse_inode, inode);
471 static inline u64 get_node_id(struct inode *inode)
473 return get_fuse_inode(inode)->nodeid;
476 /** Device operations */
477 extern const struct file_operations fuse_dev_operations;
479 extern struct dentry_operations fuse_dentry_operations;
482 * Get a filled in inode
484 struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
485 int generation, struct fuse_attr *attr,
486 u64 attr_valid, u64 attr_version);
488 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
489 struct fuse_entry_out *outarg, struct inode **inode);
492 * Send FORGET command
494 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
495 u64 nodeid, u64 nlookup);
498 * Initialize READ or READDIR request
500 void fuse_read_fill(struct fuse_req *req, struct file *file,
501 struct inode *inode, loff_t pos, size_t count, int opcode);
504 * Send OPEN or OPENDIR request
506 int fuse_open_common(struct inode *inode, struct file *file, int isdir);
508 struct fuse_file *fuse_file_alloc(struct fuse_conn *fc);
509 void fuse_file_free(struct fuse_file *ff);
510 void fuse_finish_open(struct inode *inode, struct file *file,
511 struct fuse_file *ff, struct fuse_open_out *outarg);
513 /** Fill in ff->reserved_req with a RELEASE request */
514 void fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags, int opcode);
517 * Send RELEASE or RELEASEDIR request
519 int fuse_release_common(struct inode *inode, struct file *file, int isdir);
522 * Send FSYNC or FSYNCDIR request
524 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
528 * Initialize file operations on a regular file
530 void fuse_init_file_inode(struct inode *inode);
533 * Initialize inode operations on regular files and special files
535 void fuse_init_common(struct inode *inode);
538 * Initialize inode and file operations on a directory
540 void fuse_init_dir(struct inode *inode);
543 * Initialize inode operations on a symlink
545 void fuse_init_symlink(struct inode *inode);
548 * Change attributes of an inode
550 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
551 u64 attr_valid, u64 attr_version);
553 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
556 void fuse_truncate(struct address_space *mapping, loff_t offset);
559 * Initialize the client device
561 int fuse_dev_init(void);
564 * Cleanup the client device
566 void fuse_dev_cleanup(void);
568 int fuse_ctl_init(void);
569 void fuse_ctl_cleanup(void);
574 struct fuse_req *fuse_request_alloc(void);
576 struct fuse_req *fuse_request_alloc_nofs(void);
581 void fuse_request_free(struct fuse_req *req);
584 * Get a request, may fail with -ENOMEM
586 struct fuse_req *fuse_get_req(struct fuse_conn *fc);
589 * Gets a requests for a file operation, always succeeds
591 struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file);
594 * Decrement reference count of a request. If count goes to zero free
597 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req);
600 * Send a request (synchronous)
602 void request_send(struct fuse_conn *fc, struct fuse_req *req);
605 * Send a request with no reply
607 void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req);
610 * Send a request in the background
612 void request_send_background(struct fuse_conn *fc, struct fuse_req *req);
614 void request_send_background_locked(struct fuse_conn *fc, struct fuse_req *req);
616 /* Abort all requests */
617 void fuse_abort_conn(struct fuse_conn *fc);
620 * Invalidate inode attributes
622 void fuse_invalidate_attr(struct inode *inode);
624 void fuse_invalidate_entry_cache(struct dentry *entry);
627 * Acquire reference to fuse_conn
629 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
632 * Release reference to fuse_conn
634 void fuse_conn_put(struct fuse_conn *fc);
637 * Add connection to control filesystem
639 int fuse_ctl_add_conn(struct fuse_conn *fc);
642 * Remove connection from control filesystem
644 void fuse_ctl_remove_conn(struct fuse_conn *fc);
647 * Is file type valid?
649 int fuse_valid_type(int m);
652 * Is task allowed to perform filesystem operation?
654 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task);
656 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id);
658 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
659 struct file *file, bool *refreshed);
661 void fuse_flush_writepages(struct inode *inode);
663 void fuse_set_nowrite(struct inode *inode);
664 void fuse_release_nowrite(struct inode *inode);
666 u64 fuse_get_attr_version(struct fuse_conn *fc);
668 #endif /* _FS_FUSE_I_H */