dentry_operations¶

prototypes:

int (*d_revalidate)(struct dentry *, unsigned int);int (*d_weak_revalidate)(struct dentry *, unsigned int);int (*d_hash)(const struct dentry *, struct qstr *);int (*d_compare)(const struct dentry *,                unsigned int, const char *, const struct qstr *);int (*d_delete)(struct dentry *);int (*d_init)(struct dentry *);void (*d_release)(struct dentry *);void (*d_iput)(struct dentry *, struct inode *);char *(*d_dname)((struct dentry *dentry, char *buffer, int buflen);struct vfsmount *(*d_automount)(struct path *path);int (*d_manage)(const struct path *, bool);struct dentry *(*d_real)(struct dentry *, const struct inode *);

locking rules:

inode_operations¶

prototypes:

int (*create) (struct inode *,struct dentry *,umode_t, bool);struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);int (*link) (struct dentry *,struct inode *,struct dentry *);int (*unlink) (struct inode *,struct dentry *);int (*symlink) (struct inode *,struct dentry *,const char *);int (*mkdir) (struct inode *,struct dentry *,umode_t);int (*rmdir) (struct inode *,struct dentry *);int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);int (*rename) (struct inode *, struct dentry *,                struct inode *, struct dentry *, unsigned int);int (*readlink) (struct dentry *, char __user *,int);const char *(*get_link) (struct dentry *, struct inode *, struct delayed_call *);void (*truncate) (struct inode *);int (*permission) (struct inode *, int, unsigned int);int (*get_acl)(struct inode *, int);int (*setattr) (struct dentry *, struct iattr *);int (*getattr) (const struct path *, struct kstat *, u32, unsigned int);ssize_t (*listxattr) (struct dentry *, char *, size_t);int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);void (*update_time)(struct inode *, struct timespec *, int);int (*atomic_open)(struct inode *, struct dentry *,                        struct file *, unsigned open_flag,                        umode_t create_mode);int (*tmpfile) (struct inode *, struct dentry *, umode_t);

locking rules:

all may block

Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_rwsemexclusive on victim.cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem.

See Documentation/filesystems/directory-locking.rst for more detailed discussionof the locking scheme for directory operations.

xattr_handler operations¶

prototypes:

bool (*list)(struct dentry *dentry);int (*get)(const struct xattr_handler *handler, struct dentry *dentry,           struct inode *inode, const char *name, void *buffer,           size_t size);int (*set)(const struct xattr_handler *handler, struct dentry *dentry,           struct inode *inode, const char *name, const void *buffer,           size_t size, int flags);

locking rules:

all may block

super_operations¶

prototypes:

struct inode *(*alloc_inode)(struct super_block *sb);void (*free_inode)(struct inode *);void (*destroy_inode)(struct inode *);void (*dirty_inode) (struct inode *, int flags);int (*write_inode) (struct inode *, struct writeback_control *wbc);int (*drop_inode) (struct inode *);void (*evict_inode) (struct inode *);void (*put_super) (struct super_block *);int (*sync_fs)(struct super_block *sb, int wait);int (*freeze_fs) (struct super_block *);int (*unfreeze_fs) (struct super_block *);int (*statfs) (struct dentry *, struct kstatfs *);int (*remount_fs) (struct super_block *, int *, char *);void (*umount_begin) (struct super_block *);int (*show_options)(struct seq_file *, struct dentry *);ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);

locking rules:

All may block [not true, see below]

->statfs() has s_umount (shared) when called by ustat(2) (native orcompat), but that’s an accident of bad API; s_umount is used to pinthe superblock down when we only have dev_t given us by userland toidentify the superblock. Everything else (statfs(), fstatfs(), etc.)doesn’t hold it when calling ->statfs() - superblock is pinned downby resolving the pathname passed to syscall.

->quota_read() and ->quota_write() functions are both guaranteed tobe the only ones operating on the quota file by the quota code (viadqio_sem) (unless an admin really wants to screw up something andwrites to quota files with quotas on). For other details about lockingsee also dquot_operations section.

->bdev_try_to_free_page is called from the ->releasepage handler ofthe block device inode. See there for more details.

file_system_type¶

prototypes:

struct dentry *(*mount) (struct file_system_type *, int,               const char *, void *);void (*kill_sb) (struct super_block *);

locking rules:

