runtime/objc-lockdebug.mm

   1 /*
   2  * Copyright (c) 2007 Apple Inc.  All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /***********************************************************************
  25 * objc-lock.m
  26 * Error-checking locks for debugging.
  27 **********************************************************************/
  28
  29 #include "objc-private.h"
  30
  31 #if LOCKDEBUG  &&  !TARGET_OS_WIN32
  32
  33 #include <unordered_map>
  34
  35
  36 /***********************************************************************
  37 * Thread-local bool set during _objc_atfork_prepare().
  38 * That function is allowed to break some lock ordering rules.
  39 **********************************************************************/
  40
  41 static tls_key_t fork_prepare_tls;
  42
  43 void
  44 lockdebug_setInForkPrepare(bool inForkPrepare)
  45 {
  46     INIT_ONCE_PTR(fork_prepare_tls, tls_create(nil), (void)0);
  47     tls_set(fork_prepare_tls, (void*)inForkPrepare);
  48 }
  49
  50 static bool
  51 inForkPrepare()
  52 {
  53     INIT_ONCE_PTR(fork_prepare_tls, tls_create(nil), (void)0);
  54     return (bool)tls_get(fork_prepare_tls);
  55 }
  56
  57
  58
  59 /***********************************************************************
  60 * Lock order graph.
  61 * "lock X precedes lock Y" means that X must be acquired first.
  62 * This property is transitive.
  63 **********************************************************************/
  64
  65 struct lockorder {
  66     const void *l;
  67     std::vector<const lockorder *> predecessors;
  68
  69     mutable std::unordered_map<const lockorder *, bool> memo;
  70
  71     lockorder(const void *newl) : l(newl) { }
  72 };
  73
  74 static std::unordered_map<const void*, lockorder *> lockOrderList;
  75 // not mutex_t because we don't want lock debugging on this lock
  76 static mutex_tt<false> lockOrderLock;
  77
  78 static bool
  79 lockPrecedesLock(const lockorder *oldlock, const lockorder *newlock)
  80 {
  81     auto memoed = newlock->memo.find(oldlock);
  82     if (memoed != newlock->memo.end()) {
  83         return memoed->second;
  84     }
  85
  86     bool result = false;
  87     for (const auto *pre : newlock->predecessors) {
  88         if (oldlock == pre  ||  lockPrecedesLock(oldlock, pre)) {
  89             result = true;
  90             break;
  91         }
  92     }
  93
  94     newlock->memo[oldlock] = result;
  95     return result;
  96 }
  97
  98 static bool
  99 lockPrecedesLock(const void *oldlock, const void *newlock)
 100 {
 101     mutex_tt<false>::locker lock(lockOrderLock);
 102
 103     auto oldorder = lockOrderList.find(oldlock);
 104     auto neworder = lockOrderList.find(newlock);
 105     if (neworder == lockOrderList.end() || oldorder == lockOrderList.end()) {
 106         return false;
 107     }
 108     return lockPrecedesLock(oldorder->second, neworder->second);
 109 }
 110
 111 static bool
 112 lockUnorderedWithLock(const void *oldlock, const void *newlock)
 113 {
 114     mutex_tt<false>::locker lock(lockOrderLock);
 115
 116     auto oldorder = lockOrderList.find(oldlock);
 117     auto neworder = lockOrderList.find(newlock);
 118     if (neworder == lockOrderList.end() || oldorder == lockOrderList.end()) {
 119         return true;
 120     }
 121
 122     if (lockPrecedesLock(oldorder->second, neworder->second) ||
 123         lockPrecedesLock(neworder->second, oldorder->second))
 124     {
 125         return false;
 126     }
 127
 128     return true;
 129 }
 130
 131 void lockdebug_lock_precedes_lock(const void *oldlock, const void *newlock)
 132 {
 133     if (lockPrecedesLock(newlock, oldlock)) {
 134         _objc_fatal("contradiction in lock order declaration");
 135     }
 136
 137     mutex_tt<false>::locker lock(lockOrderLock);
 138
 139     auto oldorder = lockOrderList.find(oldlock);
 140     auto neworder = lockOrderList.find(newlock);
 141     if (oldorder == lockOrderList.end()) {
 142         lockOrderList[oldlock] = new lockorder(oldlock);
 143         oldorder = lockOrderList.find(oldlock);
 144     }
 145     if (neworder == lockOrderList.end()) {
 146         lockOrderList[newlock] = new lockorder(newlock);
 147         neworder = lockOrderList.find(newlock);
 148     }
 149
 150     neworder->second->predecessors.push_back(oldorder->second);
 151 }
 152
 153
 154 /***********************************************************************
 155 * Recording - per-thread list of mutexes and monitors held
 156 **********************************************************************/
 157
 158 enum class lockkind {
 159     MUTEX = 1, MONITOR = 2, RDLOCK = 3, WRLOCK = 4, RECURSIVE = 5
 160 };
 161
 162 #define MUTEX     lockkind::MUTEX
 163 #define MONITOR   lockkind::MONITOR
 164 #define RDLOCK    lockkind::RDLOCK
 165 #define WRLOCK    lockkind::WRLOCK
 166 #define RECURSIVE lockkind::RECURSIVE
 167
 168 struct lockcount {
 169     lockkind k;  // the kind of lock it is (MUTEX, MONITOR, etc)
 170     int i;       // the lock's nest count
 171 };
 172
 173 using objc_lock_list = std::unordered_map<const void *, lockcount>;
 174
 175
 176 // Thread-local list of locks owned by a thread.
 177 // Used by lock ownership checks.
 178 static tls_key_t lock_tls;
 179
 180 // Global list of all locks.
 181 // Used by fork() safety check.
 182 // This can't be a static struct because of C++ initialization order problems.
 183 static objc_lock_list& AllLocks() {
 184     static objc_lock_list *locks;
 185     INIT_ONCE_PTR(locks, new objc_lock_list, (void)0);
 186     return *locks;
 187 }
 188
 189
 190 static void
 191 destroyLocks(void *value)
 192 {
 193     auto locks = (objc_lock_list *)value;
 194     // fixme complain about any still-held locks?
 195     if (locks) delete locks;
 196 }
 197
 198 static objc_lock_list&
 199 ownedLocks()
 200 {
 201     // Use a dedicated tls key to prevent differences vs non-debug in
 202     // usage of objc's other tls keys (required for some unit tests).
 203     INIT_ONCE_PTR(lock_tls, tls_create(&destroyLocks), (void)0);
 204
 205     auto locks = (objc_lock_list *)tls_get(lock_tls);
 206     if (!locks) {
 207         locks = new objc_lock_list;
 208         tls_set(lock_tls, locks);
 209     }
 210
 211     return *locks;
 212 }
 213
 214 static bool
 215 hasLock(objc_lock_list& locks, const void *lock, lockkind kind)
 216 {
 217     auto iter = locks.find(lock);
 218     if (iter != locks.end() && iter->second.k == kind) return true;
 219     return false;
 220 }
 221
 222
 223 static const char *sym(const void *lock)
 224 {
 225     Dl_info info;
 226     int ok = dladdr(lock, &info);
 227     if (ok && info.dli_sname && info.dli_sname[0]) return info.dli_sname;
 228     else return "??";
 229 }
 230
 231 static void
 232 setLock(objc_lock_list& locks, const void *lock, lockkind kind)
 233 {
 234     // Check if we already own this lock.
 235     auto iter = locks.find(lock);
 236     if (iter != locks.end() && iter->second.k == kind) {
 237         iter->second.i++;
 238         return;
 239     }
 240
 241     // Newly-acquired lock. Verify lock ordering.
 242     // Locks not in AllLocks are exempt (i.e. @synchronize locks)
 243     if (&locks != &AllLocks() && AllLocks().find(lock) != AllLocks().end()) {
 244         for (auto& oldlock : locks) {
 245             if (AllLocks().find(oldlock.first) == AllLocks().end()) {
 246                 // oldlock is exempt
 247                 continue;
 248             }
 249
 250             if (lockPrecedesLock(lock, oldlock.first)) {
 251                 _objc_fatal("lock %p (%s) incorrectly acquired before %p (%s)",
 252                             oldlock.first, sym(oldlock.first), lock, sym(lock));
 253             }
 254             if (!inForkPrepare() &&
 255                 lockUnorderedWithLock(lock, oldlock.first))
 256             {
 257                 // _objc_atfork_prepare is allowed to acquire
 258                 // otherwise-unordered locks, but nothing else may.
 259                 _objc_fatal("lock %p (%s) acquired before %p (%s) "
 260                             "with no defined lock order",
 261                             oldlock.first, sym(oldlock.first), lock, sym(lock));
 262             }
 263         }
 264     }
 265
 266     locks[lock] = lockcount{kind, 1};
 267 }
 268
 269 static void
 270 clearLock(objc_lock_list& locks, const void *lock, lockkind kind)
 271 {
 272     auto iter = locks.find(lock);
 273     if (iter != locks.end()) {
 274         auto& l = iter->second;
 275         if (l.k == kind) {
 276             if (--l.i == 0) {
 277                 locks.erase(iter);
 278             }
 279             return;
 280         }
 281     }
 282
 283     _objc_fatal("lock not found!");
 284 }
 285
 286
 287 /***********************************************************************
 288 * fork() safety checking
 289 **********************************************************************/
 290
 291 void
 292 lockdebug_remember_mutex(mutex_t *lock)
 293 {
 294     setLock(AllLocks(), lock, MUTEX);
 295 }
 296
 297 void
 298 lockdebug_remember_recursive_mutex(recursive_mutex_t *lock)
 299 {
 300     setLock(AllLocks(), lock, RECURSIVE);
 301 }
 302
 303 void
 304 lockdebug_remember_monitor(monitor_t *lock)
 305 {
 306     setLock(AllLocks(), lock, MONITOR);
 307 }
 308
 309 void
 310 lockdebug_assert_all_locks_locked()
 311 {
 312     auto& owned = ownedLocks();
 313
 314     for (const auto& l : AllLocks()) {
 315         if (!hasLock(owned, l.first, l.second.k)) {
 316             _objc_fatal("lock %p:%d is incorrectly not owned",
 317                         l.first, l.second.k);
 318         }
 319     }
 320 }
 321
 322 void
 323 lockdebug_assert_no_locks_locked()
 324 {
 325     auto& owned = ownedLocks();
 326
 327     for (const auto& l : AllLocks()) {
 328         if (hasLock(owned, l.first, l.second.k)) {
 329             _objc_fatal("lock %p:%d is incorrectly owned", l.first, l.second.k);
 330         }
 331     }
 332 }
 333
 334
 335 /***********************************************************************
 336 * Mutex checking
 337 **********************************************************************/
 338
 339 void
 340 lockdebug_mutex_lock(mutex_t *lock)
 341 {
 342     auto& locks = ownedLocks();
 343
 344     if (hasLock(locks, lock, MUTEX)) {
 345         _objc_fatal("deadlock: relocking mutex");
 346     }
 347     setLock(locks, lock, MUTEX);
 348 }
 349
 350 // try-lock success is the only case with lockdebug effects.
 351 // try-lock when already locked is OK (will fail)
 352 // try-lock failure does nothing.
 353 void
 354 lockdebug_mutex_try_lock_success(mutex_t *lock)
 355 {
 356     auto& locks = ownedLocks();
 357     setLock(locks, lock, MUTEX);
 358 }
 359
 360 void
 361 lockdebug_mutex_unlock(mutex_t *lock)
 362 {
 363     auto& locks = ownedLocks();
 364
 365     if (!hasLock(locks, lock, MUTEX)) {
 366         _objc_fatal("unlocking unowned mutex");
 367     }
 368     clearLock(locks, lock, MUTEX);
 369 }
 370
 371
 372 void
 373 lockdebug_mutex_assert_locked(mutex_t *lock)
 374 {
 375     auto& locks = ownedLocks();
 376
 377     if (!hasLock(locks, lock, MUTEX)) {
 378         _objc_fatal("mutex incorrectly not locked");
 379     }
 380 }
 381
 382 void
 383 lockdebug_mutex_assert_unlocked(mutex_t *lock)
 384 {
 385     auto& locks = ownedLocks();
 386
 387     if (hasLock(locks, lock, MUTEX)) {
 388         _objc_fatal("mutex incorrectly locked");
 389     }
 390 }
 391
 392
 393 /***********************************************************************
 394 * Recursive mutex checking
 395 **********************************************************************/
 396
 397 void
 398 lockdebug_recursive_mutex_lock(recursive_mutex_t *lock)
 399 {
 400     auto& locks = ownedLocks();
 401     setLock(locks, lock, RECURSIVE);
 402 }
 403
 404 void
 405 lockdebug_recursive_mutex_unlock(recursive_mutex_t *lock)
 406 {
 407     auto& locks = ownedLocks();
 408
 409     if (!hasLock(locks, lock, RECURSIVE)) {
 410         _objc_fatal("unlocking unowned recursive mutex");
 411     }
 412     clearLock(locks, lock, RECURSIVE);
 413 }
 414
 415
 416 void
 417 lockdebug_recursive_mutex_assert_locked(recursive_mutex_t *lock)
 418 {
 419     auto& locks = ownedLocks();
 420
 421     if (!hasLock(locks, lock, RECURSIVE)) {
 422         _objc_fatal("recursive mutex incorrectly not locked");
 423     }
 424 }
 425
 426 void
 427 lockdebug_recursive_mutex_assert_unlocked(recursive_mutex_t *lock)
 428 {
 429     auto& locks = ownedLocks();
 430
 431     if (hasLock(locks, lock, RECURSIVE)) {
 432         _objc_fatal("recursive mutex incorrectly locked");
 433     }
 434 }
 435
 436
 437 /***********************************************************************
 438 * Monitor checking
 439 **********************************************************************/
 440
 441 void
 442 lockdebug_monitor_enter(monitor_t *lock)
 443 {
 444     auto& locks = ownedLocks();
 445
 446     if (hasLock(locks, lock, MONITOR)) {
 447         _objc_fatal("deadlock: relocking monitor");
 448     }
 449     setLock(locks, lock, MONITOR);
 450 }
 451
 452 void
 453 lockdebug_monitor_leave(monitor_t *lock)
 454 {
 455     auto& locks = ownedLocks();
 456
 457     if (!hasLock(locks, lock, MONITOR)) {
 458         _objc_fatal("unlocking unowned monitor");
 459     }
 460     clearLock(locks, lock, MONITOR);
 461 }
 462
 463 void
 464 lockdebug_monitor_wait(monitor_t *lock)
 465 {
 466     auto& locks = ownedLocks();
 467
 468     if (!hasLock(locks, lock, MONITOR)) {
 469         _objc_fatal("waiting in unowned monitor");
 470     }
 471 }
 472
 473
 474 void
 475 lockdebug_monitor_assert_locked(monitor_t *lock)
 476 {
 477     auto& locks = ownedLocks();
 478
 479     if (!hasLock(locks, lock, MONITOR)) {
 480         _objc_fatal("monitor incorrectly not locked");
 481     }
 482 }
 483
 484 void
 485 lockdebug_monitor_assert_unlocked(monitor_t *lock)
 486 {
 487     auto& locks = ownedLocks();
 488
 489     if (hasLock(locks, lock, MONITOR)) {
 490         _objc_fatal("monitor incorrectly held");
 491     }
 492 }
 493
 494 #endif