1======= 2Locking 3======= 4 5The text below describes the locking rules for VFS-related methods. 6It is (believed to be) up-to-date. *Please*, if you change anything in 7prototypes or locking protocols - update this file. And update the relevant 8instances in the tree, don't leave that to maintainers of filesystems/devices/ 9etc. At the very least, put the list of dubious cases in the end of this file. 10Don't turn it into log - maintainers of out-of-the-tree code are supposed to 11be able to use diff(1). 12 13Thing currently missing here: socket operations. Alexey? 14 15dentry_operations 16================= 17 18prototypes:: 19 20 int (*d_revalidate)(struct inode *, const struct qstr *, 21 struct dentry *, unsigned int); 22 int (*d_weak_revalidate)(struct dentry *, unsigned int); 23 int (*d_hash)(const struct dentry *, struct qstr *); 24 int (*d_compare)(const struct dentry *, 25 unsigned int, const char *, const struct qstr *); 26 int (*d_delete)(struct dentry *); 27 int (*d_init)(struct dentry *); 28 void (*d_release)(struct dentry *); 29 void (*d_iput)(struct dentry *, struct inode *); 30 char *(*d_dname)((struct dentry *dentry, char *buffer, int buflen); 31 struct vfsmount *(*d_automount)(struct path *path); 32 int (*d_manage)(const struct path *, bool); 33 struct dentry *(*d_real)(struct dentry *, enum d_real_type type); 34 bool (*d_unalias_trylock)(const struct dentry *); 35 void (*d_unalias_unlock)(const struct dentry *); 36 37locking rules: 38 39================== =========== ======== ============== ======== 40ops rename_lock ->d_lock may block rcu-walk 41================== =========== ======== ============== ======== 42d_revalidate: no no yes (ref-walk) maybe 43d_weak_revalidate: no no yes no 44d_hash no no no maybe 45d_compare: yes no no maybe 46d_delete: no yes no no 47d_init: no no yes no 48d_release: no no yes no 49d_prune: no yes no no 50d_iput: no no yes no 51d_dname: no no no no 52d_automount: no no yes no 53d_manage: no no yes (ref-walk) maybe 54d_real no no yes no 55d_unalias_trylock yes no no no 56d_unalias_unlock yes no no no 57================== =========== ======== ============== ======== 58 59inode_operations 60================ 61 62prototypes:: 63 64 int (*create) (struct mnt_idmap *, struct inode *,struct dentry *,umode_t, bool); 65 struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int); 66 int (*link) (struct dentry *,struct inode *,struct dentry *); 67 int (*unlink) (struct inode *,struct dentry *); 68 int (*symlink) (struct mnt_idmap *, struct inode *,struct dentry *,const char *); 69 struct dentry *(*mkdir) (struct mnt_idmap *, struct inode *,struct dentry *,umode_t); 70 int (*rmdir) (struct inode *,struct dentry *); 71 int (*mknod) (struct mnt_idmap *, struct inode *,struct dentry *,umode_t,dev_t); 72 int (*rename) (struct mnt_idmap *, struct inode *, struct dentry *, 73 struct inode *, struct dentry *, unsigned int); 74 int (*readlink) (struct dentry *, char __user *,int); 75 const char *(*get_link) (struct dentry *, struct inode *, struct delayed_call *); 76 void (*truncate) (struct inode *); 77 int (*permission) (struct mnt_idmap *, struct inode *, int, unsigned int); 78 struct posix_acl * (*get_inode_acl)(struct inode *, int, bool); 79 int (*setattr) (struct mnt_idmap *, struct dentry *, struct iattr *); 80 int (*getattr) (struct mnt_idmap *, const struct path *, struct kstat *, u32, unsigned int); 81 ssize_t (*listxattr) (struct dentry *, char *, size_t); 82 int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len); 83 void (*update_time)(struct inode *, struct timespec *, int); 84 int (*atomic_open)(struct inode *, struct dentry *, 85 struct file *, unsigned open_flag, 86 umode_t create_mode); 87 int (*tmpfile) (struct mnt_idmap *, struct inode *, 88 struct file *, umode_t); 89 int (*fileattr_set)(struct mnt_idmap *idmap, 90 struct dentry *dentry, struct file_kattr *fa); 91 int (*fileattr_get)(struct dentry *dentry, struct file_kattr *fa); 92 struct posix_acl * (*get_acl)(struct mnt_idmap *, struct dentry *, int); 93 struct offset_ctx *(*get_offset_ctx)(struct inode *inode); 94 95locking rules: 96 all may block 97 98============== ================================================== 99ops i_rwsem(inode) 100============== ================================================== 101lookup: shared 102create: exclusive 103link: exclusive (both) 104mknod: exclusive 105symlink: exclusive 106mkdir: exclusive 107unlink: exclusive (both) 108rmdir: exclusive (both)(see below) 109rename: exclusive (both parents, some children) (see below) 110readlink: no 111get_link: no 112setattr: exclusive 113permission: no (may not block if called in rcu-walk mode) 114get_inode_acl: no 115get_acl: no 116getattr: no 117listxattr: no 118fiemap: no 119update_time: no 120atomic_open: shared (exclusive if O_CREAT is set in open flags) 121tmpfile: no 122fileattr_get: no or exclusive 123fileattr_set: exclusive 124get_offset_ctx no 125============== ================================================== 126 127 128 Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_rwsem 129 exclusive on victim. 130 cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem. 131 ->unlink() and ->rename() have ->i_rwsem exclusive on all non-directories 132 involved. 133 ->rename() has ->i_rwsem exclusive on any subdirectory that changes parent. 134 135See Documentation/filesystems/directory-locking.rst for more detailed discussion 136of the locking scheme for directory operations. 137 138xattr_handler operations 139======================== 140 141prototypes:: 142 143 bool (*list)(struct dentry *dentry); 144 int (*get)(const struct xattr_handler *handler, struct dentry *dentry, 145 struct inode *inode, const char *name, void *buffer, 146 size_t size); 147 int (*set)(const struct xattr_handler *handler, 148 struct mnt_idmap *idmap, 149 struct dentry *dentry, struct inode *inode, const char *name, 150 const void *buffer, size_t size, int flags); 151 152locking rules: 153 all may block 154 155===== ============== 156ops i_rwsem(inode) 157===== ============== 158list: no 159get: no 160set: exclusive 161===== ============== 162 163super_operations 164================ 165 166prototypes:: 167 168 struct inode *(*alloc_inode)(struct super_block *sb); 169 void (*free_inode)(struct inode *); 170 void (*destroy_inode)(struct inode *); 171 void (*dirty_inode) (struct inode *, int flags); 172 int (*write_inode) (struct inode *, struct writeback_control *wbc); 173 int (*drop_inode) (struct inode *); 174 void (*evict_inode) (struct inode *); 175 void (*put_super) (struct super_block *); 176 int (*sync_fs)(struct super_block *sb, int wait); 177 int (*freeze_fs) (struct super_block *); 178 int (*unfreeze_fs) (struct super_block *); 179 int (*statfs) (struct dentry *, struct kstatfs *); 180 void (*umount_begin) (struct super_block *); 181 int (*show_options)(struct seq_file *, struct dentry *); 182 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); 183 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); 184 185locking rules: 186 All may block [not true, see below] 187 188====================== ============ ======================== 189ops s_umount note 190====================== ============ ======================== 191alloc_inode: 192free_inode: called from RCU callback 193destroy_inode: 194dirty_inode: 195write_inode: 196drop_inode: !!!inode->i_lock!!! 197evict_inode: 198put_super: write 199sync_fs: read 200freeze_fs: write 201unfreeze_fs: write 202statfs: maybe(read) (see below) 203umount_begin: no 204show_options: no (namespace_sem) 205quota_read: no (see below) 206quota_write: no (see below) 207====================== ============ ======================== 208 209->statfs() has s_umount (shared) when called by ustat(2) (native or 210compat), but that's an accident of bad API; s_umount is used to pin 211the superblock down when we only have dev_t given us by userland to 212identify the superblock. Everything else (statfs(), fstatfs(), etc.) 213doesn't hold it when calling ->statfs() - superblock is pinned down 214by resolving the pathname passed to syscall. 215 216->quota_read() and ->quota_write() functions are both guaranteed to 217be the only ones operating on the quota file by the quota code (via 218dqio_sem) (unless an admin really wants to screw up something and 219writes to quota files with quotas on). For other details about locking 220see also dquot_operations section. 221 222file_system_type 223================ 224 225prototypes:: 226 227 void (*kill_sb) (struct super_block *); 228 229locking rules: 230 231======= ========= 232ops may block 233======= ========= 234kill_sb yes 235======= ========= 236 237->kill_sb() takes a write-locked superblock, does all shutdown work on it, 238unlocks and drops the reference. 239 240address_space_operations 241======================== 242prototypes:: 243 244 int (*read_folio)(struct file *, struct folio *); 245 int (*writepages)(struct address_space *, struct writeback_control *); 246 bool (*dirty_folio)(struct address_space *, struct folio *folio); 247 void (*readahead)(struct readahead_control *); 248 int (*write_begin)(const struct kiocb *, struct address_space *mapping, 249 loff_t pos, unsigned len, 250 struct folio **foliop, void **fsdata); 251 int (*write_end)(const struct kiocb *, struct address_space *mapping, 252 loff_t pos, unsigned len, unsigned copied, 253 struct folio *folio, void *fsdata); 254 sector_t (*bmap)(struct address_space *, sector_t); 255 void (*invalidate_folio) (struct folio *, size_t start, size_t len); 256 bool (*release_folio)(struct folio *, gfp_t); 257 void (*free_folio)(struct folio *); 258 int (*direct_IO)(struct kiocb *, struct iov_iter *iter); 259 int (*migrate_folio)(struct address_space *, struct folio *dst, 260 struct folio *src, enum migrate_mode); 261 int (*launder_folio)(struct folio *); 262 bool (*is_partially_uptodate)(struct folio *, size_t from, size_t count); 263 int (*error_remove_folio)(struct address_space *, struct folio *); 264 int (*swap_activate)(struct swap_info_struct *sis, struct file *f, sector_t *span) 265 int (*swap_deactivate)(struct file *); 266 int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter); 267 268locking rules: 269 All except dirty_folio and free_folio may block 270 271====================== ======================== ========= =============== 272ops folio locked i_rwsem invalidate_lock 273====================== ======================== ========= =============== 274read_folio: yes, unlocks shared 275writepages: 276dirty_folio: maybe 277readahead: yes, unlocks shared 278write_begin: locks the folio exclusive 279write_end: yes, unlocks exclusive 280bmap: 281invalidate_folio: yes exclusive 282release_folio: yes 283free_folio: yes 284direct_IO: 285migrate_folio: yes (both) 286launder_folio: yes 287is_partially_uptodate: yes 288error_remove_folio: yes 289swap_activate: no 290swap_deactivate: no 291swap_rw: yes, unlocks 292====================== ======================== ========= =============== 293 294->write_begin(), ->write_end() and ->read_folio() may be called from 295the request handler (/dev/loop). 296 297->read_folio() unlocks the folio, either synchronously or via I/O 298completion. 299 300->readahead() unlocks the folios that I/O is attempted on like ->read_folio(). 301 302->writepages() is used for periodic writeback and for syscall-initiated 303sync operations. The address_space should start I/O against at least 304``*nr_to_write`` pages. ``*nr_to_write`` must be decremented for each page 305which is written. The address_space implementation may write more (or less) 306pages than ``*nr_to_write`` asks for, but it should try to be reasonably close. 307If nr_to_write is NULL, all dirty pages must be written. 308 309writepages should _only_ write pages which are present in 310mapping->i_pages. 311 312->dirty_folio() is called from various places in the kernel when 313the target folio is marked as needing writeback. The folio cannot be 314truncated because either the caller holds the folio lock, or the caller 315has found the folio while holding the page table lock which will block 316truncation. 317 318->bmap() is currently used by legacy ioctl() (FIBMAP) provided by some 319filesystems and by the swapper. The latter will eventually go away. Please, 320keep it that way and don't breed new callers. 321 322->invalidate_folio() is called when the filesystem must attempt to drop 323some or all of the buffers from the page when it is being truncated. It 324returns zero on success. The filesystem must exclusively acquire 325invalidate_lock before invalidating page cache in truncate / hole punch 326path (and thus calling into ->invalidate_folio) to block races between page 327cache invalidation and page cache filling functions (fault, read, ...). 328 329->release_folio() is called when the MM wants to make a change to the 330folio that would invalidate the filesystem's private data. For example, 331it may be about to be removed from the address_space or split. The folio 332is locked and not under writeback. It may be dirty. The gfp parameter 333is not usually used for allocation, but rather to indicate what the 334filesystem may do to attempt to free the private data. The filesystem may 335return false to indicate that the folio's private data cannot be freed. 336If it returns true, it should have already removed the private data from 337the folio. If a filesystem does not provide a ->release_folio method, 338the pagecache will assume that private data is buffer_heads and call 339try_to_free_buffers(). 340 341->free_folio() is called when the kernel has dropped the folio 342from the page cache. 343 344->launder_folio() may be called prior to releasing a folio if 345it is still found to be dirty. It returns zero if the folio was successfully 346cleaned, or an error value if not. Note that in order to prevent the folio 347getting mapped back in and redirtied, it needs to be kept locked 348across the entire operation. 349 350->swap_activate() will be called to prepare the given file for swap. It 351should perform any validation and preparation necessary to ensure that 352writes can be performed with minimal memory allocation. It should call 353add_swap_extent(), or the helper iomap_swapfile_activate(), and return 354the number of extents added. If IO should be submitted through 355->swap_rw(), it should set SWP_FS_OPS, otherwise IO will be submitted 356directly to the block device ``sis->bdev``. 357 358->swap_deactivate() will be called in the sys_swapoff() 359path after ->swap_activate() returned success. 360 361->swap_rw will be called for swap IO if SWP_FS_OPS was set by ->swap_activate(). 362 363file_lock_operations 364==================== 365 366prototypes:: 367 368 void (*fl_copy_lock)(struct file_lock *, struct file_lock *); 369 void (*fl_release_private)(struct file_lock *); 370 371 372locking rules: 373 374=================== ============= ========= 375ops inode->i_lock may block 376=================== ============= ========= 377fl_copy_lock: yes no 378fl_release_private: maybe maybe[1]_ 379=================== ============= ========= 380 381.. [1]: 382 ->fl_release_private for flock or POSIX locks is currently allowed 383 to block. Leases however can still be freed while the i_lock is held and 384 so fl_release_private called on a lease should not block. 385 386lock_manager_operations 387======================= 388 389prototypes:: 390 391 void (*lm_notify)(struct file_lock *); /* unblock callback */ 392 int (*lm_grant)(struct file_lock *, struct file_lock *, int); 393 void (*lm_break)(struct file_lock *); /* break_lease callback */ 394 int (*lm_change)(struct file_lock **, int); 395 bool (*lm_breaker_owns_lease)(struct file_lock *); 396 bool (*lm_lock_expirable)(struct file_lock *); 397 void (*lm_expire_lock)(void); 398 399locking rules: 400 401====================== ============= ================= ========= 402ops flc_lock blocked_lock_lock may block 403====================== ============= ================= ========= 404lm_notify: no yes no 405lm_grant: no no no 406lm_break: yes no no 407lm_change yes no no 408lm_breaker_owns_lease: yes no no 409lm_lock_expirable yes no no 410lm_expire_lock no no yes 411====================== ============= ================= ========= 412 413buffer_head 414=========== 415 416prototypes:: 417 418 void (*b_end_io)(struct buffer_head *bh, int uptodate); 419 420locking rules: 421 422called from interrupts. In other words, extreme care is needed here. 423bh is locked, but that's all warranties we have here. Currently only RAID1, 424highmem, fs/buffer.c, and fs/ntfs/aops.c are providing these. Block devices 425call this method upon the IO completion. 426 427block_device_operations 428======================= 429prototypes:: 430 431 int (*open) (struct block_device *, fmode_t); 432 int (*release) (struct gendisk *, fmode_t); 433 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 434 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long); 435 int (*direct_access) (struct block_device *, sector_t, void **, 436 unsigned long *); 437 void (*unlock_native_capacity) (struct gendisk *); 438 int (*getgeo)(struct gendisk *, struct hd_geometry *); 439 void (*swap_slot_free_notify) (struct block_device *, unsigned long); 440 441locking rules: 442 443======================= =================== 444ops open_mutex 445======================= =================== 446open: yes 447release: yes 448ioctl: no 449compat_ioctl: no 450direct_access: no 451unlock_native_capacity: no 452getgeo: no 453swap_slot_free_notify: no (see below) 454======================= =================== 455 456swap_slot_free_notify is called with swap_lock and sometimes the page lock 457held. 458 459 460file_operations 461=============== 462 463prototypes:: 464 465 loff_t (*llseek) (struct file *, loff_t, int); 466 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); 467 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); 468 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 469 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 470 int (*iopoll) (struct kiocb *kiocb, bool spin); 471 int (*iterate_shared) (struct file *, struct dir_context *); 472 __poll_t (*poll) (struct file *, struct poll_table_struct *); 473 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 474 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 475 int (*mmap) (struct file *, struct vm_area_struct *); 476 int (*open) (struct inode *, struct file *); 477 int (*flush) (struct file *); 478 int (*release) (struct inode *, struct file *); 479 int (*fsync) (struct file *, loff_t start, loff_t end, int datasync); 480 int (*fasync) (int, struct file *, int); 481 int (*lock) (struct file *, int, struct file_lock *); 482 unsigned long (*get_unmapped_area)(struct file *, unsigned long, 483 unsigned long, unsigned long, unsigned long); 484 int (*check_flags)(int); 485 int (*flock) (struct file *, int, struct file_lock *); 486 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, 487 size_t, unsigned int); 488 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, 489 size_t, unsigned int); 490 int (*setlease)(struct file *, long, struct file_lock **, void **); 491 long (*fallocate)(struct file *, int, loff_t, loff_t); 492 void (*show_fdinfo)(struct seq_file *m, struct file *f); 493 unsigned (*mmap_capabilities)(struct file *); 494 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, 495 loff_t, size_t, unsigned int); 496 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in, 497 struct file *file_out, loff_t pos_out, 498 loff_t len, unsigned int remap_flags); 499 int (*fadvise)(struct file *, loff_t, loff_t, int); 500 501locking rules: 502 All may block. 503 504->llseek() locking has moved from llseek to the individual llseek 505implementations. If your fs is not using generic_file_llseek, you 506need to acquire and release the appropriate locks in your ->llseek(). 507For many filesystems, it is probably safe to acquire the inode 508mutex or just to use i_size_read() instead. 509Note: this does not protect the file->f_pos against concurrent modifications 510since this is something the userspace has to take care about. 511 512->iterate_shared() is called with i_rwsem held for reading, and with the 513file f_pos_lock held exclusively 514 515->fasync() is responsible for maintaining the FASYNC bit in filp->f_flags. 516Most instances call fasync_helper(), which does that maintenance, so it's 517not normally something one needs to worry about. Return values > 0 will be 518mapped to zero in the VFS layer. 519 520->readdir() and ->ioctl() on directories must be changed. Ideally we would 521move ->readdir() to inode_operations and use a separate method for directory 522->ioctl() or kill the latter completely. One of the problems is that for 523anything that resembles union-mount we won't have a struct file for all 524components. And there are other reasons why the current interface is a mess... 525 526->read on directories probably must go away - we should just enforce -EISDIR 527in sys_read() and friends. 528 529->setlease operations should call generic_setlease() before or after setting 530the lease within the individual filesystem to record the result of the 531operation 532 533->fallocate implementation must be really careful to maintain page cache 534consistency when punching holes or performing other operations that invalidate 535page cache contents. Usually the filesystem needs to call 536truncate_inode_pages_range() to invalidate relevant range of the page cache. 537However the filesystem usually also needs to update its internal (and on disk) 538view of file offset -> disk block mapping. Until this update is finished, the 539filesystem needs to block page faults and reads from reloading now-stale page 540cache contents from the disk. Since VFS acquires mapping->invalidate_lock in 541shared mode when loading pages from disk (filemap_fault(), filemap_read(), 542readahead paths), the fallocate implementation must take the invalidate_lock to 543prevent reloading. 544 545->copy_file_range and ->remap_file_range implementations need to serialize 546against modifications of file data while the operation is running. For 547blocking changes through write(2) and similar operations inode->i_rwsem can be 548used. To block changes to file contents via a memory mapping during the 549operation, the filesystem must take mapping->invalidate_lock to coordinate 550with ->page_mkwrite. 551 552dquot_operations 553================ 554 555prototypes:: 556 557 int (*write_dquot) (struct dquot *); 558 int (*acquire_dquot) (struct dquot *); 559 int (*release_dquot) (struct dquot *); 560 int (*mark_dirty) (struct dquot *); 561 int (*write_info) (struct super_block *, int); 562 563These operations are intended to be more or less wrapping functions that ensure 564a proper locking wrt the filesystem and call the generic quota operations. 565 566What filesystem should expect from the generic quota functions: 567 568============== ============ ========================= 569ops FS recursion Held locks when called 570============== ============ ========================= 571write_dquot: yes dqonoff_sem or dqptr_sem 572acquire_dquot: yes dqonoff_sem or dqptr_sem 573release_dquot: yes dqonoff_sem or dqptr_sem 574mark_dirty: no - 575write_info: yes dqonoff_sem 576============== ============ ========================= 577 578FS recursion means calling ->quota_read() and ->quota_write() from superblock 579operations. 580 581More details about quota locking can be found in fs/dquot.c. 582 583vm_operations_struct 584==================== 585 586prototypes:: 587 588 void (*open)(struct vm_area_struct *); 589 void (*close)(struct vm_area_struct *); 590 vm_fault_t (*fault)(struct vm_fault *); 591 vm_fault_t (*huge_fault)(struct vm_fault *, unsigned int order); 592 vm_fault_t (*map_pages)(struct vm_fault *, pgoff_t start, pgoff_t end); 593 vm_fault_t (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *); 594 vm_fault_t (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault *); 595 int (*access)(struct vm_area_struct *, unsigned long, void*, int, int); 596 597locking rules: 598 599============= ========== =========================== 600ops mmap_lock PageLocked(page) 601============= ========== =========================== 602open: write 603close: read/write 604fault: read can return with page locked 605huge_fault: maybe-read 606map_pages: maybe-read 607page_mkwrite: read can return with page locked 608pfn_mkwrite: read 609access: read 610============= ========== =========================== 611 612->fault() is called when a previously not present pte is about to be faulted 613in. The filesystem must find and return the page associated with the passed in 614"pgoff" in the vm_fault structure. If it is possible that the page may be 615truncated and/or invalidated, then the filesystem must lock invalidate_lock, 616then ensure the page is not already truncated (invalidate_lock will block 617subsequent truncate), and then return with VM_FAULT_LOCKED, and the page 618locked. The VM will unlock the page. 619 620->huge_fault() is called when there is no PUD or PMD entry present. This 621gives the filesystem the opportunity to install a PUD or PMD sized page. 622Filesystems can also use the ->fault method to return a PMD sized page, 623so implementing this function may not be necessary. In particular, 624filesystems should not call filemap_fault() from ->huge_fault(). 625The mmap_lock may not be held when this method is called. 626 627->map_pages() is called when VM asks to map easy accessible pages. 628Filesystem should find and map pages associated with offsets from "start_pgoff" 629till "end_pgoff". ->map_pages() is called with the RCU lock held and must 630not block. If it's not possible to reach a page without blocking, 631filesystem should skip it. Filesystem should use set_pte_range() to setup 632page table entry. Pointer to entry associated with the page is passed in 633"pte" field in vm_fault structure. Pointers to entries for other offsets 634should be calculated relative to "pte". 635 636->page_mkwrite() is called when a previously read-only pte is about to become 637writeable. The filesystem again must ensure that there are no 638truncate/invalidate races or races with operations such as ->remap_file_range 639or ->copy_file_range, and then return with the page locked. Usually 640mapping->invalidate_lock is suitable for proper serialization. If the page has 641been truncated, the filesystem should not look up a new page like the ->fault() 642handler, but simply return with VM_FAULT_NOPAGE, which will cause the VM to 643retry the fault. 644 645->pfn_mkwrite() is the same as page_mkwrite but when the pte is 646VM_PFNMAP or VM_MIXEDMAP with a page-less entry. Expected return is 647VM_FAULT_NOPAGE. Or one of the VM_FAULT_ERROR types. The default behavior 648after this call is to make the pte read-write, unless pfn_mkwrite returns 649an error. 650 651->access() is called when get_user_pages() fails in 652access_process_vm(), typically used to debug a process through 653/proc/pid/mem or ptrace. This function is needed only for 654VM_IO | VM_PFNMAP VMAs. 655 656-------------------------------------------------------------------------------- 657 658 Dubious stuff 659 660(if you break something or notice that it is broken and do not fix it yourself 661- at least put it here) 662