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 #ifndef pr_fmt 13 # define pr_fmt(fmt) "fuse: " fmt 14 #endif 15 16 #include <linux/fuse.h> 17 #include <linux/fs.h> 18 #include <linux/mount.h> 19 #include <linux/wait.h> 20 #include <linux/list.h> 21 #include <linux/spinlock.h> 22 #include <linux/mm.h> 23 #include <linux/backing-dev.h> 24 #include <linux/mutex.h> 25 #include <linux/rwsem.h> 26 #include <linux/rbtree.h> 27 #include <linux/poll.h> 28 #include <linux/workqueue.h> 29 #include <linux/kref.h> 30 #include <linux/xattr.h> 31 #include <linux/pid_namespace.h> 32 #include <linux/refcount.h> 33 #include <linux/user_namespace.h> 34 35 /** Default max number of pages that can be used in a single read request */ 36 #define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32 37 38 /** Maximum of max_pages received in init_out */ 39 #define FUSE_MAX_MAX_PAGES 256 40 41 /** Bias for fi->writectr, meaning new writepages must not be sent */ 42 #define FUSE_NOWRITE INT_MIN 43 44 /** It could be as large as PATH_MAX, but would that have any uses? */ 45 #define FUSE_NAME_MAX 1024 46 47 /** Number of dentries for each connection in the control filesystem */ 48 #define FUSE_CTL_NUM_DENTRIES 5 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 /* Which attributes are invalid */ 85 u32 inval_mask; 86 87 /** The sticky bit in inode->i_mode may have been removed, so 88 preserve the original mode */ 89 umode_t orig_i_mode; 90 91 /** 64 bit inode number */ 92 u64 orig_ino; 93 94 /** Version of last attribute change */ 95 u64 attr_version; 96 97 union { 98 /* Write related fields (regular file only) */ 99 struct { 100 /* Files usable in writepage. Protected by fi->lock */ 101 struct list_head write_files; 102 103 /* Writepages pending on truncate or fsync */ 104 struct list_head queued_writes; 105 106 /* Number of sent writes, a negative bias 107 * (FUSE_NOWRITE) means more writes are blocked */ 108 int writectr; 109 110 /* Waitq for writepage completion */ 111 wait_queue_head_t page_waitq; 112 113 /* List of writepage requestst (pending or sent) */ 114 struct rb_root writepages; 115 }; 116 117 /* readdir cache (directory only) */ 118 struct { 119 /* true if fully cached */ 120 bool cached; 121 122 /* size of cache */ 123 loff_t size; 124 125 /* position at end of cache (position of next entry) */ 126 loff_t pos; 127 128 /* version of the cache */ 129 u64 version; 130 131 /* modification time of directory when cache was 132 * started */ 133 struct timespec64 mtime; 134 135 /* iversion of directory when cache was started */ 136 u64 iversion; 137 138 /* protects above fields */ 139 spinlock_t lock; 140 } rdc; 141 }; 142 143 /** Miscellaneous bits describing inode state */ 144 unsigned long state; 145 146 /** Lock for serializing lookup and readdir for back compatibility*/ 147 struct mutex mutex; 148 149 /** Lock to protect write related fields */ 150 spinlock_t lock; 151 152 #ifdef CONFIG_FUSE_DAX 153 /* 154 * Dax specific inode data 155 */ 156 struct fuse_inode_dax *dax; 157 #endif 158 }; 159 160 /** FUSE inode state bits */ 161 enum { 162 /** Advise readdirplus */ 163 FUSE_I_ADVISE_RDPLUS, 164 /** Initialized with readdirplus */ 165 FUSE_I_INIT_RDPLUS, 166 /** An operation changing file size is in progress */ 167 FUSE_I_SIZE_UNSTABLE, 168 /* Bad inode */ 169 FUSE_I_BAD, 170 }; 171 172 struct fuse_conn; 173 struct fuse_mount; 174 struct fuse_release_args; 175 176 /** FUSE specific file data */ 177 struct fuse_file { 178 /** Fuse connection for this file */ 179 struct fuse_mount *fm; 180 181 /* Argument space reserved for release */ 182 struct fuse_release_args *release_args; 183 184 /** Kernel file handle guaranteed to be unique */ 185 u64 kh; 186 187 /** File handle used by userspace */ 188 u64 fh; 189 190 /** Node id of this file */ 191 u64 nodeid; 192 193 /** Refcount */ 194 refcount_t count; 195 196 /** FOPEN_* flags returned by open */ 197 u32 open_flags; 198 199 /** Entry on inode's write_files list */ 200 struct list_head write_entry; 201 202 /* Readdir related */ 203 struct { 204 /* 205 * Protects below fields against (crazy) parallel readdir on 206 * same open file. Uncontended in the normal case. 207 */ 208 struct mutex lock; 209 210 /* Dir stream position */ 211 loff_t pos; 212 213 /* Offset in cache */ 214 loff_t cache_off; 215 216 /* Version of cache we are reading */ 217 u64 version; 218 219 } readdir; 220 221 /** RB node to be linked on fuse_conn->polled_files */ 222 struct rb_node polled_node; 223 224 /** Wait queue head for poll */ 225 wait_queue_head_t poll_wait; 226 227 /** Has flock been performed on this file? */ 228 bool flock:1; 229 }; 230 231 /** One input argument of a request */ 232 struct fuse_in_arg { 233 unsigned size; 234 const void *value; 235 }; 236 237 /** One output argument of a request */ 238 struct fuse_arg { 239 unsigned size; 240 void *value; 241 }; 242 243 /** FUSE page descriptor */ 244 struct fuse_page_desc { 245 unsigned int length; 246 unsigned int offset; 247 }; 248 249 struct fuse_args { 250 uint64_t nodeid; 251 uint32_t opcode; 252 uint8_t in_numargs; 253 uint8_t out_numargs; 254 uint8_t ext_idx; 255 bool force:1; 256 bool noreply:1; 257 bool nocreds:1; 258 bool in_pages:1; 259 bool out_pages:1; 260 bool user_pages:1; 261 bool out_argvar:1; 262 bool page_zeroing:1; 263 bool page_replace:1; 264 bool may_block:1; 265 bool is_ext:1; 266 struct fuse_in_arg in_args[3]; 267 struct fuse_arg out_args[2]; 268 void (*end)(struct fuse_mount *fm, struct fuse_args *args, int error); 269 }; 270 271 struct fuse_args_pages { 272 struct fuse_args args; 273 struct page **pages; 274 struct fuse_page_desc *descs; 275 unsigned int num_pages; 276 }; 277 278 #define FUSE_ARGS(args) struct fuse_args args = {} 279 280 /** The request IO state (for asynchronous processing) */ 281 struct fuse_io_priv { 282 struct kref refcnt; 283 int async; 284 spinlock_t lock; 285 unsigned reqs; 286 ssize_t bytes; 287 size_t size; 288 __u64 offset; 289 bool write; 290 bool should_dirty; 291 int err; 292 struct kiocb *iocb; 293 struct completion *done; 294 bool blocking; 295 }; 296 297 #define FUSE_IO_PRIV_SYNC(i) \ 298 { \ 299 .refcnt = KREF_INIT(1), \ 300 .async = 0, \ 301 .iocb = i, \ 302 } 303 304 /** 305 * Request flags 306 * 307 * FR_ISREPLY: set if the request has reply 308 * FR_FORCE: force sending of the request even if interrupted 309 * FR_BACKGROUND: request is sent in the background 310 * FR_WAITING: request is counted as "waiting" 311 * FR_ABORTED: the request was aborted 312 * FR_INTERRUPTED: the request has been interrupted 313 * FR_LOCKED: data is being copied to/from the request 314 * FR_PENDING: request is not yet in userspace 315 * FR_SENT: request is in userspace, waiting for an answer 316 * FR_FINISHED: request is finished 317 * FR_PRIVATE: request is on private list 318 * FR_ASYNC: request is asynchronous 319 */ 320 enum fuse_req_flag { 321 FR_ISREPLY, 322 FR_FORCE, 323 FR_BACKGROUND, 324 FR_WAITING, 325 FR_ABORTED, 326 FR_INTERRUPTED, 327 FR_LOCKED, 328 FR_PENDING, 329 FR_SENT, 330 FR_FINISHED, 331 FR_PRIVATE, 332 FR_ASYNC, 333 }; 334 335 /** 336 * A request to the client 337 * 338 * .waitq.lock protects the following fields: 339 * - FR_ABORTED 340 * - FR_LOCKED (may also be modified under fc->lock, tested under both) 341 */ 342 struct fuse_req { 343 /** This can be on either pending processing or io lists in 344 fuse_conn */ 345 struct list_head list; 346 347 /** Entry on the interrupts list */ 348 struct list_head intr_entry; 349 350 /* Input/output arguments */ 351 struct fuse_args *args; 352 353 /** refcount */ 354 refcount_t count; 355 356 /* Request flags, updated with test/set/clear_bit() */ 357 unsigned long flags; 358 359 /* The request input header */ 360 struct { 361 struct fuse_in_header h; 362 } in; 363 364 /* The request output header */ 365 struct { 366 struct fuse_out_header h; 367 } out; 368 369 /** Used to wake up the task waiting for completion of request*/ 370 wait_queue_head_t waitq; 371 372 #if IS_ENABLED(CONFIG_VIRTIO_FS) 373 /** virtio-fs's physically contiguous buffer for in and out args */ 374 void *argbuf; 375 #endif 376 377 /** fuse_mount this request belongs to */ 378 struct fuse_mount *fm; 379 }; 380 381 struct fuse_iqueue; 382 383 /** 384 * Input queue callbacks 385 * 386 * Input queue signalling is device-specific. For example, the /dev/fuse file 387 * uses fiq->waitq and fasync to wake processes that are waiting on queue 388 * readiness. These callbacks allow other device types to respond to input 389 * queue activity. 390 */ 391 struct fuse_iqueue_ops { 392 /** 393 * Signal that a forget has been queued 394 */ 395 void (*wake_forget_and_unlock)(struct fuse_iqueue *fiq) 396 __releases(fiq->lock); 397 398 /** 399 * Signal that an INTERRUPT request has been queued 400 */ 401 void (*wake_interrupt_and_unlock)(struct fuse_iqueue *fiq) 402 __releases(fiq->lock); 403 404 /** 405 * Signal that a request has been queued 406 */ 407 void (*wake_pending_and_unlock)(struct fuse_iqueue *fiq) 408 __releases(fiq->lock); 409 410 /** 411 * Clean up when fuse_iqueue is destroyed 412 */ 413 void (*release)(struct fuse_iqueue *fiq); 414 }; 415 416 /** /dev/fuse input queue operations */ 417 extern const struct fuse_iqueue_ops fuse_dev_fiq_ops; 418 419 struct fuse_iqueue { 420 /** Connection established */ 421 unsigned connected; 422 423 /** Lock protecting accesses to members of this structure */ 424 spinlock_t lock; 425 426 /** Readers of the connection are waiting on this */ 427 wait_queue_head_t waitq; 428 429 /** The next unique request id */ 430 u64 reqctr; 431 432 /** The list of pending requests */ 433 struct list_head pending; 434 435 /** Pending interrupts */ 436 struct list_head interrupts; 437 438 /** Queue of pending forgets */ 439 struct fuse_forget_link forget_list_head; 440 struct fuse_forget_link *forget_list_tail; 441 442 /** Batching of FORGET requests (positive indicates FORGET batch) */ 443 int forget_batch; 444 445 /** O_ASYNC requests */ 446 struct fasync_struct *fasync; 447 448 /** Device-specific callbacks */ 449 const struct fuse_iqueue_ops *ops; 450 451 /** Device-specific state */ 452 void *priv; 453 }; 454 455 #define FUSE_PQ_HASH_BITS 8 456 #define FUSE_PQ_HASH_SIZE (1 << FUSE_PQ_HASH_BITS) 457 458 struct fuse_pqueue { 459 /** Connection established */ 460 unsigned connected; 461 462 /** Lock protecting accessess to members of this structure */ 463 spinlock_t lock; 464 465 /** Hash table of requests being processed */ 466 struct list_head *processing; 467 468 /** The list of requests under I/O */ 469 struct list_head io; 470 }; 471 472 /** 473 * Fuse device instance 474 */ 475 struct fuse_dev { 476 /** Fuse connection for this device */ 477 struct fuse_conn *fc; 478 479 /** Processing queue */ 480 struct fuse_pqueue pq; 481 482 /** list entry on fc->devices */ 483 struct list_head entry; 484 }; 485 486 enum fuse_dax_mode { 487 FUSE_DAX_INODE_DEFAULT, /* default */ 488 FUSE_DAX_ALWAYS, /* "-o dax=always" */ 489 FUSE_DAX_NEVER, /* "-o dax=never" */ 490 FUSE_DAX_INODE_USER, /* "-o dax=inode" */ 491 }; 492 fuse_is_inode_dax_mode(enum fuse_dax_mode mode)493 static inline bool fuse_is_inode_dax_mode(enum fuse_dax_mode mode) 494 { 495 return mode == FUSE_DAX_INODE_DEFAULT || mode == FUSE_DAX_INODE_USER; 496 } 497 498 struct fuse_fs_context { 499 int fd; 500 struct file *file; 501 unsigned int rootmode; 502 kuid_t user_id; 503 kgid_t group_id; 504 bool is_bdev:1; 505 bool fd_present:1; 506 bool rootmode_present:1; 507 bool user_id_present:1; 508 bool group_id_present:1; 509 bool default_permissions:1; 510 bool allow_other:1; 511 bool destroy:1; 512 bool no_control:1; 513 bool no_force_umount:1; 514 bool legacy_opts_show:1; 515 enum fuse_dax_mode dax_mode; 516 unsigned int max_read; 517 unsigned int blksize; 518 const char *subtype; 519 520 /* DAX device, may be NULL */ 521 struct dax_device *dax_dev; 522 523 /* fuse_dev pointer to fill in, should contain NULL on entry */ 524 void **fudptr; 525 }; 526 527 struct fuse_sync_bucket { 528 /* count is a possible scalability bottleneck */ 529 atomic_t count; 530 wait_queue_head_t waitq; 531 struct rcu_head rcu; 532 }; 533 534 /** 535 * A Fuse connection. 536 * 537 * This structure is created, when the root filesystem is mounted, and 538 * is destroyed, when the client device is closed and the last 539 * fuse_mount is destroyed. 540 */ 541 struct fuse_conn { 542 /** Lock protecting accessess to members of this structure */ 543 spinlock_t lock; 544 545 /** Refcount */ 546 refcount_t count; 547 548 /** Number of fuse_dev's */ 549 atomic_t dev_count; 550 551 struct rcu_head rcu; 552 553 /** The user id for this mount */ 554 kuid_t user_id; 555 556 /** The group id for this mount */ 557 kgid_t group_id; 558 559 /** The pid namespace for this mount */ 560 struct pid_namespace *pid_ns; 561 562 /** The user namespace for this mount */ 563 struct user_namespace *user_ns; 564 565 /** Maximum read size */ 566 unsigned max_read; 567 568 /** Maximum write size */ 569 unsigned max_write; 570 571 /** Maximum number of pages that can be used in a single request */ 572 unsigned int max_pages; 573 574 /** Constrain ->max_pages to this value during feature negotiation */ 575 unsigned int max_pages_limit; 576 577 /** Input queue */ 578 struct fuse_iqueue iq; 579 580 /** The next unique kernel file handle */ 581 atomic64_t khctr; 582 583 /** rbtree of fuse_files waiting for poll events indexed by ph */ 584 struct rb_root polled_files; 585 586 /** Maximum number of outstanding background requests */ 587 unsigned max_background; 588 589 /** Number of background requests at which congestion starts */ 590 unsigned congestion_threshold; 591 592 /** Number of requests currently in the background */ 593 unsigned num_background; 594 595 /** Number of background requests currently queued for userspace */ 596 unsigned active_background; 597 598 /** The list of background requests set aside for later queuing */ 599 struct list_head bg_queue; 600 601 /** Protects: max_background, congestion_threshold, num_background, 602 * active_background, bg_queue, blocked */ 603 spinlock_t bg_lock; 604 605 /** Flag indicating that INIT reply has been received. Allocating 606 * any fuse request will be suspended until the flag is set */ 607 int initialized; 608 609 /** Flag indicating if connection is blocked. This will be 610 the case before the INIT reply is received, and if there 611 are too many outstading backgrounds requests */ 612 int blocked; 613 614 /** waitq for blocked connection */ 615 wait_queue_head_t blocked_waitq; 616 617 /** Connection established, cleared on umount, connection 618 abort and device release */ 619 unsigned connected; 620 621 /** Connection aborted via sysfs */ 622 bool aborted; 623 624 /** Connection failed (version mismatch). Cannot race with 625 setting other bitfields since it is only set once in INIT 626 reply, before any other request, and never cleared */ 627 unsigned conn_error:1; 628 629 /** Connection successful. Only set in INIT */ 630 unsigned conn_init:1; 631 632 /** Do readahead asynchronously? Only set in INIT */ 633 unsigned async_read:1; 634 635 /** Return an unique read error after abort. Only set in INIT */ 636 unsigned abort_err:1; 637 638 /** Do not send separate SETATTR request before open(O_TRUNC) */ 639 unsigned atomic_o_trunc:1; 640 641 /** Filesystem supports NFS exporting. Only set in INIT */ 642 unsigned export_support:1; 643 644 /** write-back cache policy (default is write-through) */ 645 unsigned writeback_cache:1; 646 647 /** allow parallel lookups and readdir (default is serialized) */ 648 unsigned parallel_dirops:1; 649 650 /** handle fs handles killing suid/sgid/cap on write/chown/trunc */ 651 unsigned handle_killpriv:1; 652 653 /** cache READLINK responses in page cache */ 654 unsigned cache_symlinks:1; 655 656 /* show legacy mount options */ 657 unsigned int legacy_opts_show:1; 658 659 /* 660 * fs kills suid/sgid/cap on write/chown/trunc. suid is killed on 661 * write/trunc only if caller did not have CAP_FSETID. sgid is killed 662 * on write/truncate only if caller did not have CAP_FSETID as well as 663 * file has group execute permission. 664 */ 665 unsigned handle_killpriv_v2:1; 666 667 /* 668 * The following bitfields are only for optimization purposes 669 * and hence races in setting them will not cause malfunction 670 */ 671 672 /** Is open/release not implemented by fs? */ 673 unsigned no_open:1; 674 675 /** Is opendir/releasedir not implemented by fs? */ 676 unsigned no_opendir:1; 677 678 /** Is fsync not implemented by fs? */ 679 unsigned no_fsync:1; 680 681 /** Is fsyncdir not implemented by fs? */ 682 unsigned no_fsyncdir:1; 683 684 /** Is flush not implemented by fs? */ 685 unsigned no_flush:1; 686 687 /** Is setxattr not implemented by fs? */ 688 unsigned no_setxattr:1; 689 690 /** Does file server support extended setxattr */ 691 unsigned setxattr_ext:1; 692 693 /** Is getxattr not implemented by fs? */ 694 unsigned no_getxattr:1; 695 696 /** Is listxattr not implemented by fs? */ 697 unsigned no_listxattr:1; 698 699 /** Is removexattr not implemented by fs? */ 700 unsigned no_removexattr:1; 701 702 /** Are posix file locking primitives not implemented by fs? */ 703 unsigned no_lock:1; 704 705 /** Is access not implemented by fs? */ 706 unsigned no_access:1; 707 708 /** Is create not implemented by fs? */ 709 unsigned no_create:1; 710 711 /** Is interrupt not implemented by fs? */ 712 unsigned no_interrupt:1; 713 714 /** Is bmap not implemented by fs? */ 715 unsigned no_bmap:1; 716 717 /** Is poll not implemented by fs? */ 718 unsigned no_poll:1; 719 720 /** Do multi-page cached writes */ 721 unsigned big_writes:1; 722 723 /** Don't apply umask to creation modes */ 724 unsigned dont_mask:1; 725 726 /** Are BSD file locking primitives not implemented by fs? */ 727 unsigned no_flock:1; 728 729 /** Is fallocate not implemented by fs? */ 730 unsigned no_fallocate:1; 731 732 /** Is rename with flags implemented by fs? */ 733 unsigned no_rename2:1; 734 735 /** Use enhanced/automatic page cache invalidation. */ 736 unsigned auto_inval_data:1; 737 738 /** Filesystem is fully responsible for page cache invalidation. */ 739 unsigned explicit_inval_data:1; 740 741 /** Does the filesystem support readdirplus? */ 742 unsigned do_readdirplus:1; 743 744 /** Does the filesystem want adaptive readdirplus? */ 745 unsigned readdirplus_auto:1; 746 747 /** Does the filesystem support asynchronous direct-IO submission? */ 748 unsigned async_dio:1; 749 750 /** Is lseek not implemented by fs? */ 751 unsigned no_lseek:1; 752 753 /** Does the filesystem support posix acls? */ 754 unsigned posix_acl:1; 755 756 /** Check permissions based on the file mode or not? */ 757 unsigned default_permissions:1; 758 759 /** Allow other than the mounter user to access the filesystem ? */ 760 unsigned allow_other:1; 761 762 /** Does the filesystem support copy_file_range? */ 763 unsigned no_copy_file_range:1; 764 765 /* Send DESTROY request */ 766 unsigned int destroy:1; 767 768 /* Delete dentries that have gone stale */ 769 unsigned int delete_stale:1; 770 771 /** Do not create entry in fusectl fs */ 772 unsigned int no_control:1; 773 774 /** Do not allow MNT_FORCE umount */ 775 unsigned int no_force_umount:1; 776 777 /* Auto-mount submounts announced by the server */ 778 unsigned int auto_submounts:1; 779 780 /* Propagate syncfs() to server */ 781 unsigned int sync_fs:1; 782 783 /* Initialize security xattrs when creating a new inode */ 784 unsigned int init_security:1; 785 786 /* Add supplementary group info when creating a new inode */ 787 unsigned int create_supp_group:1; 788 789 /* Does the filesystem support per inode DAX? */ 790 unsigned int inode_dax:1; 791 792 /* Is tmpfile not implemented by fs? */ 793 unsigned int no_tmpfile:1; 794 795 /** The number of requests waiting for completion */ 796 atomic_t num_waiting; 797 798 /** Negotiated minor version */ 799 unsigned minor; 800 801 /** Entry on the fuse_mount_list */ 802 struct list_head entry; 803 804 /** Device ID from the root super block */ 805 dev_t dev; 806 807 /** Dentries in the control filesystem */ 808 struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES]; 809 810 /** number of dentries used in the above array */ 811 int ctl_ndents; 812 813 /** Key for lock owner ID scrambling */ 814 u32 scramble_key[4]; 815 816 /** Version counter for attribute changes */ 817 atomic64_t attr_version; 818 819 /** Called on final put */ 820 void (*release)(struct fuse_conn *); 821 822 /** 823 * Read/write semaphore to hold when accessing the sb of any 824 * fuse_mount belonging to this connection 825 */ 826 struct rw_semaphore killsb; 827 828 /** List of device instances belonging to this connection */ 829 struct list_head devices; 830 831 #ifdef CONFIG_FUSE_DAX 832 /* Dax mode */ 833 enum fuse_dax_mode dax_mode; 834 835 /* Dax specific conn data, non-NULL if DAX is enabled */ 836 struct fuse_conn_dax *dax; 837 #endif 838 839 /** List of filesystems using this connection */ 840 struct list_head mounts; 841 842 /* New writepages go into this bucket */ 843 struct fuse_sync_bucket __rcu *curr_bucket; 844 }; 845 846 /* 847 * Represents a mounted filesystem, potentially a submount. 848 * 849 * This object allows sharing a fuse_conn between separate mounts to 850 * allow submounts with dedicated superblocks and thus separate device 851 * IDs. 852 */ 853 struct fuse_mount { 854 /* Underlying (potentially shared) connection to the FUSE server */ 855 struct fuse_conn *fc; 856 857 /* 858 * Super block for this connection (fc->killsb must be held when 859 * accessing this). 860 */ 861 struct super_block *sb; 862 863 /* Entry on fc->mounts */ 864 struct list_head fc_entry; 865 }; 866 get_fuse_mount_super(struct super_block * sb)867 static inline struct fuse_mount *get_fuse_mount_super(struct super_block *sb) 868 { 869 return sb->s_fs_info; 870 } 871 get_fuse_conn_super(struct super_block * sb)872 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb) 873 { 874 return get_fuse_mount_super(sb)->fc; 875 } 876 get_fuse_mount(struct inode * inode)877 static inline struct fuse_mount *get_fuse_mount(struct inode *inode) 878 { 879 return get_fuse_mount_super(inode->i_sb); 880 } 881 get_fuse_conn(struct inode * inode)882 static inline struct fuse_conn *get_fuse_conn(struct inode *inode) 883 { 884 return get_fuse_mount_super(inode->i_sb)->fc; 885 } 886 get_fuse_inode(struct inode * inode)887 static inline struct fuse_inode *get_fuse_inode(struct inode *inode) 888 { 889 return container_of(inode, struct fuse_inode, inode); 890 } 891 get_node_id(struct inode * inode)892 static inline u64 get_node_id(struct inode *inode) 893 { 894 return get_fuse_inode(inode)->nodeid; 895 } 896 invalid_nodeid(u64 nodeid)897 static inline int invalid_nodeid(u64 nodeid) 898 { 899 return !nodeid || nodeid == FUSE_ROOT_ID; 900 } 901 fuse_get_attr_version(struct fuse_conn * fc)902 static inline u64 fuse_get_attr_version(struct fuse_conn *fc) 903 { 904 return atomic64_read(&fc->attr_version); 905 } 906 fuse_stale_inode(const struct inode * inode,int generation,struct fuse_attr * attr)907 static inline bool fuse_stale_inode(const struct inode *inode, int generation, 908 struct fuse_attr *attr) 909 { 910 return inode->i_generation != generation || 911 inode_wrong_type(inode, attr->mode); 912 } 913 fuse_make_bad(struct inode * inode)914 static inline void fuse_make_bad(struct inode *inode) 915 { 916 remove_inode_hash(inode); 917 set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state); 918 } 919 fuse_is_bad(struct inode * inode)920 static inline bool fuse_is_bad(struct inode *inode) 921 { 922 return unlikely(test_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state)); 923 } 924 fuse_pages_alloc(unsigned int npages,gfp_t flags,struct fuse_page_desc ** desc)925 static inline struct page **fuse_pages_alloc(unsigned int npages, gfp_t flags, 926 struct fuse_page_desc **desc) 927 { 928 struct page **pages; 929 930 pages = kzalloc(npages * (sizeof(struct page *) + 931 sizeof(struct fuse_page_desc)), flags); 932 *desc = (void *) (pages + npages); 933 934 return pages; 935 } 936 fuse_page_descs_length_init(struct fuse_page_desc * descs,unsigned int index,unsigned int nr_pages)937 static inline void fuse_page_descs_length_init(struct fuse_page_desc *descs, 938 unsigned int index, 939 unsigned int nr_pages) 940 { 941 int i; 942 943 for (i = index; i < index + nr_pages; i++) 944 descs[i].length = PAGE_SIZE - descs[i].offset; 945 } 946 fuse_sync_bucket_dec(struct fuse_sync_bucket * bucket)947 static inline void fuse_sync_bucket_dec(struct fuse_sync_bucket *bucket) 948 { 949 /* Need RCU protection to prevent use after free after the decrement */ 950 rcu_read_lock(); 951 if (atomic_dec_and_test(&bucket->count)) 952 wake_up(&bucket->waitq); 953 rcu_read_unlock(); 954 } 955 956 /** Device operations */ 957 extern const struct file_operations fuse_dev_operations; 958 959 extern const struct dentry_operations fuse_dentry_operations; 960 extern const struct dentry_operations fuse_root_dentry_operations; 961 962 /** 963 * Get a filled in inode 964 */ 965 struct inode *fuse_iget(struct super_block *sb, u64 nodeid, 966 int generation, struct fuse_attr *attr, 967 u64 attr_valid, u64 attr_version); 968 969 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name, 970 struct fuse_entry_out *outarg, struct inode **inode); 971 972 /** 973 * Send FORGET command 974 */ 975 void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget, 976 u64 nodeid, u64 nlookup); 977 978 struct fuse_forget_link *fuse_alloc_forget(void); 979 980 struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq, 981 unsigned int max, 982 unsigned int *countp); 983 984 /* 985 * Initialize READ or READDIR request 986 */ 987 struct fuse_io_args { 988 union { 989 struct { 990 struct fuse_read_in in; 991 u64 attr_ver; 992 } read; 993 struct { 994 struct fuse_write_in in; 995 struct fuse_write_out out; 996 bool page_locked; 997 } write; 998 }; 999 struct fuse_args_pages ap; 1000 struct fuse_io_priv *io; 1001 struct fuse_file *ff; 1002 }; 1003 1004 void fuse_read_args_fill(struct fuse_io_args *ia, struct file *file, loff_t pos, 1005 size_t count, int opcode); 1006 1007 1008 /** 1009 * Send OPEN or OPENDIR request 1010 */ 1011 int fuse_open_common(struct inode *inode, struct file *file, bool isdir); 1012 1013 struct fuse_file *fuse_file_alloc(struct fuse_mount *fm); 1014 void fuse_file_free(struct fuse_file *ff); 1015 void fuse_finish_open(struct inode *inode, struct file *file); 1016 1017 void fuse_sync_release(struct fuse_inode *fi, struct fuse_file *ff, 1018 unsigned int flags); 1019 1020 /** 1021 * Send RELEASE or RELEASEDIR request 1022 */ 1023 void fuse_release_common(struct file *file, bool isdir); 1024 1025 /** 1026 * Send FSYNC or FSYNCDIR request 1027 */ 1028 int fuse_fsync_common(struct file *file, loff_t start, loff_t end, 1029 int datasync, int opcode); 1030 1031 /** 1032 * Notify poll wakeup 1033 */ 1034 int fuse_notify_poll_wakeup(struct fuse_conn *fc, 1035 struct fuse_notify_poll_wakeup_out *outarg); 1036 1037 /** 1038 * Initialize file operations on a regular file 1039 */ 1040 void fuse_init_file_inode(struct inode *inode, unsigned int flags); 1041 1042 /** 1043 * Initialize inode operations on regular files and special files 1044 */ 1045 void fuse_init_common(struct inode *inode); 1046 1047 /** 1048 * Initialize inode and file operations on a directory 1049 */ 1050 void fuse_init_dir(struct inode *inode); 1051 1052 /** 1053 * Initialize inode operations on a symlink 1054 */ 1055 void fuse_init_symlink(struct inode *inode); 1056 1057 /** 1058 * Change attributes of an inode 1059 */ 1060 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr, 1061 u64 attr_valid, u64 attr_version); 1062 1063 void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr, 1064 u64 attr_valid, u32 cache_mask); 1065 1066 u32 fuse_get_cache_mask(struct inode *inode); 1067 1068 /** 1069 * Initialize the client device 1070 */ 1071 int fuse_dev_init(void); 1072 1073 /** 1074 * Cleanup the client device 1075 */ 1076 void fuse_dev_cleanup(void); 1077 1078 int fuse_ctl_init(void); 1079 void __exit fuse_ctl_cleanup(void); 1080 1081 /** 1082 * Simple request sending that does request allocation and freeing 1083 */ 1084 ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args); 1085 int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args, 1086 gfp_t gfp_flags); 1087 1088 /** 1089 * End a finished request 1090 */ 1091 void fuse_request_end(struct fuse_req *req); 1092 1093 /* Abort all requests */ 1094 void fuse_abort_conn(struct fuse_conn *fc); 1095 void fuse_wait_aborted(struct fuse_conn *fc); 1096 1097 /** 1098 * Invalidate inode attributes 1099 */ 1100 1101 /* Attributes possibly changed on data modification */ 1102 #define FUSE_STATX_MODIFY (STATX_MTIME | STATX_CTIME | STATX_BLOCKS) 1103 1104 /* Attributes possibly changed on data and/or size modification */ 1105 #define FUSE_STATX_MODSIZE (FUSE_STATX_MODIFY | STATX_SIZE) 1106 1107 void fuse_invalidate_attr(struct inode *inode); 1108 void fuse_invalidate_attr_mask(struct inode *inode, u32 mask); 1109 1110 void fuse_invalidate_entry_cache(struct dentry *entry); 1111 1112 void fuse_invalidate_atime(struct inode *inode); 1113 1114 u64 entry_attr_timeout(struct fuse_entry_out *o); 1115 void fuse_change_entry_timeout(struct dentry *entry, struct fuse_entry_out *o); 1116 1117 /** 1118 * Acquire reference to fuse_conn 1119 */ 1120 struct fuse_conn *fuse_conn_get(struct fuse_conn *fc); 1121 1122 /** 1123 * Initialize fuse_conn 1124 */ 1125 void fuse_conn_init(struct fuse_conn *fc, struct fuse_mount *fm, 1126 struct user_namespace *user_ns, 1127 const struct fuse_iqueue_ops *fiq_ops, void *fiq_priv); 1128 1129 /** 1130 * Release reference to fuse_conn 1131 */ 1132 void fuse_conn_put(struct fuse_conn *fc); 1133 1134 struct fuse_dev *fuse_dev_alloc_install(struct fuse_conn *fc); 1135 struct fuse_dev *fuse_dev_alloc(void); 1136 void fuse_dev_install(struct fuse_dev *fud, struct fuse_conn *fc); 1137 void fuse_dev_free(struct fuse_dev *fud); 1138 void fuse_send_init(struct fuse_mount *fm); 1139 1140 /** 1141 * Fill in superblock and initialize fuse connection 1142 * @sb: partially-initialized superblock to fill in 1143 * @ctx: mount context 1144 */ 1145 int fuse_fill_super_common(struct super_block *sb, struct fuse_fs_context *ctx); 1146 1147 /* 1148 * Remove the mount from the connection 1149 * 1150 * Returns whether this was the last mount 1151 */ 1152 bool fuse_mount_remove(struct fuse_mount *fm); 1153 1154 /* 1155 * Setup context ops for submounts 1156 */ 1157 int fuse_init_fs_context_submount(struct fs_context *fsc); 1158 1159 /* 1160 * Shut down the connection (possibly sending DESTROY request). 1161 */ 1162 void fuse_conn_destroy(struct fuse_mount *fm); 1163 1164 /* Drop the connection and free the fuse mount */ 1165 void fuse_mount_destroy(struct fuse_mount *fm); 1166 1167 /** 1168 * Add connection to control filesystem 1169 */ 1170 int fuse_ctl_add_conn(struct fuse_conn *fc); 1171 1172 /** 1173 * Remove connection from control filesystem 1174 */ 1175 void fuse_ctl_remove_conn(struct fuse_conn *fc); 1176 1177 /** 1178 * Is file type valid? 1179 */ 1180 int fuse_valid_type(int m); 1181 1182 bool fuse_invalid_attr(struct fuse_attr *attr); 1183 1184 /** 1185 * Is current process allowed to perform filesystem operation? 1186 */ 1187 bool fuse_allow_current_process(struct fuse_conn *fc); 1188 1189 u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id); 1190 1191 void fuse_flush_time_update(struct inode *inode); 1192 void fuse_update_ctime(struct inode *inode); 1193 1194 int fuse_update_attributes(struct inode *inode, struct file *file, u32 mask); 1195 1196 void fuse_flush_writepages(struct inode *inode); 1197 1198 void fuse_set_nowrite(struct inode *inode); 1199 void fuse_release_nowrite(struct inode *inode); 1200 1201 /** 1202 * Scan all fuse_mounts belonging to fc to find the first where 1203 * ilookup5() returns a result. Return that result and the 1204 * respective fuse_mount in *fm (unless fm is NULL). 1205 * 1206 * The caller must hold fc->killsb. 1207 */ 1208 struct inode *fuse_ilookup(struct fuse_conn *fc, u64 nodeid, 1209 struct fuse_mount **fm); 1210 1211 /** 1212 * File-system tells the kernel to invalidate cache for the given node id. 1213 */ 1214 int fuse_reverse_inval_inode(struct fuse_conn *fc, u64 nodeid, 1215 loff_t offset, loff_t len); 1216 1217 /** 1218 * File-system tells the kernel to invalidate parent attributes and 1219 * the dentry matching parent/name. 1220 * 1221 * If the child_nodeid is non-zero and: 1222 * - matches the inode number for the dentry matching parent/name, 1223 * - is not a mount point 1224 * - is a file or oan empty directory 1225 * then the dentry is unhashed (d_delete()). 1226 */ 1227 int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid, 1228 u64 child_nodeid, struct qstr *name, u32 flags); 1229 1230 int fuse_do_open(struct fuse_mount *fm, u64 nodeid, struct file *file, 1231 bool isdir); 1232 1233 /** 1234 * fuse_direct_io() flags 1235 */ 1236 1237 /** If set, it is WRITE; otherwise - READ */ 1238 #define FUSE_DIO_WRITE (1 << 0) 1239 1240 /** CUSE pass fuse_direct_io() a file which f_mapping->host is not from FUSE */ 1241 #define FUSE_DIO_CUSE (1 << 1) 1242 1243 ssize_t fuse_direct_io(struct fuse_io_priv *io, struct iov_iter *iter, 1244 loff_t *ppos, int flags); 1245 long fuse_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg, 1246 unsigned int flags); 1247 long fuse_ioctl_common(struct file *file, unsigned int cmd, 1248 unsigned long arg, unsigned int flags); 1249 __poll_t fuse_file_poll(struct file *file, poll_table *wait); 1250 int fuse_dev_release(struct inode *inode, struct file *file); 1251 1252 bool fuse_write_update_attr(struct inode *inode, loff_t pos, ssize_t written); 1253 1254 int fuse_flush_times(struct inode *inode, struct fuse_file *ff); 1255 int fuse_write_inode(struct inode *inode, struct writeback_control *wbc); 1256 1257 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr, 1258 struct file *file); 1259 1260 void fuse_set_initialized(struct fuse_conn *fc); 1261 1262 void fuse_unlock_inode(struct inode *inode, bool locked); 1263 bool fuse_lock_inode(struct inode *inode); 1264 1265 int fuse_setxattr(struct inode *inode, const char *name, const void *value, 1266 size_t size, int flags, unsigned int extra_flags); 1267 ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value, 1268 size_t size); 1269 ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size); 1270 int fuse_removexattr(struct inode *inode, const char *name); 1271 extern const struct xattr_handler *fuse_xattr_handlers[]; 1272 1273 struct posix_acl; 1274 struct posix_acl *fuse_get_inode_acl(struct inode *inode, int type, bool rcu); 1275 struct posix_acl *fuse_get_acl(struct mnt_idmap *idmap, 1276 struct dentry *dentry, int type); 1277 int fuse_set_acl(struct mnt_idmap *, struct dentry *dentry, 1278 struct posix_acl *acl, int type); 1279 1280 /* readdir.c */ 1281 int fuse_readdir(struct file *file, struct dir_context *ctx); 1282 1283 /** 1284 * Return the number of bytes in an arguments list 1285 */ 1286 unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args); 1287 1288 /** 1289 * Get the next unique ID for a request 1290 */ 1291 u64 fuse_get_unique(struct fuse_iqueue *fiq); 1292 void fuse_free_conn(struct fuse_conn *fc); 1293 1294 /* dax.c */ 1295 1296 #define FUSE_IS_DAX(inode) (IS_ENABLED(CONFIG_FUSE_DAX) && IS_DAX(inode)) 1297 1298 ssize_t fuse_dax_read_iter(struct kiocb *iocb, struct iov_iter *to); 1299 ssize_t fuse_dax_write_iter(struct kiocb *iocb, struct iov_iter *from); 1300 int fuse_dax_mmap(struct file *file, struct vm_area_struct *vma); 1301 int fuse_dax_break_layouts(struct inode *inode, u64 dmap_start, u64 dmap_end); 1302 int fuse_dax_conn_alloc(struct fuse_conn *fc, enum fuse_dax_mode mode, 1303 struct dax_device *dax_dev); 1304 void fuse_dax_conn_free(struct fuse_conn *fc); 1305 bool fuse_dax_inode_alloc(struct super_block *sb, struct fuse_inode *fi); 1306 void fuse_dax_inode_init(struct inode *inode, unsigned int flags); 1307 void fuse_dax_inode_cleanup(struct inode *inode); 1308 void fuse_dax_dontcache(struct inode *inode, unsigned int flags); 1309 bool fuse_dax_check_alignment(struct fuse_conn *fc, unsigned int map_alignment); 1310 void fuse_dax_cancel_work(struct fuse_conn *fc); 1311 1312 /* ioctl.c */ 1313 long fuse_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 1314 long fuse_file_compat_ioctl(struct file *file, unsigned int cmd, 1315 unsigned long arg); 1316 int fuse_fileattr_get(struct dentry *dentry, struct fileattr *fa); 1317 int fuse_fileattr_set(struct mnt_idmap *idmap, 1318 struct dentry *dentry, struct fileattr *fa); 1319 1320 /* file.c */ 1321 1322 struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid, 1323 unsigned int open_flags, bool isdir); 1324 void fuse_file_release(struct inode *inode, struct fuse_file *ff, 1325 unsigned int open_flags, fl_owner_t id, bool isdir); 1326 1327 #endif /* _FS_FUSE_I_H */ 1328