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 /** Number of page pointers embedded in fuse_req */ 48 #define FUSE_REQ_INLINE_PAGES 1 49 50 /** List of active connections */ 51 extern struct list_head fuse_conn_list; 52 53 /** Global mutex protecting fuse_conn_list and the control filesystem */ 54 extern struct mutex fuse_mutex; 55 56 /** Module parameters */ 57 extern unsigned max_user_bgreq; 58 extern unsigned max_user_congthresh; 59 60 /* One forget request */ 61 struct fuse_forget_link { 62 struct fuse_forget_one forget_one; 63 struct fuse_forget_link *next; 64 }; 65 66 /** FUSE inode */ 67 struct fuse_inode { 68 /** Inode data */ 69 struct inode inode; 70 71 /** Unique ID, which identifies the inode between userspace 72 * and kernel */ 73 u64 nodeid; 74 75 /** Number of lookups on this inode */ 76 u64 nlookup; 77 78 /** The request used for sending the FORGET message */ 79 struct fuse_forget_link *forget; 80 81 /** Time in jiffies until the file attributes are valid */ 82 u64 i_time; 83 84 /** The sticky bit in inode->i_mode may have been removed, so 85 preserve the original mode */ 86 umode_t orig_i_mode; 87 88 /** 64 bit inode number */ 89 u64 orig_ino; 90 91 /** Version of last attribute change */ 92 u64 attr_version; 93 94 /** Files usable in writepage. Protected by fc->lock */ 95 struct list_head write_files; 96 97 /** Writepages pending on truncate or fsync */ 98 struct list_head queued_writes; 99 100 /** Number of sent writes, a negative bias (FUSE_NOWRITE) 101 * means more writes are blocked */ 102 int writectr; 103 104 /** Waitq for writepage completion */ 105 wait_queue_head_t page_waitq; 106 107 /** List of writepage requestst (pending or sent) */ 108 struct list_head writepages; 109 110 /** Miscellaneous bits describing inode state */ 111 unsigned long state; 112 }; 113 114 /** FUSE inode state bits */ 115 enum { 116 /** Advise readdirplus */ 117 FUSE_I_ADVISE_RDPLUS, 118 /** Initialized with readdirplus */ 119 FUSE_I_INIT_RDPLUS, 120 /** An operation changing file size is in progress */ 121 FUSE_I_SIZE_UNSTABLE, 122 }; 123 124 struct fuse_conn; 125 126 /** FUSE specific file data */ 127 struct fuse_file { 128 /** Fuse connection for this file */ 129 struct fuse_conn *fc; 130 131 /** Request reserved for flush and release */ 132 struct fuse_req *reserved_req; 133 134 /** Kernel file handle guaranteed to be unique */ 135 u64 kh; 136 137 /** File handle used by userspace */ 138 u64 fh; 139 140 /** Node id of this file */ 141 u64 nodeid; 142 143 /** Refcount */ 144 atomic_t count; 145 146 /** FOPEN_* flags returned by open */ 147 u32 open_flags; 148 149 /** Entry on inode's write_files list */ 150 struct list_head write_entry; 151 152 /** RB node to be linked on fuse_conn->polled_files */ 153 struct rb_node polled_node; 154 155 /** Wait queue head for poll */ 156 wait_queue_head_t poll_wait; 157 158 /** Has flock been performed on this file? */ 159 bool flock:1; 160 }; 161 162 /** One input argument of a request */ 163 struct fuse_in_arg { 164 unsigned size; 165 const void *value; 166 }; 167 168 /** The request input */ 169 struct fuse_in { 170 /** The request header */ 171 struct fuse_in_header h; 172 173 /** True if the data for the last argument is in req->pages */ 174 unsigned argpages:1; 175 176 /** Number of arguments */ 177 unsigned numargs; 178 179 /** Array of arguments */ 180 struct fuse_in_arg args[3]; 181 }; 182 183 /** One output argument of a request */ 184 struct fuse_arg { 185 unsigned size; 186 void *value; 187 }; 188 189 /** The request output */ 190 struct fuse_out { 191 /** Header returned from userspace */ 192 struct fuse_out_header h; 193 194 /* 195 * The following bitfields are not changed during the request 196 * processing 197 */ 198 199 /** Last argument is variable length (can be shorter than 200 arg->size) */ 201 unsigned argvar:1; 202 203 /** Last argument is a list of pages to copy data to */ 204 unsigned argpages:1; 205 206 /** Zero partially or not copied pages */ 207 unsigned page_zeroing:1; 208 209 /** Pages may be replaced with new ones */ 210 unsigned page_replace:1; 211 212 /** Number or arguments */ 213 unsigned numargs; 214 215 /** Array of arguments */ 216 struct fuse_arg args[2]; 217 }; 218 219 /** FUSE page descriptor */ 220 struct fuse_page_desc { 221 unsigned int length; 222 unsigned int offset; 223 }; 224 225 struct fuse_args { 226 struct { 227 struct { 228 uint32_t opcode; 229 uint64_t nodeid; 230 } h; 231 unsigned numargs; 232 struct fuse_in_arg args[3]; 233 234 } in; 235 struct { 236 unsigned argvar:1; 237 unsigned numargs; 238 struct fuse_arg args[2]; 239 } out; 240 }; 241 242 #define FUSE_ARGS(args) struct fuse_args args = {} 243 244 /** The request IO state (for asynchronous processing) */ 245 struct fuse_io_priv { 246 int async; 247 spinlock_t lock; 248 unsigned reqs; 249 ssize_t bytes; 250 size_t size; 251 __u64 offset; 252 bool write; 253 int err; 254 struct kiocb *iocb; 255 struct file *file; 256 struct completion *done; 257 }; 258 259 /** 260 * Request flags 261 * 262 * FR_ISREPLY: set if the request has reply 263 * FR_FORCE: force sending of the request even if interrupted 264 * FR_BACKGROUND: request is sent in the background 265 * FR_WAITING: request is counted as "waiting" 266 * FR_ABORTED: the request was aborted 267 * FR_INTERRUPTED: the request has been interrupted 268 * FR_LOCKED: data is being copied to/from the request 269 * FR_PENDING: request is not yet in userspace 270 * FR_SENT: request is in userspace, waiting for an answer 271 * FR_FINISHED: request is finished 272 * FR_PRIVATE: request is on private list 273 */ 274 enum fuse_req_flag { 275 FR_ISREPLY, 276 FR_FORCE, 277 FR_BACKGROUND, 278 FR_WAITING, 279 FR_ABORTED, 280 FR_INTERRUPTED, 281 FR_LOCKED, 282 FR_PENDING, 283 FR_SENT, 284 FR_FINISHED, 285 FR_PRIVATE, 286 }; 287 288 /** 289 * A request to the client 290 * 291 * .waitq.lock protects the following fields: 292 * - FR_ABORTED 293 * - FR_LOCKED (may also be modified under fc->lock, tested under both) 294 */ 295 struct fuse_req { 296 /** This can be on either pending processing or io lists in 297 fuse_conn */ 298 struct list_head list; 299 300 /** Entry on the interrupts list */ 301 struct list_head intr_entry; 302 303 /** refcount */ 304 atomic_t count; 305 306 /** Unique ID for the interrupt request */ 307 u64 intr_unique; 308 309 /* Request flags, updated with test/set/clear_bit() */ 310 unsigned long flags; 311 312 /** The request input */ 313 struct fuse_in in; 314 315 /** The request output */ 316 struct fuse_out out; 317 318 /** Used to wake up the task waiting for completion of request*/ 319 wait_queue_head_t waitq; 320 321 /** Data for asynchronous requests */ 322 union { 323 struct { 324 struct fuse_release_in in; 325 struct inode *inode; 326 } release; 327 struct fuse_init_in init_in; 328 struct fuse_init_out init_out; 329 struct cuse_init_in cuse_init_in; 330 struct { 331 struct fuse_read_in in; 332 u64 attr_ver; 333 } read; 334 struct { 335 struct fuse_write_in in; 336 struct fuse_write_out out; 337 struct fuse_req *next; 338 } write; 339 struct fuse_notify_retrieve_in retrieve_in; 340 } misc; 341 342 /** page vector */ 343 struct page **pages; 344 345 /** page-descriptor vector */ 346 struct fuse_page_desc *page_descs; 347 348 /** size of the 'pages' array */ 349 unsigned max_pages; 350 351 /** inline page vector */ 352 struct page *inline_pages[FUSE_REQ_INLINE_PAGES]; 353 354 /** inline page-descriptor vector */ 355 struct fuse_page_desc inline_page_descs[FUSE_REQ_INLINE_PAGES]; 356 357 /** number of pages in vector */ 358 unsigned num_pages; 359 360 /** File used in the request (or NULL) */ 361 struct fuse_file *ff; 362 363 /** Inode used in the request or NULL */ 364 struct inode *inode; 365 366 /** AIO control block */ 367 struct fuse_io_priv *io; 368 369 /** Link on fi->writepages */ 370 struct list_head writepages_entry; 371 372 /** Request completion callback */ 373 void (*end)(struct fuse_conn *, struct fuse_req *); 374 375 /** Request is stolen from fuse_file->reserved_req */ 376 struct file *stolen_file; 377 }; 378 379 struct fuse_iqueue { 380 /** Connection established */ 381 unsigned connected; 382 383 /** Readers of the connection are waiting on this */ 384 wait_queue_head_t waitq; 385 386 /** The next unique request id */ 387 u64 reqctr; 388 389 /** The list of pending requests */ 390 struct list_head pending; 391 392 /** Pending interrupts */ 393 struct list_head interrupts; 394 395 /** Queue of pending forgets */ 396 struct fuse_forget_link forget_list_head; 397 struct fuse_forget_link *forget_list_tail; 398 399 /** Batching of FORGET requests (positive indicates FORGET batch) */ 400 int forget_batch; 401 402 /** O_ASYNC requests */ 403 struct fasync_struct *fasync; 404 }; 405 406 struct fuse_pqueue { 407 /** Connection established */ 408 unsigned connected; 409 410 /** Lock protecting accessess to members of this structure */ 411 spinlock_t lock; 412 413 /** The list of requests being processed */ 414 struct list_head processing; 415 416 /** The list of requests under I/O */ 417 struct list_head io; 418 }; 419 420 /** 421 * Fuse device instance 422 */ 423 struct fuse_dev { 424 /** Fuse connection for this device */ 425 struct fuse_conn *fc; 426 427 /** Processing queue */ 428 struct fuse_pqueue pq; 429 430 /** list entry on fc->devices */ 431 struct list_head entry; 432 }; 433 434 /** 435 * A Fuse connection. 436 * 437 * This structure is created, when the filesystem is mounted, and is 438 * destroyed, when the client device is closed and the filesystem is 439 * unmounted. 440 */ 441 struct fuse_conn { 442 /** Lock protecting accessess to members of this structure */ 443 spinlock_t lock; 444 445 /** Refcount */ 446 atomic_t count; 447 448 /** Number of fuse_dev's */ 449 atomic_t dev_count; 450 451 struct rcu_head rcu; 452 453 /** The user id for this mount */ 454 kuid_t user_id; 455 456 /** The group id for this mount */ 457 kgid_t group_id; 458 459 /** The fuse mount flags for this mount */ 460 unsigned flags; 461 462 /** Maximum read size */ 463 unsigned max_read; 464 465 /** Maximum write size */ 466 unsigned max_write; 467 468 /** Input queue */ 469 struct fuse_iqueue iq; 470 471 /** The next unique kernel file handle */ 472 u64 khctr; 473 474 /** rbtree of fuse_files waiting for poll events indexed by ph */ 475 struct rb_root polled_files; 476 477 /** Maximum number of outstanding background requests */ 478 unsigned max_background; 479 480 /** Number of background requests at which congestion starts */ 481 unsigned congestion_threshold; 482 483 /** Number of requests currently in the background */ 484 unsigned num_background; 485 486 /** Number of background requests currently queued for userspace */ 487 unsigned active_background; 488 489 /** The list of background requests set aside for later queuing */ 490 struct list_head bg_queue; 491 492 /** Flag indicating that INIT reply has been received. Allocating 493 * any fuse request will be suspended until the flag is set */ 494 int initialized; 495 496 /** Flag indicating if connection is blocked. This will be 497 the case before the INIT reply is received, and if there 498 are too many outstading backgrounds requests */ 499 int blocked; 500 501 /** waitq for blocked connection */ 502 wait_queue_head_t blocked_waitq; 503 504 /** waitq for reserved requests */ 505 wait_queue_head_t reserved_req_waitq; 506 507 /** Connection established, cleared on umount, connection 508 abort and device release */ 509 unsigned connected; 510 511 /** Connection failed (version mismatch). Cannot race with 512 setting other bitfields since it is only set once in INIT 513 reply, before any other request, and never cleared */ 514 unsigned conn_error:1; 515 516 /** Connection successful. Only set in INIT */ 517 unsigned conn_init:1; 518 519 /** Do readpages asynchronously? Only set in INIT */ 520 unsigned async_read:1; 521 522 /** Do not send separate SETATTR request before open(O_TRUNC) */ 523 unsigned atomic_o_trunc:1; 524 525 /** Filesystem supports NFS exporting. Only set in INIT */ 526 unsigned export_support:1; 527 528 /** Set if bdi is valid */ 529 unsigned bdi_initialized:1; 530 531 /** write-back cache policy (default is write-through) */ 532 unsigned writeback_cache:1; 533 534 /* 535 * The following bitfields are only for optimization purposes 536 * and hence races in setting them will not cause malfunction 537 */ 538 539 /** Is open/release not implemented by fs? */ 540 unsigned no_open:1; 541 542 /** Is fsync not implemented by fs? */ 543 unsigned no_fsync:1; 544 545 /** Is fsyncdir not implemented by fs? */ 546 unsigned no_fsyncdir:1; 547 548 /** Is flush not implemented by fs? */ 549 unsigned no_flush:1; 550 551 /** Is setxattr not implemented by fs? */ 552 unsigned no_setxattr:1; 553 554 /** Is getxattr not implemented by fs? */ 555 unsigned no_getxattr:1; 556 557 /** Is listxattr not implemented by fs? */ 558 unsigned no_listxattr:1; 559 560 /** Is removexattr not implemented by fs? */ 561 unsigned no_removexattr:1; 562 563 /** Are posix file locking primitives not implemented by fs? */ 564 unsigned no_lock:1; 565 566 /** Is access not implemented by fs? */ 567 unsigned no_access:1; 568 569 /** Is create not implemented by fs? */ 570 unsigned no_create:1; 571 572 /** Is interrupt not implemented by fs? */ 573 unsigned no_interrupt:1; 574 575 /** Is bmap not implemented by fs? */ 576 unsigned no_bmap:1; 577 578 /** Is poll not implemented by fs? */ 579 unsigned no_poll:1; 580 581 /** Do multi-page cached writes */ 582 unsigned big_writes:1; 583 584 /** Don't apply umask to creation modes */ 585 unsigned dont_mask:1; 586 587 /** Are BSD file locking primitives not implemented by fs? */ 588 unsigned no_flock:1; 589 590 /** Is fallocate not implemented by fs? */ 591 unsigned no_fallocate:1; 592 593 /** Is rename with flags implemented by fs? */ 594 unsigned no_rename2:1; 595 596 /** Use enhanced/automatic page cache invalidation. */ 597 unsigned auto_inval_data:1; 598 599 /** Does the filesystem support readdirplus? */ 600 unsigned do_readdirplus:1; 601 602 /** Does the filesystem want adaptive readdirplus? */ 603 unsigned readdirplus_auto:1; 604 605 /** Does the filesystem support asynchronous direct-IO submission? */ 606 unsigned async_dio:1; 607 608 /** The number of requests waiting for completion */ 609 atomic_t num_waiting; 610 611 /** Negotiated minor version */ 612 unsigned minor; 613 614 /** Backing dev info */ 615 struct backing_dev_info bdi; 616 617 /** Entry on the fuse_conn_list */ 618 struct list_head entry; 619 620 /** Device ID from super block */ 621 dev_t dev; 622 623 /** Dentries in the control filesystem */ 624 struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES]; 625 626 /** number of dentries used in the above array */ 627 int ctl_ndents; 628 629 /** Key for lock owner ID scrambling */ 630 u32 scramble_key[4]; 631 632 /** Reserved request for the DESTROY message */ 633 struct fuse_req *destroy_req; 634 635 /** Version counter for attribute changes */ 636 u64 attr_version; 637 638 /** Called on final put */ 639 void (*release)(struct fuse_conn *); 640 641 /** Super block for this connection. */ 642 struct super_block *sb; 643 644 /** Read/write semaphore to hold when accessing sb. */ 645 struct rw_semaphore killsb; 646 647 /** List of device instances belonging to this connection */ 648 struct list_head devices; 649 }; 650 651 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 652 { 653 return sb->s_fs_info; 654 } 655 656 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 657 { 658 return get_fuse_conn_super(inode->i_sb); 659 } 660 661 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 662 { 663 return container_of(inode, struct fuse_inode, inode); 664 } 665 666 static inline u64 get_node_id(struct inode *inode) 667 { 668 return get_fuse_inode(inode)->nodeid; 669 } 670 671 /** Device operations */ 672 extern const struct file_operations fuse_dev_operations; 673 674 extern const struct dentry_operations fuse_dentry_operations; 675 676 /** 677 * Inode to nodeid comparison. 678 */ 679 int fuse_inode_eq(struct inode *inode, void *_nodeidp); 680 681 /** 682 * Get a filled in inode 683 */ 684 struct inode *fuse_iget(struct super_block *sb, u64 nodeid, 685 int generation, struct fuse_attr *attr, 686 u64 attr_valid, u64 attr_version); 687 688 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name, 689 struct fuse_entry_out *outarg, struct inode **inode); 690 691 /** 692 * Send FORGET command 693 */ 694 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget, 695 u64 nodeid, u64 nlookup); 696 697 struct fuse_forget_link *fuse_alloc_forget(void); 698 699 /* Used by READDIRPLUS */ 700 void fuse_force_forget(struct file *file, u64 nodeid); 701 702 /** 703 * Initialize READ or READDIR request 704 */ 705 void fuse_read_fill(struct fuse_req *req, struct file *file, 706 loff_t pos, size_t count, int opcode); 707 708 /** 709 * Send OPEN or OPENDIR request 710 */ 711 int fuse_open_common(struct inode *inode, struct file *file, bool isdir); 712 713 struct fuse_file *fuse_file_alloc(struct fuse_conn *fc); 714 struct fuse_file *fuse_file_get(struct fuse_file *ff); 715 void fuse_file_free(struct fuse_file *ff); 716 void fuse_finish_open(struct inode *inode, struct file *file); 717 718 void fuse_sync_release(struct fuse_file *ff, int flags); 719 720 /** 721 * Send RELEASE or RELEASEDIR request 722 */ 723 void fuse_release_common(struct file *file, int opcode); 724 725 /** 726 * Send FSYNC or FSYNCDIR request 727 */ 728 int fuse_fsync_common(struct file *file, loff_t start, loff_t end, 729 int datasync, int isdir); 730 731 /** 732 * Notify poll wakeup 733 */ 734 int fuse_notify_poll_wakeup(struct fuse_conn *fc, 735 struct fuse_notify_poll_wakeup_out *outarg); 736 737 /** 738 * Initialize file operations on a regular file 739 */ 740 void fuse_init_file_inode(struct inode *inode); 741 742 /** 743 * Initialize inode operations on regular files and special files 744 */ 745 void fuse_init_common(struct inode *inode); 746 747 /** 748 * Initialize inode and file operations on a directory 749 */ 750 void fuse_init_dir(struct inode *inode); 751 752 /** 753 * Initialize inode operations on a symlink 754 */ 755 void fuse_init_symlink(struct inode *inode); 756 757 /** 758 * Change attributes of an inode 759 */ 760 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr, 761 u64 attr_valid, u64 attr_version); 762 763 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr, 764 u64 attr_valid); 765 766 /** 767 * Initialize the client device 768 */ 769 int fuse_dev_init(void); 770 771 /** 772 * Cleanup the client device 773 */ 774 void fuse_dev_cleanup(void); 775 776 int fuse_ctl_init(void); 777 void __exit fuse_ctl_cleanup(void); 778 779 /** 780 * Allocate a request 781 */ 782 struct fuse_req *fuse_request_alloc(unsigned npages); 783 784 struct fuse_req *fuse_request_alloc_nofs(unsigned npages); 785 786 /** 787 * Free a request 788 */ 789 void fuse_request_free(struct fuse_req *req); 790 791 /** 792 * Get a request, may fail with -ENOMEM, 793 * caller should specify # elements in req->pages[] explicitly 794 */ 795 struct fuse_req *fuse_get_req(struct fuse_conn *fc, unsigned npages); 796 struct fuse_req *fuse_get_req_for_background(struct fuse_conn *fc, 797 unsigned npages); 798 799 /* 800 * Increment reference count on request 801 */ 802 void __fuse_get_request(struct fuse_req *req); 803 804 /** 805 * Gets a requests for a file operation, always succeeds 806 */ 807 struct fuse_req *fuse_get_req_nofail_nopages(struct fuse_conn *fc, 808 struct file *file); 809 810 /** 811 * Decrement reference count of a request. If count goes to zero free 812 * the request. 813 */ 814 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 815 816 /** 817 * Send a request (synchronous) 818 */ 819 void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req); 820 821 /** 822 * Simple request sending that does request allocation and freeing 823 */ 824 ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args); 825 826 /** 827 * Send a request in the background 828 */ 829 void fuse_request_send_background(struct fuse_conn *fc, struct fuse_req *req); 830 831 void fuse_request_send_background_locked(struct fuse_conn *fc, 832 struct fuse_req *req); 833 834 /* Abort all requests */ 835 void fuse_abort_conn(struct fuse_conn *fc); 836 837 /** 838 * Invalidate inode attributes 839 */ 840 void fuse_invalidate_attr(struct inode *inode); 841 842 void fuse_invalidate_entry_cache(struct dentry *entry); 843 844 void fuse_invalidate_atime(struct inode *inode); 845 846 /** 847 * Acquire reference to fuse_conn 848 */ 849 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc); 850 851 /** 852 * Initialize fuse_conn 853 */ 854 void fuse_conn_init(struct fuse_conn *fc); 855 856 /** 857 * Release reference to fuse_conn 858 */ 859 void fuse_conn_put(struct fuse_conn *fc); 860 861 struct fuse_dev *fuse_dev_alloc(struct fuse_conn *fc); 862 void fuse_dev_free(struct fuse_dev *fud); 863 864 /** 865 * Add connection to control filesystem 866 */ 867 int fuse_ctl_add_conn(struct fuse_conn *fc); 868 869 /** 870 * Remove connection from control filesystem 871 */ 872 void fuse_ctl_remove_conn(struct fuse_conn *fc); 873 874 /** 875 * Is file type valid? 876 */ 877 int fuse_valid_type(int m); 878 879 /** 880 * Is current process allowed to perform filesystem operation? 881 */ 882 int fuse_allow_current_process(struct fuse_conn *fc); 883 884 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id); 885 886 int fuse_update_attributes(struct inode *inode, struct kstat *stat, 887 struct file *file, bool *refreshed); 888 889 void fuse_flush_writepages(struct inode *inode); 890 891 void fuse_set_nowrite(struct inode *inode); 892 void fuse_release_nowrite(struct inode *inode); 893 894 u64 fuse_get_attr_version(struct fuse_conn *fc); 895 896 /** 897 * File-system tells the kernel to invalidate cache for the given node id. 898 */ 899 int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid, 900 loff_t offset, loff_t len); 901 902 /** 903 * File-system tells the kernel to invalidate parent attributes and 904 * the dentry matching parent/name. 905 * 906 * If the child_nodeid is non-zero and: 907 * - matches the inode number for the dentry matching parent/name, 908 * - is not a mount point 909 * - is a file or oan empty directory 910 * then the dentry is unhashed (d_delete()). 911 */ 912 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, 913 u64 child_nodeid, struct qstr *name); 914 915 int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file, 916 bool isdir); 917 918 /** 919 * fuse_direct_io() flags 920 */ 921 922 /** If set, it is WRITE; otherwise - READ */ 923 #define FUSE_DIO_WRITE (1 << 0) 924 925 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */ 926 #define FUSE_DIO_CUSE (1 << 1) 927 928 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter, 929 loff_t *ppos, int flags); 930 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg, 931 unsigned int flags); 932 long fuse_ioctl_common(struct file *file, unsigned int cmd, 933 unsigned long arg, unsigned int flags); 934 unsigned fuse_file_poll(struct file *file, poll_table *wait); 935 int fuse_dev_release(struct inode *inode, struct file *file); 936 937 bool fuse_write_update_size(struct inode *inode, loff_t pos); 938 939 int fuse_flush_times(struct inode *inode, struct fuse_file *ff); 940 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc); 941 942 int fuse_do_setattr(struct inode *inode, struct iattr *attr, 943 struct file *file); 944 945 void fuse_set_initialized(struct fuse_conn *fc); 946 947 #endif /* _FS_FUSE_I_H */ 948