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     lockdebug_assert_no_locks_locked_except({});
 326 }
 327
 328 void lockdebug_assert_no_locks_locked_except(std::initializer_list<void *> canBeLocked)
 329 {
 330     auto& owned = ownedLocks();
 331
 332     for (const auto& l : AllLocks()) {
 333         if (std::find(canBeLocked.begin(), canBeLocked.end(), l.first) != canBeLocked.end())
 334             continue;
 335
 336         if (hasLock(owned, l.first, l.second.k)) {
 337             _objc_fatal("lock %p:%d is incorrectly owned", l.first, l.second.k);
 338         }
 339     }
 340 }
 341
 342
 343 /***********************************************************************
 344 * Mutex checking
 345 **********************************************************************/
 346
 347 void
 348 lockdebug_mutex_lock(mutex_t *lock)
 349 {
 350     auto& locks = ownedLocks();
 351
 352     if (hasLock(locks, lock, MUTEX)) {
 353         _objc_fatal("deadlock: relocking mutex");
 354     }
 355     setLock(locks, lock, MUTEX);
 356 }
 357
 358 // try-lock success is the only case with lockdebug effects.
 359 // try-lock when already locked is OK (will fail)
 360 // try-lock failure does nothing.
 361 void
 362 lockdebug_mutex_try_lock_success(mutex_t *lock)
 363 {
 364     auto& locks = ownedLocks();
 365     setLock(locks, lock, MUTEX);
 366 }
 367
 368 void
 369 lockdebug_mutex_unlock(mutex_t *lock)
 370 {
 371     auto& locks = ownedLocks();
 372
 373     if (!hasLock(locks, lock, MUTEX)) {
 374         _objc_fatal("unlocking unowned mutex");
 375     }
 376     clearLock(locks, lock, MUTEX);
 377 }
 378
 379
 380 void
 381 lockdebug_mutex_assert_locked(mutex_t *lock)
 382 {
 383     auto& locks = ownedLocks();
 384
 385     if (!hasLock(locks, lock, MUTEX)) {
 386         _objc_fatal("mutex incorrectly not locked");
 387     }
 388 }
 389
 390 void
 391 lockdebug_mutex_assert_unlocked(mutex_t *lock)
 392 {
 393     auto& locks = ownedLocks();
 394
 395     if (hasLock(locks, lock, MUTEX)) {
 396         _objc_fatal("mutex incorrectly locked");
 397     }
 398 }
 399
 400
 401 /***********************************************************************
 402 * Recursive mutex checking
 403 **********************************************************************/
 404
 405 void
 406 lockdebug_recursive_mutex_lock(recursive_mutex_t *lock)
 407 {
 408     auto& locks = ownedLocks();
 409     setLock(locks, lock, RECURSIVE);
 410 }
 411
 412 void
 413 lockdebug_recursive_mutex_unlock(recursive_mutex_t *lock)
 414 {
 415     auto& locks = ownedLocks();
 416
 417     if (!hasLock(locks, lock, RECURSIVE)) {
 418         _objc_fatal("unlocking unowned recursive mutex");
 419     }
 420     clearLock(locks, lock, RECURSIVE);
 421 }
 422
 423
 424 void
 425 lockdebug_recursive_mutex_assert_locked(recursive_mutex_t *lock)
 426 {
 427     auto& locks = ownedLocks();
 428
 429     if (!hasLock(locks, lock, RECURSIVE)) {
 430         _objc_fatal("recursive mutex incorrectly not locked");
 431     }
 432 }
 433
 434 void
 435 lockdebug_recursive_mutex_assert_unlocked(recursive_mutex_t *lock)
 436 {
 437     auto& locks = ownedLocks();
 438
 439     if (hasLock(locks, lock, RECURSIVE)) {
 440         _objc_fatal("recursive mutex incorrectly locked");
 441     }
 442 }
 443
 444
 445 /***********************************************************************
 446 * Monitor checking
 447 **********************************************************************/
 448
 449 void
 450 lockdebug_monitor_enter(monitor_t *lock)
 451 {
 452     auto& locks = ownedLocks();
 453
 454     if (hasLock(locks, lock, MONITOR)) {
 455         _objc_fatal("deadlock: relocking monitor");
 456     }
 457     setLock(locks, lock, MONITOR);
 458 }
 459
 460 void
 461 lockdebug_monitor_leave(monitor_t *lock)
 462 {
 463     auto& locks = ownedLocks();
 464
 465     if (!hasLock(locks, lock, MONITOR)) {
 466         _objc_fatal("unlocking unowned monitor");
 467     }
 468     clearLock(locks, lock, MONITOR);
 469 }
 470
 471 void
 472 lockdebug_monitor_wait(monitor_t *lock)
 473 {
 474     auto& locks = ownedLocks();
 475
 476     if (!hasLock(locks, lock, MONITOR)) {
 477         _objc_fatal("waiting in unowned monitor");
 478     }
 479 }
 480
 481
 482 void
 483 lockdebug_monitor_assert_locked(monitor_t *lock)
 484 {
 485     auto& locks = ownedLocks();
 486
 487     if (!hasLock(locks, lock, MONITOR)) {
 488         _objc_fatal("monitor incorrectly not locked");
 489     }
 490 }
 491
 492 void
 493 lockdebug_monitor_assert_unlocked(monitor_t *lock)
 494 {
 495     auto& locks = ownedLocks();
 496
 497     if (hasLock(locks, lock, MONITOR)) {
 498         _objc_fatal("monitor incorrectly held");
 499     }
 500 }
 501
 502 #endif