GNU Linux-libre 4.4.284-gnu1
[releases.git] / lib / lockref.c
1 #include <linux/export.h>
2 #include <linux/lockref.h>
3
4 #if USE_CMPXCHG_LOCKREF
5
6 /*
7  * Note that the "cmpxchg()" reloads the "old" value for the
8  * failure case.
9  */
10 #define CMPXCHG_LOOP(CODE, SUCCESS) do {                                        \
11         struct lockref old;                                                     \
12         BUILD_BUG_ON(sizeof(old) != 8);                                         \
13         old.lock_count = READ_ONCE(lockref->lock_count);                        \
14         while (likely(arch_spin_value_unlocked(old.lock.rlock.raw_lock))) {     \
15                 struct lockref new = old, prev = old;                           \
16                 CODE                                                            \
17                 old.lock_count = cmpxchg64_relaxed(&lockref->lock_count,        \
18                                                    old.lock_count,              \
19                                                    new.lock_count);             \
20                 if (likely(old.lock_count == prev.lock_count)) {                \
21                         SUCCESS;                                                \
22                 }                                                               \
23                 cpu_relax_lowlatency();                                         \
24         }                                                                       \
25 } while (0)
26
27 #else
28
29 #define CMPXCHG_LOOP(CODE, SUCCESS) do { } while (0)
30
31 #endif
32
33 /**
34  * lockref_get - Increments reference count unconditionally
35  * @lockref: pointer to lockref structure
36  *
37  * This operation is only valid if you already hold a reference
38  * to the object, so you know the count cannot be zero.
39  */
40 void lockref_get(struct lockref *lockref)
41 {
42         CMPXCHG_LOOP(
43                 new.count++;
44         ,
45                 return;
46         );
47
48         spin_lock(&lockref->lock);
49         lockref->count++;
50         spin_unlock(&lockref->lock);
51 }
52 EXPORT_SYMBOL(lockref_get);
53
54 /**
55  * lockref_get_not_zero - Increments count unless the count is 0 or dead
56  * @lockref: pointer to lockref structure
57  * Return: 1 if count updated successfully or 0 if count was zero
58  */
59 int lockref_get_not_zero(struct lockref *lockref)
60 {
61         int retval;
62
63         CMPXCHG_LOOP(
64                 new.count++;
65                 if (old.count <= 0)
66                         return 0;
67         ,
68                 return 1;
69         );
70
71         spin_lock(&lockref->lock);
72         retval = 0;
73         if (lockref->count > 0) {
74                 lockref->count++;
75                 retval = 1;
76         }
77         spin_unlock(&lockref->lock);
78         return retval;
79 }
80 EXPORT_SYMBOL(lockref_get_not_zero);
81
82 /**
83  * lockref_get_or_lock - Increments count unless the count is 0 or dead
84  * @lockref: pointer to lockref structure
85  * Return: 1 if count updated successfully or 0 if count was zero
86  * and we got the lock instead.
87  */
88 int lockref_get_or_lock(struct lockref *lockref)
89 {
90         CMPXCHG_LOOP(
91                 new.count++;
92                 if (old.count <= 0)
93                         break;
94         ,
95                 return 1;
96         );
97
98         spin_lock(&lockref->lock);
99         if (lockref->count <= 0)
100                 return 0;
101         lockref->count++;
102         spin_unlock(&lockref->lock);
103         return 1;
104 }
105 EXPORT_SYMBOL(lockref_get_or_lock);
106
107 /**
108  * lockref_put_return - Decrement reference count if possible
109  * @lockref: pointer to lockref structure
110  *
111  * Decrement the reference count and return the new value.
112  * If the lockref was dead or locked, return an error.
113  */
114 int lockref_put_return(struct lockref *lockref)
115 {
116         CMPXCHG_LOOP(
117                 new.count--;
118                 if (old.count <= 0)
119                         return -1;
120         ,
121                 return new.count;
122         );
123         return -1;
124 }
125 EXPORT_SYMBOL(lockref_put_return);
126
127 /**
128  * lockref_put_or_lock - decrements count unless count <= 1 before decrement
129  * @lockref: pointer to lockref structure
130  * Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
131  */
132 int lockref_put_or_lock(struct lockref *lockref)
133 {
134         CMPXCHG_LOOP(
135                 new.count--;
136                 if (old.count <= 1)
137                         break;
138         ,
139                 return 1;
140         );
141
142         spin_lock(&lockref->lock);
143         if (lockref->count <= 1)
144                 return 0;
145         lockref->count--;
146         spin_unlock(&lockref->lock);
147         return 1;
148 }
149 EXPORT_SYMBOL(lockref_put_or_lock);
150
151 /**
152  * lockref_mark_dead - mark lockref dead
153  * @lockref: pointer to lockref structure
154  */
155 void lockref_mark_dead(struct lockref *lockref)
156 {
157         assert_spin_locked(&lockref->lock);
158         lockref->count = -128;
159 }
160 EXPORT_SYMBOL(lockref_mark_dead);
161
162 /**
163  * lockref_get_not_dead - Increments count unless the ref is dead
164  * @lockref: pointer to lockref structure
165  * Return: 1 if count updated successfully or 0 if lockref was dead
166  */
167 int lockref_get_not_dead(struct lockref *lockref)
168 {
169         int retval;
170
171         CMPXCHG_LOOP(
172                 new.count++;
173                 if (old.count < 0)
174                         return 0;
175         ,
176                 return 1;
177         );
178
179         spin_lock(&lockref->lock);
180         retval = 0;
181         if (lockref->count >= 0) {
182                 lockref->count++;
183                 retval = 1;
184         }
185         spin_unlock(&lockref->lock);
186         return retval;
187 }
188 EXPORT_SYMBOL(lockref_get_not_dead);