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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.