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 bool blocking; 263 }; 264 265 #define FUSE_IO_PRIV_SYNC(f) \ 266 { \ 267 .refcnt = { ATOMIC_INIT(1) }, \ 268 .async = 0, \ 269 .file = f, \ 270 } 271 272 /** 273 * Request flags 274 * 275 * FR_ISREPLY: set if the request has reply 276 * FR_FORCE: force sending of the request even if interrupted 277 * FR_BACKGROUND: request is sent in the background 278 * FR_WAITING: request is counted as "waiting" 279 * FR_ABORTED: the request was aborted 280 * FR_INTERRUPTED: the request has been interrupted 281 * FR_LOCKED: data is being copied to/from the request 282 * FR_PENDING: request is not yet in userspace 283 * FR_SENT: request is in userspace, waiting for an answer 284 * FR_FINISHED: request is finished 285 * FR_PRIVATE: request is on private list 286 */ 287 enum fuse_req_flag { 288 FR_ISREPLY, 289 FR_FORCE, 290 FR_BACKGROUND, 291 FR_WAITING, 292 FR_ABORTED, 293 FR_INTERRUPTED, 294 FR_LOCKED, 295 FR_PENDING, 296 FR_SENT, 297 FR_FINISHED, 298 FR_PRIVATE, 299 }; 300 301 /** 302 * A request to the client 303 * 304 * .waitq.lock protects the following fields: 305 * - FR_ABORTED 306 * - FR_LOCKED (may also be modified under fc->lock, tested under both) 307 */ 308 struct fuse_req { 309 /** This can be on either pending processing or io lists in 310 fuse_conn */ 311 struct list_head list; 312 313 /** Entry on the interrupts list */ 314 struct list_head intr_entry; 315 316 /** refcount */ 317 atomic_t count; 318 319 /** Unique ID for the interrupt request */ 320 u64 intr_unique; 321 322 /* Request flags, updated with test/set/clear_bit() */ 323 unsigned long flags; 324 325 /** The request input */ 326 struct fuse_in in; 327 328 /** The request output */ 329 struct fuse_out out; 330 331 /** Used to wake up the task waiting for completion of request*/ 332 wait_queue_head_t waitq; 333 334 /** Data for asynchronous requests */ 335 union { 336 struct { 337 struct fuse_release_in in; 338 struct inode *inode; 339 } release; 340 struct fuse_init_in init_in; 341 struct fuse_init_out init_out; 342 struct cuse_init_in cuse_init_in; 343 struct { 344 struct fuse_read_in in; 345 u64 attr_ver; 346 } read; 347 struct { 348 struct fuse_write_in in; 349 struct fuse_write_out out; 350 struct fuse_req *next; 351 } write; 352 struct fuse_notify_retrieve_in retrieve_in; 353 } misc; 354 355 /** page vector */ 356 struct page **pages; 357 358 /** page-descriptor vector */ 359 struct fuse_page_desc *page_descs; 360 361 /** size of the 'pages' array */ 362 unsigned max_pages; 363 364 /** inline page vector */ 365 struct page *inline_pages[FUSE_REQ_INLINE_PAGES]; 366 367 /** inline page-descriptor vector */ 368 struct fuse_page_desc inline_page_descs[FUSE_REQ_INLINE_PAGES]; 369 370 /** number of pages in vector */ 371 unsigned num_pages; 372 373 /** File used in the request (or NULL) */ 374 struct fuse_file *ff; 375 376 /** Inode used in the request or NULL */ 377 struct inode *inode; 378 379 /** AIO control block */ 380 struct fuse_io_priv *io; 381 382 /** Link on fi->writepages */ 383 struct list_head writepages_entry; 384 385 /** Request completion callback */ 386 void (*end)(struct fuse_conn *, struct fuse_req *); 387 388 /** Request is stolen from fuse_file->reserved_req */ 389 struct file *stolen_file; 390 }; 391 392 struct fuse_iqueue { 393 /** Connection established */ 394 unsigned connected; 395 396 /** Readers of the connection are waiting on this */ 397 wait_queue_head_t waitq; 398 399 /** The next unique request id */ 400 u64 reqctr; 401 402 /** The list of pending requests */ 403 struct list_head pending; 404 405 /** Pending interrupts */ 406 struct list_head interrupts; 407 408 /** Queue of pending forgets */ 409 struct fuse_forget_link forget_list_head; 410 struct fuse_forget_link *forget_list_tail; 411 412 /** Batching of FORGET requests (positive indicates FORGET batch) */ 413 int forget_batch; 414 415 /** O_ASYNC requests */ 416 struct fasync_struct *fasync; 417 }; 418 419 struct fuse_pqueue { 420 /** Connection established */ 421 unsigned connected; 422 423 /** Lock protecting accessess to members of this structure */ 424 spinlock_t lock; 425 426 /** The list of requests being processed */ 427 struct list_head processing; 428 429 /** The list of requests under I/O */ 430 struct list_head io; 431 }; 432 433 /** 434 * Fuse device instance 435 */ 436 struct fuse_dev { 437 /** Fuse connection for this device */ 438 struct fuse_conn *fc; 439 440 /** Processing queue */ 441 struct fuse_pqueue pq; 442 443 /** list entry on fc->devices */ 444 struct list_head entry; 445 }; 446 447 /** 448 * A Fuse connection. 449 * 450 * This structure is created, when the filesystem is mounted, and is 451 * destroyed, when the client device is closed and the filesystem is 452 * unmounted. 453 */ 454 struct fuse_conn { 455 /** Lock protecting accessess to members of this structure */ 456 spinlock_t lock; 457 458 /** Refcount */ 459 atomic_t count; 460 461 /** Number of fuse_dev's */ 462 atomic_t dev_count; 463 464 struct rcu_head rcu; 465 466 /** The user id for this mount */ 467 kuid_t user_id; 468 469 /** The group id for this mount */ 470 kgid_t group_id; 471 472 /** The fuse mount flags for this mount */ 473 unsigned flags; 474 475 /** Maximum read size */ 476 unsigned max_read; 477 478 /** Maximum write size */ 479 unsigned max_write; 480 481 /** Input queue */ 482 struct fuse_iqueue iq; 483 484 /** The next unique kernel file handle */ 485 u64 khctr; 486 487 /** rbtree of fuse_files waiting for poll events indexed by ph */ 488 struct rb_root polled_files; 489 490 /** Maximum number of outstanding background requests */ 491 unsigned max_background; 492 493 /** Number of background requests at which congestion starts */ 494 unsigned congestion_threshold; 495 496 /** Number of requests currently in the background */ 497 unsigned num_background; 498 499 /** Number of background requests currently queued for userspace */ 500 unsigned active_background; 501 502 /** The list of background requests set aside for later queuing */ 503 struct list_head bg_queue; 504 505 /** Flag indicating that INIT reply has been received. Allocating 506 * any fuse request will be suspended until the flag is set */ 507 int initialized; 508 509 /** Flag indicating if connection is blocked. This will be 510 the case before the INIT reply is received, and if there 511 are too many outstading backgrounds requests */ 512 int blocked; 513 514 /** waitq for blocked connection */ 515 wait_queue_head_t blocked_waitq; 516 517 /** waitq for reserved requests */ 518 wait_queue_head_t reserved_req_waitq; 519 520 /** Connection established, cleared on umount, connection 521 abort and device release */ 522 unsigned connected; 523 524 /** Connection failed (version mismatch). Cannot race with 525 setting other bitfields since it is only set once in INIT 526 reply, before any other request, and never cleared */ 527 unsigned conn_error:1; 528 529 /** Connection successful. Only set in INIT */ 530 unsigned conn_init:1; 531 532 /** Do readpages asynchronously? Only set in INIT */ 533 unsigned async_read:1; 534 535 /** Do not send separate SETATTR request before open(O_TRUNC) */ 536 unsigned atomic_o_trunc:1; 537 538 /** Filesystem supports NFS exporting. Only set in INIT */ 539 unsigned export_support:1; 540 541 /** Set if bdi is valid */ 542 unsigned bdi_initialized:1; 543 544 /** write-back cache policy (default is write-through) */ 545 unsigned writeback_cache:1; 546 547 /** allow parallel lookups and readdir (default is serialized) */ 548 unsigned parallel_dirops:1; 549 550 /* 551 * The following bitfields are only for optimization purposes 552 * and hence races in setting them will not cause malfunction 553 */ 554 555 /** Is open/release not implemented by fs? */ 556 unsigned no_open:1; 557 558 /** Is fsync not implemented by fs? */ 559 unsigned no_fsync:1; 560 561 /** Is fsyncdir not implemented by fs? */ 562 unsigned no_fsyncdir:1; 563 564 /** Is flush not implemented by fs? */ 565 unsigned no_flush:1; 566 567 /** Is setxattr not implemented by fs? */ 568 unsigned no_setxattr:1; 569 570 /** Is getxattr not implemented by fs? */ 571 unsigned no_getxattr:1; 572 573 /** Is listxattr not implemented by fs? */ 574 unsigned no_listxattr:1; 575 576 /** Is removexattr not implemented by fs? */ 577 unsigned no_removexattr:1; 578 579 /** Are posix file locking primitives not implemented by fs? */ 580 unsigned no_lock:1; 581 582 /** Is access not implemented by fs? */ 583 unsigned no_access:1; 584 585 /** Is create not implemented by fs? */ 586 unsigned no_create:1; 587 588 /** Is interrupt not implemented by fs? */ 589 unsigned no_interrupt:1; 590 591 /** Is bmap not implemented by fs? */ 592 unsigned no_bmap:1; 593 594 /** Is poll not implemented by fs? */ 595 unsigned no_poll:1; 596 597 /** Do multi-page cached writes */ 598 unsigned big_writes:1; 599 600 /** Don't apply umask to creation modes */ 601 unsigned dont_mask:1; 602 603 /** Are BSD file locking primitives not implemented by fs? */ 604 unsigned no_flock:1; 605 606 /** Is fallocate not implemented by fs? */ 607 unsigned no_fallocate:1; 608 609 /** Is rename with flags implemented by fs? */ 610 unsigned no_rename2:1; 611 612 /** Use enhanced/automatic page cache invalidation. */ 613 unsigned auto_inval_data:1; 614 615 /** Does the filesystem support readdirplus? */ 616 unsigned do_readdirplus:1; 617 618 /** Does the filesystem want adaptive readdirplus? */ 619 unsigned readdirplus_auto:1; 620 621 /** Does the filesystem support asynchronous direct-IO submission? */ 622 unsigned async_dio:1; 623 624 /** Is lseek not implemented by fs? */ 625 unsigned no_lseek:1; 626 627 /** The number of requests waiting for completion */ 628 atomic_t num_waiting; 629 630 /** Negotiated minor version */ 631 unsigned minor; 632 633 /** Backing dev info */ 634 struct backing_dev_info bdi; 635 636 /** Entry on the fuse_conn_list */ 637 struct list_head entry; 638 639 /** Device ID from super block */ 640 dev_t dev; 641 642 /** Dentries in the control filesystem */ 643 struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES]; 644 645 /** number of dentries used in the above array */ 646 int ctl_ndents; 647 648 /** Key for lock owner ID scrambling */ 649 u32 scramble_key[4]; 650 651 /** Reserved request for the DESTROY message */ 652 struct fuse_req *destroy_req; 653 654 /** Version counter for attribute changes */ 655 u64 attr_version; 656 657 /** Called on final put */ 658 void (*release)(struct fuse_conn *); 659 660 /** Super block for this connection. */ 661 struct super_block *sb; 662 663 /** Read/write semaphore to hold when accessing sb. */ 664 struct rw_semaphore killsb; 665 666 /** List of device instances belonging to this connection */ 667 struct list_head devices; 668 }; 669 670 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 671 { 672 return sb->s_fs_info; 673 } 674 675 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 676 { 677 return get_fuse_conn_super(inode->i_sb); 678 } 679 680 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 681 { 682 return container_of(inode, struct fuse_inode, inode); 683 } 684 685 static inline u64 get_node_id(struct inode *inode) 686 { 687 return get_fuse_inode(inode)->nodeid; 688 } 689 690 /** Device operations */ 691 extern const struct file_operations fuse_dev_operations; 692 693 extern const struct dentry_operations fuse_dentry_operations; 694 695 /** 696 * Inode to nodeid comparison. 697 */ 698 int fuse_inode_eq(struct inode *inode, void *_nodeidp); 699 700 /** 701 * Get a filled in inode 702 */ 703 struct inode *fuse_iget(struct super_block *sb, u64 nodeid, 704 int generation, struct fuse_attr *attr, 705 u64 attr_valid, u64 attr_version); 706 707 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name, 708 struct fuse_entry_out *outarg, struct inode **inode); 709 710 /** 711 * Send FORGET command 712 */ 713 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget, 714 u64 nodeid, u64 nlookup); 715 716 struct fuse_forget_link *fuse_alloc_forget(void); 717 718 /* Used by READDIRPLUS */ 719 void fuse_force_forget(struct file *file, u64 nodeid); 720 721 /** 722 * Initialize READ or READDIR request 723 */ 724 void fuse_read_fill(struct fuse_req *req, struct file *file, 725 loff_t pos, size_t count, int opcode); 726 727 /** 728 * Send OPEN or OPENDIR request 729 */ 730 int fuse_open_common(struct inode *inode, struct file *file, bool isdir); 731 732 struct fuse_file *fuse_file_alloc(struct fuse_conn *fc); 733 struct fuse_file *fuse_file_get(struct fuse_file *ff); 734 void fuse_file_free(struct fuse_file *ff); 735 void fuse_finish_open(struct inode *inode, struct file *file); 736 737 void fuse_sync_release(struct fuse_file *ff, int flags); 738 739 /** 740 * Send RELEASE or RELEASEDIR request 741 */ 742 void fuse_release_common(struct file *file, int opcode); 743 744 /** 745 * Send FSYNC or FSYNCDIR request 746 */ 747 int fuse_fsync_common(struct file *file, loff_t start, loff_t end, 748 int datasync, int isdir); 749 750 /** 751 * Notify poll wakeup 752 */ 753 int fuse_notify_poll_wakeup(struct fuse_conn *fc, 754 struct fuse_notify_poll_wakeup_out *outarg); 755 756 /** 757 * Initialize file operations on a regular file 758 */ 759 void fuse_init_file_inode(struct inode *inode); 760 761 /** 762 * Initialize inode operations on regular files and special files 763 */ 764 void fuse_init_common(struct inode *inode); 765 766 /** 767 * Initialize inode and file operations on a directory 768 */ 769 void fuse_init_dir(struct inode *inode); 770 771 /** 772 * Initialize inode operations on a symlink 773 */ 774 void fuse_init_symlink(struct inode *inode); 775 776 /** 777 * Change attributes of an inode 778 */ 779 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr, 780 u64 attr_valid, u64 attr_version); 781 782 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr, 783 u64 attr_valid); 784 785 /** 786 * Initialize the client device 787 */ 788 int fuse_dev_init(void); 789 790 /** 791 * Cleanup the client device 792 */ 793 void fuse_dev_cleanup(void); 794 795 int fuse_ctl_init(void); 796 void __exit fuse_ctl_cleanup(void); 797 798 /** 799 * Allocate a request 800 */ 801 struct fuse_req *fuse_request_alloc(unsigned npages); 802 803 struct fuse_req *fuse_request_alloc_nofs(unsigned npages); 804 805 /** 806 * Free a request 807 */ 808 void fuse_request_free(struct fuse_req *req); 809 810 /** 811 * Get a request, may fail with -ENOMEM, 812 * caller should specify # elements in req->pages[] explicitly 813 */ 814 struct fuse_req *fuse_get_req(struct fuse_conn *fc, unsigned npages); 815 struct fuse_req *fuse_get_req_for_background(struct fuse_conn *fc, 816 unsigned npages); 817 818 /* 819 * Increment reference count on request 820 */ 821 void __fuse_get_request(struct fuse_req *req); 822 823 /** 824 * Gets a requests for a file operation, always succeeds 825 */ 826 struct fuse_req *fuse_get_req_nofail_nopages(struct fuse_conn *fc, 827 struct file *file); 828 829 /** 830 * Decrement reference count of a request. If count goes to zero free 831 * the request. 832 */ 833 void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req); 834 835 /** 836 * Send a request (synchronous) 837 */ 838 void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req); 839 840 /** 841 * Simple request sending that does request allocation and freeing 842 */ 843 ssize_t fuse_simple_request(struct fuse_conn *fc, struct fuse_args *args); 844 845 /** 846 * Send a request in the background 847 */ 848 void fuse_request_send_background(struct fuse_conn *fc, struct fuse_req *req); 849 850 void fuse_request_send_background_locked(struct fuse_conn *fc, 851 struct fuse_req *req); 852 853 /* Abort all requests */ 854 void fuse_abort_conn(struct fuse_conn *fc); 855 856 /** 857 * Invalidate inode attributes 858 */ 859 void fuse_invalidate_attr(struct inode *inode); 860 861 void fuse_invalidate_entry_cache(struct dentry *entry); 862 863 void fuse_invalidate_atime(struct inode *inode); 864 865 /** 866 * Acquire reference to fuse_conn 867 */ 868 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc); 869 870 /** 871 * Initialize fuse_conn 872 */ 873 void fuse_conn_init(struct fuse_conn *fc); 874 875 /** 876 * Release reference to fuse_conn 877 */ 878 void fuse_conn_put(struct fuse_conn *fc); 879 880 struct fuse_dev *fuse_dev_alloc(struct fuse_conn *fc); 881 void fuse_dev_free(struct fuse_dev *fud); 882 883 /** 884 * Add connection to control filesystem 885 */ 886 int fuse_ctl_add_conn(struct fuse_conn *fc); 887 888 /** 889 * Remove connection from control filesystem 890 */ 891 void fuse_ctl_remove_conn(struct fuse_conn *fc); 892 893 /** 894 * Is file type valid? 895 */ 896 int fuse_valid_type(int m); 897 898 /** 899 * Is current process allowed to perform filesystem operation? 900 */ 901 int fuse_allow_current_process(struct fuse_conn *fc); 902 903 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id); 904 905 int fuse_update_attributes(struct inode *inode, struct kstat *stat, 906 struct file *file, bool *refreshed); 907 908 void fuse_flush_writepages(struct inode *inode); 909 910 void fuse_set_nowrite(struct inode *inode); 911 void fuse_release_nowrite(struct inode *inode); 912 913 u64 fuse_get_attr_version(struct fuse_conn *fc); 914 915 /** 916 * File-system tells the kernel to invalidate cache for the given node id. 917 */ 918 int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid, 919 loff_t offset, loff_t len); 920 921 /** 922 * File-system tells the kernel to invalidate parent attributes and 923 * the dentry matching parent/name. 924 * 925 * If the child_nodeid is non-zero and: 926 * - matches the inode number for the dentry matching parent/name, 927 * - is not a mount point 928 * - is a file or oan empty directory 929 * then the dentry is unhashed (d_delete()). 930 */ 931 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid, 932 u64 child_nodeid, struct qstr *name); 933 934 int fuse_do_open(struct fuse_conn *fc, u64 nodeid, struct file *file, 935 bool isdir); 936 937 /** 938 * fuse_direct_io() flags 939 */ 940 941 /** If set, it is WRITE; otherwise - READ */ 942 #define FUSE_DIO_WRITE (1 << 0) 943 944 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */ 945 #define FUSE_DIO_CUSE (1 << 1) 946 947 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter, 948 loff_t *ppos, int flags); 949 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg, 950 unsigned int flags); 951 long fuse_ioctl_common(struct file *file, unsigned int cmd, 952 unsigned long arg, unsigned int flags); 953 unsigned fuse_file_poll(struct file *file, poll_table *wait); 954 int fuse_dev_release(struct inode *inode, struct file *file); 955 956 bool fuse_write_update_size(struct inode *inode, loff_t pos); 957 958 int fuse_flush_times(struct inode *inode, struct fuse_file *ff); 959 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc); 960 961 int fuse_do_setattr(struct inode *inode, struct iattr *attr, 962 struct file *file); 963 964 void fuse_set_initialized(struct fuse_conn *fc); 965 966 void fuse_unlock_inode(struct inode *inode); 967 void fuse_lock_inode(struct inode *inode); 968 969 #endif /* _FS_FUSE_I_H */ 970