Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
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
419lm_open_conflict yes no no
420====================== ============= ================= =========
421
422buffer_head
423===========
424
425prototypes::
426
427 void (*b_end_io)(struct buffer_head *bh, int uptodate);
428
429locking rules:
430
431called from interrupts. In other words, extreme care is needed here.
432bh is locked, but that's all warranties we have here. Currently only RAID1,
433highmem, fs/buffer.c, and fs/ntfs/aops.c are providing these. Block devices
434call this method upon the IO completion.
435
436block_device_operations
437=======================
438prototypes::
439
440 int (*open) (struct block_device *, fmode_t);
441 int (*release) (struct gendisk *, fmode_t);
442 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
443 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
444 int (*direct_access) (struct block_device *, sector_t, void **,
445 unsigned long *);
446 void (*unlock_native_capacity) (struct gendisk *);
447 int (*getgeo)(struct gendisk *, struct hd_geometry *);
448 void (*swap_slot_free_notify) (struct block_device *, unsigned long);
449
450locking rules:
451
452======================= ===================
453ops open_mutex
454======================= ===================
455open: yes
456release: yes
457ioctl: no
458compat_ioctl: no
459direct_access: no
460unlock_native_capacity: no
461getgeo: no
462swap_slot_free_notify: no (see below)
463======================= ===================
464
465swap_slot_free_notify is called with swap_lock and sometimes the page lock
466held.
467
468
469file_operations
470===============
471
472prototypes::
473
474 loff_t (*llseek) (struct file *, loff_t, int);
475 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
476 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
477 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
478 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
479 int (*iopoll) (struct kiocb *kiocb, bool spin);
480 int (*iterate_shared) (struct file *, struct dir_context *);
481 __poll_t (*poll) (struct file *, struct poll_table_struct *);
482 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
483 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
484 int (*mmap) (struct file *, struct vm_area_struct *);
485 int (*open) (struct inode *, struct file *);
486 int (*flush) (struct file *);
487 int (*release) (struct inode *, struct file *);
488 int (*fsync) (struct file *, loff_t start, loff_t end, int datasync);
489 int (*fasync) (int, struct file *, int);
490 int (*lock) (struct file *, int, struct file_lock *);
491 unsigned long (*get_unmapped_area)(struct file *, unsigned long,
492 unsigned long, unsigned long, unsigned long);
493 int (*check_flags)(int);
494 int (*flock) (struct file *, int, struct file_lock *);
495 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *,
496 size_t, unsigned int);
497 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,
498 size_t, unsigned int);
499 int (*setlease)(struct file *, long, struct file_lock **, void **);
500 long (*fallocate)(struct file *, int, loff_t, loff_t);
501 void (*show_fdinfo)(struct seq_file *m, struct file *f);
502 unsigned (*mmap_capabilities)(struct file *);
503 ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
504 loff_t, size_t, unsigned int);
505 loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
506 struct file *file_out, loff_t pos_out,
507 loff_t len, unsigned int remap_flags);
508 int (*fadvise)(struct file *, loff_t, loff_t, int);
509
510locking rules:
511 All may block.
512
513->llseek() locking has moved from llseek to the individual llseek
514implementations. If your fs is not using generic_file_llseek, you
515need to acquire and release the appropriate locks in your ->llseek().
516For many filesystems, it is probably safe to acquire the inode
517mutex or just to use i_size_read() instead.
518Note: this does not protect the file->f_pos against concurrent modifications
519since this is something the userspace has to take care about.
520
521->iterate_shared() is called with i_rwsem held for reading, and with the
522file f_pos_lock held exclusively
523
524->fasync() is responsible for maintaining the FASYNC bit in filp->f_flags.
525Most instances call fasync_helper(), which does that maintenance, so it's
526not normally something one needs to worry about. Return values > 0 will be
527mapped to zero in the VFS layer.
528
529->readdir() and ->ioctl() on directories must be changed. Ideally we would
530move ->readdir() to inode_operations and use a separate method for directory
531->ioctl() or kill the latter completely. One of the problems is that for
532anything that resembles union-mount we won't have a struct file for all
533components. And there are other reasons why the current interface is a mess...
534
535->read on directories probably must go away - we should just enforce -EISDIR
536in sys_read() and friends.
537
538->setlease operations should call generic_setlease() before or after setting
539the lease within the individual filesystem to record the result of the
540operation
541
542->fallocate implementation must be really careful to maintain page cache
543consistency when punching holes or performing other operations that invalidate
544page cache contents. Usually the filesystem needs to call
545truncate_inode_pages_range() to invalidate relevant range of the page cache.
546However the filesystem usually also needs to update its internal (and on disk)
547view of file offset -> disk block mapping. Until this update is finished, the
548filesystem needs to block page faults and reads from reloading now-stale page
549cache contents from the disk. Since VFS acquires mapping->invalidate_lock in
550shared mode when loading pages from disk (filemap_fault(), filemap_read(),
551readahead paths), the fallocate implementation must take the invalidate_lock to
552prevent reloading.
553
554->copy_file_range and ->remap_file_range implementations need to serialize
555against modifications of file data while the operation is running. For
556blocking changes through write(2) and similar operations inode->i_rwsem can be
557used. To block changes to file contents via a memory mapping during the
558operation, the filesystem must take mapping->invalidate_lock to coordinate
559with ->page_mkwrite.
560
561dquot_operations
562================
563
564prototypes::
565
566 int (*write_dquot) (struct dquot *);
567 int (*acquire_dquot) (struct dquot *);
568 int (*release_dquot) (struct dquot *);
569 int (*mark_dirty) (struct dquot *);
570 int (*write_info) (struct super_block *, int);
571
572These operations are intended to be more or less wrapping functions that ensure
573a proper locking wrt the filesystem and call the generic quota operations.
574
575What filesystem should expect from the generic quota functions:
576
577============== ============ =========================
578ops FS recursion Held locks when called
579============== ============ =========================
580write_dquot: yes dqonoff_sem or dqptr_sem
581acquire_dquot: yes dqonoff_sem or dqptr_sem
582release_dquot: yes dqonoff_sem or dqptr_sem
583mark_dirty: no -
584write_info: yes dqonoff_sem
585============== ============ =========================
586
587FS recursion means calling ->quota_read() and ->quota_write() from superblock
588operations.
589
590More details about quota locking can be found in fs/dquot.c.
591
592vm_operations_struct
593====================
594
595prototypes::
596
597 void (*open)(struct vm_area_struct *);
598 void (*close)(struct vm_area_struct *);
599 vm_fault_t (*fault)(struct vm_fault *);
600 vm_fault_t (*huge_fault)(struct vm_fault *, unsigned int order);
601 vm_fault_t (*map_pages)(struct vm_fault *, pgoff_t start, pgoff_t end);
602 vm_fault_t (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *);
603 vm_fault_t (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault *);
604 int (*access)(struct vm_area_struct *, unsigned long, void*, int, int);
605
606locking rules:
607
608============= ========== ===========================
609ops mmap_lock PageLocked(page)
610============= ========== ===========================
611open: write
612close: read/write
613fault: read can return with page locked
614huge_fault: maybe-read
615map_pages: maybe-read
616page_mkwrite: read can return with page locked
617pfn_mkwrite: read
618access: read
619============= ========== ===========================
620
621->fault() is called when a previously not present pte is about to be faulted
622in. The filesystem must find and return the page associated with the passed in
623"pgoff" in the vm_fault structure. If it is possible that the page may be
624truncated and/or invalidated, then the filesystem must lock invalidate_lock,
625then ensure the page is not already truncated (invalidate_lock will block
626subsequent truncate), and then return with VM_FAULT_LOCKED, and the page
627locked. The VM will unlock the page.
628
629->huge_fault() is called when there is no PUD or PMD entry present. This
630gives the filesystem the opportunity to install a PUD or PMD sized page.
631Filesystems can also use the ->fault method to return a PMD sized page,
632so implementing this function may not be necessary. In particular,
633filesystems should not call filemap_fault() from ->huge_fault().
634The mmap_lock may not be held when this method is called.
635
636->map_pages() is called when VM asks to map easy accessible pages.
637Filesystem should find and map pages associated with offsets from "start_pgoff"
638till "end_pgoff". ->map_pages() is called with the RCU lock held and must
639not block. If it's not possible to reach a page without blocking,
640filesystem should skip it. Filesystem should use set_pte_range() to setup
641page table entry. Pointer to entry associated with the page is passed in
642"pte" field in vm_fault structure. Pointers to entries for other offsets
643should be calculated relative to "pte".
644
645->page_mkwrite() is called when a previously read-only pte is about to become
646writeable. The filesystem again must ensure that there are no
647truncate/invalidate races or races with operations such as ->remap_file_range
648or ->copy_file_range, and then return with the page locked. Usually
649mapping->invalidate_lock is suitable for proper serialization. If the page has
650been truncated, the filesystem should not look up a new page like the ->fault()
651handler, but simply return with VM_FAULT_NOPAGE, which will cause the VM to
652retry the fault.
653
654->pfn_mkwrite() is the same as page_mkwrite but when the pte is
655VM_PFNMAP or VM_MIXEDMAP with a page-less entry. Expected return is
656VM_FAULT_NOPAGE. Or one of the VM_FAULT_ERROR types. The default behavior
657after this call is to make the pte read-write, unless pfn_mkwrite returns
658an error.
659
660->access() is called when get_user_pages() fails in
661access_process_vm(), typically used to debug a process through
662/proc/pid/mem or ptrace. This function is needed only for
663VM_IO | VM_PFNMAP VMAs.
664
665--------------------------------------------------------------------------------
666
667 Dubious stuff
668
669(if you break something or notice that it is broken and do not fix it yourself
670- at least put it here)