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