#define _GNU_SOURCE #include #include #include #include #include #include "include/liblockdep/mutex.h" #include "../../include/linux/rbtree.h" /** * struct lock_lookup - liblockdep's view of a single unique lock * @orig: pointer to the original pthread lock, used for lookups * @dep_map: lockdep's dep_map structure * @key: lockdep's key structure * @node: rb-tree node used to store the lock in a global tree * @name: a unique name for the lock */ struct lock_lookup { void *orig; /* Original pthread lock, used for lookups */ struct lockdep_map dep_map; /* Since all locks are dynamic, we need * a dep_map and a key for each lock */ /* * Wait, there's no support for key classes? Yup :( * Most big projects wrap the pthread api with their own calls to * be compatible with different locking methods. This means that * "classes" will be brokes since the function that creates all * locks will point to a generic locking function instead of the * actual code that wants to do the locking. */ struct lock_class_key key; struct rb_node node; #define LIBLOCKDEP_MAX_LOCK_NAME 22 char name[LIBLOCKDEP_MAX_LOCK_NAME]; }; /* This is where we store our locks */ static struct rb_root locks = RB_ROOT; static pthread_rwlock_t locks_rwlock = PTHREAD_RWLOCK_INITIALIZER; /* pthread mutex API */ #ifdef __GLIBC__ extern int __pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); extern int __pthread_mutex_lock(pthread_mutex_t *mutex); extern int __pthread_mutex_trylock(pthread_mutex_t *mutex); extern int __pthread_mutex_unlock(pthread_mutex_t *mutex); extern int __pthread_mutex_destroy(pthread_mutex_t *mutex); #else #define __pthread_mutex_init NULL #define __pthread_mutex_lock NULL #define __pthread_mutex_trylock NULL #define __pthread_mutex_unlock NULL #define __pthread_mutex_destroy NULL #endif static int (*ll_pthread_mutex_init)(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) = __pthread_mutex_init; static int (*ll_pthread_mutex_lock)(pthread_mutex_t *mutex) = __pthread_mutex_lock; static int (*ll_pthread_mutex_trylock)(pthread_mutex_t *mutex) = __pthread_mutex_trylock; static int (*ll_pthread_mutex_unlock)(pthread_mutex_t *mutex) = __pthread_mutex_unlock; static int (*ll_pthread_mutex_destroy)(pthread_mutex_t *mutex) = __pthread_mutex_destroy; /* pthread rwlock API */ #ifdef __GLIBC__ extern int __pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); extern int __pthread_rwlock_destroy(pthread_rwlock_t *rwlock); extern int __pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); extern int __pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); extern int __pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); extern int __pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); extern int __pthread_rwlock_unlock(pthread_rwlock_t *rwlock); #else #define __pthread_rwlock_init NULL #define __pthread_rwlock_destroy NULL #define __pthread_rwlock_wrlock NULL #define __pthread_rwlock_trywrlock NULL #define __pthread_rwlock_rdlock NULL #define __pthread_rwlock_tryrdlock NULL #define __pthread_rwlock_unlock NULL #endif static int (*ll_pthread_rwlock_init)(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) = __pthread_rwlock_init; static int (*ll_pthread_rwlock_destroy)(pthread_rwlock_t *rwlock) = __pthread_rwlock_destroy; static int (*ll_pthread_rwlock_rdlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_rdlock; static int (*ll_pthread_rwlock_tryrdlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_tryrdlock; static int (*ll_pthread_rwlock_trywrlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_trywrlock; static int (*ll_pthread_rwlock_wrlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_wrlock; static int (*ll_pthread_rwlock_unlock)(pthread_rwlock_t *rwlock) = __pthread_rwlock_unlock; enum { none, prepare, done, } __init_state; static void init_preload(void); static void try_init_preload(void) { if (__init_state != done) init_preload(); } static struct rb_node **__get_lock_node(void *lock, struct rb_node **parent) { struct rb_node **node = &locks.rb_node; struct lock_lookup *l; *parent = NULL; while (*node) { l = rb_entry(*node, struct lock_lookup, node); *parent = *node; if (lock < l->orig) node = &l->node.rb_left; else if (lock > l->orig) node = &l->node.rb_right; else return node; } return node; } #ifndef LIBLOCKDEP_STATIC_ENTRIES #define LIBLOCKDEP_STATIC_ENTRIES 1024 #endif #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) static struct lock_lookup __locks[LIBLOCKDEP_STATIC_ENTRIES]; static int __locks_nr; static inline bool is_static_lock(struct lock_lookup *lock) { return lock >= __locks && lock < __locks + ARRAY_SIZE(__locks); } static struct lock_lookup *alloc_lock(void) { if (__init_state != done) { /* * Some programs attempt to initialize and use locks in their * allocation path. This means that a call to malloc() would * result in locks being initialized and locked. * * Why is it an issue for us? dlsym() below will try allocating * to give us the original function. Since this allocation will * result in a locking operations, we have to let pthread deal * with it, but we can't! we don't have the pointer to the * original API since we're inside dlsym() trying to get it */ int idx = __locks_nr++; if (idx >= ARRAY_SIZE(__locks)) { fprintf(stderr, "LOCKDEP error: insufficient LIBLOCKDEP_STATIC_ENTRIES\n"); exit(EX_UNAVAILABLE); } return __locks + idx; } return malloc(sizeof(struct lock_lookup)); } static inline void free_lock(struct lock_lookup *lock) { if (likely(!is_static_lock(lock))) free(lock); } /** * __get_lock - find or create a lock instance * @lock: pointer to a pthread lock function * * Try to find an existing lock in the rbtree using the provided pointer. If * one wasn't found - create it. */ static struct lock_lookup *__get_lock(void *lock) { struct rb_node **node, *parent; struct lock_lookup *l; ll_pthread_rwlock_rdlock(&locks_rwlock); node = __get_lock_node(lock, &parent); ll_pthread_rwlock_unlock(&locks_rwlock); if (*node) { return rb_entry(*node, struct lock_lookup, node); } /* We didn't find the lock, let's create it */ l = alloc_lock(); if (l == NULL) return NULL; l->orig = lock; /* * Currently the name of the lock is the ptr value of the pthread lock, * while not optimal, it makes debugging a bit easier. * * TODO: Get the real name of the lock using libdwarf */ sprintf(l->name, "%p", lock); lockdep_init_map(&l->dep_map, l->name, &l->key, 0); ll_pthread_rwlock_wrlock(&locks_rwlock); /* This might have changed since the last time we fetched it */ node = __get_lock_node(lock, &parent); rb_link_node(&l->node, parent, node); rb_insert_color(&l->node, &locks); ll_pthread_rwlock_unlock(&locks_rwlock); return l; } static void __del_lock(struct lock_lookup *lock) { ll_pthread_rwlock_wrlock(&locks_rwlock); rb_erase(&lock->node, &locks); ll_pthread_rwlock_unlock(&locks_rwlock); free_lock(lock); } int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) { int r; /* * We keep trying to init our preload module because there might be * code in init sections that tries to touch locks before we are * initialized, in that case we'll need to manually call preload * to get us going. * * Funny enough, kernel's lockdep had the same issue, and used * (almost) the same solution. See look_up_lock_class() in * kernel/locking/lockdep.c for details. */ try_init_preload(); r = ll_pthread_mutex_init(mutex, attr); if (r == 0) /* * We do a dummy initialization here so that lockdep could * warn us if something fishy is going on - such as * initializing a held lock. */ __get_lock(mutex); return r; } int pthread_mutex_lock(pthread_mutex_t *mutex) { int r; try_init_preload(); lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); /* * Here's the thing with pthread mutexes: unlike the kernel variant, * they can fail. * * This means that the behaviour here is a bit different from what's * going on in the kernel: there we just tell lockdep that we took the * lock before actually taking it, but here we must deal with the case * that locking failed. * * To do that we'll "release" the lock if locking failed - this way * we'll get lockdep doing the correct checks when we try to take * the lock, and if that fails - we'll be back to the correct * state by releasing it. */ r = ll_pthread_mutex_lock(mutex); if (r) lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_mutex_trylock(pthread_mutex_t *mutex) { int r; try_init_preload(); lock_acquire(&__get_lock(mutex)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_); r = ll_pthread_mutex_trylock(mutex); if (r) lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_mutex_unlock(pthread_mutex_t *mutex) { int r; try_init_preload(); lock_release(&__get_lock(mutex)->dep_map, 0, (unsigned long)_RET_IP_); /* * Just like taking a lock, only in reverse! * * If we fail releasing the lock, tell lockdep we're holding it again. */ r = ll_pthread_mutex_unlock(mutex); if (r) lock_acquire(&__get_lock(mutex)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); return r; } int pthread_mutex_destroy(pthread_mutex_t *mutex) { try_init_preload(); /* * Let's see if we're releasing a lock that's held. * * TODO: Hook into free() and add that check there as well. */ debug_check_no_locks_freed(mutex, sizeof(*mutex)); __del_lock(__get_lock(mutex)); return ll_pthread_mutex_destroy(mutex); } /* This is the rwlock part, very similar to what happened with mutex above */ int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) { int r; try_init_preload(); r = ll_pthread_rwlock_init(rwlock, attr); if (r == 0) __get_lock(rwlock); return r; } int pthread_rwlock_destroy(pthread_rwlock_t *rwlock) { try_init_preload(); debug_check_no_locks_freed(rwlock, sizeof(*rwlock)); __del_lock(__get_lock(rwlock)); return ll_pthread_rwlock_destroy(rwlock); } int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) { int r; init_preload(); lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 2, 1, NULL, (unsigned long)_RET_IP_); r = ll_pthread_rwlock_rdlock(rwlock); if (r) lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) { int r; init_preload(); lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 2, 1, NULL, (unsigned long)_RET_IP_); r = ll_pthread_rwlock_tryrdlock(rwlock); if (r) lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) { int r; init_preload(); lock_acquire(&__get_lock(rwlock)->dep_map, 0, 1, 0, 1, NULL, (unsigned long)_RET_IP_); r = ll_pthread_rwlock_trywrlock(rwlock); if (r) lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) { int r; init_preload(); lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); r = ll_pthread_rwlock_wrlock(rwlock); if (r) lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); return r; } int pthread_rwlock_unlock(pthread_rwlock_t *rwlock) { int r; init_preload(); lock_release(&__get_lock(rwlock)->dep_map, 0, (unsigned long)_RET_IP_); r = ll_pthread_rwlock_unlock(rwlock); if (r) lock_acquire(&__get_lock(rwlock)->dep_map, 0, 0, 0, 1, NULL, (unsigned long)_RET_IP_); return r; } __attribute__((constructor)) static void init_preload(void) { if (__init_state == done) return; #ifndef __GLIBC__ __init_state = prepare; ll_pthread_mutex_init = dlsym(RTLD_NEXT, "pthread_mutex_init"); ll_pthread_mutex_lock = dlsym(RTLD_NEXT, "pthread_mutex_lock"); ll_pthread_mutex_trylock = dlsym(RTLD_NEXT, "pthread_mutex_trylock"); ll_pthread_mutex_unlock = dlsym(RTLD_NEXT, "pthread_mutex_unlock"); ll_pthread_mutex_destroy = dlsym(RTLD_NEXT, "pthread_mutex_destroy"); ll_pthread_rwlock_init = dlsym(RTLD_NEXT, "pthread_rwlock_init"); ll_pthread_rwlock_destroy = dlsym(RTLD_NEXT, "pthread_rwlock_destroy"); ll_pthread_rwlock_rdlock = dlsym(RTLD_NEXT, "pthread_rwlock_rdlock"); ll_pthread_rwlock_tryrdlock = dlsym(RTLD_NEXT, "pthread_rwlock_tryrdlock"); ll_pthread_rwlock_wrlock = dlsym(RTLD_NEXT, "pthread_rwlock_wrlock"); ll_pthread_rwlock_trywrlock = dlsym(RTLD_NEXT, "pthread_rwlock_trywrlock"); ll_pthread_rwlock_unlock = dlsym(RTLD_NEXT, "pthread_rwlock_unlock"); #endif __init_state = done; } e&id=c45f8e109b6214a80c27d785c044178231ef4990'>plain -rw-r--r--cache.h733logplain -rw-r--r--call-path.c2893logplain -rw-r--r--call-path.h2203logplain -rw-r--r--callchain.c29332logplain -rw-r--r--callchain.h7881logplain -rw-r--r--cgroup.c3195logplain -rw-r--r--cgroup.h359logplain -rw-r--r--cloexec.c1950logplain -rw-r--r--cloexec.h251logplain -rw-r--r--color.c4787logplain -rw-r--r--color.h1647logplain -rw-r--r--comm.c2239logplain -rw-r--r--comm.h561logplain -rw-r--r--config.c16262logplain -rw-r--r--config.h2113logplain -rw-r--r--counts.c1026logplain -rw-r--r--counts.h790logplain -rw-r--r--cpumap.c12627logplain -rw-r--r--cpumap.h1954logplain -rw-r--r--cs-etm.h2061logplain -rw-r--r--ctype.c2018logplain -rw-r--r--data-convert-bt.c36671logplain -rw-r--r--data-convert-bt.h302logplain -rw-r--r--data-convert.h141logplain -rw-r--r--data.c3459logplain -rw-r--r--data.h1369logplain -rw-r--r--db-export.c11434logplain -rw-r--r--db-export.h3816logplain -rw-r--r--debug.c4417logplain -rw-r--r--debug.h2023logplain -rw-r--r--demangle-java.c4219logplain -rw-r--r--demangle-java.h249logplain -rw-r--r--demangle-rust.c6602logplain -rw-r--r--demangle-rust.h170logplain -rw-r--r--drv_configs.c1834logplain -rw-r--r--drv_configs.h844logplain -rw-r--r--dso.c31994logplain -rw-r--r--dso.h10399logplain -rw-r--r--dwarf-aux.c33828logplain -rw-r--r--dwarf-aux.h5101logplain -rw-r--r--dwarf-regs.c1816logplain -rw-r--r--env.c1884logplain -rw-r--r--env.h1268logplain -rw-r--r--event.c36670logplain -rw-r--r--event.h15997logplain -rw-r--r--evlist.c47104logplain -rw-r--r--evlist.h12584logplain -rw-r--r--evsel.c63917logplain -rw-r--r--evsel.h13041logplain -rw-r--r--evsel_fprintf.c5831logplain -rw-r--r--find-vdso-map.c581logplain -rw-r--r--genelf.c11653logplain -rw-r--r--genelf.h1814logplain -rw-r--r--genelf_debug.c14374logplain -rwxr-xr-xgenerate-cmdlist.sh1141logplain -rw-r--r--group.h122logplain -rw-r--r--header.c73410logplain -rw-r--r--header.h4365logplain -rw-r--r--help-unknown-cmd.c3221logplain