->mount() returns ERR_PTR or the root dentry; its superblock should be lockedon return.

->kill_sb() takes a write-locked superblock, does all shutdown work on it,unlocks and drops the reference.

address_space_operations¶

prototypes:

int (*writepage)(struct page *page, struct writeback_control *wbc);int (*readpage)(struct file *, struct page *);int (*writepages)(struct address_space *, struct writeback_control *);int (*set_page_dirty)(struct page *page);void (*readahead)(struct readahead_control *);int (*readpages)(struct file *filp, struct address_space *mapping,                struct list_head *pages, unsigned nr_pages);int (*write_begin)(struct file *, struct address_space *mapping,                        loff_t pos, unsigned len, unsigned flags,                        struct page **pagep, void **fsdata);int (*write_end)(struct file *, struct address_space *mapping,                        loff_t pos, unsigned len, unsigned copied,                        struct page *page, void *fsdata);sector_t (*bmap)(struct address_space *, sector_t);void (*invalidatepage) (struct page *, unsigned int, unsigned int);int (*releasepage) (struct page *, int);void (*freepage)(struct page *);int (*direct_IO)(struct kiocb *, struct iov_iter *iter);bool (*isolate_page) (struct page *, isolate_mode_t);int (*migratepage)(struct address_space *, struct page *, struct page *);void (*putback_page) (struct page *);int (*launder_page)(struct page *);int (*is_partially_uptodate)(struct page *, unsigned long, unsigned long);int (*error_remove_page)(struct address_space *, struct page *);int (*swap_activate)(struct file *);int (*swap_deactivate)(struct file *);

locking rules:

All except set_page_dirty and freepage may block

->write_begin(), ->write_end() and ->readpage() may be called fromthe request handler (/dev/loop).

->readpage() unlocks the page, either synchronously or via I/Ocompletion.

->readahead() unlocks the pages that I/O is attempted on like ->readpage().

->readpages() populates the pagecache with the passed pages and startsI/O against them. They come unlocked upon I/O completion.

->writepage() is used for two purposes: for “memory cleansing” and for“sync”. These are quite different operations and the behaviour may differdepending upon the mode.

If writepage is called for sync (wbc->sync_mode != WBC_SYNC_NONE) thenitmust start I/O against the page, even if that would involveblocking on in-progress I/O.

If writepage is called for memory cleansing (sync_mode ==WBC_SYNC_NONE) then its role is to get as much writeout underway aspossible. So writepage should try to avoid blocking againstcurrently-in-progress I/O.

If the filesystem is not called for “sync” and it determines that itwould need to block against in-progress I/O to be able to start new I/Oagainst the page the filesystem should redirty the page withredirty_page_for_writepage(), then unlock the page and return zero.This may also be done to avoid internal deadlocks, but rarely.

If the filesystem is called for sync then it must wait on anyin-progress I/O and then start new I/O.

The filesystem should unlock the page synchronously, before returning to thecaller, unless ->writepage() returns special WRITEPAGE_ACTIVATEvalue. WRITEPAGE_ACTIVATE means that page cannot really be written outcurrently, and VM should stop calling ->writepage() on this page for sometime. VM does this by moving page to the head of the active list, hence thename.

Unless the filesystem is going to redirty_page_for_writepage(), unlock the pageand return zero, writepagemust run set_page_writeback() against the page,followed by unlocking it. Once set_page_writeback() has been run against thepage, write I/O can be submitted and the write I/O completion handler must runend_page_writeback() once the I/O is complete. If no I/O is submitted, thefilesystem must runend_page_writeback() against the page before returning fromwritepage.

That is: after 2.5.12, pages which are under writeout arenot locked. Note,if the filesystem needs the page to be locked during writeout, that is ok, too,the page is allowed to be unlocked at any point in time between the calls toset_page_writeback() andend_page_writeback().

Note, failure to run either redirty_page_for_writepage() or the combination ofset_page_writeback()/end_page_writeback() on a page submitted to writepagewill leave the page itself marked clean but it will be tagged as dirty in theradix tree. This incoherency can lead to all sorts of hard-to-debug problemsin the filesystem like having dirty inodes at umount and losing written data.

->writepages() is used for periodic writeback and for syscall-initiatedsync operations. The address_space should start I/O against at least*nr_to_write pages.*nr_to_write must be decremented for each pagewhich is written. The address_space implementation may write more (or less)pages than*nr_to_write asks for, but it should try to be reasonably close.If nr_to_write is NULL, all dirty pages must be written.

