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