reiserfs: kill-the-BKL
[linux-2.6.git] / fs / reiserfs / lock.c
1 #include <linux/reiserfs_fs.h>
2 #include <linux/mutex.h>
3
4 /*
5  * The previous reiserfs locking scheme was heavily based on
6  * the tricky properties of the Bkl:
7  *
8  * - it was acquired recursively by a same task
9  * - the performances relied on the release-while-schedule() property
10  *
11  * Now that we replace it by a mutex, we still want to keep the same
12  * recursive property to avoid big changes in the code structure.
13  * We use our own lock_owner here because the owner field on a mutex
14  * is only available in SMP or mutex debugging, also we only need this field
15  * for this mutex, no need for a system wide mutex facility.
16  *
17  * Also this lock is often released before a call that could block because
18  * reiserfs performances were partialy based on the release while schedule()
19  * property of the Bkl.
20  */
21 void reiserfs_write_lock(struct super_block *s)
22 {
23         struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
24
25         if (sb_i->lock_owner != current) {
26                 mutex_lock(&sb_i->lock);
27                 sb_i->lock_owner = current;
28         }
29
30         /* No need to protect it, only the current task touches it */
31         sb_i->lock_depth++;
32 }
33
34 void reiserfs_write_unlock(struct super_block *s)
35 {
36         struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
37
38         /*
39          * Are we unlocking without even holding the lock?
40          * Such a situation could even raise a BUG() if we don't
41          * want the data become corrupted
42          */
43         WARN_ONCE(sb_i->lock_owner != current,
44                   "Superblock write lock imbalance");
45
46         if (--sb_i->lock_depth == -1) {
47                 sb_i->lock_owner = NULL;
48                 mutex_unlock(&sb_i->lock);
49         }
50 }
51
52 /*
53  * Utility function to force a BUG if it is called without the superblock
54  * write lock held.  caller is the string printed just before calling BUG()
55  */
56 void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
57 {
58         struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
59
60         if (sb_i->lock_depth < 0)
61                 reiserfs_panic(sb, "%s called without kernel lock held %d",
62                                caller);
63 }