lib/libprocstat/libprocstat.c

1309

error = kvm_read_all(kd, (unsigned long)vnode.v_lock.lock_object.lo_name,

sys/amd64/amd64/pmap.c

655

static struct lock_object invl_gen_ts = {

sys/cddl/compat/opensolaris/sys/rwlock.h

62

KASSERT(((lock)->lock_object.lo_flags & LO_ALLMASK) != \

sys/compat/linuxkpi/common/include/linux/lockdep.h

58

struct lock_object *__lock = (struct lock_object *)(m); \

sys/compat/linuxkpi/common/include/linux/lockdep.h

63

struct lock_object *__lock = (struct lock_object *)(m); \

sys/compat/linuxkpi/common/include/linux/lockdep.h

68

struct lock_object *__lock = (struct lock_object *)(m); \

sys/compat/linuxkpi/common/include/linux/lockdep.h

90

struct lock_object *__lock;

sys/crypto/ccp/ccp.c

711

#define db_show_lock(lk) _db_show_lock(&(lk)->lock_object)

sys/ddb/db_ps.c

345

struct lock_object *lock;

sys/ddb/db_ps.c

354

lock = (struct lock_object *)td->td_lock;

sys/dev/cxgb/cxgb_adapter.h

74

printf("destroying %s at %s:%d\n", (lock)->lock_object.lo_name, __FILE__, __LINE__); \

sys/dev/ioat/ioat.c

2049

#define db_show_lock(lk) _db_show_lock(&(lk)->lock_object)

sys/kern/kern_condvar.c

108

_cv_wait(struct cv *cvp, struct lock_object *lock)

sys/kern/kern_condvar.c

140

if (lock == &Giant.lock_object)

sys/kern/kern_condvar.c

145

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

160

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

171

_cv_wait_unlock(struct cv *cvp, struct lock_object *lock)

sys/kern/kern_condvar.c

183

KASSERT(lock != &Giant.lock_object,

sys/kern/kern_condvar.c

228

_cv_wait_sig(struct cv *cvp, struct lock_object *lock)

sys/kern/kern_condvar.c

261

if (lock == &Giant.lock_object)

sys/kern/kern_condvar.c

267

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

282

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

296

_cv_timedwait_sbt(struct cv *cvp, struct lock_object *lock, sbintime_t sbt,

sys/kern/kern_condvar.c

329

if (lock == &Giant.lock_object)

sys/kern/kern_condvar.c

335

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

350

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

366

_cv_timedwait_sig_sbt(struct cv *cvp, struct lock_object *lock,

sys/kern/kern_condvar.c

399

if (lock == &Giant.lock_object)

sys/kern/kern_condvar.c

406

if (lock != &Giant.lock_object) {

sys/kern/kern_condvar.c

421

if (lock != &Giant.lock_object) {

sys/kern/kern_lock.c

1010

LOCK_LOG_LOCK("XUPGRADE", &lk->lock_object, 0, 0, file,

sys/kern/kern_lock.c

1012

WITNESS_UPGRADE(&lk->lock_object, LOP_EXCLUSIVE |

sys/kern/kern_lock.c

1029

lockmgr_lock_flags(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

1045

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER,

sys/kern/kern_lock.c

1047

if (__predict_false(lk->lock_object.lo_flags & LK_NOSHARE))

sys/kern/kern_lock.c

105

WITNESS_RESTORE(&Giant.lock_object, Giant); \

sys/kern/kern_lock.c

1061

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER |

sys/kern/kern_lock.c

1094

lockmgr_sunlock_hard(struct lock *lk, uintptr_t x, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

110

WITNESS_SAVE(&Giant.lock_object, Giant); \

sys/kern/kern_lock.c

1104

lockmgr_xunlock_hard(struct lock *lk, uintptr_t x, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

1142

sleepq_lock(&lk->lock_object);

sys/kern/kern_lock.c

1162

realexslp = sleepq_sleepcnt(&lk->lock_object, SQ_EXCLUSIVE_QUEUE);

sys/kern/kern_lock.c

1176

sleepq_broadcast(&lk->lock_object, SLEEPQ_LK, 0,

sys/kern/kern_lock.c

1195

sleepq_broadcast(&lk->lock_object, SLEEPQ_LK, 0, queue);

sys/kern/kern_lock.c

1196

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

1221

MPASS((lk->lock_object.lo_flags & LK_NOSHARE) == 0);

sys/kern/kern_lock.c

1224

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER,

sys/kern/kern_lock.c

1244

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER |

sys/kern/kern_lock.c

1288

__lockmgr_args(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

1309

iwmesg = (wmesg == LK_WMESG_DEFAULT) ? lk->lock_object.lo_name : wmesg;

sys/kern/kern_lock.c

1333

if (lk->lock_object.lo_flags & LK_NOSHARE) {

sys/kern/kern_lock.c

1362

WITNESS_DOWNGRADE(&lk->lock_object, 0, file, line);

sys/kern/kern_lock.c

1387

LOCK_LOG_LOCK("XDOWNGRADE", &lk->lock_object, 0, 0, file, line);

sys/kern/kern_lock.c

1404

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER |

sys/kern/kern_lock.c

1427

lock_profile_obtain_lock_failed(&lk->lock_object, false,

sys/kern/kern_lock.c

1445

sleepq_lock(&lk->lock_object);

sys/kern/kern_lock.c

1453

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

146

static void assert_lockmgr(const struct lock_object *lock, int how);

sys/kern/kern_lock.c

148

static void db_show_lockmgr(const struct lock_object *lock);

sys/kern/kern_lock.c

1493

sleepq_sleepcnt(&lk->lock_object,

sys/kern/kern_lock.c

150

static void lock_lockmgr(struct lock_object *lock, uintptr_t how);

sys/kern/kern_lock.c

1507

&lk->lock_object,

sys/kern/kern_lock.c

1515

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

152

static int owner_lockmgr(const struct lock_object *lock,

sys/kern/kern_lock.c

1522

sleepq_broadcast(&lk->lock_object, SLEEPQ_LK, 0,

sys/kern/kern_lock.c

1546

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

155

static uintptr_t unlock_lockmgr(struct lock_object *lock);

sys/kern/kern_lock.c

1563

sleepq_add(&lk->lock_object, NULL, iwmesg, SLEEPQ_LK,

sys/kern/kern_lock.c

1565

sleepq_wait(&lk->lock_object, ipri & PRIMASK);

sys/kern/kern_lock.c

1572

lock_profile_obtain_lock_success(&lk->lock_object,

sys/kern/kern_lock.c

1574

LOCK_LOG_LOCK("DRAIN", &lk->lock_object, 0,

sys/kern/kern_lock.c

1576

WITNESS_LOCK(&lk->lock_object, LOP_EXCLUSIVE |

sys/kern/kern_lock.c

1617

lock_profile_release_lock(&lk->lock_object, false);

sys/kern/kern_lock.c

1619

LOCK_LOG_LOCK("XDISOWN", &lk->lock_object, 0, 0, file, line);

sys/kern/kern_lock.c

1620

WITNESS_UNLOCK(&lk->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_lock.c

1645

printf("lock type %s: UNLOCKED\n", lk->lock_object.lo_name);

sys/kern/kern_lock.c

1648

lk->lock_object.lo_name,

sys/kern/kern_lock.c

1654

lk->lock_object.lo_name);

sys/kern/kern_lock.c

1657

"(pid %d, %s, tid %d)\n", lk->lock_object.lo_name,

sys/kern/kern_lock.c

1727

witness_assert(&lk->lock_object, what, file, line);

sys/kern/kern_lock.c

1735

lk->lock_object.lo_name, slocked ? "share" : "",

sys/kern/kern_lock.c

1742

lk->lock_object.lo_name, file,

sys/kern/kern_lock.c

1746

lk->lock_object.lo_name, file, line);

sys/kern/kern_lock.c

1754

lk->lock_object.lo_name, file, line);

sys/kern/kern_lock.c

1758

lk->lock_object.lo_name, file, line);

sys/kern/kern_lock.c

1761

lk->lock_object.lo_name, file, line);

sys/kern/kern_lock.c

1766

lk->lock_object.lo_name, file, line);

sys/kern/kern_lock.c

1784

LOCK_CLASS(&lk->lock_object) != &lock_class_lockmgr)

sys/kern/kern_lock.c

1786

db_printf("blocked on lock %p (%s) \"%s\" ", &lk->lock_object,

sys/kern/kern_lock.c

1787

lock_class_lockmgr.lc_name, lk->lock_object.lo_name);

sys/kern/kern_lock.c

1799

db_show_lockmgr(const struct lock_object *lock)

sys/kern/kern_lock.c

189

lockmgr_exit(u_int flags, struct lock_object *ilk)

sys/kern/kern_lock.c

206

LOCK_LOG_LOCK("SLOCK", &lk->lock_object, 0, 0, file, line);

sys/kern/kern_lock.c

207

WITNESS_LOCK(&lk->lock_object, LK_TRYWIT(flags), file, line);

sys/kern/kern_lock.c

217

WITNESS_UNLOCK(&lk->lock_object, 0, file, line);

sys/kern/kern_lock.c

218

LOCK_LOG_LOCK("SUNLOCK", &lk->lock_object, 0, 0, file, line);

sys/kern/kern_lock.c

230

LOCK_LOG_LOCK("XLOCK", &lk->lock_object, 0, lk->lk_recurse, file, line);

sys/kern/kern_lock.c

231

WITNESS_LOCK(&lk->lock_object, LOP_EXCLUSIVE | LK_TRYWIT(flags), file,

sys/kern/kern_lock.c

242

WITNESS_UNLOCK(&lk->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_lock.c

245

LOCK_LOG_LOCK("XUNLOCK", &lk->lock_object, 0, lk->lk_recurse, file,

sys/kern/kern_lock.c

265

sleeplk(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

287

sleepq_add(&lk->lock_object, NULL, wmesg, SLEEPQ_LK | (catch ?

sys/kern/kern_lock.c

290

sleepq_set_timeout(&lk->lock_object, timo);

sys/kern/kern_lock.c

296

error = sleepq_timedwait_sig(&lk->lock_object, pri);

sys/kern/kern_lock.c

298

error = sleepq_timedwait(&lk->lock_object, pri);

sys/kern/kern_lock.c

300

error = sleepq_wait_sig(&lk->lock_object, pri);

sys/kern/kern_lock.c

302

sleepq_wait(&lk->lock_object, pri);

sys/kern/kern_lock.c

326

sleepq_lock(&lk->lock_object);

sys/kern/kern_lock.c

345

realexslp = sleepq_sleepcnt(&lk->lock_object,

sys/kern/kern_lock.c

360

sleepq_broadcast(&lk->lock_object, SLEEPQ_LK, 0,

sys/kern/kern_lock.c

376

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

388

sleepq_broadcast(&lk->lock_object, SLEEPQ_LK, 0, queue);

sys/kern/kern_lock.c

389

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

397

assert_lockmgr(const struct lock_object *lock, int what)

sys/kern/kern_lock.c

404

lock_lockmgr(struct lock_object *lock, uintptr_t how)

sys/kern/kern_lock.c

411

unlock_lockmgr(struct lock_object *lock)

sys/kern/kern_lock.c

419

owner_lockmgr(const struct lock_object *lock, struct thread **owner)

sys/kern/kern_lock.c

453

lock_init(&lk->lock_object, &lock_class_lockmgr, wmesg, NULL, iflags);

sys/kern/kern_lock.c

471

lk->lock_object.lo_flags &= ~LK_NOSHARE;

sys/kern/kern_lock.c

479

lk->lock_object.lo_flags |= LK_NOSHARE;

sys/kern/kern_lock.c

487

lk->lock_object.lo_flags |= LO_RECURSABLE;

sys/kern/kern_lock.c

495

lk->lock_object.lo_flags &= ~LO_RECURSABLE;

sys/kern/kern_lock.c

505

lock_destroy(&lk->lock_object);

sys/kern/kern_lock.c

577

lockmgr_slock_hard(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

600

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER,

sys/kern/kern_lock.c

622

lock_profile_obtain_lock_failed(&lk->lock_object, false,

sys/kern/kern_lock.c

649

sleepq_lock(&lk->lock_object);

sys/kern/kern_lock.c

658

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

676

iwmesg = lk->lock_object.lo_name;

sys/kern/kern_lock.c

691

sleep_time -= lockstat_nsecs(&lk->lock_object);

sys/kern/kern_lock.c

696

sleep_time += lockstat_nsecs(&lk->lock_object);

sys/kern/kern_lock.c

762

lockmgr_xlock_hard(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lock.c

786

WITNESS_CHECKORDER(&lk->lock_object, LOP_NEWORDER |

sys/kern/kern_lock.c

796

(lk->lock_object.lo_flags & LO_RECURSABLE) == 0) {

sys/kern/kern_lock.c

819

LOCK_LOG_LOCK("XLOCK", &lk->lock_object, 0,

sys/kern/kern_lock.c

821

WITNESS_LOCK(&lk->lock_object, LOP_EXCLUSIVE |

sys/kern/kern_lock.c

838

lock_profile_obtain_lock_failed(&lk->lock_object, false,

sys/kern/kern_lock.c

864

sleepq_lock(&lk->lock_object);

sys/kern/kern_lock.c

873

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

891

sleepq_release(&lk->lock_object);

sys/kern/kern_lock.c

914

iwmesg = lk->lock_object.lo_name;

sys/kern/kern_lock.c

92

if (LOCK_LOG_TEST(&(lk)->lock_object, 0)) \

sys/kern/kern_lock.c

929

sleep_time -= lockstat_nsecs(&lk->lock_object);

sys/kern/kern_lock.c

934

sleep_time += lockstat_nsecs(&lk->lock_object);

sys/kern/kern_lock.c

95

if (LOCK_LOG_TEST(&(lk)->lock_object, 0)) \

sys/kern/kern_lock.c

969

lockmgr_upgrade(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/kern/kern_lockstat.c

75

lockstat_nsecs(struct lock_object *lo)

sys/kern/kern_mutex.c

101

static void lock_mtx(struct lock_object *lock, uintptr_t how);

sys/kern/kern_mutex.c

102

static void lock_spin(struct lock_object *lock, uintptr_t how);

sys/kern/kern_mutex.c

103

static int trylock_mtx(struct lock_object *lock, uintptr_t how);

sys/kern/kern_mutex.c

104

static int trylock_spin(struct lock_object *lock, uintptr_t how);

sys/kern/kern_mutex.c

1055

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

106

static int owner_mtx(const struct lock_object *lock,

sys/kern/kern_mutex.c

1068

turnstile_chain_lock(&m->lock_object);

sys/kern/kern_mutex.c

1070

ts = turnstile_lookup(&m->lock_object);

sys/kern/kern_mutex.c

1072

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

1081

turnstile_chain_unlock(&m->lock_object);

sys/kern/kern_mutex.c

109

static uintptr_t unlock_mtx(struct lock_object *lock);

sys/kern/kern_mutex.c

110

static uintptr_t unlock_spin(struct lock_object *lock);

sys/kern/kern_mutex.c

1109

m->lock_object.lo_name, file, line);

sys/kern/kern_mutex.c

1113

m->lock_object.lo_name, file, line);

sys/kern/kern_mutex.c

1116

m->lock_object.lo_name, file, line);

sys/kern/kern_mutex.c

1122

m->lock_object.lo_name, file, line);

sys/kern/kern_mutex.c

1183

lock_init(&m->lock_object, class, name, type, flags);

sys/kern/kern_mutex.c

1208

if (LOCK_CLASS(&m->lock_object) == &lock_class_mtx_spin) {

sys/kern/kern_mutex.c

1209

lock_profile_release_lock(&m->lock_object, true);

sys/kern/kern_mutex.c

1213

lock_profile_release_lock(&m->lock_object, false);

sys/kern/kern_mutex.c

1217

WITNESS_UNLOCK(&m->lock_object, LOP_EXCLUSIVE, __FILE__,

sys/kern/kern_mutex.c

1222

lock_destroy(&m->lock_object);

sys/kern/kern_mutex.c

1268

m, m->lock_object.lo_name, td, td->td_tid);

sys/kern/kern_mutex.c

1270

witness_display_spinlock(&m->lock_object, td, printf);

sys/kern/kern_mutex.c

1284

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_sleep,

sys/kern/kern_mutex.c

1286

m->lock_object.lo_name));

sys/kern/kern_mutex.c

1288

m->lock_object.lo_name));

sys/kern/kern_mutex.c

1310

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_spin,

sys/kern/kern_mutex.c

1312

m->lock_object.lo_name));

sys/kern/kern_mutex.c

1314

m->lock_object.lo_name));

sys/kern/kern_mutex.c

1333

db_show_mtx(const struct lock_object *lock)

sys/kern/kern_mutex.c

1345

if (m->lock_object.lo_flags & LO_RECURSABLE)

sys/kern/kern_mutex.c

1347

if (m->lock_object.lo_flags & LO_DUPOK)

sys/kern/kern_mutex.c

188

assert_mtx(const struct lock_object *lock, int what)

sys/kern/kern_mutex.c

210

lock_mtx(struct lock_object *lock, uintptr_t how)

sys/kern/kern_mutex.c

217

lock_spin(struct lock_object *lock, uintptr_t how)

sys/kern/kern_mutex.c

224

trylock_mtx(struct lock_object *lock, uintptr_t how)

sys/kern/kern_mutex.c

231

trylock_spin(struct lock_object *lock, uintptr_t how)

sys/kern/kern_mutex.c

238

unlock_mtx(struct lock_object *lock)

sys/kern/kern_mutex.c

249

unlock_spin(struct lock_object *lock)

sys/kern/kern_mutex.c

261

owner_mtx(const struct lock_object *lock, struct thread **owner)

sys/kern/kern_mutex.c

291

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_spin,

sys/kern/kern_mutex.c

292

("mtx_lock() of spin mutex %s @ %s:%d", m->lock_object.lo_name,

sys/kern/kern_mutex.c

294

WITNESS_CHECKORDER(&m->lock_object, (opts & ~MTX_RECURSE) |

sys/kern/kern_mutex.c

304

LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file,

sys/kern/kern_mutex.c

306

WITNESS_LOCK(&m->lock_object, (opts & ~MTX_RECURSE) | LOP_EXCLUSIVE,

sys/kern/kern_mutex.c

320

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_spin,

sys/kern/kern_mutex.c

321

("mtx_unlock() of spin mutex %s @ %s:%d", m->lock_object.lo_name,

sys/kern/kern_mutex.c

323

WITNESS_UNLOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

324

LOCK_LOG_LOCK("UNLOCK", &m->lock_object, opts, m->mtx_recurse, file,

sys/kern/kern_mutex.c

349

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_sleep,

sys/kern/kern_mutex.c

351

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

353

KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) != 0 ||

sys/kern/kern_mutex.c

356

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

358

WITNESS_CHECKORDER(&m->lock_object, opts | LOP_NEWORDER | LOP_EXCLUSIVE,

sys/kern/kern_mutex.c

372

LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file,

sys/kern/kern_mutex.c

374

WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

391

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_sleep,

sys/kern/kern_mutex.c

393

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

396

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

398

LOCK_LOG_TRY("LOCK", &m->lock_object, opts, 1, file, line);

sys/kern/kern_mutex.c

399

WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

402

LOCK_LOG_TRY("LOCK", &m->lock_object, opts, 0, file, line);

sys/kern/kern_mutex.c

417

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_sleep,

sys/kern/kern_mutex.c

419

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

420

WITNESS_UNLOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

421

LOCK_LOG_LOCK("UNLOCK", &m->lock_object, opts, m->mtx_recurse, file,

sys/kern/kern_mutex.c

455

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_spin,

sys/kern/kern_mutex.c

456

("mtx_trylock() of spin mutex %s @ %s:%d", m->lock_object.lo_name,

sys/kern/kern_mutex.c

468

((m->lock_object.lo_flags & LO_RECURSABLE) != 0 ||

sys/kern/kern_mutex.c

481

LOCK_LOG_TRY("LOCK", &m->lock_object, opts, rval, file, line);

sys/kern/kern_mutex.c

483

WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_mutex.c

550

all_time -= lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

564

KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) != 0 ||

sys/kern/kern_mutex.c

567

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

573

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

590

lock_profile_obtain_lock_failed(&m->lock_object, false,

sys/kern/kern_mutex.c

592

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

595

m->lock_object.lo_name, (void *)m->mtx_lock, file, line);

sys/kern/kern_mutex.c

597

THREAD_CONTENDS_ON_LOCK(&m->lock_object);

sys/kern/kern_mutex.c

615

if (LOCK_LOG_TEST(&m->lock_object, 0))

sys/kern/kern_mutex.c

622

m->lock_object.lo_name);

sys/kern/kern_mutex.c

635

ts = turnstile_trywait(&m->lock_object);

sys/kern/kern_mutex.c

677

sleep_time -= lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

685

sleep_time += lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

690

THREAD_CONTENTION_DONE(&m->lock_object);

sys/kern/kern_mutex.c

696

all_time += lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

751

spin_time -= lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

769

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

772

"spinning", "lockname:\"%s\"", m->lock_object.lo_name);

sys/kern/kern_mutex.c

779

lock_profile_obtain_lock_failed(&m->lock_object, true, &contested, &waittime);

sys/kern/kern_mutex.c

800

if (LOCK_LOG_TEST(&m->lock_object, opts))

sys/kern/kern_mutex.c

810

spin_time += lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

827

KASSERT(LOCK_CLASS(&m->lock_object) != &lock_class_mtx_sleep,

sys/kern/kern_mutex.c

829

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

830

KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) == 0,

sys/kern/kern_mutex.c

832

m->lock_object.lo_name, file, line));

sys/kern/kern_mutex.c

833

WITNESS_CHECKORDER(&m->lock_object,

sys/kern/kern_mutex.c

864

WITNESS_LOCK(&m->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

921

spin_time -= lockstat_nsecs(&td->td_lock->lock_object);

sys/kern/kern_mutex.c

937

lock_profile_obtain_lock_failed(&m->lock_object, true,

sys/kern/kern_mutex.c

959

LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file,

sys/kern/kern_mutex.c

961

WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line);

sys/kern/kern_mutex.c

968

spin_time += lockstat_nsecs(&m->lock_object);

sys/kern/kern_mutex.c

97

static void assert_mtx(const struct lock_object *lock, int what);

sys/kern/kern_mutex.c

99

static void db_show_mtx(const struct lock_object *lock);

sys/kern/kern_rmlock.c

115

assert_rm(const struct lock_object *lock, int what)

sys/kern/kern_rmlock.c

122

lock_rm(struct lock_object *lock, uintptr_t how)

sys/kern/kern_rmlock.c

137

unlock_rm(struct lock_object *lock)

sys/kern/kern_rmlock.c

180

owner_rm(const struct lock_object *lock, struct thread **owner)

sys/kern/kern_rmlock.c

306

lock_init(&rm->lock_object, lc, name, NULL, liflags);

sys/kern/kern_rmlock.c

322

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

326

lock_destroy(&rm->lock_object);

sys/kern/kern_rmlock.c

333

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

381

if ((rm->lock_object.lo_flags & LO_RECURSABLE) != 0) {

sys/kern/kern_rmlock.c

402

if (rm->lock_object.lo_flags & LO_SLEEPABLE) {

sys/kern/kern_rmlock.c

410

if (rm->lock_object.lo_flags & LO_SLEEPABLE) {

sys/kern/kern_rmlock.c

425

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

446

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

492

turnstile_chain_lock(&rm->lock_object);

sys/kern/kern_rmlock.c

495

ts = turnstile_lookup(&rm->lock_object);

sys/kern/kern_rmlock.c

499

turnstile_chain_unlock(&rm->lock_object);

sys/kern/kern_rmlock.c

523

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

542

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

570

ts = turnstile_trywait(&rm->lock_object);

sys/kern/kern_rmlock.c

585

if (rm->lock_object.lo_flags & LO_SLEEPABLE)

sys/kern/kern_rmlock.c

607

WITNESS_CHECKORDER(&rm->lock_object, LOP_NEWORDER | LOP_EXCLUSIVE,

sys/kern/kern_rmlock.c

612

LOCK_LOG_LOCK("RMWLOCK", &rm->lock_object, 0, 0, file, line);

sys/kern/kern_rmlock.c

613

WITNESS_LOCK(&rm->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_rmlock.c

627

WITNESS_UNLOCK(&rm->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_rmlock.c

628

LOCK_LOG_LOCK("RMWUNLOCK", &rm->lock_object, 0, 0, file, line);

sys/kern/kern_rmlock.c

642

if (!(rm->lock_object.lo_flags & LO_RECURSABLE) && !trylock) {

sys/kern/kern_rmlock.c

659

rm->lock_object.lo_name, file, line));

sys/kern/kern_rmlock.c

660

WITNESS_CHECKORDER(&rm->lock_object,

sys/kern/kern_rmlock.c

666

LOCK_LOG_TRY("RMRLOCK", &rm->lock_object, 0, 1, file,

sys/kern/kern_rmlock.c

669

LOCK_LOG_LOCK("RMRLOCK", &rm->lock_object, 0, 0, file,

sys/kern/kern_rmlock.c

671

WITNESS_LOCK(&rm->lock_object, LOP_NOSLEEP, file, line);

sys/kern/kern_rmlock.c

675

LOCK_LOG_TRY("RMRLOCK", &rm->lock_object, 0, 0, file, line);

sys/kern/kern_rmlock.c

691

WITNESS_UNLOCK(&rm->lock_object, 0, file, line);

sys/kern/kern_rmlock.c

692

LOCK_LOG_LOCK("RMRUNLOCK", &rm->lock_object, 0, 0, file, line);

sys/kern/kern_rmlock.c

76

static void assert_rm(const struct lock_object *lock, int what);

sys/kern/kern_rmlock.c

766

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

769

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

779

rm->lock_object.lo_name, (what & RA_RLOCKED) ?

sys/kern/kern_rmlock.c

78

static void db_show_rm(const struct lock_object *lock);

sys/kern/kern_rmlock.c

784

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

787

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

792

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

797

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

80

static void lock_rm(struct lock_object *lock, uintptr_t how);

sys/kern/kern_rmlock.c

805

rm->lock_object.lo_name, file, line);

sys/kern/kern_rmlock.c

82

static int owner_rm(const struct lock_object *lock, struct thread **owner);

sys/kern/kern_rmlock.c

833

db_show_rm(const struct lock_object *lock)

sys/kern/kern_rmlock.c

84

static uintptr_t unlock_rm(struct lock_object *lock);

sys/kern/kern_rwlock.c

1025

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1030

rw->lock_object.lo_name);

sys/kern/kern_rwlock.c

1060

rw->lock_object.lo_name);

sys/kern/kern_rwlock.c

1083

ts = turnstile_trywait(&rw->lock_object);

sys/kern/kern_rwlock.c

1151

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1162

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1166

sleep_time -= lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

1171

sleep_time += lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

1174

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1182

THREAD_CONTENTION_DONE(&rw->lock_object);

sys/kern/kern_rwlock.c

1194

all_time += lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

1236

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1248

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1251

turnstile_chain_lock(&rw->lock_object);

sys/kern/kern_rwlock.c

1279

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

1283

ts = turnstile_lookup(&rw->lock_object);

sys/kern/kern_rwlock.c

1287

turnstile_chain_unlock(&rw->lock_object);

sys/kern/kern_rwlock.c

1333

ts = turnstile_trywait(&rw->lock_object);

sys/kern/kern_rwlock.c

1357

LOCK_LOG_TRY("WUPGRADE", &rw->lock_object, 0, success, file, line);

sys/kern/kern_rwlock.c

1360

WITNESS_UPGRADE(&rw->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_rwlock.c

1397

WITNESS_DOWNGRADE(&rw->lock_object, 0, file, line);

sys/kern/kern_rwlock.c

1412

turnstile_chain_lock(&rw->lock_object);

sys/kern/kern_rwlock.c

1422

ts = turnstile_lookup(&rw->lock_object);

sys/kern/kern_rwlock.c

1436

turnstile_chain_unlock(&rw->lock_object);

sys/kern/kern_rwlock.c

1439

LOCK_LOG_LOCK("WDOWNGRADE", &rw->lock_object, 0, 0, file, line);

sys/kern/kern_rwlock.c

1480

witness_assert(&rw->lock_object, what, file, line);

sys/kern/kern_rwlock.c

1491

rw->lock_object.lo_name, (what & RA_RLOCKED) ?

sys/kern/kern_rwlock.c

1498

rw->lock_object.lo_name, file,

sys/kern/kern_rwlock.c

1502

rw->lock_object.lo_name, file, line);

sys/kern/kern_rwlock.c

1511

rw->lock_object.lo_name, file, line);

sys/kern/kern_rwlock.c

1515

rw->lock_object.lo_name, file, line);

sys/kern/kern_rwlock.c

1518

rw->lock_object.lo_name, file, line);

sys/kern/kern_rwlock.c

1522

witness_assert(&rw->lock_object, what, file, line);

sys/kern/kern_rwlock.c

1530

rw->lock_object.lo_name, file, line);

sys/kern/kern_rwlock.c

1542

db_show_rwlock(const struct lock_object *lock)

sys/kern/kern_rwlock.c

163

assert_rw(const struct lock_object *lock, int what)

sys/kern/kern_rwlock.c

170

lock_rw(struct lock_object *lock, uintptr_t how)

sys/kern/kern_rwlock.c

182

trylock_rw(struct lock_object *lock, uintptr_t how)

sys/kern/kern_rwlock.c

194

unlock_rw(struct lock_object *lock)

sys/kern/kern_rwlock.c

211

owner_rw(const struct lock_object *lock, struct thread **owner)

sys/kern/kern_rwlock.c

250

lock_init(&rw->lock_object, &lock_class_rw, name, NULL, flags);

sys/kern/kern_rwlock.c

265

lock_destroy(&rw->lock_object);

sys/kern/kern_rwlock.c

299

WITNESS_CHECKORDER(&rw->lock_object, LOP_NEWORDER | LOP_EXCLUSIVE, file,

sys/kern/kern_rwlock.c

309

LOCK_LOG_LOCK("WLOCK", &rw->lock_object, 0, rw->rw_recurse, file, line);

sys/kern/kern_rwlock.c

310

WITNESS_LOCK(&rw->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_rwlock.c

341

if (v == tid && (rw->lock_object.lo_flags & LO_RECURSABLE)) {

sys/kern/kern_rwlock.c

350

LOCK_LOG_TRY("WLOCK", &rw->lock_object, 0, rval, file, line);

sys/kern/kern_rwlock.c

352

WITNESS_LOCK(&rw->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_rwlock.c

381

WITNESS_UNLOCK(&rw->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_rwlock.c

382

LOCK_LOG_LOCK("WUNLOCK", &rw->lock_object, 0, rw->rw_recurse, file,

sys/kern/kern_rwlock.c

431

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

475

all_time -= lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

495

lock_profile_obtain_lock_failed(&rw->lock_object, false,

sys/kern/kern_rwlock.c

498

THREAD_CONTENDS_ON_LOCK(&rw->lock_object);

sys/kern/kern_rwlock.c

516

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

522

"lockname:\"%s\"", rw->lock_object.lo_name);

sys/kern/kern_rwlock.c

543

rw->lock_object.lo_name);

sys/kern/kern_rwlock.c

573

ts = turnstile_trywait(&rw->lock_object);

sys/kern/kern_rwlock.c

620

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

629

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

633

sleep_time -= lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

638

sleep_time += lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

641

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

646

THREAD_CONTENTION_DONE(&rw->lock_object);

sys/kern/kern_rwlock.c

652

all_time += lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

691

WITNESS_CHECKORDER(&rw->lock_object, LOP_NEWORDER, file, line, NULL);

sys/kern/kern_rwlock.c

698

lock_profile_obtain_lock_success(&rw->lock_object, false, 0, 0,

sys/kern/kern_rwlock.c

701

LOCK_LOG_LOCK("RLOCK", &rw->lock_object, 0, 0, file, line);

sys/kern/kern_rwlock.c

702

WITNESS_LOCK(&rw->lock_object, 0, file, line);

sys/kern/kern_rwlock.c

71

static void db_show_rwlock(const struct lock_object *lock);

sys/kern/kern_rwlock.c

73

static void assert_rw(const struct lock_object *lock, int what);

sys/kern/kern_rwlock.c

735

LOCK_LOG_TRY("RLOCK", &rw->lock_object, 0, 1, file,

sys/kern/kern_rwlock.c

737

WITNESS_LOCK(&rw->lock_object, LOP_TRYLOCK, file, line);

sys/kern/kern_rwlock.c

74

static void lock_rw(struct lock_object *lock, uintptr_t how);

sys/kern/kern_rwlock.c

746

LOCK_LOG_TRY("RLOCK", &rw->lock_object, 0, 0, file, line);

sys/kern/kern_rwlock.c

75

static int trylock_rw(struct lock_object *lock, uintptr_t how);

sys/kern/kern_rwlock.c

767

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

77

static int owner_rw(const struct lock_object *lock, struct thread **owner);

sys/kern/kern_rwlock.c

79

static uintptr_t unlock_rw(struct lock_object *lock);

sys/kern/kern_rwlock.c

799

turnstile_chain_lock(&rw->lock_object);

sys/kern/kern_rwlock.c

832

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

843

ts = turnstile_lookup(&rw->lock_object);

sys/kern/kern_rwlock.c

850

turnstile_chain_unlock(&rw->lock_object);

sys/kern/kern_rwlock.c

864

WITNESS_UNLOCK(&rw->lock_object, 0, file, line);

sys/kern/kern_rwlock.c

865

LOCK_LOG_LOCK("RUNLOCK", &rw->lock_object, 0, 0, file, line);

sys/kern/kern_rwlock.c

874

lock_profile_release_lock(&rw->lock_object, false);

sys/kern/kern_rwlock.c

953

all_time -= lockstat_nsecs(&rw->lock_object);

sys/kern/kern_rwlock.c

969

KASSERT(rw->lock_object.lo_flags & LO_RECURSABLE,

sys/kern/kern_rwlock.c

974

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

979

if (LOCK_LOG_TEST(&rw->lock_object, 0))

sys/kern/kern_rwlock.c

981

rw->lock_object.lo_name, (void *)rw->rw_lock, file, line);

sys/kern/kern_rwlock.c

992

lock_profile_obtain_lock_failed(&rw->lock_object, false,

sys/kern/kern_rwlock.c

995

THREAD_CONTENDS_ON_LOCK(&rw->lock_object);

sys/kern/kern_sig.c

2883

&p->p_mtx.lock_object, "Stopping for traced signal");

sys/kern/kern_sig.c

3280

&p->p_mtx.lock_object, "Catching SIGSTOP");

sys/kern/kern_sx.c

1005

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

104

WITNESS_RESTORE(&Giant.lock_object, Giant); \

sys/kern/kern_sx.c

1048

all_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1068

lock_profile_obtain_lock_failed(&sx->lock_object, false, &contested,

sys/kern/kern_sx.c

1075

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

1100

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1106

"lockname:\"%s\"", sx->lock_object.lo_name);

sys/kern/kern_sx.c

1126

sx->lock_object.lo_name);

sys/kern/kern_sx.c

114

static void assert_sx(const struct lock_object *lock, int what);

sys/kern/kern_sx.c

1154

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

1159

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

116

static void db_show_sx(const struct lock_object *lock);

sys/kern/kern_sx.c

1172

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

118

static void lock_sx(struct lock_object *lock, uintptr_t how);

sys/kern/kern_sx.c

1188

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1197

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

120

static int owner_sx(const struct lock_object *lock, struct thread **owner);

sys/kern/kern_sx.c

1202

sleep_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1204

sleepq_add(&sx->lock_object, NULL, sx->lock_object.lo_name,

sys/kern/kern_sx.c

1212

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

1214

sleepq_wait(&sx->lock_object, 0);

sys/kern/kern_sx.c

1216

error = sleepq_wait_sig(&sx->lock_object, 0);

sys/kern/kern_sx.c

1217

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

1219

sleep_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

122

static uintptr_t unlock_sx(struct lock_object *lock);

sys/kern/kern_sx.c

1223

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1229

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1234

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

1240

all_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

1272

WITNESS_CHECKORDER(&sx->lock_object, LOP_NEWORDER, file, line, NULL);

sys/kern/kern_sx.c

1281

lock_profile_obtain_lock_success(&sx->lock_object, false, 0, 0,

sys/kern/kern_sx.c

1284

LOCK_LOG_LOCK("SLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

1285

WITNESS_LOCK(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

1306

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1333

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

1354

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

1357

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0, queue);

sys/kern/kern_sx.c

1361

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

1375

WITNESS_UNLOCK(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

1376

LOCK_LOG_LOCK("SUNLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

1384

lock_profile_release_lock(&sx->lock_object, false);

sys/kern/kern_sx.c

1427

witness_assert(&sx->lock_object, what, file, line);

sys/kern/kern_sx.c

1438

sx->lock_object.lo_name, slocked ? "share " : "",

sys/kern/kern_sx.c

1445

sx->lock_object.lo_name, file,

sys/kern/kern_sx.c

1449

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1458

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1462

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1465

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1469

witness_assert(&sx->lock_object, what, file, line);

sys/kern/kern_sx.c

1478

sx->lock_object.lo_name, file, line);

sys/kern/kern_sx.c

1490

db_show_sx(const struct lock_object *lock)

sys/kern/kern_sx.c

1548

LOCK_CLASS(&sx->lock_object) != &lock_class_sx ||

sys/kern/kern_sx.c

1549

sx->lock_object.lo_name != td->td_wmesg)

sys/kern/kern_sx.c

1553

db_printf("blocked on lock %p (%s) \"%s\" ", &sx->lock_object,

sys/kern/kern_sx.c

175

assert_sx(const struct lock_object *lock, int what)

sys/kern/kern_sx.c

182

lock_sx(struct lock_object *lock, uintptr_t how)

sys/kern/kern_sx.c

194

unlock_sx(struct lock_object *lock)

sys/kern/kern_sx.c

211

owner_sx(const struct lock_object *lock, struct thread **owner)

sys/kern/kern_sx.c

257

lock_init(&sx->lock_object, &lock_class_sx, description, NULL, flags);

sys/kern/kern_sx.c

269

lock_destroy(&sx->lock_object);

sys/kern/kern_sx.c

292

LOCK_LOG_TRY("SLOCK", &sx->lock_object, 0, 1, file, line);

sys/kern/kern_sx.c

293

WITNESS_LOCK(&sx->lock_object, LOP_TRYLOCK, file, line);

sys/kern/kern_sx.c

302

LOCK_LOG_TRY("SLOCK", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

325

WITNESS_CHECKORDER(&sx->lock_object, LOP_NEWORDER | LOP_EXCLUSIVE, file,

sys/kern/kern_sx.c

335

LOCK_LOG_LOCK("XLOCK", &sx->lock_object, 0, sx->sx_recurse,

sys/kern/kern_sx.c

337

WITNESS_LOCK(&sx->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_sx.c

371

if (x == tid && (sx->lock_object.lo_flags & LO_RECURSABLE)) {

sys/kern/kern_sx.c

380

LOCK_LOG_TRY("XLOCK", &sx->lock_object, 0, rval, file, line);

sys/kern/kern_sx.c

382

WITNESS_LOCK(&sx->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_sx.c

407

WITNESS_UNLOCK(&sx->lock_object, LOP_EXCLUSIVE, file, line);

sys/kern/kern_sx.c

408

LOCK_LOG_LOCK("XUNLOCK", &sx->lock_object, 0, sx->sx_recurse, file,

sys/kern/kern_sx.c

454

LOCK_LOG_TRY("XUPGRADE", &sx->lock_object, 0, success, file, line);

sys/kern/kern_sx.c

457

WITNESS_UPGRADE(&sx->lock_object, LOP_EXCLUSIVE | LOP_TRYLOCK,

sys/kern/kern_sx.c

490

WITNESS_DOWNGRADE(&sx->lock_object, 0, file, line);

sys/kern/kern_sx.c

513

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

523

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0,

sys/kern/kern_sx.c

525

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

529

LOCK_LOG_LOCK("XDOWNGRADE", &sx->lock_object, 0, 0, file, line);

sys/kern/kern_sx.c

603

all_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

620

KASSERT((sx->lock_object.lo_flags & LO_RECURSABLE) != 0,

sys/kern/kern_sx.c

625

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

630

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

632

sx->lock_object.lo_name, (void *)sx->sx_lock, file, line);

sys/kern/kern_sx.c

643

lock_profile_obtain_lock_failed(&sx->lock_object, false, &contested,

sys/kern/kern_sx.c

650

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

682

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

687

sx->lock_object.lo_name);

sys/kern/kern_sx.c

717

sx->lock_object.lo_name);

sys/kern/kern_sx.c

740

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

749

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

765

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

771

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

792

sleepq_release(&sx->lock_object);

sys/kern/kern_sx.c

828

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

841

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

846

sleep_time -= lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

848

sleepq_add(&sx->lock_object, NULL, sx->lock_object.lo_name,

sys/kern/kern_sx.c

856

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

858

sleepq_wait(&sx->lock_object, 0);

sys/kern/kern_sx.c

860

error = sleepq_wait_sig(&sx->lock_object, 0);

sys/kern/kern_sx.c

861

THREAD_CONTENDS_ON_LOCK(&sx->lock_object);

sys/kern/kern_sx.c

863

sleep_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

867

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

873

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

878

THREAD_CONTENTION_DONE(&sx->lock_object);

sys/kern/kern_sx.c

891

all_time += lockstat_nsecs(&sx->lock_object);

sys/kern/kern_sx.c

91

WITNESS_SAVE(&Giant.lock_object, Giant); \

sys/kern/kern_sx.c

934

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

944

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

947

sleepq_lock(&sx->lock_object);

sys/kern/kern_sx.c

963

sleepq_sleepcnt(&sx->lock_object, SQ_EXCLUSIVE_QUEUE) != 0) {

sys/kern/kern_sx.c

970

if (LOCK_LOG_TEST(&sx->lock_object, 0))

sys/kern/kern_sx.c

975

sleepq_broadcast(&sx->lock_object, SLEEPQ_SX, 0, queue);

sys/kern/kern_sx.c

976

sleepq_release(&sx->lock_object);

sys/kern/kern_synch.c

131

_sleep(const void *ident, struct lock_object *lock, int priority,

sys/kern/kern_synch.c

155

KASSERT(lock != NULL && lock != &Giant.lock_object,

sys/kern/kern_synch.c

184

if (lock == &Giant.lock_object)

sys/kern/kern_synch.c

187

if (lock != NULL && lock != &Giant.lock_object &&

sys/kern/kern_synch.c

232

if (lock != NULL && lock != &Giant.lock_object && !(priority & PDROP)) {

sys/kern/kern_synch.c

263

WITNESS_SAVE(&mtx->lock_object, mtx);

sys/kern/kern_synch.c

269

sleepq_add(ident, &mtx->lock_object, wmesg, SLEEPQ_SLEEP, 0);

sys/kern/kern_synch.c

297

WITNESS_RESTORE(&mtx->lock_object, mtx);

sys/kern/kern_synch.c

390

_blockcount_sleep(blockcount_t *bc, struct lock_object *lock, const char *wmesg,

sys/kern/kern_synch.c

399

KASSERT(lock != &Giant.lock_object,

sys/kern/kern_timeout.c

1104

if (c->c_lock == &Giant.lock_object)

sys/kern/kern_timeout.c

1220

&cc->cc_lock.lock_object, "codrain",

sys/kern/kern_timeout.c

1340

c->c_lock = &Giant.lock_object;

sys/kern/kern_timeout.c

1347

_callout_init_lock(struct callout *c, struct lock_object *lock, int flags)

sys/kern/kern_timeout.c

635

struct lock_object *c_lock;

sys/kern/kern_timeout.c

701

if (c_lock == &Giant.lock_object) {

sys/kern/sched_4bsd.c

1076

lock_profile_release_lock(&sched_lock.lock_object, true);

sys/kern/sched_4bsd.c

1088

lock_profile_obtain_lock_success(&sched_lock.lock_object, true,

sys/kern/sched_4bsd.c

1710

lock_profile_release_lock(&sched_lock.lock_object, true);

sys/kern/sched_4bsd.c

1727

lock_profile_obtain_lock_success(&sched_lock.lock_object, true,

sys/kern/subr_epoch.c

571

struct lock_object *lock;

sys/kern/subr_lock.c

103

lock_destroy(struct lock_object *lock)

sys/kern/subr_lock.c

178

struct lock_object *lock;

sys/kern/subr_lock.c

183

lock = (struct lock_object *)addr;

sys/kern/subr_lock.c

203

struct lock_object *lpo_obj;

sys/kern/subr_lock.c

516

lock_profile_lookup(struct lock_object *lo, int spin, const char *file,

sys/kern/subr_lock.c

553

lock_profile_object_lookup(struct lock_object *lo, int spin, const char *file,

sys/kern/subr_lock.c

582

lock_profile_obtain_lock_success(struct lock_object *lo, bool spin,

sys/kern/subr_lock.c

655

lock_profile_release_lock(struct lock_object *lo, bool spin)

sys/kern/subr_lock.c

78

lock_init(struct lock_object *lock, struct lock_class *class, const char *name,

sys/kern/subr_sleepqueue.c

133

struct lock_object *sq_lock; /* (c) Associated lock. */

sys/kern/subr_sleepqueue.c

1449

struct lock_object *lock;

sys/kern/subr_sleepqueue.c

307

sleepq_add(const void *wchan, struct lock_object *lock, const char *wmesg,

sys/kern/subr_turnstile.c

1121

struct lock_object *lock;

sys/kern/subr_turnstile.c

1131

lock = (struct lock_object *)addr;

sys/kern/subr_turnstile.c

1171

struct lock_object *lock;

sys/kern/subr_turnstile.c

127

struct lock_object *ts_lockobj; /* (c) Lock we reference. */

sys/kern/subr_turnstile.c

1287

struct lock_object *lock;

sys/kern/subr_turnstile.c

1309

struct lock_object *lock;

sys/kern/subr_turnstile.c

1316

lock = (struct lock_object *)addr;

sys/kern/subr_turnstile.c

560

turnstile_chain_lock(struct lock_object *lock)

sys/kern/subr_turnstile.c

569

turnstile_trywait(struct lock_object *lock)

sys/kern/subr_turnstile.c

592

turnstile_lock(struct turnstile *ts, struct lock_object **lockp,

sys/kern/subr_turnstile.c

596

struct lock_object *lock;

sys/kern/subr_turnstile.c

614

turnstile_unlock(struct turnstile *ts, struct lock_object *lock)

sys/kern/subr_turnstile.c

636

struct lock_object *lock;

sys/kern/subr_turnstile.c

654

turnstile_lookup(struct lock_object *lock)

sys/kern/subr_turnstile.c

673

turnstile_chain_unlock(struct lock_object *lock)

sys/kern/subr_turnstile.c

743

struct lock_object *lock;

sys/kern/subr_witness.c

1321

witness_defineorder(struct lock_object *lock1, struct lock_object *lock2)

sys/kern/subr_witness.c

1353

witness_checkorder(struct lock_object *lock, int flags, const char *file,

sys/kern/subr_witness.c

1354

int line, struct lock_object *interlock)

sys/kern/subr_witness.c

1553

lock == &Giant.lock_object)

sys/kern/subr_witness.c

1562

lock1->li_lock == &Giant.lock_object)

sys/kern/subr_witness.c

1581

lock == &Giant.lock_object)

sys/kern/subr_witness.c

1650

&& lock == &Giant.lock_object)

sys/kern/subr_witness.c

1772

!(plock->li_lock == &Giant.lock_object &&

sys/kern/subr_witness.c

1784

witness_lock(struct lock_object *lock, int flags, const char *file, int line)

sys/kern/subr_witness.c

1842

witness_upgrade(struct lock_object *lock, int flags, const char *file, int line)

sys/kern/subr_witness.c

1887

witness_downgrade(struct lock_object *lock, int flags, const char *file,

sys/kern/subr_witness.c

192

struct lock_object *li_lock;

sys/kern/subr_witness.c

1933

witness_unlock(struct lock_object *lock, int flags, const char *file, int line)

sys/kern/subr_witness.c

2075

witness_warn(int flags, struct lock_object *lock, const char *fmt, ...)

sys/kern/subr_witness.c

2093

lock1->li_lock == &Giant.lock_object)

sys/kern/subr_witness.c

2156

witness_file(struct lock_object *lock)

sys/kern/subr_witness.c

2167

witness_line(struct lock_object *lock)

sys/kern/subr_witness.c

2513

find_instance(struct lock_list_entry *list, const struct lock_object *lock)

sys/kern/subr_witness.c

2532

struct lock_object *lock;

sys/kern/subr_witness.c

2621

witness_display_spinlock(struct lock_object *lock, struct thread *owner,

sys/kern/subr_witness.c

2636

witness_save(struct lock_object *lock, const char **filep, int *linep)

sys/kern/subr_witness.c

2675

witness_restore(struct lock_object *lock, const char *file, int line)

sys/kern/subr_witness.c

2712

witness_find_instance(const struct lock_object *lock,

sys/kern/subr_witness.c

2738

witness_assert(const struct lock_object *lock, int flags, const char *file,

sys/kern/subr_witness.c

279

struct lock_object *wh_lock;

sys/kern/subr_witness.c

2808

witness_is_owned(const struct lock_object *lock)

sys/kern/subr_witness.c

2822

witness_setflag(struct lock_object *lock, int flag, int set)

sys/kern/subr_witness.c

2852

witness_norelease(struct lock_object *lock)

sys/kern/subr_witness.c

2858

witness_releaseok(struct lock_object *lock)

sys/kern/subr_witness.c

313

const struct lock_object *lock);

sys/kern/subr_witness.c

356

static void witness_setflag(struct lock_object *lock, int flag, int set);

sys/kern/subr_witness.c

798

struct lock_object *lock;

sys/kern/subr_witness.c

887

witness_init(struct lock_object *lock, const char *type)

sys/kern/subr_witness.c

928

witness_destroy(struct lock_object *lock)

sys/kern/vfs_default.c

481

&ilk->lock_object, ap->a_file, ap->a_line));

sys/kern/vfs_default.c

529

&ilk->lock_object, ap->a_file, ap->a_line));

sys/kern/vfs_lookup.c

141

LOCK_LOG_LOCK("SLOCK", &lk->lock_object, 0, 0, ap->a_file, ap->a_line);

sys/kern/vfs_lookup.c

154

LOCK_LOG_LOCK("SUNLOCK", &lk->lock_object, 0, 0, LOCK_FILE,

sys/kern/vfs_subr.c

2078

struct lock_object *lo;

sys/kern/vfs_subr.c

2111

lo = &vp->v_vnlock->lock_object;

sys/kern/vfs_subr.c

2124

vp->v_vnlock->lock_object.lo_flags |= LK_NOSHARE;

sys/kern/vfs_subr.c

5781

witness_is_owned(&vp->v_vnlock->lock_object) == -1);

sys/kern/vfs_subr.c

5799

witness_is_owned(&vp->v_vnlock->lock_object) == 1;

sys/kern/vfs_vnops.c

4386

if ((vp1->v_vnlock->lock_object.lo_flags &

sys/kern/vfs_vnops.c

4406

(vp1->v_vnlock->lock_object.lo_flags & LK_NOSHARE) != 0)

sys/kern/vfs_vnops.c

4424

(vp2->v_vnlock->lock_object.lo_flags & LK_NOSHARE) != 0)

sys/sys/_callout.h

43

struct lock_object;

sys/sys/_callout.h

61

struct lock_object *c_lock; /* lock to handle */

sys/sys/_lockmgr.h

39

struct lock_object lock_object;

sys/sys/_mutex.h

48

struct lock_object lock_object; /* Common lock properties. */

sys/sys/_mutex.h

62

struct lock_object lock_object; /* Common lock properties. */

sys/sys/_rmlock.h

55

struct lock_object lock_object;

sys/sys/_rmlock.h

59

struct lock_object _rm_wlock_object;

sys/sys/_rwlock.h

45

struct lock_object lock_object;

sys/sys/_rwlock.h

59

struct lock_object lock_object;

sys/sys/_sx.h

41

struct lock_object lock_object;

sys/sys/blockcount.h

40

struct lock_object;

sys/sys/blockcount.h

42

int _blockcount_sleep(blockcount_t *bc, struct lock_object *, const char *wmesg,

sys/sys/blockcount.h

78

_blockcount_wait(blockcount_t *bc, struct lock_object *lo, const char *wmesg,

sys/sys/blockcount.h

88

_blockcount_sleep((bc), (struct lock_object *)(lo), (wmesg), (prio))

sys/sys/blockcount.h

90

_blockcount_wait((bc), (struct lock_object *)(lo), (wmesg), (prio))

sys/sys/callout.h

86

void _callout_init_lock(struct callout *, struct lock_object *, int);

sys/sys/callout.h

88

_callout_init_lock((c), &(mtx)->lock_object, (flags))

sys/sys/callout.h

90

_callout_init_lock((c), &(rm)->lock_object, (flags))

sys/sys/callout.h

92

_callout_init_lock((c), &(rw)->lock_object, (flags))

sys/sys/condvar.h

46

struct lock_object;

sys/sys/condvar.h

51

void _cv_wait(struct cv *cvp, struct lock_object *lock);

sys/sys/condvar.h

52

void _cv_wait_unlock(struct cv *cvp, struct lock_object *lock);

sys/sys/condvar.h

53

int _cv_wait_sig(struct cv *cvp, struct lock_object *lock);

sys/sys/condvar.h

54

int _cv_timedwait_sbt(struct cv *cvp, struct lock_object *lock,

sys/sys/condvar.h

56

int _cv_timedwait_sig_sbt(struct cv *cvp, struct lock_object *lock,

sys/sys/condvar.h

63

_cv_wait((cvp), &(lock)->lock_object)

sys/sys/condvar.h

65

_cv_wait_unlock((cvp), &(lock)->lock_object)

sys/sys/condvar.h

67

_cv_wait_sig((cvp), &(lock)->lock_object)

sys/sys/condvar.h

69

_cv_timedwait_sbt((cvp), &(lock)->lock_object, \

sys/sys/condvar.h

72

_cv_timedwait_sbt((cvp), &(lock)->lock_object, (sbt), (pr), (flags))

sys/sys/condvar.h

74

_cv_timedwait_sig_sbt((cvp), &(lock)->lock_object, \

sys/sys/condvar.h

77

_cv_timedwait_sig_sbt((cvp), &(lock)->lock_object, (sbt), (pr), (flags))

sys/sys/lock.h

218

void lock_init(struct lock_object *, struct lock_class *,

sys/sys/lock.h

220

void lock_destroy(struct lock_object *);

sys/sys/lock.h

225

void witness_init(struct lock_object *, const char *);

sys/sys/lock.h

226

void witness_destroy(struct lock_object *);

sys/sys/lock.h

227

int witness_defineorder(struct lock_object *, struct lock_object *);

sys/sys/lock.h

228

void witness_checkorder(struct lock_object *, int, const char *, int,

sys/sys/lock.h

229

struct lock_object *);

sys/sys/lock.h

230

void witness_lock(struct lock_object *, int, const char *, int);

sys/sys/lock.h

231

void witness_upgrade(struct lock_object *, int, const char *, int);

sys/sys/lock.h

232

void witness_downgrade(struct lock_object *, int, const char *, int);

sys/sys/lock.h

233

void witness_unlock(struct lock_object *, int, const char *, int);

sys/sys/lock.h

234

void witness_save(struct lock_object *, const char **, int *);

sys/sys/lock.h

235

void witness_restore(struct lock_object *, const char *, int);

sys/sys/lock.h

238

int witness_warn(int, struct lock_object *, const char *, ...);

sys/sys/lock.h

239

void witness_assert(const struct lock_object *, int, const char *, int);

sys/sys/lock.h

240

int witness_is_owned(const struct lock_object *lock);

sys/sys/lock.h

241

void witness_display_spinlock(struct lock_object *, struct thread *,

sys/sys/lock.h

243

int witness_line(struct lock_object *);

sys/sys/lock.h

244

void witness_norelease(struct lock_object *);

sys/sys/lock.h

245

void witness_releaseok(struct lock_object *);

sys/sys/lock.h

246

const char *witness_file(struct lock_object *);

sys/sys/lock.h

268

witness_defineorder((struct lock_object *)(lock1), \

sys/sys/lock.h

269

(struct lock_object *)(lock2))

sys/sys/lock.h

300

witness_norelease(&(lock)->lock_object)

sys/sys/lock.h

303

witness_releaseok(&(lock)->lock_object)

sys/sys/lock.h

63

void (*lc_assert)(const struct lock_object *lock, int what);

sys/sys/lock.h

64

void (*lc_ddb_show)(const struct lock_object *lock);

sys/sys/lock.h

65

void (*lc_lock)(struct lock_object *lock, uintptr_t how);

sys/sys/lock.h

66

int (*lc_owner)(const struct lock_object *lock,

sys/sys/lock.h

68

uintptr_t (*lc_unlock)(struct lock_object *lock);

sys/sys/lock.h

69

int (*lc_trylock)(struct lock_object *lock, uintptr_t how);

sys/sys/lock_profile.h

47

void lock_profile_obtain_lock_success(struct lock_object *lo, bool spin,

sys/sys/lock_profile.h

49

void lock_profile_release_lock(struct lock_object *lo, bool spin);

sys/sys/lock_profile.h

53

lock_profile_obtain_lock_failed(struct lock_object *lo, bool spin,

sys/sys/lockmgr.h

105

return (__lockmgr_args(lk, flags, (ilk != NULL) ? &ilk->lock_object :

sys/sys/lockmgr.h

114

return (__lockmgr_args(lk, flags, (ilk != NULL) ? &ilk->lock_object :

sys/sys/lockmgr.h

64

#define lk_recurse lock_object.lo_data

sys/sys/lockmgr.h

70

int __lockmgr_args(struct lock *lk, u_int flags, struct lock_object *ilk,

sys/sys/lockmgr.h

73

struct lock_object *ilk, const char *file, int line);

sys/sys/lockstat.h

103

lock_profile_obtain_lock_success(&(lp)->lock_object, true, c, wt, f, l); \

sys/sys/lockstat.h

108

lock_profile_obtain_lock_success(&(lp)->lock_object, false, c, wt, f, l); \

sys/sys/lockstat.h

113

lock_profile_release_lock(&(lp)->lock_object, false); \

sys/sys/lockstat.h

118

lock_profile_release_lock(&(lp)->lock_object, true); \

sys/sys/lockstat.h

123

lock_profile_release_lock(&(lp)->lock_object, false); \

sys/sys/lockstat.h

129

struct lock_object;

sys/sys/lockstat.h

130

uint64_t lockstat_nsecs(struct lock_object *);

sys/sys/lockstat.h

141

lock_profile_obtain_lock_success(&(lp)->lock_object, false, c, wt, f, l)

sys/sys/lockstat.h

144

lock_profile_obtain_lock_success(&(lp)->lock_object, true, c, wt, f, l)

sys/sys/lockstat.h

150

lock_profile_release_lock(&(lp)->lock_object, false)

sys/sys/lockstat.h

153

lock_profile_release_lock(&(lp)->lock_object, true)

sys/sys/lockstat.h

98

lock_profile_obtain_lock_success(&(lp)->lock_object, false, c, wt, f, l); \

sys/sys/mutex.h

209

#define mtx_recurse lock_object.lo_data

sys/sys/mutex.h

463

_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), \

sys/sys/mutex.h

468

#define mtx_initialized(m) lock_initialized(&(m)->lock_object)

sys/sys/mutex.h

478

#define mtx_name(m) ((m)->lock_object.lo_name)

sys/sys/mutex.h

500

WITNESS_SAVE(&Giant.lock_object, Giant); \

sys/sys/mutex.h

511

WITNESS_RESTORE(&Giant.lock_object, Giant); \

sys/sys/proc.h

278

struct lock_object *td_wantedlock; /* (k) Lock we are contending on */

sys/sys/rmlock.h

98

_sleep((chan), &(rm)->lock_object, (pri), (wmesg), \

sys/sys/rwlock.h

242

_sleep((chan), &(rw)->lock_object, (pri), (wmesg), \

sys/sys/rwlock.h

245

#define rw_initialized(rw) lock_initialized(&(rw)->lock_object)

sys/sys/rwlock.h

77

#define rw_recurse lock_object.lo_data

sys/sys/sleepqueue.h

69

struct lock_object;

sys/sys/sleepqueue.h

87

void sleepq_add(const void *wchan, struct lock_object *lock,

sys/sys/sx.h

265

_sleep((chan), &(sx)->lock_object, (pri), (wmesg), \

sys/sys/sx.h

91

#define sx_recurse lock_object.lo_data

sys/sys/systm.h

130

struct lock_object;

sys/sys/systm.h

452

int _sleep(const void * _Nonnull chan, struct lock_object *lock, int pri,

sys/sys/systm.h

455

_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), \

sys/sys/systm.h

458

_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), (bt), (pr), \

sys/sys/turnstile.h

100

bool turnstile_lock(struct turnstile *, struct lock_object **,

sys/sys/turnstile.h

102

void turnstile_unlock(struct turnstile *, struct lock_object *);

sys/sys/turnstile.h

73

struct lock_object;

sys/sys/turnstile.h

88

void turnstile_chain_lock(struct lock_object *);

sys/sys/turnstile.h

89

void turnstile_chain_unlock(struct lock_object *);

sys/sys/turnstile.h

95

struct turnstile *turnstile_lookup(struct lock_object *);

sys/sys/turnstile.h

97

struct turnstile *turnstile_trywait(struct lock_object *);

sys/ufs/ffs/ffs_vnops.c

514

&VI_MTX(vp)->lock_object, ap->a_file, ap->a_line);

sys/vm/vm_object.h

276

lock_class_rw.lc_unlock(&(object)->lock.lock_object)

sys/vm/vm_object.h

278

lock_class_rw.lc_lock(&(object)->lock.lock_object, (state))