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