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