~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/lib/lockref.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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);
189 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp