2 #include <linux/mutex.h>
5 * The previous reiserfs locking scheme was heavily based on
6 * the tricky properties of the Bkl:
8 * - it was acquired recursively by a same task
9 * - the performances relied on the release-while-schedule() property
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.
17 * Also this lock is often released before a call that could block because
18 * reiserfs performances were partially based on the release while schedule()
19 * property of the Bkl.
21 void reiserfs_write_lock(struct super_block
*s
)
23 struct reiserfs_sb_info
*sb_i
= REISERFS_SB(s
);
25 if (sb_i
->lock_owner
!= current
) {
26 mutex_lock(&sb_i
->lock
);
27 sb_i
->lock_owner
= current
;
30 /* No need to protect it, only the current task touches it */
34 void reiserfs_write_unlock(struct super_block
*s
)
36 struct reiserfs_sb_info
*sb_i
= REISERFS_SB(s
);
39 * Are we unlocking without even holding the lock?
40 * Such a situation must raise a BUG() if we don't want
41 * to corrupt the data.
43 BUG_ON(sb_i
->lock_owner
!= current
);
45 if (--sb_i
->lock_depth
== -1) {
46 sb_i
->lock_owner
= NULL
;
47 mutex_unlock(&sb_i
->lock
);
52 * If we already own the lock, just exit and don't increase the depth.
53 * Useful when we don't want to lock more than once.
55 * We always return the lock_depth we had before calling
58 int reiserfs_write_lock_once(struct super_block
*s
)
60 struct reiserfs_sb_info
*sb_i
= REISERFS_SB(s
);
62 if (sb_i
->lock_owner
!= current
) {
63 mutex_lock(&sb_i
->lock
);
64 sb_i
->lock_owner
= current
;
65 return sb_i
->lock_depth
++;
68 return sb_i
->lock_depth
;
71 void reiserfs_write_unlock_once(struct super_block
*s
, int lock_depth
)
74 reiserfs_write_unlock(s
);
78 * Utility function to force a BUG if it is called without the superblock
79 * write lock held. caller is the string printed just before calling BUG()
81 void reiserfs_check_lock_depth(struct super_block
*sb
, char *caller
)
83 struct reiserfs_sb_info
*sb_i
= REISERFS_SB(sb
);
85 if (sb_i
->lock_depth
< 0)
86 reiserfs_panic(sb
, "%s called without kernel lock held %d",
90 #ifdef CONFIG_REISERFS_CHECK
91 void reiserfs_lock_check_recursive(struct super_block
*sb
)
93 struct reiserfs_sb_info
*sb_i
= REISERFS_SB(sb
);
95 WARN_ONCE((sb_i
->lock_depth
> 0), "Unwanted recursive reiserfs lock!\n");
This page took 0.031564 seconds and 5 git commands to generate.