fs: break out inode operations from inode_lock V3
Subsystems (9)
Hi Al,
This series is a merge of the two previous sets of patches that broke the inode LRU operations and the first half of iput_final() out from under the inode_lock and then split the lists under separate locks. The patches should apply to your current merge-stem tree. I can rebase it on a different tree if you want.
Version 3:
- remove up wake_up_inode() inode_lock avoidance optimisation as the inode_lock is no longer protecting i_state.
- Added a BUG_ON() check to evict() to ensure that inodes are removed from the LRU before being evicted.
- removed inode_lock from igrab() when removing inode_lock from the first half of iput_final()
- added 3 patches to convert the per-sb inode list, the writeback lists and the inode hashes under their own locks. The changes from the first version of these patches (posted separately) are:
- cleaned up comment for writeback_single_inode()
- dropped __mark_inode_dirty() cleanup and just moved the minimum amount of code around to handle the locking changes cleanly.
- moved adding inodes to sb list under the hash lock as well so we don't have inodes that are not on the per-sb lists on the hash.
- added a patch to clean up inode_lock references in documentation and comments.
Version 2:
- make i_state checks/__iget() atomic under inode->i_lock
- merge dispose_one_inode() into evict()
- move inode hash removal after ->evict_inode call.
- always take the inode_lru_lock() when checking whether the inode is on the lru or not.
PATCH 1/8 fs: protect inode->i_state with inode->i_lock
From: Dave Chinner <[email protected]>
Protect inode state transitions and validity checks with the inode->i_lock. This enables us to make inode state transitions independently of the inode_lock and is the first step to peeling away the inode_lock from the code.
This requires that __iget() is done atomically with i_state checks during list traversals so that we don't race with another thread marking the inode I_FREEING between the state check and grabbing the reference.
Also remove the unlock_new_inode() memory barrier optimisation required to avoid taking the inode_lock when clearing I_NEW. Simplify the code by simply taking the inode->i_lock around the state change and wakeup. Because the wakeup is no longer tricky, remove the wake_up_inode() function and open code the wakeup where necessary.
--- fs/drop_caches.c | 9 ++- fs/fs-writeback.c | 42 +++++++++++--- fs/inode.c | 138 +++++++++++++++++++++++++++++++++--------------- fs/notify/inode_mark.c | 21 +++++-- fs/quota/dquot.c | 13 +++-- 5 files changed, 157 insertions(+), 66 deletions(-)
fs/drop_caches.c +6 -3
@@ -18,11 +18,14 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused)spin_lock (&inode_lock);list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { -if (inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) -continue ; -if (inode->i_mapping->nrpages ==0 ) +spin_lock (&inode->i_lock); +if ((inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) || + (inode->i_mapping->nrpages ==0 )) { +spin_unlock (&inode->i_lock);continue ; + }__iget (inode); +spin_unlock (&inode->i_lock);spin_unlock (&inode_lock);invalidate_mapping_pages (inode->i_mapping,0 ,-1 );iput (toput_inode);
fs/fs-writeback.c +33 -9
149 lines not on this page · raw message
fs/inode.c +96 -42
392 lines not on this page · raw message
fs/notify/inode_mark.c +15 -6
@@ -249,8 +249,11 @@ void fsnotify_unmount_inodes(struct list_head *list)* I_WILL_FREE, or I_NEW which is fine because by that point * the inode cannot have any associated watches. */ -if (inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) +spin_lock (&inode->i_lock); +if (inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) { +spin_unlock (&inode->i_lock);continue ; + }/* * If i_count is zero, the inode cannot have any watches and
@@ -258,8 +261,10 @@ void fsnotify_unmount_inodes(struct list_head *list)* evict all inodes with zero i_count from icache which is * unnecessarily violent and may in fact be illegal to do. */ -if (!atomic_read (&inode->i_count)) +if (!atomic_read (&inode->i_count)) { +spin_unlock (&inode->i_lock);continue ; + } need_iput_tmp = need_iput; need_iput =NULL ;
@@ -269,13 +274,17 @@ void fsnotify_unmount_inodes(struct list_head *list)__iget (inode); else need_iput_tmp =NULL ; +spin_unlock (&inode->i_lock);/* In case the dropping of a reference would nuke next_i. */ if ((&next_i->i_sb_list != list) && -atomic_read (&next_i->i_count) && - !(next_i->i_state & (I_FREEING |I_WILL_FREE ))) { -__iget (next_i); - need_iput = next_i; +atomic_read (&next_i->i_count)) { +spin_lock (&next_i->i_lock); +if (!(next_i->i_state & (I_FREEING |I_WILL_FREE ))) { +__iget (next_i); + need_iput = next_i; + } +spin_unlock (&next_i->i_lock); }/*
fs/quota/dquot.c +7 -6
@@ -898,18 +898,19 @@ static void add_dquot_ref(struct super_block *sb, int type)spin_lock (&inode_lock);list_for_each_entry (inode, &sb->s_inodes, i_sb_list) { -if (inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) +spin_lock (&inode->i_lock); +if ((inode->i_state & (I_FREEING |I_WILL_FREE |I_NEW )) || + !atomic_read (&inode->i_writecount) || + !dqinit_needed (inode, type)) { +spin_unlock (&inode->i_lock);continue ; + }#ifdef CONFIG_QUOTA_DEBUG if (unlikely (inode_get_rsv_space (inode) >0 )) reserved =1 ;#endif -if (!atomic_read (&inode->i_writecount)) -continue ; -if (!dqinit_needed (inode, type)) -continue ; -__iget (inode); +spin_unlock (&inode->i_lock);spin_unlock (&inode_lock);iput (old_inode);
Signature · 1 line
1.7.1
Al Viro
maintainerRe: [PATCH 1/8] fs: protect inode->i_state with inode->i_lock
fs/fs-writeback.c static void inode_wait_for_writeback(struct inode *inode) · line 296
Quoted 5 lines · Dave Chinner
fs/fs-writeback.c +1
-0@@ -293,9 +293,11 @@ static void inode_wait_for_writeback(struct inode *inode) wqh =bit_waitqueue (&inode->i_state, __I_SYNC);while (inode->i_state &I_SYNC ) { +spin_unlock (&inode->i_lock);
Minor annoyance, but... Let's replace spaces with tab in that while.
fs/fs-writeback.c static int writeback_sb_inodes(struct super_block *sb, struct bdi_writeback *wb, · line 524
Quoted 4 lines
fs/fs-writeback.c +2
-0+spin_unlock (&inode->i_lock); + pages_skipped = wbc->pages_skipped;writeback_single_inode (inode, wbc);
Might make sense to lift locking i_lock into callers ofwriteback_single_inode() (it has to grab the damn thing as soon as it's called) and collapse it with spin_unlock() here. Separate patch.
fs/fs-writeback.c void __mark_inode_dirty(struct inode *inode, int flags) · line 995
Quoted 4 lines
fs/fs-writeback.c +1
-0+spin_unlock (&inode->i_lock);/* * If the inode was already on b_dirty/b_io/b_more_io, don't * reposition it (that would break b_dirty time-ordering).
I'm not sure there's any point in dropping it here, actually.
fs/inode.c void end_writeback(struct inode *inode) · line 436
Quoted 3 lines
fs/inode.c +2
-0+spin_lock (&inode->i_lock); inode->i_state =I_FREEING |I_CLEAR ; +spin_unlock (&inode->i_lock);
_Probably_ not needed here; we already had I_FREEING set by the time we'd called that and no other thread will modify ->i_state of that inode at that point. Check for I_CLEAR will be later in the same thread, so no barriers are needed. Separate patch.
fs/inode.c int invalidate_inodes(struct super_block *sb) · line 572
Quoted 8 lines
fs/inode.c +0
-2@@ -552,8 +568,6 @@ int invalidate_inodes(struct super_block *sb)*/ list_move (&inode->i_lru, &dispose);list_del_init (&inode->i_wb_list); -if (!(inode->i_state & (I_DIRTY |I_SYNC ))) -percpu_counter_dec (&nr_inodes_unused); }spin_unlock (&inode_lock);
Ho-hum...
I'm not sure we need that list_del_init() here, actually, seeing that I_FREEING is already set... For later patch, anyway.
fs/inode.c static struct inode *get_new_inode_fast(struct super_block *sb, · line 952
Quoted 8 lines
fs/inode.c +3
-0@@ -917,10 +946,12 @@ static struct inode *get_new_inode_fast(struct super_block *sb,/* We released the lock, so.. */ old =find_inode_fast (sb, head, ino);if (!old) { +spin_lock (&inode->i_lock); inode->i_ino = ino; + inode->i_state =I_NEW ; +spin_unlock (&inode->i_lock);
Almost certainly not needed; nobody can find this inode at that point.
fs/inode.c EXPORT_SYMBOL(inode_wait); · line 1640
Quoted 2 lines
fs/inode.c +2
-0+* wake_up_bit(&inode->i_state, __I_NEW) after removing from the hash list +* will DTRT.
Add that i_lock is not regained.
PATCH 2/8 fs: factor inode disposal
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
We have a couple of places that dispose of inodes. factor the disposal into evict() to isolate this code and make it simpler to peel away the inode_lock from the code.
While doing this, change the logic flow in iput_final() to separate the different cases that need to be handled to make the transitions the inode goes through more obvious.
--- fs/inode.c | 102 +++++++++++++++++++++++++++-------------------------------- 1 files changed, 47 insertions(+), 55 deletions(-)
fs/inode.c +47 -55
@@ -399,17 +399,6 @@ void __insert_inode_hash(struct inode *inode, unsigned long hashval)EXPORT_SYMBOL (__insert_inode_hash);/** -* __remove_inode_hash - remove an inode from the hash -* @inode: inode to unhash -* -* Remove an inode from the superblock. -*/ -static void __remove_inode_hash (struct inode *inode) -{ -hlist_del_init (&inode->i_hash); -} - -/** * remove_inode_hash - remove an inode from the hash * @inode: inode to unhash *
@@ -437,10 +426,31 @@ void end_writeback(struct inode *inode) }EXPORT_SYMBOL (end_writeback); +/* +* Free the inode passed in, removing it from the lists it is still connected +* to. We remove any pages still attached to the inode and wait for any IO that +* is still in progress before finally destroying the inode. +* +* An inode must already be marked I_FREEING so that we avoid the inode being +* moved back onto lists if we race with other code that manipulates the lists +* (e.g. writeback_single_inode). The caller is responsible for setting this. +* +* An inode must already be removed from the LRU list before being evicted from +* the cache. This should occur atomically with setting the I_FREEING state +* flag, so no inodes here should ever be on the LRU. +*/ static void evict (struct inode *inode) {const struct super_operations *op = inode->i_sb->s_op; +BUG_ON (!(inode->i_state &I_FREEING )); +BUG_ON (!list_empty (&inode->i_lru)); + +spin_lock (&inode_lock); +list_del_init (&inode->i_wb_list); +__inode_sb_list_del (inode); +spin_unlock (&inode_lock); +if (op->evict_inode) { op->evict_inode (inode); }else {
@@ -452,6 +462,15 @@ static void evict(struct inode *inode)bd_forget (inode);if (S_ISCHR (inode->i_mode) && inode->i_cdev)cd_forget (inode); + +remove_inode_hash (inode); + +spin_lock (&inode->i_lock); +wake_up_bit (&inode->i_state, __I_NEW); +BUG_ON (inode->i_state != (I_FREEING |I_CLEAR )); +spin_unlock (&inode->i_lock); + +destroy_inode (inode); }/*
@@ -470,16 +489,6 @@ static void dispose_list(struct list_head *head)list_del_init (&inode->i_lru);evict (inode); - -spin_lock (&inode_lock); -__remove_inode_hash (inode); -__inode_sb_list_del (inode); -spin_unlock (&inode_lock); - -spin_lock (&inode->i_lock); -wake_up_bit (&inode->i_state, __I_NEW); -spin_unlock (&inode->i_lock); -destroy_inode (inode); } }
@@ -517,11 +526,10 @@ void evict_inodes(struct super_block *sb)spin_unlock (&inode->i_lock);/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is set so that it +* won't get moved back on. */ list_move (&inode->i_lru, &dispose); -list_del_init (&inode->i_wb_list); }spin_unlock (&inode_lock);
@@ -563,11 +571,10 @@ int invalidate_inodes(struct super_block *sb)spin_unlock (&inode->i_lock);/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is +* set so that it won't get moved back on. */ list_move (&inode->i_lru, &dispose); -list_del_init (&inode->i_wb_list); }spin_unlock (&inode_lock);
@@ -666,11 +673,10 @@ static void prune_icache(int nr_to_scan)spin_unlock (&inode->i_lock);/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is +* set so that it won't get moved back on. */ list_move (&inode->i_lru, &freeable); -list_del_init (&inode->i_wb_list);percpu_counter_dec (&nr_inodes_unused); }if (current_is_kswapd ())
@@ -1401,16 +1407,16 @@ static void iput_final(struct inode *inode)else drop =generic_drop_inode (inode); +if (!drop && (sb->s_flags &MS_ACTIVE )) { + inode->i_state |=I_REFERENCED ; +if (!(inode->i_state & (I_DIRTY |I_SYNC ))) +inode_lru_list_add (inode); +spin_unlock (&inode->i_lock); +spin_unlock (&inode_lock); +return ; + } +if (!drop) { -if (sb->s_flags &MS_ACTIVE ) { - inode->i_state |=I_REFERENCED ; -if (!(inode->i_state & (I_DIRTY |I_SYNC ))) { -inode_lru_list_add (inode); - } -spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock); -return ; - } inode->i_state |=I_WILL_FREE ;spin_unlock (&inode->i_lock);spin_unlock (&inode_lock);
@@ -1419,28 +1425,14 @@ static void iput_final(struct inode *inode)spin_lock (&inode->i_lock);WARN_ON (inode->i_state &I_NEW ); inode->i_state &= ~I_WILL_FREE ; -__remove_inode_hash (inode); } inode->i_state |=I_FREEING ; -spin_unlock (&inode->i_lock); - -/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. -*/ inode_lru_list_del (inode); -list_del_init (&inode->i_wb_list); - -__inode_sb_list_del (inode); +spin_unlock (&inode->i_lock);spin_unlock (&inode_lock); +evict (inode); -remove_inode_hash (inode); -spin_lock (&inode->i_lock); -wake_up_bit (&inode->i_state, __I_NEW); -BUG_ON (inode->i_state != (I_FREEING |I_CLEAR )); -spin_unlock (&inode->i_lock); -destroy_inode (inode); }/**
Signature · 1 line
1.7.1
Al Viro
maintainerRe: [PATCH 2/8] fs: factor inode disposal
fs/inode.c void evict_inodes(struct super_block *sb) · line 524
Quoted 8 lines · Dave Chinner
fs/inode.c +2
-3/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is set so that it +* won't get moved back on. */ list_move (&inode->i_lru, &dispose); -list_del_init (&inode->i_wb_list);
a) OK, so you've killed that list_del_init(). Good.
b) The comment is completely misleading. We don't put I_FREEING inodes back on LRU (or IO) lists, no matter where we find them. What's happening here is that we are collecting inodes to evict, period.
fs/inode.c int invalidate_inodes(struct super_block *sb) · line 575
Quoted 4 lines
fs/inode.c +2
-2-* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is +* set so that it won't get moved back on.
Ditto.
fs/inode.c int invalidate_inodes(struct super_block *sb) · line 576
Quoted 6 lines
fs/inode.c +2
-2/* -* Move the inode off the IO lists and LRU once I_FREEING is -* set so that it won't get moved back on there if it is dirty. +* Move the inode off the LRU once I_FREEING is +* set so that it won't get moved back on. */
Ditto.
PATCH 3/8 fs: Lock the inode LRU list separately
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Introduce the inode_lru_lock to protect the inode_lru list. This lock is nested inside the inode->i_lock to allow the inode to be added to the LRU list in iput_final without needing to deal with lock inversions. This keeps iput_final() clean and neat.
Further, where marking the inode I_FREEING and removing it from the LRU, move the LRU list manipulation within the inode->i_lock to keep the list manipulation consistent with iput_final. This also means that most of the open coded LRU list removal + unused inode accounting can now use the inode_lru_list_del() wrappers which cleans the code up further.
However, this locking change means what the LRU traversal in prune_icache() inverts this lock ordering and needs to use trylock semantics on the inode->i_lock to avoid deadlocking. In these cases, if we fail to lock the inode we move it to the back of the LRU to prevent spinning on it.
--- fs/inode.c | 47 ++++++++++++++++++++++++++++++----------------- 1 files changed, 30 insertions(+), 17 deletions(-)
fs/inode.c +30 -17
@@ -30,10 +30,13 @@* * inode->i_lock protects: * inode->i_state, __iget() +* inode_lru_lock protects: +* inode_lru, inode->i_lru * * Lock ordering: * inode_lock * inode->i_lock +* inode_lru_lock */ /*
@@ -83,6 +86,7 @@ static unsigned int i_hash_shift __read_mostly;*/ static LIST_HEAD (inode_lru); +static DEFINE_SPINLOCK (inode_lru_lock);static struct hlist_head *inode_hashtable__read_mostly ;/*
@@ -334,18 +338,22 @@ EXPORT_SYMBOL(ihold);static void inode_lru_list_add (struct inode *inode) { +spin_lock (&inode_lru_lock);if (list_empty (&inode->i_lru)) {list_add (&inode->i_lru, &inode_lru);percpu_counter_inc (&nr_inodes_unused); } +spin_unlock (&inode_lru_lock); }static void inode_lru_list_del (struct inode *inode) { +spin_lock (&inode_lru_lock);if (!list_empty (&inode->i_lru)) {list_del_init (&inode->i_lru);percpu_counter_dec (&nr_inodes_unused); } +spin_unlock (&inode_lru_lock); }static inline void __inode_sb_list_add (struct inode *inode)
@@ -521,15 +529,10 @@ void evict_inodes(struct super_block *sb) } inode->i_state |=I_FREEING ; -if (!(inode->i_state & (I_DIRTY |I_SYNC ))) -percpu_counter_dec (&nr_inodes_unused); +inode_lru_list_del (inode);spin_unlock (&inode->i_lock); -/* -* Move the inode off the LRU once I_FREEING is set so that it -* won't get moved back on. -*/ -list_move (&inode->i_lru, &dispose); +list_add (&inode->i_lru, &dispose); }spin_unlock (&inode_lock);
@@ -566,15 +569,10 @@ int invalidate_inodes(struct super_block *sb) } inode->i_state |=I_FREEING ; -if (!(inode->i_state & (I_DIRTY |I_SYNC ))) -percpu_counter_dec (&nr_inodes_unused); +inode_lru_list_del (inode);spin_unlock (&inode->i_lock); -/* -* Move the inode off the LRU once I_FREEING is -* set so that it won't get moved back on. -*/ -list_move (&inode->i_lru, &dispose); +list_add (&inode->i_lru, &dispose); }spin_unlock (&inode_lock);
@@ -599,7 +597,7 @@ static int can_unuse(struct inode *inode)/* * Scan `goal' inodes on the unused list for freeable ones. They are moved to a -* temporary list and then are freed outside inode_lock by dispose_list(). +* temporary list and then are freed outside inode_lru_lock by dispose_list(). * * Any inodes which are pinned purely because of attached pagecache have their * pagecache removed. If the inode has metadata buffers attached to
@@ -621,6 +619,7 @@ static void prune_icache(int nr_to_scan)down_read (&iprune_sem);spin_lock (&inode_lock); +spin_lock (&inode_lru_lock);for (nr_scanned =0 ; nr_scanned < nr_to_scan; nr_scanned++) {struct inode *inode;
@@ -630,10 +629,19 @@ static void prune_icache(int nr_to_scan) inode = list_entry(inode_lru.prev, struct inode, i_lru);/* +* we are inverting the inode_lru_lock/inode->i_lock here, +* so use a trylock. If we fail to get the lock, just move the +* inode to the back of the list so we don't spin on it. +*/ +if (!spin_trylock (&inode->i_lock)) { +list_move (&inode->i_lru, &inode_lru); +continue ; + } + +/* * Referenced or dirty inodes are still in use. Give them * another pass through the LRU as we canot reclaim them now. */ -spin_lock (&inode->i_lock);if (atomic_read (&inode->i_count) || (inode->i_state & ~I_REFERENCED )) {spin_unlock (&inode->i_lock);
@@ -652,17 +660,21 @@ static void prune_icache(int nr_to_scan)if (inode_has_buffers (inode) || inode->i_data.nrpages) {__iget (inode);spin_unlock (&inode->i_lock); +spin_unlock (&inode_lru_lock);spin_unlock (&inode_lock);if (remove_inode_buffers (inode)) reap +=invalidate_mapping_pages (&inode->i_data,0 ,-1 );iput (inode);spin_lock (&inode_lock); +spin_lock (&inode_lru_lock);if (inode !=list_entry (inode_lru.next, struct inode, i_lru))continue ;/* wrong inode or list_empty */ -spin_lock (&inode->i_lock); +/* avoid lock inversions with trylock */ +if (!spin_trylock (&inode->i_lock)) +continue ;if (!can_unuse (inode)) {spin_unlock (&inode->i_lock);continue ;
@@ -683,6 +695,7 @@ static void prune_icache(int nr_to_scan)__count_vm_events (KSWAPD_INODESTEAL , reap); else__count_vm_events (PGINODESTEAL ,reap ); +spin_unlock (&inode_lru_lock);spin_unlock (&inode_lock);dispose_list (&freeable);
Signature · 1 line
1.7.1
PATCH 4/8 fs: remove inode_lock from iput_final and prune_icache
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that inode state changes are protected by the inode->i_lock and the inode LRU manipulations by the inode_lru_lock, we can remove the inode_lock from prune_icache and the initial part of iput_final().
instead of using the inode_lock to protect the inode during iput_final, use the inode->i_lock instead. This protects the inode against new references being taken while we change the inode state to I_FREEING, as well as preventing prune_icache from grabbing the inode while we are manipulating it. Hence we no longer need the inode_lock in iput_final prior to setting I_FREEING on the inode.
For prune_icache, we no longer need the inode_lock to protect the LRU list, and the inodes themselves are protected against freeing races by the inode->i_lock. Hence we can lift the inode_lock from prune_icache as well.
--- fs/inode.c | 17 +++-------------- 1 files changed, 3 insertions(+), 14 deletions(-)
fs/inode.c +3 -14
@@ -618,7 +618,6 @@ static void prune_icache(int nr_to_scan)unsigned long reap =0 ;down_read (&iprune_sem); -spin_lock (&inode_lock);spin_lock (&inode_lru_lock);for (nr_scanned =0 ; nr_scanned < nr_to_scan; nr_scanned++) {struct inode *inode;
@@ -644,8 +643,8 @@ static void prune_icache(int nr_to_scan)*/ if (atomic_read (&inode->i_count) || (inode->i_state & ~I_REFERENCED )) { -spin_unlock (&inode->i_lock);list_del_init (&inode->i_lru); +spin_unlock (&inode->i_lock);percpu_counter_dec (&nr_inodes_unused);continue ; }
@@ -653,20 +652,18 @@ static void prune_icache(int nr_to_scan)/* recently referenced inodes get one more pass */ if (inode->i_state &I_REFERENCED ) { inode->i_state &= ~I_REFERENCED ; -spin_unlock (&inode->i_lock);list_move (&inode->i_lru, &inode_lru); +spin_unlock (&inode->i_lock);continue ; } if (inode_has_buffers(inode) || inode->i_data.nrpages) { __iget(inode); spin_unlock(&inode->i_lock); spin_unlock(&inode_lru_lock); - spin_unlock(&inode_lock); if (remove_inode_buffers(inode)) reap += invalidate_mapping_pages(&inode->i_data, 0, -1); iput(inode); - spin_lock(&inode_lock); spin_lock(&inode_lru_lock); if (inode != list_entry(inode_lru.next,
@@ -696,7 +693,6 @@ static void prune_icache(int nr_to_scan)else __count_vm_events (PGINODESTEAL , reap);spin_unlock (&inode_lru_lock); -spin_unlock (&inode_lock);dispose_list (&freeable);up_read (&iprune_sem);
@@ -1054,7 +1050,6 @@ EXPORT_SYMBOL(iunique);struct inode *igrab (struct inode *inode) { -spin_lock (&inode_lock);spin_lock (&inode->i_lock);if (!(inode->i_state & (I_FREEING |I_WILL_FREE ))) {__iget (inode);
@@ -1068,7 +1063,6 @@ struct inode *igrab(struct inode *inode)*/ inode =NULL ; } -spin_unlock (&inode_lock);return inode; }EXPORT_SYMBOL (igrab);
@@ -1412,7 +1406,6 @@ static void iput_final(struct inode *inode)const struct super_operations *op = inode->i_sb->s_op;int drop; -spin_lock (&inode->i_lock);WARN_ON (inode->i_state &I_NEW );if (op && op->drop_inode)
@@ -1425,16 +1418,13 @@ static void iput_final(struct inode *inode)if (!(inode->i_state & (I_DIRTY |I_SYNC )))inode_lru_list_add (inode);spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock);return ; }if (!drop) { inode->i_state |=I_WILL_FREE ;spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock);write_inode_now (inode,1 ); -spin_lock (&inode_lock);spin_lock (&inode->i_lock);WARN_ON (inode->i_state &I_NEW ); inode->i_state &= ~I_WILL_FREE ;
@@ -1443,7 +1433,6 @@ static void iput_final(struct inode *inode) inode->i_state |=I_FREEING ;inode_lru_list_del (inode);spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock);evict (inode); }
@@ -1462,7 +1451,7 @@ void iput(struct inode *inode)if (inode) {BUG_ON (inode->i_state &I_CLEAR ); -if (atomic_dec_and_lock (&inode->i_count, &inode_lock)) +if (atomic_dec_and_lock (&inode->i_count, &inode->i_lock))iput_final (inode); } }
Signature · 1 line
1.7.1
Al Viro
maintainerRe: [PATCH 4/8] fs: remove inode_lock from iput_final and prune_icache
Quoted 13 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Now that inode state changes are protected by the
inode->i_lockand the inode LRU manipulations by theinode_lru_lock, we can remove theinode_lockfromprune_icacheand the initial part ofiput_final().instead of using the
inode_lockto protect the inode duringiput_final, use theinode->i_lockinstead. This protects the inode against new references being taken while we change the inode state toI_FREEING, as well as preventingprune_icachefrom grabbing the inode while we are manipulating it. Hence we no longer need theinode_lockiniput_finalprior to settingI_FREEINGon the inode.
Quoted 4 lines
For
prune_icache, we no longer need theinode_lockto protect the LRU list, and the inodes themselves are protected against freeing races by theinode->i_lock. Hence we can lift theinode_lockfromprune_icacheas well.
Careful. At that point we still rely on inode_lock to protectinode_unhashed(). Note that ->drop_inode() uses it a lot and this step moves it from inode_lock to ->i_lock.
What you need to do is pretty simple - make remove_inode_hash()
take both inode_lock (later - inode_hash_lock) and ->i_lock. That's enough for inode_unhashed() protection, but I'd also hold ->i_lock on insertions into hash. It's trivial (we hold ->i_lock just next to that insertion) and would make for more consistent rules.
PATCH 5/8 fs: move i_sb_list out from under inode_lock
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Protect the per-sb inode list with a new global lock inode_sb_list_lock and use it to protect the list manipulations and traversals. This lock replaces the inode_lock as the inodes on the list can be validity checked while holding the inode->i_lock and hence the inode_lock is no longer needed to protect the list.
--- fs/drop_caches.c | 9 +++++---- fs/fs-writeback.c | 21 +++++++++++---------- fs/inode.c | 43 +++++++++++++++++++++++-------------------- fs/internal.h | 2 ++ fs/notify/inode_mark.c | 15 ++++++++------- fs/quota/dquot.c | 28 ++++++++++++++++------------ 6 files changed, 65 insertions(+), 53 deletions(-)
fs/drop_caches.c +5 -4
@@ -8,6 +8,7 @@#include <linux/writeback.h> #include <linux/sysctl.h> #include <linux/gfp.h> +#include "internal.h" /* A global variable is a bit ugly, but it keeps the code simple */ int sysctl_drop_caches;
@@ -16,7 +17,7 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused) {struct inode *inode, *toput_inode =NULL ; -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock);list_for_each_entry (inode, &sb->s_inodes, i_sb_list) {spin_lock (&inode->i_lock); if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
@@ -26,13 +27,13 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused) }__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);invalidate_mapping_pages (inode->i_mapping,0 ,-1 );iput (toput_inode); toput_inode = inode; -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock); } -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);iput (toput_inode); }
fs/fs-writeback.c +11 -10
@@ -1053,7 +1053,7 @@ static void wait_sb_inodes(struct super_block *sb)*/ WARN_ON (!rwsem_is_locked (&sb->s_umount)); -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock);/* * Data integrity sync. Must wait for all pages under writeback,
@@ -1073,14 +1073,15 @@ static void wait_sb_inodes(struct super_block *sb) }__iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock); +/* -* We hold a reference to 'inode' so it couldn't have -* been removed from s_inodes list while we dropped the -* inode_lock. We cannot iput the inode now as we can -* be holding the last reference and we cannot iput it -* under inode_lock. So we keep the reference and iput -* it later. +* We hold a reference to 'inode' so it couldn't have been +* removed from s_inodes list while we dropped the +* inode_sb_list_lock. We cannot iput the inode now as we can +* be holding the last reference and we cannot iput it under +* inode_sb_list_lock. So we keep the reference and iput it +* later. */ iput (old_inode); old_inode = inode;
@@ -1089,9 +1090,9 @@ static void wait_sb_inodes(struct super_block *sb)cond_resched (); -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock); } -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);iput (old_inode); }
fs/inode.c +23 -20
132 lines not on this page · raw message
fs/internal.h +2 -0
@@ -108,3 +108,5 @@ extern void release_open_intent(struct nameidata *);extern int get_nr_dirty_inodes (void );extern int evict_inodes (struct super_block *);extern int invalidate_inodes (struct super_block *); + +extern spinlock_t inode_sb_list_lock;
fs/notify/inode_mark.c +8 -7
@@ -29,6 +29,8 @@#include <linux/fsnotify_backend.h> #include "fsnotify.h" +#include "../internal.h" +/* * Recalculate the mask of events relevant to a given inode locked. */
@@ -232,15 +234,14 @@ out:* fsnotify_unmount_inodes - an sb is unmounting. handle any watched inodes. * @list: list of inodes being unmounted (sb->s_inodes) * -* Called with inode_lock held, protecting the unmounting super block's list -* of inodes, and with iprune_mutex held, keeping shrink_icache_memory() at bay. -* We temporarily drop inode_lock, however, and CAN block. +* Called during unmount with no locks held, so needs to be safe against +* concurrent modifiers. We temporarily drop inode_sb_list_lock and CAN block. */ void fsnotify_unmount_inodes (struct list_head *list) {struct inode *inode, *next_i, *need_iput =NULL ; -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock);list_for_each_entry_safe (inode, next_i, list, i_sb_list) {struct inode *need_iput_tmp;
@@ -293,7 +294,7 @@ void fsnotify_unmount_inodes(struct list_head *list)* will be added since the umount has begun. Finally, * iprune_mutex keeps shrink_icache_memory() away. */ -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);if (need_iput_tmp)iput (need_iput_tmp);
@@ -305,7 +306,7 @@ void fsnotify_unmount_inodes(struct list_head *list)iput (inode); -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock); } -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock); }
fs/quota/dquot.c +16 -12
@@ -76,7 +76,7 @@#include <linux/buffer_head.h> #include <linux/capability.h> #include <linux/quotaops.h> -#include <linux/writeback.h> /* for inode_lock, oddly enough.. */ +#include "../internal.h" /* ugh */ #include <asm/uaccess.h>
@@ -896,7 +896,7 @@ static void add_dquot_ref(struct super_block *sb, int type)int reserved =0 ;#endif -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock);list_for_each_entry (inode, &sb->s_inodes, i_sb_list) {spin_lock (&inode->i_lock); if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
@@ -911,19 +911,23 @@ static void add_dquot_ref(struct super_block *sb, int type)#endif __iget (inode);spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);iput (old_inode);__dquot_initialize (inode, type); -/* We hold a reference to 'inode' so it couldn't have been -* removed from s_inodes list while we dropped the inode_lock. -* We cannot iput the inode now as we can be holding the last -* reference and we cannot iput it under inode_lock. So we -* keep the reference and iput it later. */ + +/* +* We hold a reference to 'inode' so it couldn't have been +* removed from s_inodes list while we dropped the +* inode_sb_list_lock We cannot iput the inode now as we can be +* holding the last reference and we cannot iput it under +* inode_sb_list_lock. So we keep the reference and iput it +* later. +*/ old_inode = inode; -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock); } -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);iput (old_inode);#ifdef CONFIG_QUOTA_DEBUG
@@ -1004,7 +1008,7 @@ static void remove_dquot_ref(struct super_block *sb, int type,struct inode *inode;int reserved =0 ; -spin_lock (&inode_lock); +spin_lock (&inode_sb_list_lock);list_for_each_entry (inode, &sb->s_inodes, i_sb_list) {/* * We have to scan also I_NEW inodes because they can already
@@ -1018,7 +1022,7 @@ static void remove_dquot_ref(struct super_block *sb, int type,remove_inode_dquot_ref (inode, type, tofree_head); } } -spin_unlock (&inode_lock); +spin_unlock (&inode_sb_list_lock);#ifdef CONFIG_QUOTA_DEBUG if (reserved) { printk(KERN_WARNING "VFS (%s): Writes happened after quota"
Signature · 1 line
1.7.1
PATCH 6/8 fs: move i_wb_list out from under inode_lock
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Protect the inode writeback list with a new global lock inode_wb_list_lock and use it to protect the list manipulations and traversals. This lock replaces the inode_lock as the inodes on the list can be validity checked while holding the inode->i_lock and hence the inode_lock is no longer needed to protect the list.
--- fs/block_dev.c | 4 +- fs/fs-writeback.c | 76 ++++++++++++++++++++++++++------------------- fs/inode.c | 12 +++++-- fs/internal.h | 7 +++- include/linux/writeback.h | 1 + mm/backing-dev.c | 8 ++-- 6 files changed, 65 insertions(+), 43 deletions(-)
fs/block_dev.c +2 -2
@@ -56,11 +56,11 @@ EXPORT_SYMBOL(I_BDEV);static void bdev_inode_switch_bdi (struct inode *inode,struct backing_dev_info *dst) { -spin_lock (&inode_lock); +spin_lock (&inode_wb_list_lock); inode->i_data.backing_dev_info = dst;if (inode->i_state &I_DIRTY )list_move (&inode->i_wb_list, &dst->wb.b_dirty); -spin_unlock (&inode_lock); +spin_unlock (&inode_wb_list_lock); }static sector_t max_block (struct block_device *bdev)
fs/fs-writeback.c +44 -32
238 lines not on this page · raw message
fs/inode.c +8 -4
@@ -24,6 +24,7 @@#include <linux/mount.h> #include <linux/async.h> #include <linux/posix_acl.h> +#include "internal.h" /* * inode locking rules.
@@ -34,6 +35,8 @@* inode_lru, inode->i_lru * inode_sb_list_lock protects: * sb->s_inodes, inode->i_sb_list +* inode_sb_list_lock protects: +* bdi->wb.b_{dirty,io,more_io}, inode->i_wb_list * * Lock ordering: * inode_lock
@@ -42,6 +45,9 @@* inode_sb_list_lock * inode->i_lock * inode_lru_lock +* +* inode_wb_list_lock +* inode->i_lock */ /*
@@ -103,6 +109,7 @@ static struct hlist_head *inode_hashtable __read_mostly;DEFINE_SPINLOCK (inode_lock);__cacheline_aligned_in_smp DEFINE_SPINLOCK (inode_sb_list_lock ); +__cacheline_aligned_in_smp DEFINE_SPINLOCK (inode_wb_list_lock );/* * iprune_sem provides exclusion between the kswapd or try_to_free_pages
@@ -458,10 +465,7 @@ static void evict(struct inode *inode)BUG_ON (!(inode->i_state &I_FREEING ));BUG_ON (!list_empty (&inode->i_lru)); -spin_lock (&inode_lock); -list_del_init (&inode->i_wb_list); -spin_unlock (&inode_lock); - +inode_wb_list_del (inode);inode_sb_list_del (inode);if (op->evict_inode) {
fs/internal.h +6 -1
@@ -106,7 +106,12 @@ extern void release_open_intent(struct nameidata *);* inode.c */ extern int get_nr_dirty_inodes (void ); -extern int evict_inodes (struct super_block *); +extern void evict_inodes (struct super_block *);extern int invalidate_inodes (struct super_block *);extern spinlock_t inode_sb_list_lock; + +/* +* fs-writeback.c +*/ +extern void inode_wb_list_del (struct inode *inode);
include/linux/writeback.h +1 -0
@@ -10,6 +10,7 @@struct backing_dev_info ;extern spinlock_t inode_lock; +extern spinlock_t inode_wb_list_lock;/* * fs/fs-writeback.c
mm/backing-dev.c +4 -4
@@ -73,14 +73,14 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)struct inode *inode; nr_wb = nr_dirty = nr_io = nr_more_io =0 ; -spin_lock (&inode_lock); +spin_lock (&inode_wb_list_lock);list_for_each_entry (inode, &wb->b_dirty, i_wb_list) nr_dirty++;list_for_each_entry (inode, &wb->b_io, i_wb_list) nr_io++;list_for_each_entry (inode, &wb->b_more_io, i_wb_list) nr_more_io++; -spin_unlock (&inode_lock); +spin_unlock (&inode_wb_list_lock);global_dirty_limits (&background_thresh, &dirty_thresh); bdi_thresh =bdi_dirty_limit (bdi, dirty_thresh);
@@ -682,11 +682,11 @@ void bdi_destroy(struct backing_dev_info *bdi)if (bdi_has_dirty_io (bdi)) {struct bdi_writeback *dst = &default_backing_dev_info.wb; -spin_lock (&inode_lock); +spin_lock (&inode_wb_list_lock);list_splice (&bdi->wb.b_dirty, &dst->b_dirty);list_splice (&bdi->wb.b_io, &dst->b_io);list_splice (&bdi->wb.b_more_io, &dst->b_more_io); -spin_unlock (&inode_lock); +spin_unlock (&inode_wb_list_lock); }bdi_unregister (bdi);
Signature · 1 line
1.7.1
PATCH 7/8 fs: rename inode_lock to inode_hash_lock
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
All that remains of the inode_lock is protecting the inode hash list manipulation and traversals. Rename the inode_lock to inode_hash_lock to reflect it's actual function.
--- fs/inode.c | 86 +++++++++++++++++++++++--------------------- fs/notify/inode_mark.c | 1 - fs/notify/mark.c | 1 - fs/notify/vfsmount_mark.c | 1 - include/linux/writeback.h | 1 - 5 files changed, 45 insertions(+), 45 deletions(-)
fs/inode.c +45 -41
@@ -37,10 +37,10 @@* sb->s_inodes, inode->i_sb_list * inode_sb_list_lock protects: * bdi->wb.b_{dirty,io,more_io}, inode->i_wb_list +* inode_hash_lock protects: +* inode_hashtable, inode->i_hash * * Lock ordering: -* inode_lock -* inode->i_lock * * inode_sb_list_lock * inode->i_lock
@@ -48,6 +48,13 @@* * inode_wb_list_lock * inode->i_lock +* +* inode_hash_lock +* inode_sb_list_lock +* inode->i_lock +* +* iunique_lock +* inode_hash_lock */ /*
@@ -83,6 +90,8 @@static unsigned int i_hash_mask__read_mostly ;static unsigned int i_hash_shift__read_mostly ; +static struct hlist_head *inode_hashtable__read_mostly ; +static __cacheline_aligned_in_smp DEFINE_SPINLOCK (inode_hash_lock );/* * Each inode can be on two separate lists. One is
@@ -98,15 +107,6 @@ static unsigned int i_hash_shift __read_mostly;static LIST_HEAD (inode_lru);static DEFINE_SPINLOCK (inode_lru_lock); -static struct hlist_head *inode_hashtable__read_mostly ; - -/* -* A simple spinlock to protect the list manipulations. -* -* NOTE! You also have to own the lock if you change -* the i_state of an inode while it is in use.. -*/ -DEFINE_SPINLOCK (inode_lock);__cacheline_aligned_in_smp DEFINE_SPINLOCK (inode_sb_list_lock );__cacheline_aligned_in_smp DEFINE_SPINLOCK (inode_wb_list_lock );
@@ -411,9 +411,9 @@ void __insert_inode_hash(struct inode *inode, unsigned long hashval) {struct hlist_head *b = inode_hashtable +hash (inode->i_sb, hashval); -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);hlist_add_head (&inode->i_hash, b); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock); }EXPORT_SYMBOL (__insert_inode_hash);
@@ -425,9 +425,9 @@ EXPORT_SYMBOL(__insert_inode_hash);*/ void remove_inode_hash (struct inode *inode) { -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);hlist_del_init (&inode->i_hash); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock); }EXPORT_SYMBOL (remove_inode_hash);
@@ -913,7 +913,7 @@ static struct inode *get_new_inode(struct super_block *sb,if (inode) {struct inode *old; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);/* We released the lock, so.. */ old =find_inode (sb, head, test, data);if (!old) {
@@ -923,9 +923,10 @@ static struct inode *get_new_inode(struct super_block *sb,spin_lock (&inode->i_lock); inode->i_state =I_NEW ;spin_unlock (&inode->i_lock); -hlist_add_head (&inode->i_hash, head); +inode_sb_list_add (inode); -spin_unlock (&inode_lock); +hlist_add_head (&inode->i_hash, head); +spin_unlock (&inode_hash_lock);/* Return the locked inode with I_NEW set, the * caller is responsible for filling in the contents
@@ -938,7 +939,7 @@ static struct inode *get_new_inode(struct super_block *sb,* us. Use the old inode instead of the one we just * allocated. */ -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);destroy_inode (inode); inode = old;wait_on_inode (inode);
@@ -946,7 +947,7 @@ static struct inode *get_new_inode(struct super_block *sb,return inode; set_failed: -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);destroy_inode (inode);return NULL ; }
@@ -964,7 +965,7 @@ static struct inode *get_new_inode_fast(struct super_block *sb,if (inode) {struct inode *old; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);/* We released the lock, so.. */ old =find_inode_fast (sb, head, ino);if (!old) {
@@ -972,9 +973,10 @@ static struct inode *get_new_inode_fast(struct super_block *sb, inode->i_ino = ino; inode->i_state =I_NEW ;spin_unlock (&inode->i_lock); -hlist_add_head (&inode->i_hash, head); +inode_sb_list_add (inode); -spin_unlock (&inode_lock); +hlist_add_head (&inode->i_hash, head); +spin_unlock (&inode_hash_lock);/* Return the locked inode with I_NEW set, the * caller is responsible for filling in the contents
@@ -987,7 +989,7 @@ static struct inode *get_new_inode_fast(struct super_block *sb,* us. Use the old inode instead of the one we just * allocated. */ -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);destroy_inode (inode); inode = old;wait_on_inode (inode);
@@ -1008,10 +1010,14 @@ static int test_inode_iunique(struct super_block *sb, unsigned long ino)struct hlist_node *node;struct inode *inode; +spin_lock (&inode_hash_lock);hlist_for_each_entry (inode, node, b, i_hash) { -if (inode->i_ino == ino && inode->i_sb == sb) +if (inode->i_ino == ino && inode->i_sb == sb) { +spin_unlock (&inode_hash_lock);return 0 ; + } } +spin_unlock (&inode_hash_lock);return 1 ; }
@@ -1041,7 +1047,6 @@ ino_t iunique(struct super_block *sb, ino_t max_reserved)static unsigned int counter;ino_t res; -spin_lock (&inode_lock);spin_lock (&iunique_lock); do { if (counter <= max_reserved)
@@ -1049,7 +1054,6 @@ ino_t iunique(struct super_block *sb, ino_t max_reserved) res = counter++; }while (!test_inode_iunique (sb, res));spin_unlock (&iunique_lock); -spin_unlock (&inode_lock);return res; }
@@ -1099,15 +1103,15 @@ static struct inode *ifind(struct super_block *sb, {struct inode *inode; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock); inode =find_inode (sb, head, test, data);if (inode) { -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);if (likely (wait))wait_on_inode (inode);return inode; } -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);return NULL ; }
@@ -1131,14 +1135,14 @@ static struct inode *ifind_fast(struct super_block *sb, {struct inode *inode; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock); inode =find_inode_fast (sb, head, ino);if (inode) { -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);wait_on_inode (inode);return inode; } -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);return NULL ; }
@@ -1303,7 +1307,7 @@ int insert_inode_locked(struct inode *inode)while (1 ) {struct hlist_node *node;struct inode *old =NULL ; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);hlist_for_each_entry (old, node, head, i_hash) {if (old->i_ino != ino)continue ;
@@ -1318,12 +1322,12 @@ int insert_inode_locked(struct inode *inode) }if (likely (!node)) {hlist_add_head (&inode->i_hash, head); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);return 0 ; }__iget (old);spin_unlock (&old->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);wait_on_inode (old);if (unlikely (!inode_unhashed (old))) {iput (old);
@@ -1348,7 +1352,7 @@ int insert_inode_locked4(struct inode *inode, unsigned long hashval,struct hlist_node *node;struct inode *old =NULL ; -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock);hlist_for_each_entry (old, node, head, i_hash) {if (old->i_sb != sb)continue ;
@@ -1363,12 +1367,12 @@ int insert_inode_locked4(struct inode *inode, unsigned long hashval, }if (likely (!node)) {hlist_add_head (&inode->i_hash, head); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);return 0 ; }__iget (old);spin_unlock (&old->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);wait_on_inode (old);if (unlikely (!inode_unhashed (old))) {iput (old);
@@ -1647,10 +1651,10 @@ static void __wait_on_freeing_inode(struct inode *inode) wq =bit_waitqueue (&inode->i_state, __I_NEW);prepare_to_wait (wq, &wait.wait,TASK_UNINTERRUPTIBLE );spin_unlock (&inode->i_lock); -spin_unlock (&inode_lock); +spin_unlock (&inode_hash_lock);schedule ();finish_wait (wq, &wait.wait); -spin_lock (&inode_lock); +spin_lock (&inode_hash_lock); }static __initdata unsigned long ihash_entries;
fs/notify/inode_mark.c +0 -1
@@ -22,7 +22,6 @@#include <linux/module.h> #include <linux/mutex.h> #include <linux/spinlock.h> -#include <linux/writeback.h> /* for inode_lock */ #include <asm/atomic.h>
fs/notify/mark.c +0 -1
@@ -91,7 +91,6 @@#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/srcu.h> -#include <linux/writeback.h> /* for inode_lock */ #include <asm/atomic.h>
fs/notify/vfsmount_mark.c +0 -1
@@ -23,7 +23,6 @@#include <linux/mount.h> #include <linux/mutex.h> #include <linux/spinlock.h> -#include <linux/writeback.h> /* for inode_lock */ #include <asm/atomic.h>
include/linux/writeback.h +0 -1
@@ -9,7 +9,6 @@struct backing_dev_info ; -extern spinlock_t inode_lock;extern spinlock_t inode_wb_list_lock;/*
Signature · 1 line
1.7.1
PATCH 8/8 fs: Clean up documentation references to inode_lock
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
--- Documentation/filesystems/Locking | 2 +- Documentation/filesystems/porting | 11 ++++++----- Documentation/filesystems/vfs.txt | 2 +- fs/buffer.c | 2 +- fs/logfs/inode.c | 2 +- fs/notify/inode_mark.c | 5 ++--- fs/ntfs/inode.c | 4 ++-- include/linux/fs.h | 2 +- include/linux/quotaops.h | 2 +- mm/filemap.c | 8 +++++--- mm/rmap.c | 7 ++++--- 11 files changed, 25 insertions(+), 22 deletions(-)
Documentation/filesystems/Locking +1 -1
@@ -114,7 +114,7 @@ alloc_inode: destroy_inode: dirty_inode: (must not sleep) write_inode: -drop_inode: !!!inode_lock!!! +drop_inode: !!!inode->i_lock!!! evict_inode: put_super: write write_super: read
Documentation/filesystems/porting +6 -5
@@ -299,11 +299,12 @@ be used instead. It gets called whenever the inode is evicted, whether it has remaining links or not. Caller does *not* evict the pagecache or inode-associated metadata buffers; getting rid of those is responsibility of method, as it had been for ->delete_inode(). - ->drop_inode() returns int now; it's called on final iput() with inode_lock -held and it returns true if filesystems wants the inode to be dropped. As before, -generic_drop_inode() is still the default and it's been updated appropriately. -generic_delete_inode() is also alive and it consists simply of return 1. Note that -all actual eviction work is done by caller after ->drop_inode() returns. + ->drop_inode() returns int now; it's called on final iput() with +inode->i_lock held and it returns true if the filesystem wants the inode to be +dropped. As before, generic_drop_inode() is still the default and it's been +updated appropriately. generic_delete_inode() is also alive and it consists +simply of return 1. Note that all actual eviction work is done by caller after +->drop_inode() returns. clear_inode() is gone; use end_writeback() instead. As before, it must be called exactly once on each call of ->evict_inode() (as it used to be for each call of ->delete_inode()). Unlike before, if you are using inode-associated
Documentation/filesystems/vfs.txt +1 -1
@@ -246,7 +246,7 @@ or bottom half). should be synchronous or not, not all filesystems check this flag. drop_inode: called when the last access to the inode is dropped, - with the inode_lock spinlock held. + with the inode->i_lock spinlock held. This method should be either NULL (normal UNIX filesystem semantics) or "generic_delete_inode" (for filesystems that do not
fs/buffer.c +1 -1
@@ -1144,7 +1144,7 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)* inode list. * * mark_buffer_dirty() is atomic. It takes bh->b_page->mapping->private_lock, -* mapping->tree_lock and the global inode_lock. +* mapping->tree_lock, inode->i_lock and the global inode_wb_list_lock. */ void mark_buffer_dirty (struct buffer_head *bh) {
fs/logfs/inode.c +1 -1
@@ -286,7 +286,7 @@ static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)return ret; } -/* called with inode_lock held */ +/* called with inode->i_lock held */ static int logfs_drop_inode (struct inode *inode) {struct logfs_super *super =logfs_super (inode->i_sb);
fs/notify/inode_mark.c +2 -3
@@ -288,10 +288,9 @@ void fsnotify_unmount_inodes(struct list_head *list) }/* -* We can safely drop inode_lock here because we hold +* We can safely drop inode_sb_list_lock here because we hold * references on both inode and next_i. Also no new inodes -* will be added since the umount has begun. Finally, -* iprune_mutex keeps shrink_icache_memory() away. +* will be added since the umount has begun. */ spin_unlock (&inode_sb_list_lock);
fs/ntfs/inode.c +2 -2
@@ -54,7 +54,7 @@* * Return 1 if the attributes match and 0 if not. * -* NOTE: This function runs with the inode_lock spin lock held so it is not +* NOTE: This function runs with the inode->i_lock spin lock held so it is not * allowed to sleep. */ int ntfs_test_inode (struct inode *vi,ntfs_attr *na)
@@ -98,7 +98,7 @@ int ntfs_test_inode(struct inode *vi, ntfs_attr *na)* * Return 0 on success and -errno on error. * -* NOTE: This function runs with the inode_lock spin lock held so it is not +* NOTE: This function runs with the inode->i_lock spin lock held so it is not * allowed to sleep. (Hence the GFP_ATOMIC allocation.) */ static int ntfs_init_locked_inode (struct inode *vi,ntfs_attr *na)
include/linux/fs.h +1 -1
@@ -1595,7 +1595,7 @@ struct super_operations { };/* -* Inode state bits. Protected by inode_lock. +* Inode state bits. Protected by inode->i_lock. * * Three bits determine the dirty state of the inode, I_DIRTY_SYNC, * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
include/linux/quotaops.h +1 -1
@@ -278,7 +278,7 @@ static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)/* * Mark inode fully dirty. Since we are allocating blocks, inode * would become fully dirty soon anyway and it reportedly -* reduces inode_lock contention. +* reduces lock contention. */ mark_inode_dirty (inode); }
mm/filemap.c +5 -3
@@ -80,7 +80,7 @@* ->i_mutex * ->i_alloc_sem (various) * -* ->inode_lock +* ->inode_wb_list_lock * ->sb_lock (fs/fs-writeback.c) * ->mapping->tree_lock (__sync_single_inode) *
@@ -98,8 +98,10 @@* ->zone.lru_lock (check_pte_range->isolate_lru_page) * ->private_lock (page_remove_rmap->set_page_dirty) * ->tree_lock (page_remove_rmap->set_page_dirty) -* ->inode_lock (page_remove_rmap->set_page_dirty) -* ->inode_lock (zap_pte_range->set_page_dirty) +* ->inode->i_lock (page_remove_rmap->set_page_dirty) +* ->inode_wb_list_lock (page_remove_rmap->set_page_dirty) +* ->inode->i_lock (zap_pte_range->set_page_dirty) +* ->inode_wb_list_lock (zap_pte_range->set_page_dirty) * ->private_lock (zap_pte_range->__set_page_dirty_buffers) * * ->task->proc_lock
mm/rmap.c +4 -3
@@ -31,11 +31,12 @@* swap_lock (in swap_duplicate, swap_info_get) * mmlist_lock (in mmput, drain_mmlist and others) * mapping->private_lock (in __set_page_dirty_buffers) -* inode_lock (in set_page_dirty's __mark_inode_dirty) -* sb_lock (within inode_lock in fs/fs-writeback.c) +* inode->i_lock (in set_page_dirty's __mark_inode_dirty) +* inode_wb_list_lock (in set_page_dirty's __mark_inode_dirty) +* sb_lock (within inode_wb_list_lock in fs/fs-writeback.c) * mapping->tree_lock (widely used, in set_page_dirty, * in arch-dependent flush_dcache_mmap_lock, -* within inode_lock in __sync_single_inode) +* within inode_wb_list_lock in __sync_single_inode) * * (code doesn't rely on that order so it could be switched around) * ->tasklist_lock
Signature · 1 line
1.7.1
Al Viro
maintainerRe: [PATCH 8/8] fs: Clean up documentation references to inode_lock
mm/filemap.c line 83
Quoted 10 lines · Dave Chinner
mm/filemap.c +1
-1@@ -80,7 +80,7 @@* ->i_mutex * ->i_alloc_sem (various) * -* ->inode_lock +* ->inode_wb_list_lock
Huh? Please, kill -> in these two lines, while we are at it.
mm/filemap.c line 104
Quoted 13 lines
mm/filemap.c +4
-2* ->sb_lock (fs/fs-writeback.c) * ->mapping->tree_lock (__sync_single_inode) * @@ -98,8 +98,10 @@* ->zone.lru_lock (check_pte_range->isolate_lru_page) * ->private_lock (page_remove_rmap->set_page_dirty) * ->tree_lock (page_remove_rmap->set_page_dirty) -* ->inode_lock (page_remove_rmap->set_page_dirty) -* ->inode_lock (zap_pte_range->set_page_dirty) +* ->inode->i_lock (page_remove_rmap->set_page_dirty) +* ->inode_wb_list_lock (page_remove_rmap->set_page_dirty) +* ->inode->i_lock (zap_pte_range->set_page_dirty) +* ->inode_wb_list_lock (zap_pte_range->set_page_dirty)
Again, bogus ->
Re: [PATCH 8/8] fs: Clean up documentation references to inode_lock
In reply to Dave ChinnerMost of this should probably simply be folded into the relevant patches.