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