tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 int (*remount_fs) (struct super_block *, int *, char *);
181 void (*umount_begin) (struct super_block *);
182 int (*show_options)(struct seq_file *, struct dentry *);
183 ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
184 ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
185
186locking rules:
187 All may block [not true, see below]
188
189====================== ============ ========================
190ops s_umount note
191====================== ============ ========================
192alloc_inode:
193free_inode: called from RCU callback
194destroy_inode:
195dirty_inode:
196write_inode:
197drop_inode: !!!inode->i_lock!!!
198evict_inode:
199put_super: write
200sync_fs: read
201freeze_fs: write
202unfreeze_fs: write
203statfs: maybe(read) (see below)
204remount_fs: write
205umount_begin: no
206show_options: no (namespace_sem)
207quota_read: no (see below)
208quota_write: no (see below)
209====================== ============ ========================
210
211->statfs() has s_umount (shared) when called by ustat(2) (native or
212compat), but that's an accident of bad API; s_umount is used to pin
213the superblock down when we only have dev_t given us by userland to
214identify the superblock. Everything else (statfs(), fstatfs(), etc.)
215doesn't hold it when calling ->statfs() - superblock is pinned down
216by resolving the pathname passed to syscall.
217
218->quota_read() and ->quota_write() functions are both guaranteed to
219be the only ones operating on the quota file by the quota code (via
220dqio_sem) (unless an admin really wants to screw up something and
221writes to quota files with quotas on). For other details about locking
222see also dquot_operations section.
223
224file_system_type
225================
226
227prototypes::
228
229 struct dentry *(*mount) (struct file_system_type *, int,
230 const char *, void *);
231 void (*kill_sb) (struct super_block *);
232
233locking rules:
234
235======= =========
236ops may block
237======= =========
238mount yes
239kill_sb yes
240======= =========
241
242->mount() returns ERR_PTR or the root dentry; its superblock should be locked
243on return.
244
245->kill_sb() takes a write-locked superblock, does all shutdown work on it,
246unlocks and drops the reference.
247
248address_space_operations
249========================
250prototypes::
251
252 int (*read_folio)(struct file *, struct folio *);
253 int (*writepages)(struct address_space *, struct writeback_control *);
254 bool (*dirty_folio)(struct address_space *, struct folio *folio);
255 void (*readahead)(struct readahead_control *);
256 int (*write_begin)(const struct kiocb *, struct address_space *mapping,
257 loff_t pos, unsigned len,
258 struct folio **foliop, void **fsdata);
259 int (*write_end)(const struct kiocb *, struct address_space *mapping,
260 loff_t pos, unsigned len, unsigned copied,
261 struct folio *folio, void *fsdata);
262 sector_t (*bmap)(struct address_space *, sector_t);
263 void (*invalidate_folio) (struct folio *, size_t start, size_t len);
264 bool (*release_folio)(struct folio *, gfp_t);
265 void (*free_folio)(struct folio *);
266 int (*direct_IO)(struct kiocb *, struct iov_iter *iter);
267 int (*migrate_folio)(struct address_space *, struct folio *dst,
268 struct folio *src, enum migrate_mode);
269 int (*launder_folio)(struct folio *);
270 bool (*is_partially_uptodate)(struct folio *, size_t from, size_t count);
271 int (*error_remove_folio)(struct address_space *, struct folio *);
272 int (*swap_activate)(struct swap_info_struct *sis, struct file *f, sector_t *span)
273 int (*swap_deactivate)(struct file *);
274 int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
275
276locking rules:
277 All except dirty_folio and free_folio may block
278
279====================== ======================== ========= ===============
280ops folio locked i_rwsem invalidate_lock
281====================== ======================== ========= ===============
282read_folio: yes, unlocks shared
283writepages:
284dirty_folio: maybe
285readahead: yes, unlocks shared
286write_begin: locks the folio exclusive
287write_end: yes, unlocks exclusive
288bmap:
289invalidate_folio: yes exclusive
290release_folio: yes
291free_folio: yes
292direct_IO:
293migrate_folio: yes (both)
294launder_folio: yes
295is_partially_uptodate: yes
296error_remove_folio: yes
297swap_activate: no
298swap_deactivate: no
299swap_rw: yes, unlocks
300====================== ======================== ========= ===============
301
302->write_begin(), ->write_end() and ->read_folio() may be called from
303the request handler (/dev/loop).
304
305->read_folio() unlocks the folio, either synchronously or via I/O
306completion.
307
308->readahead() unlocks the folios that I/O is attempted on like ->read_folio().
309
310->writepages() is used for periodic writeback and for syscall-initiated
311sync operations. The address_space should start I/O against at least
312``*nr_to_write`` pages. ``*nr_to_write`` must be decremented for each page
313which is written. The address_space implementation may write more (or less)
314pages than ``*nr_to_write`` asks for, but it should try to be reasonably close.
315If nr_to_write is NULL, all dirty pages must be written.
316
317writepages should _only_ write pages which are present in
318mapping->i_pages.
319
320->dirty_folio() is called from various places in the kernel when
321the target folio is marked as needing writeback. The folio cannot be
322truncated because either the caller holds the folio lock, or the caller
323has found the folio while holding the page table lock which will block
324truncation.
325
326->bmap() is currently used by legacy ioctl() (FIBMAP) provided by some
327filesystems and by the swapper. The latter will eventually go away. Please,
328keep it that way and don't breed new callers.
329
330->invalidate_folio() is called when the filesystem must attempt to drop
331some or all of the buffers from the page when it is being truncated. It
332returns zero on success. The filesystem must exclusively acquire
333invalidate_lock before invalidating page cache in truncate / hole punch
334path (and thus calling into ->invalidate_folio) to block races between page
335cache invalidation and page cache filling functions (fault, read, ...).
336
337->release_folio() is called when the MM wants to make a change to the
338folio that would invalidate the filesystem's private data. For example,
339it may be about to be removed from the address_space or split. The folio
340is locked and not under writeback. It may be dirty. The gfp parameter
341is not usually used for allocation, but rather to indicate what the
342filesystem may do to attempt to free the private data. The filesystem may
343return false to indicate that the folio's private data cannot be freed.
344If it returns true, it should have already removed the private data from
345the folio. If a filesystem does not provide a ->release_folio method,
346the pagecache will assume that private data is buffer_heads and call
347try_to_free_buffers().
348
349->free_folio() is called when the kernel has dropped the folio
350from the page cache.
351
352->launder_folio() may be called prior to releasing a folio if
353it is still found to be dirty. It returns zero if the folio was successfully
354cleaned, or an error value if not. Note that in order to prevent the folio
355getting mapped back in and redirtied, it needs to be kept locked
356across the entire operation.
357
358->swap_activate() will be called to prepare the given file for swap. It
359should perform any validation and preparation necessary to ensure that
360writes can be performed with minimal memory allocation. It should call
361add_swap_extent(), or the helper iomap_swapfile_activate(), and return
362the number of extents added. If IO should be submitted through
363->swap_rw(), it should set SWP_FS_OPS, otherwise IO will be submitted
364directly to the block device ``sis->bdev``.
365
366->swap_deactivate() will be called in the sys_swapoff()
367path after ->swap_activate() returned success.
368
369->swap_rw will be called for swap IO if SWP_FS_OPS was set by ->swap_activate().
370
371file_lock_operations
372====================
373
374prototypes::
375
376 void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
377 void (*fl_release_private)(struct file_lock *);
378
379
380locking rules:
381
382=================== ============= =========
383ops inode->i_lock may block
384=================== ============= =========
385fl_copy_lock: yes no
386fl_release_private: maybe maybe[1]_
387=================== ============= =========
388
389.. [1]:
390 ->fl_release_private for flock or POSIX locks is currently allowed
391 to block. Leases however can still be freed while the i_lock is held and
392 so fl_release_private called on a lease should not block.
393
394lock_manager_operations
395=======================
396
397prototypes::
398
399 void (*lm_notify)(struct file_lock *); /* unblock callback */
400 int (*lm_grant)(struct file_lock *, struct file_lock *, int);
401 void (*lm_break)(struct file_lock *); /* break_lease callback */
402 int (*lm_change)(struct file_lock **, int);
403 bool (*lm_breaker_owns_lease)(struct file_lock *);
404 bool (*lm_lock_expirable)(struct file_lock *);
405 void (*lm_expire_lock)(void);
406
407locking rules:
408
409====================== ============= ================= =========
410ops flc_lock blocked_lock_lock may block
411====================== ============= ================= =========
412lm_notify: no yes no
413lm_grant: no no no
414lm_break: yes no no
415lm_change yes no no
416lm_breaker_owns_lease: yes no no
417lm_lock_expirable yes no no
418lm_expire_lock no no yes
419====================== ============= ================= =========
420
421buffer_head
422===========
423
424prototypes::
425
426 void (*b_end_io)(struct buffer_head *bh, int uptodate);
427
428locking rules:
429
430called from interrupts. In other words, extreme care is needed here.
431bh is locked, but that's all warranties we have here. Currently only RAID1,
432highmem, fs/buffer.c, and fs/ntfs/aops.c are providing these. Block devices
433call this method upon the IO completion.
434
435block_device_operations
436=======================
437prototypes::
438
439 int (*open) (struct block_device *, fmode_t);
440 int (*release) (struct gendisk *, fmode_t);
441 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
442 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
443 int (*direct_access) (struct block_device *, sector_t, void **,
444 unsigned long *);
445 void (*unlock_native_capacity) (struct gendisk *);
446 int (*getgeo)(struct gendisk *, struct hd_geometry *);
447 void (*swap_slot_free_notify) (struct block_device *, unsigned long);
448
449locking rules:
450
451======================= ===================
452ops open_mutex
453======================= ===================
454open: yes
455release: yes
456ioctl: no
457compat_ioctl: no
458direct_access: no
459unlock_native_capacity: no
460getgeo: no
461swap_slot_free_notify: no (see below)
462======================= ===================
463
464swap_slot_free_notify is called with swap_lock and sometimes the page lock
465held.
466
467
468file_operations
469===============
470
471prototypes::
472
473 loff_t (*llseek) (struct file *, loff_t, int);
474 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
475 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
476 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
477 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
478 int (*iopoll) (struct kiocb *kiocb, bool spin);
479 int (*iterate_shared) (struct file *, struct dir_context *);
480 __poll_t (*poll) (struct file *, struct poll_table_struct *);
481 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
482 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
483 int (*mmap) (struct file *, struct vm_area_struct *);
484 int (*open) (struct inode *, struct file *);
485 int (*flush) (struct file *);
486 int (*release) (struct inode *, struct file *);
487 int (*fsync) (struct file *, loff_t start, loff_t end, int datasync);
488 int (*fasync) (int, struct file *, int);
489 int (*lock) (struct file *, int, struct file_lock *);
490 unsigned long (*get_unmapped_area)(struct file *, unsigned long,
491 unsigned long, unsigned long, unsigned long);
492 int (*check_flags)(int);
493 int (*flock) (struct file *, int, struct file_lock *);
494 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *,
495 size_t, unsigned int);
496 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,
497 size_t, unsigned int);
498 int (*setlease)(struct file *, long, struct file_lock **, void **);
499 long (*fallocate)(struct file *, int, loff_t, loff_t);
500 void (*show_fdinfo)(struct seq_file *m, struct file *f);
501 unsigned (*mmap_capabilities)(struct file *);
502 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
503 loff_t, size_t, unsigned int);
504 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
505 struct file *file_out, loff_t pos_out,
506 loff_t len, unsigned int remap_flags);
507 int (*fadvise)(struct file *, loff_t, loff_t, int);
508
509locking rules:
510 All may block.
511
512->llseek() locking has moved from llseek to the individual llseek
513implementations. If your fs is not using generic_file_llseek, you
514need to acquire and release the appropriate locks in your ->llseek().
515For many filesystems, it is probably safe to acquire the inode
516mutex or just to use i_size_read() instead.
517Note: this does not protect the file->f_pos against concurrent modifications
518since this is something the userspace has to take care about.
519
520->iterate_shared() is called with i_rwsem held for reading, and with the
521file f_pos_lock held exclusively
522
523->fasync() is responsible for maintaining the FASYNC bit in filp->f_flags.
524Most instances call fasync_helper(), which does that maintenance, so it's
525not normally something one needs to worry about. Return values > 0 will be
526mapped to zero in the VFS layer.
527
528->readdir() and ->ioctl() on directories must be changed. Ideally we would
529move ->readdir() to inode_operations and use a separate method for directory
530->ioctl() or kill the latter completely. One of the problems is that for
531anything that resembles union-mount we won't have a struct file for all
532components. And there are other reasons why the current interface is a mess...
533
534->read on directories probably must go away - we should just enforce -EISDIR
535in sys_read() and friends.
536
537->setlease operations should call generic_setlease() before or after setting
538the lease within the individual filesystem to record the result of the
539operation
540
541->fallocate implementation must be really careful to maintain page cache
542consistency when punching holes or performing other operations that invalidate
543page cache contents. Usually the filesystem needs to call
544truncate_inode_pages_range() to invalidate relevant range of the page cache.
545However the filesystem usually also needs to update its internal (and on disk)
546view of file offset -> disk block mapping. Until this update is finished, the
547filesystem needs to block page faults and reads from reloading now-stale page
548cache contents from the disk. Since VFS acquires mapping->invalidate_lock in
549shared mode when loading pages from disk (filemap_fault(), filemap_read(),
550readahead paths), the fallocate implementation must take the invalidate_lock to
551prevent reloading.
552
553->copy_file_range and ->remap_file_range implementations need to serialize
554against modifications of file data while the operation is running. For
555blocking changes through write(2) and similar operations inode->i_rwsem can be
556used. To block changes to file contents via a memory mapping during the
557operation, the filesystem must take mapping->invalidate_lock to coordinate
558with ->page_mkwrite.
559
560dquot_operations
561================
562
563prototypes::
564
565 int (*write_dquot) (struct dquot *);
566 int (*acquire_dquot) (struct dquot *);
567 int (*release_dquot) (struct dquot *);
568 int (*mark_dirty) (struct dquot *);
569 int (*write_info) (struct super_block *, int);
570
571These operations are intended to be more or less wrapping functions that ensure
572a proper locking wrt the filesystem and call the generic quota operations.
573
574What filesystem should expect from the generic quota functions:
575
576============== ============ =========================
577ops FS recursion Held locks when called
578============== ============ =========================
579write_dquot: yes dqonoff_sem or dqptr_sem
580acquire_dquot: yes dqonoff_sem or dqptr_sem
581release_dquot: yes dqonoff_sem or dqptr_sem
582mark_dirty: no -
583write_info: yes dqonoff_sem
584============== ============ =========================
585
586FS recursion means calling ->quota_read() and ->quota_write() from superblock
587operations.
588
589More details about quota locking can be found in fs/dquot.c.
590
591vm_operations_struct
592====================
593
594prototypes::
595
596 void (*open)(struct vm_area_struct *);
597 void (*close)(struct vm_area_struct *);
598 vm_fault_t (*fault)(struct vm_fault *);
599 vm_fault_t (*huge_fault)(struct vm_fault *, unsigned int order);
600 vm_fault_t (*map_pages)(struct vm_fault *, pgoff_t start, pgoff_t end);
601 vm_fault_t (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *);
602 vm_fault_t (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault *);
603 int (*access)(struct vm_area_struct *, unsigned long, void*, int, int);
604
605locking rules:
606
607============= ========== ===========================
608ops mmap_lock PageLocked(page)
609============= ========== ===========================
610open: write
611close: read/write
612fault: read can return with page locked
613huge_fault: maybe-read
614map_pages: maybe-read
615page_mkwrite: read can return with page locked
616pfn_mkwrite: read
617access: read
618============= ========== ===========================
619
620->fault() is called when a previously not present pte is about to be faulted
621in. The filesystem must find and return the page associated with the passed in
622"pgoff" in the vm_fault structure. If it is possible that the page may be
623truncated and/or invalidated, then the filesystem must lock invalidate_lock,
624then ensure the page is not already truncated (invalidate_lock will block
625subsequent truncate), and then return with VM_FAULT_LOCKED, and the page
626locked. The VM will unlock the page.
627
628->huge_fault() is called when there is no PUD or PMD entry present. This
629gives the filesystem the opportunity to install a PUD or PMD sized page.
630Filesystems can also use the ->fault method to return a PMD sized page,
631so implementing this function may not be necessary. In particular,
632filesystems should not call filemap_fault() from ->huge_fault().
633The mmap_lock may not be held when this method is called.
634
635->map_pages() is called when VM asks to map easy accessible pages.
636Filesystem should find and map pages associated with offsets from "start_pgoff"
637till "end_pgoff". ->map_pages() is called with the RCU lock held and must
638not block. If it's not possible to reach a page without blocking,
639filesystem should skip it. Filesystem should use set_pte_range() to setup
640page table entry. Pointer to entry associated with the page is passed in
641"pte" field in vm_fault structure. Pointers to entries for other offsets
642should be calculated relative to "pte".
643
644->page_mkwrite() is called when a previously read-only pte is about to become
645writeable. The filesystem again must ensure that there are no
646truncate/invalidate races or races with operations such as ->remap_file_range
647or ->copy_file_range, and then return with the page locked. Usually
648mapping->invalidate_lock is suitable for proper serialization. If the page has
649been truncated, the filesystem should not look up a new page like the ->fault()
650handler, but simply return with VM_FAULT_NOPAGE, which will cause the VM to
651retry the fault.
652
653->pfn_mkwrite() is the same as page_mkwrite but when the pte is
654VM_PFNMAP or VM_MIXEDMAP with a page-less entry. Expected return is
655VM_FAULT_NOPAGE. Or one of the VM_FAULT_ERROR types. The default behavior
656after this call is to make the pte read-write, unless pfn_mkwrite returns
657an error.
658
659->access() is called when get_user_pages() fails in
660access_process_vm(), typically used to debug a process through
661/proc/pid/mem or ptrace. This function is needed only for
662VM_IO | VM_PFNMAP VMAs.
663
664--------------------------------------------------------------------------------
665
666 Dubious stuff
667
668(if you break something or notice that it is broken and do not fix it yourself
669- at least put it here)