diff options
author | Jeff Layton <jlayton@redhat.com> | 2013-06-21 08:58:18 -0400 |
---|---|---|
committer | Al Viro <viro@zeniv.linux.org.uk> | 2013-06-29 04:57:44 -0400 |
commit | 48f74186546cd5929397856eab209ebcb5692d11 (patch) | |
tree | 9a4bf88cd5171f470eeae0ba4f62d5b5b9d06fc7 /fs/locks.c | |
parent | 139ca04ee572fea6c0c105e88aba3a534efcd7c4 (diff) |
locks: turn the blocked_list into a hashtable
Break up the blocked_list into a hashtable, using the fl_owner as a key.
This speeds up searching the hash chains, which is especially significant
for deadlock detection.
Note that the initial implementation assumes that hashing on fl_owner is
sufficient. In most cases it should be, with the notable exception being
server-side lockd, which compares ownership using a tuple of the
nlm_host and the pid sent in the lock request. So, this may degrade to a
single hash bucket when you only have a single NFS client. That will be
addressed in a later patch.
The careful observer may note that this patch leaves the file_lock_list
alone. There's much less of a case for turning the file_lock_list into a
hashtable. The only user of that list is the code that generates
/proc/locks, and it always walks the entire list.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Acked-by: J. Bruce Fields <bfields@fieldses.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Diffstat (limited to 'fs/locks.c')
-rw-r--r-- | fs/locks.c | 25 |
1 files changed, 17 insertions, 8 deletions
diff --git a/fs/locks.c b/fs/locks.c index 941b7146b6be..71d847cbbb63 100644 --- a/fs/locks.c +++ b/fs/locks.c | |||
@@ -126,6 +126,7 @@ | |||
126 | #include <linux/time.h> | 126 | #include <linux/time.h> |
127 | #include <linux/rcupdate.h> | 127 | #include <linux/rcupdate.h> |
128 | #include <linux/pid_namespace.h> | 128 | #include <linux/pid_namespace.h> |
129 | #include <linux/hashtable.h> | ||
129 | 130 | ||
130 | #include <asm/uaccess.h> | 131 | #include <asm/uaccess.h> |
131 | 132 | ||
@@ -160,13 +161,21 @@ int lease_break_time = 45; | |||
160 | static HLIST_HEAD(file_lock_list); | 161 | static HLIST_HEAD(file_lock_list); |
161 | 162 | ||
162 | /* | 163 | /* |
163 | * The blocked_list is used to find POSIX lock loops for deadlock detection. | 164 | * The blocked_hash is used to find POSIX lock loops for deadlock detection. |
164 | * Protected by file_lock_lock. | 165 | * It is protected by file_lock_lock. |
166 | * | ||
167 | * We hash locks by lockowner in order to optimize searching for the lock a | ||
168 | * particular lockowner is waiting on. | ||
169 | * | ||
170 | * FIXME: make this value scale via some heuristic? We generally will want more | ||
171 | * buckets when we have more lockowners holding locks, but that's a little | ||
172 | * difficult to determine without knowing what the workload will look like. | ||
165 | */ | 173 | */ |
166 | static HLIST_HEAD(blocked_list); | 174 | #define BLOCKED_HASH_BITS 7 |
175 | static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS); | ||
167 | 176 | ||
168 | /* | 177 | /* |
169 | * This lock protects the blocked_list, and the file_lock_list. Generally, if | 178 | * This lock protects the blocked_hash and the file_lock_list. Generally, if |
170 | * you're accessing one of those lists, you want to be holding this lock. | 179 | * you're accessing one of those lists, you want to be holding this lock. |
171 | * | 180 | * |
172 | * In addition, it also protects the fl->fl_block list, and the fl->fl_next | 181 | * In addition, it also protects the fl->fl_block list, and the fl->fl_next |
@@ -515,13 +524,13 @@ locks_delete_global_locks(struct file_lock *fl) | |||
515 | static inline void | 524 | static inline void |
516 | locks_insert_global_blocked(struct file_lock *waiter) | 525 | locks_insert_global_blocked(struct file_lock *waiter) |
517 | { | 526 | { |
518 | hlist_add_head(&waiter->fl_link, &blocked_list); | 527 | hash_add(blocked_hash, &waiter->fl_link, (unsigned long)waiter->fl_owner); |
519 | } | 528 | } |
520 | 529 | ||
521 | static inline void | 530 | static inline void |
522 | locks_delete_global_blocked(struct file_lock *waiter) | 531 | locks_delete_global_blocked(struct file_lock *waiter) |
523 | { | 532 | { |
524 | hlist_del_init(&waiter->fl_link); | 533 | hash_del(&waiter->fl_link); |
525 | } | 534 | } |
526 | 535 | ||
527 | /* Remove waiter from blocker's block list. | 536 | /* Remove waiter from blocker's block list. |
@@ -748,7 +757,7 @@ static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl) | |||
748 | { | 757 | { |
749 | struct file_lock *fl; | 758 | struct file_lock *fl; |
750 | 759 | ||
751 | hlist_for_each_entry(fl, &blocked_list, fl_link) { | 760 | hash_for_each_possible(blocked_hash, fl, fl_link, (unsigned long)block_fl->fl_owner) { |
752 | if (posix_same_owner(fl, block_fl)) | 761 | if (posix_same_owner(fl, block_fl)) |
753 | return fl->fl_next; | 762 | return fl->fl_next; |
754 | } | 763 | } |
@@ -884,7 +893,7 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str | |||
884 | /* | 893 | /* |
885 | * New lock request. Walk all POSIX locks and look for conflicts. If | 894 | * New lock request. Walk all POSIX locks and look for conflicts. If |
886 | * there are any, either return error or put the request on the | 895 | * there are any, either return error or put the request on the |
887 | * blocker's list of waiters and the global blocked_list. | 896 | * blocker's list of waiters and the global blocked_hash. |
888 | */ | 897 | */ |
889 | if (request->fl_type != F_UNLCK) { | 898 | if (request->fl_type != F_UNLCK) { |
890 | for_each_lock(inode, before) { | 899 | for_each_lock(inode, before) { |