Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame^] | 1 | The text below describes the locking rules for VFS-related methods. |
| 2 | It is (believed to be) up-to-date. *Please*, if you change anything in |
| 3 | prototypes or locking protocols - update this file. And update the relevant |
| 4 | instances in the tree, don't leave that to maintainers of filesystems/devices/ |
| 5 | etc. At the very least, put the list of dubious cases in the end of this file. |
| 6 | Don't turn it into log - maintainers of out-of-the-tree code are supposed to |
| 7 | be able to use diff(1). |
| 8 | Thing currently missing here: socket operations. Alexey? |
| 9 | |
| 10 | --------------------------- dentry_operations -------------------------- |
| 11 | prototypes: |
| 12 | int (*d_revalidate)(struct dentry *, int); |
| 13 | int (*d_hash) (struct dentry *, struct qstr *); |
| 14 | int (*d_compare) (struct dentry *, struct qstr *, struct qstr *); |
| 15 | int (*d_delete)(struct dentry *); |
| 16 | void (*d_release)(struct dentry *); |
| 17 | void (*d_iput)(struct dentry *, struct inode *); |
| 18 | |
| 19 | locking rules: |
| 20 | none have BKL |
| 21 | dcache_lock rename_lock ->d_lock may block |
| 22 | d_revalidate: no no no yes |
| 23 | d_hash no no no yes |
| 24 | d_compare: no yes no no |
| 25 | d_delete: yes no yes no |
| 26 | d_release: no no no yes |
| 27 | d_iput: no no no yes |
| 28 | |
| 29 | --------------------------- inode_operations --------------------------- |
| 30 | prototypes: |
| 31 | int (*create) (struct inode *,struct dentry *,int, struct nameidata *); |
| 32 | struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameid |
| 33 | ata *); |
| 34 | int (*link) (struct dentry *,struct inode *,struct dentry *); |
| 35 | int (*unlink) (struct inode *,struct dentry *); |
| 36 | int (*symlink) (struct inode *,struct dentry *,const char *); |
| 37 | int (*mkdir) (struct inode *,struct dentry *,int); |
| 38 | int (*rmdir) (struct inode *,struct dentry *); |
| 39 | int (*mknod) (struct inode *,struct dentry *,int,dev_t); |
| 40 | int (*rename) (struct inode *, struct dentry *, |
| 41 | struct inode *, struct dentry *); |
| 42 | int (*readlink) (struct dentry *, char __user *,int); |
| 43 | int (*follow_link) (struct dentry *, struct nameidata *); |
| 44 | void (*truncate) (struct inode *); |
| 45 | int (*permission) (struct inode *, int, struct nameidata *); |
| 46 | int (*setattr) (struct dentry *, struct iattr *); |
| 47 | int (*getattr) (struct vfsmount *, struct dentry *, struct kstat *); |
| 48 | int (*setxattr) (struct dentry *, const char *,const void *,size_t,int); |
| 49 | ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t); |
| 50 | ssize_t (*listxattr) (struct dentry *, char *, size_t); |
| 51 | int (*removexattr) (struct dentry *, const char *); |
| 52 | |
| 53 | locking rules: |
| 54 | all may block, none have BKL |
| 55 | i_sem(inode) |
| 56 | lookup: yes |
| 57 | create: yes |
| 58 | link: yes (both) |
| 59 | mknod: yes |
| 60 | symlink: yes |
| 61 | mkdir: yes |
| 62 | unlink: yes (both) |
| 63 | rmdir: yes (both) (see below) |
| 64 | rename: yes (all) (see below) |
| 65 | readlink: no |
| 66 | follow_link: no |
| 67 | truncate: yes (see below) |
| 68 | setattr: yes |
| 69 | permission: no |
| 70 | getattr: no |
| 71 | setxattr: yes |
| 72 | getxattr: no |
| 73 | listxattr: no |
| 74 | removexattr: yes |
| 75 | Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_sem on |
| 76 | victim. |
| 77 | cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem. |
| 78 | ->truncate() is never called directly - it's a callback, not a |
| 79 | method. It's called by vmtruncate() - library function normally used by |
| 80 | ->setattr(). Locking information above applies to that call (i.e. is |
| 81 | inherited from ->setattr() - vmtruncate() is used when ATTR_SIZE had been |
| 82 | passed). |
| 83 | |
| 84 | See Documentation/filesystems/directory-locking for more detailed discussion |
| 85 | of the locking scheme for directory operations. |
| 86 | |
| 87 | --------------------------- super_operations --------------------------- |
| 88 | prototypes: |
| 89 | struct inode *(*alloc_inode)(struct super_block *sb); |
| 90 | void (*destroy_inode)(struct inode *); |
| 91 | void (*read_inode) (struct inode *); |
| 92 | void (*dirty_inode) (struct inode *); |
| 93 | int (*write_inode) (struct inode *, int); |
| 94 | void (*put_inode) (struct inode *); |
| 95 | void (*drop_inode) (struct inode *); |
| 96 | void (*delete_inode) (struct inode *); |
| 97 | void (*put_super) (struct super_block *); |
| 98 | void (*write_super) (struct super_block *); |
| 99 | int (*sync_fs)(struct super_block *sb, int wait); |
| 100 | void (*write_super_lockfs) (struct super_block *); |
| 101 | void (*unlockfs) (struct super_block *); |
| 102 | int (*statfs) (struct super_block *, struct kstatfs *); |
| 103 | int (*remount_fs) (struct super_block *, int *, char *); |
| 104 | void (*clear_inode) (struct inode *); |
| 105 | void (*umount_begin) (struct super_block *); |
| 106 | int (*show_options)(struct seq_file *, struct vfsmount *); |
| 107 | ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); |
| 108 | ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); |
| 109 | |
| 110 | locking rules: |
| 111 | All may block. |
| 112 | BKL s_lock s_umount |
| 113 | alloc_inode: no no no |
| 114 | destroy_inode: no |
| 115 | read_inode: no (see below) |
| 116 | dirty_inode: no (must not sleep) |
| 117 | write_inode: no |
| 118 | put_inode: no |
| 119 | drop_inode: no !!!inode_lock!!! |
| 120 | delete_inode: no |
| 121 | put_super: yes yes no |
| 122 | write_super: no yes read |
| 123 | sync_fs: no no read |
| 124 | write_super_lockfs: ? |
| 125 | unlockfs: ? |
| 126 | statfs: no no no |
| 127 | remount_fs: no yes maybe (see below) |
| 128 | clear_inode: no |
| 129 | umount_begin: yes no no |
| 130 | show_options: no (vfsmount->sem) |
| 131 | quota_read: no no no (see below) |
| 132 | quota_write: no no no (see below) |
| 133 | |
| 134 | ->read_inode() is not a method - it's a callback used in iget(). |
| 135 | ->remount_fs() will have the s_umount lock if it's already mounted. |
| 136 | When called from get_sb_single, it does NOT have the s_umount lock. |
| 137 | ->quota_read() and ->quota_write() functions are both guaranteed to |
| 138 | be the only ones operating on the quota file by the quota code (via |
| 139 | dqio_sem) (unless an admin really wants to screw up something and |
| 140 | writes to quota files with quotas on). For other details about locking |
| 141 | see also dquot_operations section. |
| 142 | |
| 143 | --------------------------- file_system_type --------------------------- |
| 144 | prototypes: |
| 145 | struct super_block *(*get_sb) (struct file_system_type *, int, |
| 146 | const char *, void *); |
| 147 | void (*kill_sb) (struct super_block *); |
| 148 | locking rules: |
| 149 | may block BKL |
| 150 | get_sb yes yes |
| 151 | kill_sb yes yes |
| 152 | |
| 153 | ->get_sb() returns error or a locked superblock (exclusive on ->s_umount). |
| 154 | ->kill_sb() takes a write-locked superblock, does all shutdown work on it, |
| 155 | unlocks and drops the reference. |
| 156 | |
| 157 | --------------------------- address_space_operations -------------------------- |
| 158 | prototypes: |
| 159 | int (*writepage)(struct page *page, struct writeback_control *wbc); |
| 160 | int (*readpage)(struct file *, struct page *); |
| 161 | int (*sync_page)(struct page *); |
| 162 | int (*writepages)(struct address_space *, struct writeback_control *); |
| 163 | int (*set_page_dirty)(struct page *page); |
| 164 | int (*readpages)(struct file *filp, struct address_space *mapping, |
| 165 | struct list_head *pages, unsigned nr_pages); |
| 166 | int (*prepare_write)(struct file *, struct page *, unsigned, unsigned); |
| 167 | int (*commit_write)(struct file *, struct page *, unsigned, unsigned); |
| 168 | sector_t (*bmap)(struct address_space *, sector_t); |
| 169 | int (*invalidatepage) (struct page *, unsigned long); |
| 170 | int (*releasepage) (struct page *, int); |
| 171 | int (*direct_IO)(int, struct kiocb *, const struct iovec *iov, |
| 172 | loff_t offset, unsigned long nr_segs); |
| 173 | |
| 174 | locking rules: |
| 175 | All except set_page_dirty may block |
| 176 | |
| 177 | BKL PageLocked(page) |
| 178 | writepage: no yes, unlocks (see below) |
| 179 | readpage: no yes, unlocks |
| 180 | sync_page: no maybe |
| 181 | writepages: no |
| 182 | set_page_dirty no no |
| 183 | readpages: no |
| 184 | prepare_write: no yes |
| 185 | commit_write: no yes |
| 186 | bmap: yes |
| 187 | invalidatepage: no yes |
| 188 | releasepage: no yes |
| 189 | direct_IO: no |
| 190 | |
| 191 | ->prepare_write(), ->commit_write(), ->sync_page() and ->readpage() |
| 192 | may be called from the request handler (/dev/loop). |
| 193 | |
| 194 | ->readpage() unlocks the page, either synchronously or via I/O |
| 195 | completion. |
| 196 | |
| 197 | ->readpages() populates the pagecache with the passed pages and starts |
| 198 | I/O against them. They come unlocked upon I/O completion. |
| 199 | |
| 200 | ->writepage() is used for two purposes: for "memory cleansing" and for |
| 201 | "sync". These are quite different operations and the behaviour may differ |
| 202 | depending upon the mode. |
| 203 | |
| 204 | If writepage is called for sync (wbc->sync_mode != WBC_SYNC_NONE) then |
| 205 | it *must* start I/O against the page, even if that would involve |
| 206 | blocking on in-progress I/O. |
| 207 | |
| 208 | If writepage is called for memory cleansing (sync_mode == |
| 209 | WBC_SYNC_NONE) then its role is to get as much writeout underway as |
| 210 | possible. So writepage should try to avoid blocking against |
| 211 | currently-in-progress I/O. |
| 212 | |
| 213 | If the filesystem is not called for "sync" and it determines that it |
| 214 | would need to block against in-progress I/O to be able to start new I/O |
| 215 | against the page the filesystem should redirty the page with |
| 216 | redirty_page_for_writepage(), then unlock the page and return zero. |
| 217 | This may also be done to avoid internal deadlocks, but rarely. |
| 218 | |
| 219 | If the filesytem is called for sync then it must wait on any |
| 220 | in-progress I/O and then start new I/O. |
| 221 | |
| 222 | The filesystem should unlock the page synchronously, before returning |
| 223 | to the caller. |
| 224 | |
| 225 | Unless the filesystem is going to redirty_page_for_writepage(), unlock the page |
| 226 | and return zero, writepage *must* run set_page_writeback() against the page, |
| 227 | followed by unlocking it. Once set_page_writeback() has been run against the |
| 228 | page, write I/O can be submitted and the write I/O completion handler must run |
| 229 | end_page_writeback() once the I/O is complete. If no I/O is submitted, the |
| 230 | filesystem must run end_page_writeback() against the page before returning from |
| 231 | writepage. |
| 232 | |
| 233 | That is: after 2.5.12, pages which are under writeout are *not* locked. Note, |
| 234 | if the filesystem needs the page to be locked during writeout, that is ok, too, |
| 235 | the page is allowed to be unlocked at any point in time between the calls to |
| 236 | set_page_writeback() and end_page_writeback(). |
| 237 | |
| 238 | Note, failure to run either redirty_page_for_writepage() or the combination of |
| 239 | set_page_writeback()/end_page_writeback() on a page submitted to writepage |
| 240 | will leave the page itself marked clean but it will be tagged as dirty in the |
| 241 | radix tree. This incoherency can lead to all sorts of hard-to-debug problems |
| 242 | in the filesystem like having dirty inodes at umount and losing written data. |
| 243 | |
| 244 | ->sync_page() locking rules are not well-defined - usually it is called |
| 245 | with lock on page, but that is not guaranteed. Considering the currently |
| 246 | existing instances of this method ->sync_page() itself doesn't look |
| 247 | well-defined... |
| 248 | |
| 249 | ->writepages() is used for periodic writeback and for syscall-initiated |
| 250 | sync operations. The address_space should start I/O against at least |
| 251 | *nr_to_write pages. *nr_to_write must be decremented for each page which is |
| 252 | written. The address_space implementation may write more (or less) pages |
| 253 | than *nr_to_write asks for, but it should try to be reasonably close. If |
| 254 | nr_to_write is NULL, all dirty pages must be written. |
| 255 | |
| 256 | writepages should _only_ write pages which are present on |
| 257 | mapping->io_pages. |
| 258 | |
| 259 | ->set_page_dirty() is called from various places in the kernel |
| 260 | when the target page is marked as needing writeback. It may be called |
| 261 | under spinlock (it cannot block) and is sometimes called with the page |
| 262 | not locked. |
| 263 | |
| 264 | ->bmap() is currently used by legacy ioctl() (FIBMAP) provided by some |
| 265 | filesystems and by the swapper. The latter will eventually go away. All |
| 266 | instances do not actually need the BKL. Please, keep it that way and don't |
| 267 | breed new callers. |
| 268 | |
| 269 | ->invalidatepage() is called when the filesystem must attempt to drop |
| 270 | some or all of the buffers from the page when it is being truncated. It |
| 271 | returns zero on success. If ->invalidatepage is zero, the kernel uses |
| 272 | block_invalidatepage() instead. |
| 273 | |
| 274 | ->releasepage() is called when the kernel is about to try to drop the |
| 275 | buffers from the page in preparation for freeing it. It returns zero to |
| 276 | indicate that the buffers are (or may be) freeable. If ->releasepage is zero, |
| 277 | the kernel assumes that the fs has no private interest in the buffers. |
| 278 | |
| 279 | Note: currently almost all instances of address_space methods are |
| 280 | using BKL for internal serialization and that's one of the worst sources |
| 281 | of contention. Normally they are calling library functions (in fs/buffer.c) |
| 282 | and pass foo_get_block() as a callback (on local block-based filesystems, |
| 283 | indeed). BKL is not needed for library stuff and is usually taken by |
| 284 | foo_get_block(). It's an overkill, since block bitmaps can be protected by |
| 285 | internal fs locking and real critical areas are much smaller than the areas |
| 286 | filesystems protect now. |
| 287 | |
| 288 | ----------------------- file_lock_operations ------------------------------ |
| 289 | prototypes: |
| 290 | void (*fl_insert)(struct file_lock *); /* lock insertion callback */ |
| 291 | void (*fl_remove)(struct file_lock *); /* lock removal callback */ |
| 292 | void (*fl_copy_lock)(struct file_lock *, struct file_lock *); |
| 293 | void (*fl_release_private)(struct file_lock *); |
| 294 | |
| 295 | |
| 296 | locking rules: |
| 297 | BKL may block |
| 298 | fl_insert: yes no |
| 299 | fl_remove: yes no |
| 300 | fl_copy_lock: yes no |
| 301 | fl_release_private: yes yes |
| 302 | |
| 303 | ----------------------- lock_manager_operations --------------------------- |
| 304 | prototypes: |
| 305 | int (*fl_compare_owner)(struct file_lock *, struct file_lock *); |
| 306 | void (*fl_notify)(struct file_lock *); /* unblock callback */ |
| 307 | void (*fl_copy_lock)(struct file_lock *, struct file_lock *); |
| 308 | void (*fl_release_private)(struct file_lock *); |
| 309 | void (*fl_break)(struct file_lock *); /* break_lease callback */ |
| 310 | |
| 311 | locking rules: |
| 312 | BKL may block |
| 313 | fl_compare_owner: yes no |
| 314 | fl_notify: yes no |
| 315 | fl_copy_lock: yes no |
| 316 | fl_release_private: yes yes |
| 317 | fl_break: yes no |
| 318 | |
| 319 | Currently only NFSD and NLM provide instances of this class. None of the |
| 320 | them block. If you have out-of-tree instances - please, show up. Locking |
| 321 | in that area will change. |
| 322 | --------------------------- buffer_head ----------------------------------- |
| 323 | prototypes: |
| 324 | void (*b_end_io)(struct buffer_head *bh, int uptodate); |
| 325 | |
| 326 | locking rules: |
| 327 | called from interrupts. In other words, extreme care is needed here. |
| 328 | bh is locked, but that's all warranties we have here. Currently only RAID1, |
| 329 | highmem, fs/buffer.c, and fs/ntfs/aops.c are providing these. Block devices |
| 330 | call this method upon the IO completion. |
| 331 | |
| 332 | --------------------------- block_device_operations ----------------------- |
| 333 | prototypes: |
| 334 | int (*open) (struct inode *, struct file *); |
| 335 | int (*release) (struct inode *, struct file *); |
| 336 | int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long); |
| 337 | int (*media_changed) (struct gendisk *); |
| 338 | int (*revalidate_disk) (struct gendisk *); |
| 339 | |
| 340 | locking rules: |
| 341 | BKL bd_sem |
| 342 | open: yes yes |
| 343 | release: yes yes |
| 344 | ioctl: yes no |
| 345 | media_changed: no no |
| 346 | revalidate_disk: no no |
| 347 | |
| 348 | The last two are called only from check_disk_change(). |
| 349 | |
| 350 | --------------------------- file_operations ------------------------------- |
| 351 | prototypes: |
| 352 | loff_t (*llseek) (struct file *, loff_t, int); |
| 353 | ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); |
| 354 | ssize_t (*aio_read) (struct kiocb *, char __user *, size_t, loff_t); |
| 355 | ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); |
| 356 | ssize_t (*aio_write) (struct kiocb *, const char __user *, size_t, |
| 357 | loff_t); |
| 358 | int (*readdir) (struct file *, void *, filldir_t); |
| 359 | unsigned int (*poll) (struct file *, struct poll_table_struct *); |
| 360 | int (*ioctl) (struct inode *, struct file *, unsigned int, |
| 361 | unsigned long); |
| 362 | long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); |
| 363 | long (*compat_ioctl) (struct file *, unsigned int, unsigned long); |
| 364 | int (*mmap) (struct file *, struct vm_area_struct *); |
| 365 | int (*open) (struct inode *, struct file *); |
| 366 | int (*flush) (struct file *); |
| 367 | int (*release) (struct inode *, struct file *); |
| 368 | int (*fsync) (struct file *, struct dentry *, int datasync); |
| 369 | int (*aio_fsync) (struct kiocb *, int datasync); |
| 370 | int (*fasync) (int, struct file *, int); |
| 371 | int (*lock) (struct file *, int, struct file_lock *); |
| 372 | ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, |
| 373 | loff_t *); |
| 374 | ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, |
| 375 | loff_t *); |
| 376 | ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, |
| 377 | void __user *); |
| 378 | ssize_t (*sendpage) (struct file *, struct page *, int, size_t, |
| 379 | loff_t *, int); |
| 380 | unsigned long (*get_unmapped_area)(struct file *, unsigned long, |
| 381 | unsigned long, unsigned long, unsigned long); |
| 382 | int (*check_flags)(int); |
| 383 | int (*dir_notify)(struct file *, unsigned long); |
| 384 | }; |
| 385 | |
| 386 | locking rules: |
| 387 | All except ->poll() may block. |
| 388 | BKL |
| 389 | llseek: no (see below) |
| 390 | read: no |
| 391 | aio_read: no |
| 392 | write: no |
| 393 | aio_write: no |
| 394 | readdir: no |
| 395 | poll: no |
| 396 | ioctl: yes (see below) |
| 397 | unlocked_ioctl: no (see below) |
| 398 | compat_ioctl: no |
| 399 | mmap: no |
| 400 | open: maybe (see below) |
| 401 | flush: no |
| 402 | release: no |
| 403 | fsync: no (see below) |
| 404 | aio_fsync: no |
| 405 | fasync: yes (see below) |
| 406 | lock: yes |
| 407 | readv: no |
| 408 | writev: no |
| 409 | sendfile: no |
| 410 | sendpage: no |
| 411 | get_unmapped_area: no |
| 412 | check_flags: no |
| 413 | dir_notify: no |
| 414 | |
| 415 | ->llseek() locking has moved from llseek to the individual llseek |
| 416 | implementations. If your fs is not using generic_file_llseek, you |
| 417 | need to acquire and release the appropriate locks in your ->llseek(). |
| 418 | For many filesystems, it is probably safe to acquire the inode |
| 419 | semaphore. Note some filesystems (i.e. remote ones) provide no |
| 420 | protection for i_size so you will need to use the BKL. |
| 421 | |
| 422 | ->open() locking is in-transit: big lock partially moved into the methods. |
| 423 | The only exception is ->open() in the instances of file_operations that never |
| 424 | end up in ->i_fop/->proc_fops, i.e. ones that belong to character devices |
| 425 | (chrdev_open() takes lock before replacing ->f_op and calling the secondary |
| 426 | method. As soon as we fix the handling of module reference counters all |
| 427 | instances of ->open() will be called without the BKL. |
| 428 | |
| 429 | Note: ext2_release() was *the* source of contention on fs-intensive |
| 430 | loads and dropping BKL on ->release() helps to get rid of that (we still |
| 431 | grab BKL for cases when we close a file that had been opened r/w, but that |
| 432 | can and should be done using the internal locking with smaller critical areas). |
| 433 | Current worst offender is ext2_get_block()... |
| 434 | |
| 435 | ->fasync() is a mess. This area needs a big cleanup and that will probably |
| 436 | affect locking. |
| 437 | |
| 438 | ->readdir() and ->ioctl() on directories must be changed. Ideally we would |
| 439 | move ->readdir() to inode_operations and use a separate method for directory |
| 440 | ->ioctl() or kill the latter completely. One of the problems is that for |
| 441 | anything that resembles union-mount we won't have a struct file for all |
| 442 | components. And there are other reasons why the current interface is a mess... |
| 443 | |
| 444 | ->ioctl() on regular files is superceded by the ->unlocked_ioctl() that |
| 445 | doesn't take the BKL. |
| 446 | |
| 447 | ->read on directories probably must go away - we should just enforce -EISDIR |
| 448 | in sys_read() and friends. |
| 449 | |
| 450 | ->fsync() has i_sem on inode. |
| 451 | |
| 452 | --------------------------- dquot_operations ------------------------------- |
| 453 | prototypes: |
| 454 | int (*initialize) (struct inode *, int); |
| 455 | int (*drop) (struct inode *); |
| 456 | int (*alloc_space) (struct inode *, qsize_t, int); |
| 457 | int (*alloc_inode) (const struct inode *, unsigned long); |
| 458 | int (*free_space) (struct inode *, qsize_t); |
| 459 | int (*free_inode) (const struct inode *, unsigned long); |
| 460 | int (*transfer) (struct inode *, struct iattr *); |
| 461 | int (*write_dquot) (struct dquot *); |
| 462 | int (*acquire_dquot) (struct dquot *); |
| 463 | int (*release_dquot) (struct dquot *); |
| 464 | int (*mark_dirty) (struct dquot *); |
| 465 | int (*write_info) (struct super_block *, int); |
| 466 | |
| 467 | These operations are intended to be more or less wrapping functions that ensure |
| 468 | a proper locking wrt the filesystem and call the generic quota operations. |
| 469 | |
| 470 | What filesystem should expect from the generic quota functions: |
| 471 | |
| 472 | FS recursion Held locks when called |
| 473 | initialize: yes maybe dqonoff_sem |
| 474 | drop: yes - |
| 475 | alloc_space: ->mark_dirty() - |
| 476 | alloc_inode: ->mark_dirty() - |
| 477 | free_space: ->mark_dirty() - |
| 478 | free_inode: ->mark_dirty() - |
| 479 | transfer: yes - |
| 480 | write_dquot: yes dqonoff_sem or dqptr_sem |
| 481 | acquire_dquot: yes dqonoff_sem or dqptr_sem |
| 482 | release_dquot: yes dqonoff_sem or dqptr_sem |
| 483 | mark_dirty: no - |
| 484 | write_info: yes dqonoff_sem |
| 485 | |
| 486 | FS recursion means calling ->quota_read() and ->quota_write() from superblock |
| 487 | operations. |
| 488 | |
| 489 | ->alloc_space(), ->alloc_inode(), ->free_space(), ->free_inode() are called |
| 490 | only directly by the filesystem and do not call any fs functions only |
| 491 | the ->mark_dirty() operation. |
| 492 | |
| 493 | More details about quota locking can be found in fs/dquot.c. |
| 494 | |
| 495 | --------------------------- vm_operations_struct ----------------------------- |
| 496 | prototypes: |
| 497 | void (*open)(struct vm_area_struct*); |
| 498 | void (*close)(struct vm_area_struct*); |
| 499 | struct page *(*nopage)(struct vm_area_struct*, unsigned long, int *); |
| 500 | |
| 501 | locking rules: |
| 502 | BKL mmap_sem |
| 503 | open: no yes |
| 504 | close: no yes |
| 505 | nopage: no yes |
| 506 | |
| 507 | ================================================================================ |
| 508 | Dubious stuff |
| 509 | |
| 510 | (if you break something or notice that it is broken and do not fix it yourself |
| 511 | - at least put it here) |
| 512 | |
| 513 | ipc/shm.c::shm_delete() - may need BKL. |
| 514 | ->read() and ->write() in many drivers are (probably) missing BKL. |
| 515 | drivers/sgi/char/graphics.c::sgi_graphics_nopage() - may need BKL. |