writepages should _only_ write pages which are present onmapping->io_pages.

->set_page_dirty() is called from various places in the kernelwhen the target page is marked as needing writeback. It may be calledunder spinlock (it cannot block) and is sometimes called with the pagenot locked.

->bmap() is currently used by legacy ioctl() (FIBMAP) provided by somefilesystems and by the swapper. The latter will eventually go away. Please,keep it that way and don’t breed new callers.

->invalidatepage() is called when the filesystem must attempt to dropsome or all of the buffers from the page when it is being truncated. Itreturns zero on success. If ->invalidatepage is zero, the kernel usesblock_invalidatepage() instead.

->releasepage() is called when the kernel is about to try to drop thebuffers from the page in preparation for freeing it. It returns zero toindicate that the buffers are (or may be) freeable. If ->releasepage is zero,the kernel assumes that the fs has no private interest in the buffers.

->freepage() is called when the kernel is done dropping the pagefrom the page cache.

->launder_page() may be called prior to releasing a page ifit is still found to be dirty. It returns zero if the page was successfullycleaned, or an error value if not. Note that in order to prevent the pagegetting mapped back in and redirtied, it needs to be kept lockedacross the entire operation.

->swap_activate will be called with a non-zero argument onfiles backing (non block device backed) swapfiles. A return valueof zero indicates success, in which case this file can be used forbacking swapspace. The swapspace operations will be proxied to theaddress space operations.

->swap_deactivate() will be called in the sys_swapoff()path after ->swap_activate() returned success.

file_lock_operations¶

prototypes:

void (*fl_copy_lock)(struct file_lock *, struct file_lock *);void (*fl_release_private)(struct file_lock *);

locking rules:

lock_manager_operations¶

prototypes:

void (*lm_notify)(struct file_lock *);  /* unblock callback */int (*lm_grant)(struct file_lock *, struct file_lock *, int);void (*lm_break)(struct file_lock *); /* break_lease callback */int (*lm_change)(struct file_lock **, int);bool (*lm_breaker_owns_lease)(struct file_lock *);

locking rules:

buffer_head¶

prototypes:

void (*b_end_io)(struct buffer_head *bh, int uptodate);

locking rules:

called from interrupts. In other words, extreme care is needed here.bh is locked, but that’s all warranties we have here. Currently only RAID1,highmem, fs/buffer.c, and fs/ntfs/aops.c are providing these. Block devicescall this method upon the IO completion.

block_device_operations¶

prototypes:

int (*open) (struct block_device *, fmode_t);int (*release) (struct gendisk *, fmode_t);int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);int (*direct_access) (struct block_device *, sector_t, void **,                        unsigned long *);void (*unlock_native_capacity) (struct gendisk *);int (*revalidate_disk) (struct gendisk *);int (*getgeo)(struct block_device *, struct hd_geometry *);void (*swap_slot_free_notify) (struct block_device *, unsigned long);

locking rules:

unlock_native_capacity and revalidate_disk are called only fromcheck_disk_change().

swap_slot_free_notify is called with swap_lock and sometimes the page lockheld.

file_operations¶

prototypes:

loff_t (*llseek) (struct file *, loff_t, int);ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);int (*iterate) (struct file *, struct dir_context *);int (*iterate_shared) (struct file *, struct dir_context *);__poll_t (*poll) (struct file *, struct poll_table_struct *);long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);long (*compat_ioctl) (struct file *, unsigned int, unsigned long);int (*mmap) (struct file *, struct vm_area_struct *);int (*open) (struct inode *, struct file *);int (*flush) (struct file *);int (*release) (struct inode *, struct file *);int (*fsync) (struct file *, loff_t start, loff_t end, int datasync);int (*fasync) (int, struct file *, int);int (*lock) (struct file *, int, struct file_lock *);ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,                loff_t *);ssize_t (*writev) (struct file *, const struct iovec *, unsigned long,                loff_t *);ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t,                void __user *);ssize_t (*sendpage) (struct file *, struct page *, int, size_t,                loff_t *, int);unsigned long (*get_unmapped_area)(struct file *, unsigned long,                unsigned long, unsigned long, unsigned long);int (*check_flags)(int);int (*flock) (struct file *, int, struct file_lock *);ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *,                size_t, unsigned int);ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,                size_t, unsigned int);int (*setlease)(struct file *, long, struct file_lock **, void **);long (*fallocate)(struct file *, int, loff_t, loff_t);

