1 // SPDX-License-Identifier: GPL-2.0
2 #include "reiserfs.h"
3 #include <linux/mutex.h>
4 
5 /*
6  * The previous reiserfs locking scheme was heavily based on
7  * the tricky properties of the Bkl:
8  *
9  * - it was acquired recursively by a same task
10  * - the performances relied on the release-while-schedule() property
11  *
12  * Now that we replace it by a mutex, we still want to keep the same
13  * recursive property to avoid big changes in the code structure.
14  * We use our own lock_owner here because the owner field on a mutex
15  * is only available in SMP or mutex debugging, also we only need this field
16  * for this mutex, no need for a system wide mutex facility.
17  *
18  * Also this lock is often released before a call that could block because
19  * reiserfs performances were partially based on the release while schedule()
20  * property of the Bkl.
21  */
reiserfs_write_lock(struct super_block * s)22 void reiserfs_write_lock(struct super_block *s)
23 {
24 	struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
25 
26 	if (sb_i->lock_owner != current) {
27 		mutex_lock(&sb_i->lock);
28 		sb_i->lock_owner = current;
29 	}
30 
31 	/* No need to protect it, only the current task touches it */
32 	sb_i->lock_depth++;
33 }
34 
reiserfs_write_unlock(struct super_block * s)35 void reiserfs_write_unlock(struct super_block *s)
36 {
37 	struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
38 
39 	/*
40 	 * Are we unlocking without even holding the lock?
41 	 * Such a situation must raise a BUG() if we don't want
42 	 * to corrupt the data.
43 	 */
44 	BUG_ON(sb_i->lock_owner != current);
45 
46 	if (--sb_i->lock_depth == -1) {
47 		sb_i->lock_owner = NULL;
48 		mutex_unlock(&sb_i->lock);
49 	}
50 }
51 
reiserfs_write_unlock_nested(struct super_block * s)52 int __must_check reiserfs_write_unlock_nested(struct super_block *s)
53 {
54 	struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
55 	int depth;
56 
57 	/* this can happen when the lock isn't always held */
58 	if (sb_i->lock_owner != current)
59 		return -1;
60 
61 	depth = sb_i->lock_depth;
62 
63 	sb_i->lock_depth = -1;
64 	sb_i->lock_owner = NULL;
65 	mutex_unlock(&sb_i->lock);
66 
67 	return depth;
68 }
69 
reiserfs_write_lock_nested(struct super_block * s,int depth)70 void reiserfs_write_lock_nested(struct super_block *s, int depth)
71 {
72 	struct reiserfs_sb_info *sb_i = REISERFS_SB(s);
73 
74 	/* this can happen when the lock isn't always held */
75 	if (depth == -1)
76 		return;
77 
78 	mutex_lock(&sb_i->lock);
79 	sb_i->lock_owner = current;
80 	sb_i->lock_depth = depth;
81 }
82 
83 /*
84  * Utility function to force a BUG if it is called without the superblock
85  * write lock held.  caller is the string printed just before calling BUG()
86  */
reiserfs_check_lock_depth(struct super_block * sb,char * caller)87 void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
88 {
89 	struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
90 
91 	WARN_ON(sb_i->lock_depth < 0);
92 }
93 
94 #ifdef CONFIG_REISERFS_CHECK
reiserfs_lock_check_recursive(struct super_block * sb)95 void reiserfs_lock_check_recursive(struct super_block *sb)
96 {
97 	struct reiserfs_sb_info *sb_i = REISERFS_SB(sb);
98 
99 	WARN_ONCE((sb_i->lock_depth > 0), "Unwanted recursive reiserfs lock!\n");
100 }
101 #endif
102