Commit | Line | Data |
---|---|---|
231941ee SL |
1 | #define _GNU_SOURCE |
2 | #include <pthread.h> | |
3 | #include <stdio.h> | |
4 | #include <dlfcn.h> | |
5 | #include <stdlib.h> | |
6 | #include <sysexits.h> | |
7 | #include "include/liblockdep/mutex.h" | |
8 | #include "../../../include/linux/rbtree.h" | |
9 | ||
10 | /** | |
11 | * struct lock_lookup - liblockdep's view of a single unique lock | |
12 | * @orig: pointer to the original pthread lock, used for lookups | |
13 | * @dep_map: lockdep's dep_map structure | |
14 | * @key: lockdep's key structure | |
15 | * @node: rb-tree node used to store the lock in a global tree | |
16 | * @name: a unique name for the lock | |
17 | */ | |
18 | struct lock_lookup { | |
19 | void *orig; /* Original pthread lock, used for lookups */ | |
20 | struct lockdep_map dep_map; /* Since all locks are dynamic, we need | |
21 | * a dep_map and a key for each lock */ | |
22 | /* | |
23 | * Wait, there's no support for key classes? Yup :( | |
24 | * Most big projects wrap the pthread api with their own calls to | |
25 | * be compatible with different locking methods. This means that | |
26 | * "classes" will be brokes since the function that creates all | |
27 | * locks will point to a generic locking function instead of the | |
28 | * actual code that wants to do the locking. | |
29 | */ | |
30 | struct lock_class_key key; | |
31 | struct rb_node node; | |
32 | #define LIBLOCKDEP_MAX_LOCK_NAME 22 | |
33 | char name[LIBLOCKDEP_MAX_LOCK_NAME]; | |
34 | }; | |
35 | ||
36 | /* This is where we store our locks */ | |
37 | static struct rb_root locks = RB_ROOT; | |
38 | static pthread_rwlock_t locks_rwlock = PTHREAD_RWLOCK_INITIALIZER; | |
39 | ||
40 | /* pthread mutex API */ | |
41 | ||
42 | #ifdef __GLIBC__ | |
43 | extern int __pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); | |
44 | extern int __pthread_mutex_lock(pthread_mutex_t *mutex); | |
45 | extern int __pthread_mutex_trylock(pthread_mutex_t *mutex); | |
46 | extern int __pthread_mutex_unlock(pthread_mutex_t *mutex); | |
47 | extern int __pthread_mutex_destroy(pthread_mutex_t *mutex); | |
48 | #else | |
49 | #define __pthread_mutex_init NULL | |
50 | #define __pthread_mutex_lock NULL | |
51 | #define __pthread_mutex_trylock NULL | |
52 | #define __pthread_mutex_unlock NULL | |
53 | #define __pthread_mutex_destroy NULL | |
54 | #endif | |
55 | static int (*ll_pthread_mutex_init)(pthread_mutex_t *mutex, | |
56 | const pthread_mutexattr_t *attr) = __pthread_mutex_init; | |
57 | static int (*ll_pthread_mutex_lock)(pthread_mutex_t *mutex) = __pthread_mutex_lock; | |
58 | static int (*ll_pthread_mutex_trylock)(pthread_mutex_t *mutex) = __pthread_mutex_trylock; | |
59 | static int (*ll_pthread_mutex_unlock)(pthread_mutex_t *mutex) = __pthread_mutex_unlock; | |
60 | static int (*ll_pthread_mutex_destroy)(pthread_mutex_t *mutex) = __pthread_mutex_destroy; | |
61 | ||
62 | /* pthread rwlock API */ | |
63 | ||
64 | #ifdef __GLIBC__ | |
65 | extern int __pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); | |
66 | extern int __pthread_rwlock_destroy(pthread_rwlock_t *rwlock); | |
67 | extern int __pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); | |
68 | extern int __pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); | |
69 | extern int __pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); | |
70 | extern int __pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); | |
71 | extern int __pthread_rwlock_unlock(pthread_rwlock_t *rwlock); | |
72 | #else | |
73 | #define __pthread_rwlock_init NULL | |
74 | #define __pthread_rwlock_destroy NULL | |
75 | #define __pthread_rwlock_wrlock NULL | |
76 | #define __pthread_rwlock_trywrlock NULL | |
77 | #define __pthread_rwlock_rdlock NULL | |
78 | #define __pthread_rwlock_tryrdlock NULL | |
79 | #define __pthread_rwlock_unlock NULL | |
80 | #endif | |
81 | ||
82 | static int (*ll_pthread_rwlock_init)(pthread_rwlock_t *rwlock, | |
83 | const pthread_rwlockattr_t *attr) = __pthread_rwlock_init; | |
84 | static int (*ll_pthread_rwlock_destroy)(pthread_rwlock_t *rwlock) = __pthread_rwlock_destroy; | |
85 | static int (*ll_pthread_rwlock_rdlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_rdlock; | |
86 | static int (*ll_pthread_rwlock_tryrdlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_tryrdlock; | |
87 | static int (*ll_pthread_rwlock_trywrlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_trywrlock; | |
88 | static int (*ll_pthread_rwlock_wrlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_wrlock; | |
89 | static int (*ll_pthread_rwlock_unlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_unlock; | |
90 | ||
91 | enum { none, prepare, done, } __init_state; | |
92 | static void init_preload(void); | |
93 | static void try_init_preload(void) | |
94 | { | |
6c642e44 | 95 | if (__init_state != done) |
231941ee SL |
96 | init_preload(); |
97 | } | |
98 | ||
99 | static struct rb_node **__get_lock_node(void *lock, struct rb_node **parent) | |
100 | { | |
101 | struct rb_node **node = &locks.rb_node; | |
102 | struct lock_lookup *l; | |
103 | ||
104 | *parent = NULL; | |
105 | ||
106 | while (*node) { | |
107 | l = rb_entry(*node, struct lock_lookup, node); | |
108 | ||
109 | *parent = *node; | |
110 | if (lock < l->orig) | |
111 | node = &l->node.rb_left; | |
112 | else if (lock > l->orig) | |
113 | node = &l->node.rb_right; | |
114 | else | |
115 | return node; | |
116 | } | |
117 | ||
118 | return node; | |
119 | } | |
120 | ||
121 | #ifndef LIBLOCKDEP_STATIC_ENTRIES | |
122 | #define LIBLOCKDEP_STATIC_ENTRIES 1024 | |
123 | #endif | |
124 | ||
125 | #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) | |
126 | ||
127 | static struct lock_lookup __locks[LIBLOCKDEP_STATIC_ENTRIES]; | |
128 | static int __locks_nr; | |
129 | ||
130 | static inline bool is_static_lock(struct lock_lookup *lock) | |
131 | { | |
132 | return lock >= __locks && lock < __locks + ARRAY_SIZE(__locks); | |
133 | } | |
134 | ||
135 | static struct lock_lookup *alloc_lock(void) | |
136 | { | |
137 | if (__init_state != done) { | |
138 | /* | |
139 | * Some programs attempt to initialize and use locks in their | |
140 | * allocation path. This means that a call to malloc() would | |
141 | * result in locks being initialized and locked. | |
142 | * | |
143 | * Why is it an issue for us? dlsym() below will try allocating | |
144 | * to give us the original function. Since this allocation will | |
145 | * result in a locking operations, we have to let pthread deal | |
146 | * with it, but we can't! we don't have the pointer to the | |
147 | * original API since we're inside dlsym() trying to get it | |
148 | */ | |
149 | ||
150 | int idx = __locks_nr++; | |
151 | if (idx >= ARRAY_SIZE(__locks)) { | |
152 | fprintf(stderr, | |
153 | "LOCKDEP error: insufficient LIBLOCKDEP_STATIC_ENTRIES\n"); | |
154 | exit(EX_UNAVAILABLE); | |
155 | } | |
156 | return __locks + idx; | |
157 | } | |
158 | ||
159 | return malloc(sizeof(struct lock_lookup)); | |
160 | } | |
161 | ||
162 | static inline void free_lock(struct lock_lookup *lock) | |
163 | { | |
164 | if (likely(!is_static_lock(lock))) | |
165 | free(lock); | |
166 | } | |
167 | ||
168 | /** | |
169 | * __get_lock - find or create a lock instance | |
170 | * @lock: pointer to a pthread lock function | |
171 | * | |
172 | * Try to find an existing lock in the rbtree using the provided pointer. If | |
173 | * one wasn't found - create it. | |
174 | */ | |
175 | static struct lock_lookup *__get_lock(void *lock) | |
176 | { | |
177 | struct rb_node **node, *parent; | |
178 | struct lock_lookup *l; | |
179 | ||
180 | ll_pthread_rwlock_rdlock(&locks_rwlock); | |
181 | node = __get_lock_node(lock, &parent); | |
182 | ll_pthread_rwlock_unlock(&locks_rwlock); | |
183 | if (*node) { | |
184 | return rb_entry(*node, struct lock_lookup, node); | |
185 | } | |
186 | ||
187 | /* We didn't find the lock, let's create it */ | |
188 | l = alloc_lock(); | |
189 | if (l == NULL) | |
190 | return NULL; | |
191 | ||
192 | l->orig = lock; | |
193 | /* | |
194 | * Currently the name of the lock is the ptr value of the pthread lock, | |
195 | * while not optimal, it makes debugging a bit easier. | |
196 | * | |
197 | * TODO: Get the real name of the lock using libdwarf | |
198 | */ | |
199 | sprintf(l->name, "%p", lock); | |
200 | lockdep_init_map(&l->dep_map, l->name, &l->key, 0); | |
201 | ||
202 | ll_pthread_rwlock_wrlock(&locks_rwlock); | |
203 | /* This might have changed since the last time we fetched it */ | |
204 | node = __get_lock_node(lock, &parent); | |
205 | rb_link_node(&l->node, parent, node); | |
206 | rb_insert_color(&l->node, &locks); | |
207 | ll_pthread_rwlock_unlock(&locks_rwlock); | |
208 | ||
209 | return l; | |
210 | } | |
211 | ||
212 | static void __del_lock(struct lock_lookup *lock) | |
213 | { | |
214 | ll_pthread_rwlock_wrlock(&locks_rwlock); | |
215 | rb_erase(&lock->node, &locks); | |
216 | ll_pthread_rwlock_unlock(&locks_rwlock); | |
217 | free_lock(lock); | |
218 | } | |
219 | ||
220 | int pthread_mutex_init(pthread_mutex_t *mutex, | |
221 | const pthread_mutexattr_t *attr) | |
222 | { | |
223 | int r; | |
224 | ||
225 | /* | |
226 | * We keep trying to init our preload module because there might be | |
227 | * code in init sections that tries to touch locks before we are | |
228 | * initialized, in that case we'll need to manually call preload | |
229 | * to get us going. | |
230 | * | |
231 | * Funny enough, kernel's lockdep had the same issue, and used | |
232 | * (almost) the same solution. See look_up_lock_class() in | |
233 | * kernel/locking/lockdep.c for details. | |
234 | */ | |
235 | try_init_preload(); | |
236 | ||
237 | r = ll_pthread_mutex_init(mutex, attr); | |
238 | if (r == 0) | |
239 | /* | |
240 | * We do a dummy initialization here so that lockdep could | |
241 | * warn us if something fishy is going on - such as | |
242 | * initializing a held lock. | |
243 | */ | |
244 | __get_lock(mutex); | |
245 | ||
246 | return r; | |
247 | } | |
248 | ||
249 | int pthread_mutex_lock(pthread_mutex_t *mutex) | |
250 | { | |
251 | int r; | |
252 | ||
253 | try_init_preload(); | |
254 | ||
b1082781 | 255 | lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL, |
231941ee SL |
256 | (unsigned long)_RET_IP_); |
257 | /* | |
258 | * Here's the thing with pthread mutexes: unlike the kernel variant, | |
259 | * they can fail. | |
260 | * | |
261 | * This means that the behaviour here is a bit different from what's | |
262 | * going on in the kernel: there we just tell lockdep that we took the | |
263 | * lock before actually taking it, but here we must deal with the case | |
264 | * that locking failed. | |
265 | * | |
266 | * To do that we'll "release" the lock if locking failed - this way | |
267 | * we'll get lockdep doing the correct checks when we try to take | |
268 | * the lock, and if that fails - we'll be back to the correct | |
269 | * state by releasing it. | |
270 | */ | |
271 | r = ll_pthread_mutex_lock(mutex); | |
272 | if (r) | |
273 | lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); | |
274 | ||
275 | return r; | |
276 | } | |
277 | ||
278 | int pthread_mutex_trylock(pthread_mutex_t *mutex) | |
279 | { | |
280 | int r; | |
281 | ||
282 | try_init_preload(); | |
283 | ||
b1082781 | 284 | lock_acquire(&__get_lock(mutex)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
285 | r = ll_pthread_mutex_trylock(mutex); |
286 | if (r) | |
287 | lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); | |
288 | ||
289 | return r; | |
290 | } | |
291 | ||
292 | int pthread_mutex_unlock(pthread_mutex_t *mutex) | |
293 | { | |
294 | int r; | |
295 | ||
296 | try_init_preload(); | |
297 | ||
298 | lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); | |
299 | /* | |
300 | * Just like taking a lock, only in reverse! | |
301 | * | |
302 | * If we fail releasing the lock, tell lockdep we're holding it again. | |
303 | */ | |
304 | r = ll_pthread_mutex_unlock(mutex); | |
305 | if (r) | |
b1082781 | 306 | lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
307 | |
308 | return r; | |
309 | } | |
310 | ||
311 | int pthread_mutex_destroy(pthread_mutex_t *mutex) | |
312 | { | |
313 | try_init_preload(); | |
314 | ||
315 | /* | |
316 | * Let's see if we're releasing a lock that's held. | |
317 | * | |
318 | * TODO: Hook into free() and add that check there as well. | |
319 | */ | |
95bfdf23 | 320 | debug_check_no_locks_freed(mutex, sizeof(*mutex)); |
231941ee SL |
321 | __del_lock(__get_lock(mutex)); |
322 | return ll_pthread_mutex_destroy(mutex); | |
323 | } | |
324 | ||
325 | /* This is the rwlock part, very similar to what happened with mutex above */ | |
326 | int pthread_rwlock_init(pthread_rwlock_t *rwlock, | |
327 | const pthread_rwlockattr_t *attr) | |
328 | { | |
329 | int r; | |
330 | ||
331 | try_init_preload(); | |
332 | ||
333 | r = ll_pthread_rwlock_init(rwlock, attr); | |
334 | if (r == 0) | |
335 | __get_lock(rwlock); | |
336 | ||
337 | return r; | |
338 | } | |
339 | ||
340 | int pthread_rwlock_destroy(pthread_rwlock_t *rwlock) | |
341 | { | |
342 | try_init_preload(); | |
343 | ||
95bfdf23 | 344 | debug_check_no_locks_freed(rwlock, sizeof(*rwlock)); |
231941ee SL |
345 | __del_lock(__get_lock(rwlock)); |
346 | return ll_pthread_rwlock_destroy(rwlock); | |
347 | } | |
348 | ||
349 | int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) | |
350 | { | |
351 | int r; | |
352 | ||
353 | init_preload(); | |
354 | ||
b1082781 | 355 | lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 2, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
356 | r = ll_pthread_rwlock_rdlock(rwlock); |
357 | if (r) | |
358 | lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); | |
359 | ||
360 | return r; | |
361 | } | |
362 | ||
363 | int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) | |
364 | { | |
365 | int r; | |
366 | ||
367 | init_preload(); | |
368 | ||
b1082781 | 369 | lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 2, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
370 | r = ll_pthread_rwlock_tryrdlock(rwlock); |
371 | if (r) | |
372 | lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); | |
373 | ||
374 | return r; | |
375 | } | |
376 | ||
377 | int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) | |
378 | { | |
379 | int r; | |
380 | ||
381 | init_preload(); | |
382 | ||
b1082781 | 383 | lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
384 | r = ll_pthread_rwlock_trywrlock(rwlock); |
385 | if (r) | |
386 | lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); | |
387 | ||
388 | return r; | |
389 | } | |
390 | ||
391 | int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) | |
392 | { | |
393 | int r; | |
394 | ||
395 | init_preload(); | |
396 | ||
b1082781 | 397 | lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
398 | r = ll_pthread_rwlock_wrlock(rwlock); |
399 | if (r) | |
400 | lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); | |
401 | ||
402 | return r; | |
403 | } | |
404 | ||
405 | int pthread_rwlock_unlock(pthread_rwlock_t *rwlock) | |
406 | { | |
407 | int r; | |
408 | ||
409 | init_preload(); | |
410 | ||
411 | lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); | |
412 | r = ll_pthread_rwlock_unlock(rwlock); | |
413 | if (r) | |
b1082781 | 414 | lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); |
231941ee SL |
415 | |
416 | return r; | |
417 | } | |
418 | ||
419 | __attribute__((constructor)) static void init_preload(void) | |
420 | { | |
367d896d | 421 | if (__init_state == done) |
231941ee SL |
422 | return; |
423 | ||
424 | #ifndef __GLIBC__ | |
425 | __init_state = prepare; | |
426 | ||
427 | ll_pthread_mutex_init = dlsym(RTLD_NEXT, "pthread_mutex_init"); | |
428 | ll_pthread_mutex_lock = dlsym(RTLD_NEXT, "pthread_mutex_lock"); | |
429 | ll_pthread_mutex_trylock = dlsym(RTLD_NEXT, "pthread_mutex_trylock"); | |
430 | ll_pthread_mutex_unlock = dlsym(RTLD_NEXT, "pthread_mutex_unlock"); | |
431 | ll_pthread_mutex_destroy = dlsym(RTLD_NEXT, "pthread_mutex_destroy"); | |
432 | ||
433 | ll_pthread_rwlock_init = dlsym(RTLD_NEXT, "pthread_rwlock_init"); | |
434 | ll_pthread_rwlock_destroy = dlsym(RTLD_NEXT, "pthread_rwlock_destroy"); | |
435 | ll_pthread_rwlock_rdlock = dlsym(RTLD_NEXT, "pthread_rwlock_rdlock"); | |
436 | ll_pthread_rwlock_tryrdlock = dlsym(RTLD_NEXT, "pthread_rwlock_tryrdlock"); | |
437 | ll_pthread_rwlock_wrlock = dlsym(RTLD_NEXT, "pthread_rwlock_wrlock"); | |
438 | ll_pthread_rwlock_trywrlock = dlsym(RTLD_NEXT, "pthread_rwlock_trywrlock"); | |
439 | ll_pthread_rwlock_unlock = dlsym(RTLD_NEXT, "pthread_rwlock_unlock"); | |
440 | #endif | |
441 | ||
231941ee SL |
442 | lockdep_init(); |
443 | ||
444 | __init_state = done; | |
445 | } |