locking rules:

All may block.

->llseek() locking has moved from llseek to the individual llseekimplementations. If your fs is not using generic_file_llseek, youneed to acquire and release the appropriate locks in your ->llseek().For many filesystems, it is probably safe to acquire the inodemutex or just to use i_size_read() instead.Note: this does not protect the file->f_pos against concurrent modificationssince this is something the userspace has to take care about.

->iterate() is called with i_rwsem exclusive.

->iterate_shared() is called with i_rwsem at least shared.

->fasync() is responsible for maintaining the FASYNC bit in filp->f_flags.Most instances call fasync_helper(), which does that maintenance, so it’snot normally something one needs to worry about. Return values > 0 will bemapped to zero in the VFS layer.

->readdir() and ->ioctl() on directories must be changed. Ideally we wouldmove ->readdir() to inode_operations and use a separate method for directory->ioctl() or kill the latter completely. One of the problems is that foranything that resembles union-mount we won’t have a struct file for allcomponents. And there are other reasons why the current interface is a mess…

->read on directories probably must go away - we should just enforce -EISDIRin sys_read() and friends.

->setlease operations should callgeneric_setlease() before or after settingthe lease within the individual filesystem to record the result of theoperation

dquot_operations¶

prototypes:

int (*write_dquot) (struct dquot *);int (*acquire_dquot) (struct dquot *);int (*release_dquot) (struct dquot *);int (*mark_dirty) (struct dquot *);int (*write_info) (struct super_block *, int);

These operations are intended to be more or less wrapping functions that ensurea proper locking wrt the filesystem and call the generic quota operations.

What filesystem should expect from the generic quota functions:

FS recursion means calling ->quota_read() and ->quota_write() from superblockoperations.

More details about quota locking can be found in fs/dquot.c.

vm_operations_struct¶

prototypes:

void (*open)(struct vm_area_struct*);void (*close)(struct vm_area_struct*);vm_fault_t (*fault)(struct vm_area_struct*, struct vm_fault *);vm_fault_t (*page_mkwrite)(struct vm_area_struct *, struct vm_fault *);vm_fault_t (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault *);int (*access)(struct vm_area_struct *, unsigned long, void*, int, int);

locking rules:

->fault() is called when a previously not present pte is aboutto be faulted in. The filesystem must find and return the page associatedwith the passed in “pgoff” in the vm_fault structure. If it is possible thatthe page may be truncated and/or invalidated, then the filesystem must lockthe page, then ensure it is not already truncated (the page lock will blocksubsequent truncate), and then return with VM_FAULT_LOCKED, and the pagelocked. The VM will unlock the page.

->map_pages() is called when VM asks to map easy accessible pages.Filesystem should find and map pages associated with offsets from “start_pgoff”till “end_pgoff”. ->map_pages() is called with page table locked and mustnot block. If it’s not possible to reach a page without blocking,filesystem should skip it. Filesystem should use do_set_pte() to setuppage table entry. Pointer to entry associated with the page is passed in“pte” field in vm_fault structure. Pointers to entries for other offsetsshould be calculated relative to “pte”.

->page_mkwrite() is called when a previously read-only pte isabout to become writeable. The filesystem again must ensure that there areno truncate/invalidate races, and then return with the page locked. Ifthe page has been truncated, the filesystem should not look up a new pagelike the ->fault() handler, but simply return with VM_FAULT_NOPAGE, whichwill cause the VM to retry the fault.

->pfn_mkwrite() is the same as page_mkwrite but when the pte isVM_PFNMAP or VM_MIXEDMAP with a page-less entry. Expected return isVM_FAULT_NOPAGE. Or one of the VM_FAULT_ERROR types. The default behaviorafter this call is to make the pte read-write, unless pfn_mkwrite returnsan error.

->access() is called when get_user_pages() fails inaccess_process_vm(), typically used to debug a process through/proc/pid/mem or ptrace. This function is needed only forVM_IO | VM_PFNMAP VMAs.

Dubious stuff

(if you break something or notice that it is broken and do not fix it yourself- at least put it here)