blob: 045b83ef9fd9d42264fd55af61775abd62843807 [file] [log] [blame]
Al Virof466c6f2012-03-17 01:16:43 -04001#include "reiserfs.h"
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +02002#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
Lucas De Marchi25985ed2011-03-30 22:57:33 -030018 * reiserfs performances were partially based on the release while schedule()
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +020019 * property of the Bkl.
20 */
21void 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
34void 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?
Frederic Weisbecker80503182009-08-25 04:18:06 +020040 * Such a situation must raise a BUG() if we don't want
41 * to corrupt the data.
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +020042 */
Frederic Weisbecker80503182009-08-25 04:18:06 +020043 BUG_ON(sb_i->lock_owner != current);
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +020044
45 if (--sb_i->lock_depth == -1) {
46 sb_i->lock_owner = NULL;
47 mutex_unlock(&sb_i->lock);
48 }
49}
50
Jeff Mahoney278f6672013-08-08 17:34:46 -040051int __must_check reiserfs_write_unlock_nested(struct super_block *s)
52{
53 struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
54 int depth;
55
56 /* this can happen when the lock isn't always held */
57 if (sb_i->lock_owner != current)
58 return -1;
59
60 depth = sb_i->lock_depth;
61
62 sb_i->lock_depth = -1;
63 sb_i->lock_owner = NULL;
64 mutex_unlock(&sb_i->lock);
65
66 return depth;
67}
68
69void reiserfs_write_lock_nested(struct super_block *s, int depth)
Frederic Weisbeckerdaf88c82009-04-14 05:34:23 +020070{
71 struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
72
Jeff Mahoney278f6672013-08-08 17:34:46 -040073 /* this can happen when the lock isn't always held */
74 if (depth == -1)
75 return;
Frederic Weisbeckerdaf88c82009-04-14 05:34:23 +020076
Jeff Mahoney278f6672013-08-08 17:34:46 -040077 mutex_lock(&sb_i->lock);
78 sb_i->lock_owner = current;
79 sb_i->lock_depth = depth;
Frederic Weisbeckerdaf88c82009-04-14 05:34:23 +020080}
81
82/*
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +020083 * Utility function to force a BUG if it is called without the superblock
84 * write lock held. caller is the string printed just before calling BUG()
85 */
86void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
87{
88 struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
89
Jeff Mahoney278f6672013-08-08 17:34:46 -040090 WARN_ON(sb_i->lock_depth < 0);
Frederic Weisbecker8ebc4232009-04-07 04:19:49 +020091}
Frederic Weisbeckerc4a62ca2009-12-30 03:20:19 +010092
93#ifdef CONFIG_REISERFS_CHECK
94void reiserfs_lock_check_recursive(struct super_block *sb)
95{
96 struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
97
98 WARN_ONCE((sb_i->lock_depth > 0), "Unwanted recursive reiserfs lock!\n");
99}
100#endif