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 | */ |
22 | void reiserfs_write_lock(struct super_block *s) |
23 | { |
24 | struct reiserfs_sb_info *sb_i = REISERFS_SB(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 | |
35 | void reiserfs_write_unlock(struct super_block *s) |
36 | { |
37 | struct reiserfs_sb_info *sb_i = REISERFS_SB(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(lock: &sb_i->lock); |
49 | } |
50 | } |
51 | |
52 | int __must_check reiserfs_write_unlock_nested(struct super_block *s) |
53 | { |
54 | struct reiserfs_sb_info *sb_i = REISERFS_SB(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(lock: &sb_i->lock); |
66 | |
67 | return depth; |
68 | } |
69 | |
70 | void reiserfs_write_lock_nested(struct super_block *s, int depth) |
71 | { |
72 | struct reiserfs_sb_info *sb_i = REISERFS_SB(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 | */ |
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 |
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 |