Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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();                                                    \
 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);
189 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us