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

TOMOYO Linux Cross Reference
Linux/tools/lib/lockdep/preload.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ 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.72 ] ~ [ 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 #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 {
 95         if (__init_state != done)
 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 
255         lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL,
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 
284         lock_acquire(&__get_lock(mutex)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_);
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)
306                 lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_);
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          */
320         debug_check_no_locks_freed(mutex, sizeof(*mutex));
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 
344         debug_check_no_locks_freed(rwlock, sizeof(*rwlock));
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 
355         lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 2, 1, NULL, (unsigned long)_RET_IP_);
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 
369         lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 2, 1, NULL, (unsigned long)_RET_IP_);
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 
383         lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_);
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 
397         lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_);
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)
414                 lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_);
415 
416         return r;
417 }
418 
419 __attribute__((constructor)) static void init_preload(void)
420 {
421         if (__init_state == done)
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 
442         __init_state = done;
443 }
444 

~ [ 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