]> git.saurik.com Git - apple/xnu.git/blob - osfmk/kern/locks.c
projects / apple / xnu.git / blob
? search:


7ce865586d51bf3392acf51b0414b8df96110446
[apple/xnu.git] / osfmk / kern / locks.c
1 /*
2 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_OSREFERENCE_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. The rights granted to you under the
10 * License may not be used to create, or enable the creation or
11 * redistribution of, unlawful or unlicensed copies of an Apple operating
12 * system, or to circumvent, violate, or enable the circumvention or
13 * violation of, any terms of an Apple operating system software license
14 * agreement.
15 *
16 * Please obtain a copy of the License at
17 * http://www.opensource.apple.com/apsl/ and read it before using this
18 * file.
19 *
20 * The Original Code and all software distributed under the License are
21 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
22 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
23 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
25 * Please see the License for the specific language governing rights and
26 * limitations under the License.
27 *
28 * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
29 */
30 /*
31 * @OSF_COPYRIGHT@
32 */
33 /*
34 * Mach Operating System
35 * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
36 * All Rights Reserved.
37 *
38 * Permission to use, copy, modify and distribute this software and its
39 * documentation is hereby granted, provided that both the copyright
40 * notice and this permission notice appear in all copies of the
41 * software, derivative works or modified versions, and any portions
42 * thereof, and that both notices appear in supporting documentation.
43 *
44 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
45 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
46 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
47 *
48 * Carnegie Mellon requests users of this software to return to
49 *
50 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
51 * School of Computer Science
52 * Carnegie Mellon University
53 * Pittsburgh PA 15213-3890
54 *
55 * any improvements or extensions that they make and grant Carnegie Mellon
56 * the rights to redistribute these changes.
57 */
58 #include <mach_kdb.h>
59 #include <mach_ldebug.h>
60 #include <debug.h>
61
62 #include <mach/kern_return.h>
63 #include <mach/mach_host_server.h>
64 #include <mach_debug/lockgroup_info.h>
65
66 #include <kern/locks.h>
67 #include <kern/misc_protos.h>
68 #include <kern/kalloc.h>
69 #include <kern/thread.h>
70 #include <kern/processor.h>
71 #include <kern/sched_prim.h>
72 #include <kern/debug.h>
73 #include <string.h>
74
75
76 #include <sys/kdebug.h>
77
78 #define LCK_MTX_SLEEP_CODE 0
79 #define LCK_MTX_SLEEP_DEADLINE_CODE 1
80 #define LCK_MTX_LCK_WAIT_CODE 2
81 #define LCK_MTX_UNLCK_WAKEUP_CODE 3
82
83
84 static queue_head_t lck_grp_queue;
85 static unsigned int lck_grp_cnt;
86
87 decl_mutex_data(static,lck_grp_lock)
88
89 lck_grp_attr_t LockDefaultGroupAttr;
90 lck_grp_t LockCompatGroup;
91 lck_attr_t LockDefaultLckAttr;
92
93 /*
94 * Routine: lck_mod_init
95 */
96
97 void
98 lck_mod_init(
99 void)
100 {
101 queue_init(&lck_grp_queue);
102 mutex_init(&lck_grp_lock, 0);
103 lck_grp_cnt = 0;
104 lck_grp_attr_setdefault( &LockDefaultGroupAttr);
105 lck_grp_init( &LockCompatGroup, "Compatibility APIs", LCK_GRP_ATTR_NULL);
106 lck_attr_setdefault(&LockDefaultLckAttr);
107 }
108
109 /*
110 * Routine: lck_grp_attr_alloc_init
111 */
112
113 lck_grp_attr_t *
114 lck_grp_attr_alloc_init(
115 void)
116 {
117 lck_grp_attr_t *attr;
118
119 if ((attr = (lck_grp_attr_t *)kalloc(sizeof(lck_grp_attr_t))) != 0)
120 lck_grp_attr_setdefault(attr);
121
122 return(attr);
123 }
124
125
126 /*
127 * Routine: lck_grp_attr_setdefault
128 */
129
130 void
131 lck_grp_attr_setdefault(
132 lck_grp_attr_t *attr)
133 {
134 if (LcksOpts & enaLkStat)
135 attr->grp_attr_val = LCK_GRP_ATTR_STAT;
136 else
137 attr->grp_attr_val = 0;
138 }
139
140
141 /*
142 * Routine: lck_grp_attr_setstat
143 */
144
145 void
146 lck_grp_attr_setstat(
147 lck_grp_attr_t *attr)
148 {
149 (void)hw_atomic_or((uint32_t *)&attr->grp_attr_val, LCK_GRP_ATTR_STAT);
150 }
151
152
153 /*
154 * Routine: lck_grp_attr_free
155 */
156
157 void
158 lck_grp_attr_free(
159 lck_grp_attr_t *attr)
160 {
161 kfree(attr, sizeof(lck_grp_attr_t));
162 }
163
164
165 /*
166 * Routine: lck_grp_alloc_init
167 */
168
169 lck_grp_t *
170 lck_grp_alloc_init(
171 const char* grp_name,
172 lck_grp_attr_t *attr)
173 {
174 lck_grp_t *grp;
175
176 if ((grp = (lck_grp_t *)kalloc(sizeof(lck_grp_t))) != 0)
177 lck_grp_init(grp, grp_name, attr);
178
179 return(grp);
180 }
181
182
183 /*
184 * Routine: lck_grp_init
185 */
186
187 void
188 lck_grp_init(
189 lck_grp_t *grp,
190 const char* grp_name,
191 lck_grp_attr_t *attr)
192 {
193 bzero((void *)grp, sizeof(lck_grp_t));
194
195 (void) strncpy(grp->lck_grp_name, grp_name, LCK_GRP_MAX_NAME);
196
197 if (attr != LCK_GRP_ATTR_NULL)
198 grp->lck_grp_attr = attr->grp_attr_val;
199 else if (LcksOpts & enaLkStat)
200 grp->lck_grp_attr = LCK_GRP_ATTR_STAT;
201 else
202 grp->lck_grp_attr = LCK_ATTR_NONE;
203
204 grp->lck_grp_refcnt = 1;
205
206 mutex_lock(&lck_grp_lock);
207 enqueue_tail(&lck_grp_queue, (queue_entry_t)grp);
208 lck_grp_cnt++;
209 mutex_unlock(&lck_grp_lock);
210
211 }
212
213
214 /*
215 * Routine: lck_grp_free
216 */
217
218 void
219 lck_grp_free(
220 lck_grp_t *grp)
221 {
222 mutex_lock(&lck_grp_lock);
223 lck_grp_cnt--;
224 (void)remque((queue_entry_t)grp);
225 mutex_unlock(&lck_grp_lock);
226 lck_grp_deallocate(grp);
227 }
228
229
230 /*
231 * Routine: lck_grp_reference
232 */
233
234 void
235 lck_grp_reference(
236 lck_grp_t *grp)
237 {
238 (void)hw_atomic_add((uint32_t *)(&grp->lck_grp_refcnt), 1);
239 }
240
241
242 /*
243 * Routine: lck_grp_deallocate
244 */
245
246 void
247 lck_grp_deallocate(
248 lck_grp_t *grp)
249 {
250 if (hw_atomic_sub((uint32_t *)(&grp->lck_grp_refcnt), 1) == 0)
251 kfree(grp, sizeof(lck_grp_t));
252 }
253
254 /*
255 * Routine: lck_grp_lckcnt_incr
256 */
257
258 void
259 lck_grp_lckcnt_incr(
260 lck_grp_t *grp,
261 lck_type_t lck_type)
262 {
263 unsigned int *lckcnt;
264
265 switch (lck_type) {
266 case LCK_TYPE_SPIN:
267 lckcnt = &grp->lck_grp_spincnt;
268 break;
269 case LCK_TYPE_MTX:
270 lckcnt = &grp->lck_grp_mtxcnt;
271 break;
272 case LCK_TYPE_RW:
273 lckcnt = &grp->lck_grp_rwcnt;
274 break;
275 default:
276 return panic("lck_grp_lckcnt_incr(): invalid lock type: %d\n", lck_type);
277 }
278
279 (void)hw_atomic_add((uint32_t *)lckcnt, 1);
280 }
281
282 /*
283 * Routine: lck_grp_lckcnt_decr
284 */
285
286 void
287 lck_grp_lckcnt_decr(
288 lck_grp_t *grp,
289 lck_type_t lck_type)
290 {
291 unsigned int *lckcnt;
292
293 switch (lck_type) {
294 case LCK_TYPE_SPIN:
295 lckcnt = &grp->lck_grp_spincnt;
296 break;
297 case LCK_TYPE_MTX:
298 lckcnt = &grp->lck_grp_mtxcnt;
299 break;
300 case LCK_TYPE_RW:
301 lckcnt = &grp->lck_grp_rwcnt;
302 break;
303 default:
304 return panic("lck_grp_lckcnt_decr(): invalid lock type: %d\n", lck_type);
305 }
306
307 (void)hw_atomic_sub((uint32_t *)lckcnt, 1);
308 }
309
310 /*
311 * Routine: lck_attr_alloc_init
312 */
313
314 lck_attr_t *
315 lck_attr_alloc_init(
316 void)
317 {
318 lck_attr_t *attr;
319
320 if ((attr = (lck_attr_t *)kalloc(sizeof(lck_attr_t))) != 0)
321 lck_attr_setdefault(attr);
322
323 return(attr);
324 }
325
326
327 /*
328 * Routine: lck_attr_setdefault
329 */
330
331 void
332 lck_attr_setdefault(
333 lck_attr_t *attr)
334 {
335 #if !DEBUG
336 if (LcksOpts & enaLkDeb)
337 attr->lck_attr_val = LCK_ATTR_DEBUG;
338 else
339 attr->lck_attr_val = LCK_ATTR_NONE;
340 #else
341 attr->lck_attr_val = LCK_ATTR_DEBUG;
342 #endif
343
344 }
345
346
347 /*
348 * Routine: lck_attr_setdebug
349 */
350 void
351 lck_attr_setdebug(
352 lck_attr_t *attr)
353 {
354 (void)hw_atomic_or((uint32_t *)&attr->lck_attr_val, LCK_ATTR_DEBUG);
355 }
356
357
358 /*
359 * Routine: lck_attr_rw_shared_priority
360 */
361 void
362 lck_attr_rw_shared_priority(
363 lck_attr_t *attr)
364 {
365 (void)hw_atomic_or((uint32_t *)&attr->lck_attr_val, LCK_ATTR_RW_SHARED_PRIORITY);
366 }
367
368
369 /*
370 * Routine: lck_attr_free
371 */
372 void
373 lck_attr_free(
374 lck_attr_t *attr)
375 {
376 kfree(attr, sizeof(lck_attr_t));
377 }
378
379
380 /*
381 * Routine: lck_spin_sleep
382 */
383 wait_result_t
384 lck_spin_sleep(
385 lck_spin_t *lck,
386 lck_sleep_action_t lck_sleep_action,
387 event_t event,
388 wait_interrupt_t interruptible)
389 {
390 wait_result_t res;
391
392 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
393 panic("Invalid lock sleep action %x\n", lck_sleep_action);
394
395 res = assert_wait(event, interruptible);
396 if (res == THREAD_WAITING) {
397 lck_spin_unlock(lck);
398 res = thread_block(THREAD_CONTINUE_NULL);
399 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK))
400 lck_spin_lock(lck);
401 }
402 else
403 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
404 lck_spin_unlock(lck);
405
406 return res;
407 }
408
409
410 /*
411 * Routine: lck_spin_sleep_deadline
412 */
413 wait_result_t
414 lck_spin_sleep_deadline(
415 lck_spin_t *lck,
416 lck_sleep_action_t lck_sleep_action,
417 event_t event,
418 wait_interrupt_t interruptible,
419 uint64_t deadline)
420 {
421 wait_result_t res;
422
423 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
424 panic("Invalid lock sleep action %x\n", lck_sleep_action);
425
426 res = assert_wait_deadline(event, interruptible, deadline);
427 if (res == THREAD_WAITING) {
428 lck_spin_unlock(lck);
429 res = thread_block(THREAD_CONTINUE_NULL);
430 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK))
431 lck_spin_lock(lck);
432 }
433 else
434 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
435 lck_spin_unlock(lck);
436
437 return res;
438 }
439
440
441 /*
442 * Routine: lck_mtx_sleep
443 */
444 wait_result_t
445 lck_mtx_sleep(
446 lck_mtx_t *lck,
447 lck_sleep_action_t lck_sleep_action,
448 event_t event,
449 wait_interrupt_t interruptible)
450 {
451 wait_result_t res;
452
453 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_CODE) | DBG_FUNC_START,
454 (int)lck, (int)lck_sleep_action, (int)event, (int)interruptible, 0);
455
456 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
457 panic("Invalid lock sleep action %x\n", lck_sleep_action);
458
459 res = assert_wait(event, interruptible);
460 if (res == THREAD_WAITING) {
461 lck_mtx_unlock(lck);
462 res = thread_block(THREAD_CONTINUE_NULL);
463 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK))
464 lck_mtx_lock(lck);
465 }
466 else
467 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
468 lck_mtx_unlock(lck);
469
470 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_CODE) | DBG_FUNC_END, (int)res, 0, 0, 0, 0);
471
472 return res;
473 }
474
475
476 /*
477 * Routine: lck_mtx_sleep_deadline
478 */
479 wait_result_t
480 lck_mtx_sleep_deadline(
481 lck_mtx_t *lck,
482 lck_sleep_action_t lck_sleep_action,
483 event_t event,
484 wait_interrupt_t interruptible,
485 uint64_t deadline)
486 {
487 wait_result_t res;
488
489 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_DEADLINE_CODE) | DBG_FUNC_START,
490 (int)lck, (int)lck_sleep_action, (int)event, (int)interruptible, 0);
491
492 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
493 panic("Invalid lock sleep action %x\n", lck_sleep_action);
494
495 res = assert_wait_deadline(event, interruptible, deadline);
496 if (res == THREAD_WAITING) {
497 lck_mtx_unlock(lck);
498 res = thread_block(THREAD_CONTINUE_NULL);
499 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK))
500 lck_mtx_lock(lck);
501 }
502 else
503 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
504 lck_mtx_unlock(lck);
505
506 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_DEADLINE_CODE) | DBG_FUNC_END, (int)res, 0, 0, 0, 0);
507
508 return res;
509 }
510
511 /*
512 * Routine: lck_mtx_lock_wait
513 *
514 * Invoked in order to wait on contention.
515 *
516 * Called with the interlock locked and
517 * returns it unlocked.
518 */
519 void
520 lck_mtx_lock_wait (
521 lck_mtx_t *lck,
522 thread_t holder)
523 {
524 thread_t self = current_thread();
525 lck_mtx_t *mutex;
526 integer_t priority;
527 spl_t s = splsched();
528
529 if (lck->lck_mtx_tag != LCK_MTX_TAG_INDIRECT)
530 mutex = lck;
531 else
532 mutex = &lck->lck_mtx_ptr->lck_mtx;
533
534 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_LCK_WAIT_CODE) | DBG_FUNC_START, (int)lck, (int)holder, 0, 0, 0);
535
536 priority = self->sched_pri;
537 if (priority < self->priority)
538 priority = self->priority;
539 if (priority > MINPRI_KERNEL)
540 priority = MINPRI_KERNEL;
541 else
542 if (priority < BASEPRI_DEFAULT)
543 priority = BASEPRI_DEFAULT;
544
545 thread_lock(holder);
546 if (mutex->lck_mtx_pri == 0)
547 holder->promotions++;
548 if (holder->priority < MINPRI_KERNEL) {
549 holder->sched_mode |= TH_MODE_PROMOTED;
550 if ( mutex->lck_mtx_pri < priority &&
551 holder->sched_pri < priority ) {
552 KERNEL_DEBUG_CONSTANT(
553 MACHDBG_CODE(DBG_MACH_SCHED,MACH_PROMOTE) | DBG_FUNC_NONE,
554 holder->sched_pri, priority, (int)holder, (int)lck, 0);
555
556 set_sched_pri(holder, priority);
557 }
558 }
559 thread_unlock(holder);
560 splx(s);
561
562 if (mutex->lck_mtx_pri < priority)
563 mutex->lck_mtx_pri = priority;
564 if (self->pending_promoter[self->pending_promoter_index] == NULL) {
565 self->pending_promoter[self->pending_promoter_index] = mutex;
566 mutex->lck_mtx_waiters++;
567 }
568 else
569 if (self->pending_promoter[self->pending_promoter_index] != mutex) {
570 self->pending_promoter[++self->pending_promoter_index] = mutex;
571 mutex->lck_mtx_waiters++;
572 }
573
574 assert_wait((event_t)(((unsigned int*)lck)+((sizeof(lck_mtx_t)-1)/sizeof(unsigned int))), THREAD_UNINT);
575 lck_mtx_ilk_unlock(mutex);
576
577 thread_block(THREAD_CONTINUE_NULL);
578
579 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_LCK_WAIT_CODE) | DBG_FUNC_END, 0, 0, 0, 0, 0);
580 }
581
582 /*
583 * Routine: lck_mtx_lock_acquire
584 *
585 * Invoked on acquiring the mutex when there is
586 * contention.
587 *
588 * Returns the current number of waiters.
589 *
590 * Called with the interlock locked.
591 */
592 int
593 lck_mtx_lock_acquire(
594 lck_mtx_t *lck)
595 {
596 thread_t thread = current_thread();
597 lck_mtx_t *mutex;
598
599 if (lck->lck_mtx_tag != LCK_MTX_TAG_INDIRECT)
600 mutex = lck;
601 else
602 mutex = &lck->lck_mtx_ptr->lck_mtx;
603
604 if (thread->pending_promoter[thread->pending_promoter_index] == mutex) {
605 thread->pending_promoter[thread->pending_promoter_index] = NULL;
606 if (thread->pending_promoter_index > 0)
607 thread->pending_promoter_index--;
608 mutex->lck_mtx_waiters--;
609 }
610
611 if (mutex->lck_mtx_waiters > 0) {
612 integer_t priority = mutex->lck_mtx_pri;
613 spl_t s = splsched();
614
615 thread_lock(thread);
616 thread->promotions++;
617 if (thread->priority < MINPRI_KERNEL) {
618 thread->sched_mode |= TH_MODE_PROMOTED;
619 if (thread->sched_pri < priority) {
620 KERNEL_DEBUG_CONSTANT(
621 MACHDBG_CODE(DBG_MACH_SCHED,MACH_PROMOTE) | DBG_FUNC_NONE,
622 thread->sched_pri, priority, 0, (int)lck, 0);
623
624 set_sched_pri(thread, priority);
625 }
626 }
627 thread_unlock(thread);
628 splx(s);
629 }
630 else
631 mutex->lck_mtx_pri = 0;
632
633 return (mutex->lck_mtx_waiters);
634 }
635
636 /*
637 * Routine: lck_mtx_unlock_wakeup
638 *
639 * Invoked on unlock when there is contention.
640 *
641 * Called with the interlock locked.
642 */
643 void
644 lck_mtx_unlock_wakeup (
645 lck_mtx_t *lck,
646 thread_t holder)
647 {
648 thread_t thread = current_thread();
649 lck_mtx_t *mutex;
650
651 if (lck->lck_mtx_tag != LCK_MTX_TAG_INDIRECT)
652 mutex = lck;
653 else
654 mutex = &lck->lck_mtx_ptr->lck_mtx;
655
656
657 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_UNLCK_WAKEUP_CODE) | DBG_FUNC_START, (int)lck, (int)holder, 0, 0, 0);
658
659 if (thread != holder)
660 panic("lck_mtx_unlock_wakeup: mutex %x holder %x\n", mutex, holder);
661
662 if (thread->promotions > 0) {
663 spl_t s = splsched();
664
665 thread_lock(thread);
666 if ( --thread->promotions == 0 &&
667 (thread->sched_mode & TH_MODE_PROMOTED) ) {
668 thread->sched_mode &= ~TH_MODE_PROMOTED;
669 if (thread->sched_mode & TH_MODE_ISDEPRESSED) {
670 KERNEL_DEBUG_CONSTANT(
671 MACHDBG_CODE(DBG_MACH_SCHED,MACH_DEMOTE) | DBG_FUNC_NONE,
672 thread->sched_pri, DEPRESSPRI, 0, (int)lck, 0);
673
674 set_sched_pri(thread, DEPRESSPRI);
675 }
676 else {
677 if (thread->priority < thread->sched_pri) {
678 KERNEL_DEBUG_CONSTANT(
679 MACHDBG_CODE(DBG_MACH_SCHED,MACH_DEMOTE) |
680 DBG_FUNC_NONE,
681 thread->sched_pri, thread->priority,
682 0, (int)lck, 0);
683 }
684
685 compute_priority(thread, FALSE);
686 }
687 }
688 thread_unlock(thread);
689 splx(s);
690 }
691 assert(mutex->lck_mtx_waiters > 0);
692 thread_wakeup_one((event_t)(((unsigned int*)lck)+(sizeof(lck_mtx_t)-1)/sizeof(unsigned int)));
693
694 KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_UNLCK_WAKEUP_CODE) | DBG_FUNC_END, 0, 0, 0, 0, 0);
695 }
696
697 /*
698 * Routine: mutex_pause
699 *
700 * Called by former callers of simple_lock_pause().
701 */
702
703 void
704 mutex_pause(void)
705 {
706 wait_result_t wait_result;
707
708 wait_result = assert_wait_timeout((event_t)mutex_pause, THREAD_UNINT, 1, 1000*NSEC_PER_USEC);
709 assert(wait_result == THREAD_WAITING);
710
711 wait_result = thread_block(THREAD_CONTINUE_NULL);
712 assert(wait_result == THREAD_TIMED_OUT);
713 }
714
715 /*
716 * Routine: lck_rw_sleep
717 */
718 wait_result_t
719 lck_rw_sleep(
720 lck_rw_t *lck,
721 lck_sleep_action_t lck_sleep_action,
722 event_t event,
723 wait_interrupt_t interruptible)
724 {
725 wait_result_t res;
726 lck_rw_type_t lck_rw_type;
727
728 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
729 panic("Invalid lock sleep action %x\n", lck_sleep_action);
730
731 res = assert_wait(event, interruptible);
732 if (res == THREAD_WAITING) {
733 lck_rw_type = lck_rw_done(lck);
734 res = thread_block(THREAD_CONTINUE_NULL);
735 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK)) {
736 if (!(lck_sleep_action & (LCK_SLEEP_SHARED|LCK_SLEEP_EXCLUSIVE)))
737 lck_rw_lock(lck, lck_rw_type);
738 else if (lck_sleep_action & LCK_SLEEP_EXCLUSIVE)
739 lck_rw_lock_exclusive(lck);
740 else
741 lck_rw_lock_shared(lck);
742 }
743 }
744 else
745 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
746 (void)lck_rw_done(lck);
747
748 return res;
749 }
750
751
752 /*
753 * Routine: lck_rw_sleep_deadline
754 */
755 wait_result_t
756 lck_rw_sleep_deadline(
757 lck_rw_t *lck,
758 lck_sleep_action_t lck_sleep_action,
759 event_t event,
760 wait_interrupt_t interruptible,
761 uint64_t deadline)
762 {
763 wait_result_t res;
764 lck_rw_type_t lck_rw_type;
765
766 if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
767 panic("Invalid lock sleep action %x\n", lck_sleep_action);
768
769 res = assert_wait_deadline(event, interruptible, deadline);
770 if (res == THREAD_WAITING) {
771 lck_rw_type = lck_rw_done(lck);
772 res = thread_block(THREAD_CONTINUE_NULL);
773 if (!(lck_sleep_action & LCK_SLEEP_UNLOCK)) {
774 if (!(lck_sleep_action & (LCK_SLEEP_SHARED|LCK_SLEEP_EXCLUSIVE)))
775 lck_rw_lock(lck, lck_rw_type);
776 else if (lck_sleep_action & LCK_SLEEP_EXCLUSIVE)
777 lck_rw_lock_exclusive(lck);
778 else
779 lck_rw_lock_shared(lck);
780 }
781 }
782 else
783 if (lck_sleep_action & LCK_SLEEP_UNLOCK)
784 (void)lck_rw_done(lck);
785
786 return res;
787 }
788
789 kern_return_t
790 host_lockgroup_info(
791 host_t host,
792 lockgroup_info_array_t *lockgroup_infop,
793 mach_msg_type_number_t *lockgroup_infoCntp)
794 {
795 lockgroup_info_t *lockgroup_info_base;
796 lockgroup_info_t *lockgroup_info;
797 vm_offset_t lockgroup_info_addr;
798 vm_size_t lockgroup_info_size;
799 lck_grp_t *lck_grp;
800 unsigned int i;
801 vm_size_t used;
802 vm_map_copy_t copy;
803 kern_return_t kr;
804
805 if (host == HOST_NULL)
806 return KERN_INVALID_HOST;
807
808 mutex_lock(&lck_grp_lock);
809
810 lockgroup_info_size = round_page(lck_grp_cnt * sizeof *lockgroup_info);
811 kr = kmem_alloc_pageable(ipc_kernel_map,
812 &lockgroup_info_addr, lockgroup_info_size);
813 if (kr != KERN_SUCCESS) {
814 mutex_unlock(&lck_grp_lock);
815 return(kr);
816 }
817
818 lockgroup_info_base = (lockgroup_info_t *) lockgroup_info_addr;
819 lck_grp = (lck_grp_t *)queue_first(&lck_grp_queue);
820 lockgroup_info = lockgroup_info_base;
821
822 for (i = 0; i < lck_grp_cnt; i++) {
823
824 lockgroup_info->lock_spin_cnt = lck_grp->lck_grp_spincnt;
825 lockgroup_info->lock_spin_util_cnt = lck_grp->lck_grp_stat.lck_grp_spin_stat.lck_grp_spin_util_cnt;
826 lockgroup_info->lock_spin_held_cnt = lck_grp->lck_grp_stat.lck_grp_spin_stat.lck_grp_spin_held_cnt;
827 lockgroup_info->lock_spin_miss_cnt = lck_grp->lck_grp_stat.lck_grp_spin_stat.lck_grp_spin_miss_cnt;
828 lockgroup_info->lock_spin_held_max = lck_grp->lck_grp_stat.lck_grp_spin_stat.lck_grp_spin_held_max;
829 lockgroup_info->lock_spin_held_cum = lck_grp->lck_grp_stat.lck_grp_spin_stat.lck_grp_spin_held_cum;
830
831 lockgroup_info->lock_mtx_cnt = lck_grp->lck_grp_mtxcnt;
832 lockgroup_info->lock_mtx_util_cnt = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_util_cnt;
833 lockgroup_info->lock_mtx_held_cnt = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_held_cnt;
834 lockgroup_info->lock_mtx_miss_cnt = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_miss_cnt;
835 lockgroup_info->lock_mtx_wait_cnt = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_cnt;
836 lockgroup_info->lock_mtx_held_max = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_held_max;
837 lockgroup_info->lock_mtx_held_cum = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_held_cum;
838 lockgroup_info->lock_mtx_wait_max = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_max;
839 lockgroup_info->lock_mtx_wait_cum = lck_grp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_cum;
840
841 lockgroup_info->lock_rw_cnt = lck_grp->lck_grp_rwcnt;
842 lockgroup_info->lock_rw_util_cnt = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_util_cnt;
843 lockgroup_info->lock_rw_held_cnt = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_held_cnt;
844 lockgroup_info->lock_rw_miss_cnt = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_miss_cnt;
845 lockgroup_info->lock_rw_wait_cnt = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_wait_cnt;
846 lockgroup_info->lock_rw_held_max = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_held_max;
847 lockgroup_info->lock_rw_held_cum = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_held_cum;
848 lockgroup_info->lock_rw_wait_max = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_wait_max;
849 lockgroup_info->lock_rw_wait_cum = lck_grp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_wait_cum;
850
851 (void) strncpy(lockgroup_info->lockgroup_name,lck_grp->lck_grp_name, LOCKGROUP_MAX_NAME);
852
853 lck_grp = (lck_grp_t *)(queue_next((queue_entry_t)(lck_grp)));
854 lockgroup_info++;
855 }
856
857 *lockgroup_infoCntp = lck_grp_cnt;
858 mutex_unlock(&lck_grp_lock);
859
860 used = (*lockgroup_infoCntp) * sizeof *lockgroup_info;
861
862 if (used != lockgroup_info_size)
863 bzero((char *) lockgroup_info, lockgroup_info_size - used);
864
865 kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)lockgroup_info_addr,
866 (vm_map_size_t)lockgroup_info_size, TRUE, &copy);
867 assert(kr == KERN_SUCCESS);
868
869 *lockgroup_infop = (lockgroup_info_t *) copy;
870
871 return(KERN_SUCCESS);
872 }
873
874 /*
875 * Compatibility module
876 */
877
878 extern lck_rw_t *lock_alloc_EXT( boolean_t can_sleep, unsigned short tag0, unsigned short tag1);
879 extern void lock_done_EXT(lck_rw_t *lock);
880 extern void lock_free_EXT(lck_rw_t *lock);
881 extern void lock_init_EXT(lck_rw_t *lock, boolean_t can_sleep, unsigned short tag0, unsigned short tag1);
882 extern void lock_read_EXT(lck_rw_t *lock);
883 extern boolean_t lock_read_to_write_EXT(lck_rw_t *lock);
884 extern void lock_write_EXT(lck_rw_t *lock);
885 extern void lock_write_to_read_EXT(lck_rw_t *lock);
886 extern wait_result_t thread_sleep_lock_write_EXT(
887 event_t event, lck_rw_t *lock, wait_interrupt_t interruptible);
888
889 extern lck_mtx_t *mutex_alloc_EXT(unsigned short tag);
890 extern void mutex_free_EXT(lck_mtx_t *mutex);
891 extern void mutex_init_EXT(lck_mtx_t *mutex, unsigned short tag);
892 extern void mutex_lock_EXT(lck_mtx_t *mutex);
893 extern boolean_t mutex_try_EXT(lck_mtx_t *mutex);
894 extern void mutex_unlock_EXT(lck_mtx_t *mutex);
895 extern wait_result_t thread_sleep_mutex_EXT(
896 event_t event, lck_mtx_t *mutex, wait_interrupt_t interruptible);
897 extern wait_result_t thread_sleep_mutex_deadline_EXT(
898 event_t event, lck_mtx_t *mutex, uint64_t deadline, wait_interrupt_t interruptible);
899
900 extern void usimple_lock_EXT(lck_spin_t *lock);
901 extern void usimple_lock_init_EXT(lck_spin_t *lock, unsigned short tag);
902 extern unsigned int usimple_lock_try_EXT(lck_spin_t *lock);
903 extern void usimple_unlock_EXT(lck_spin_t *lock);
904 extern wait_result_t thread_sleep_usimple_lock_EXT(event_t event, lck_spin_t *lock, wait_interrupt_t interruptible);
905
906 lck_rw_t *
907 lock_alloc_EXT(
908 __unused boolean_t can_sleep,
909 __unused unsigned short tag0,
910 __unused unsigned short tag1)
911 {
912 return( lck_rw_alloc_init( &LockCompatGroup, LCK_ATTR_NULL));
913 }
914
915 void
916 lock_done_EXT(
917 lck_rw_t *lock)
918 {
919 (void) lck_rw_done(lock);
920 }
921
922 void
923 lock_free_EXT(
924 lck_rw_t *lock)
925 {
926 lck_rw_free(lock, &LockCompatGroup);
927 }
928
929 void
930 lock_init_EXT(
931 lck_rw_t *lock,
932 __unused boolean_t can_sleep,
933 __unused unsigned short tag0,
934 __unused unsigned short tag1)
935 {
936 lck_rw_init(lock, &LockCompatGroup, LCK_ATTR_NULL);
937 }
938
939 void
940 lock_read_EXT(
941 lck_rw_t *lock)
942 {
943 lck_rw_lock_shared( lock);
944 }
945
946 boolean_t
947 lock_read_to_write_EXT(
948 lck_rw_t *lock)
949 {
950 return( lck_rw_lock_shared_to_exclusive(lock));
951 }
952
953 void
954 lock_write_EXT(
955 lck_rw_t *lock)
956 {
957 lck_rw_lock_exclusive(lock);
958 }
959
960 void
961 lock_write_to_read_EXT(
962 lck_rw_t *lock)
963 {
964 lck_rw_lock_exclusive_to_shared(lock);
965 }
966
967 wait_result_t
968 thread_sleep_lock_write_EXT(
969 event_t event,
970 lck_rw_t *lock,
971 wait_interrupt_t interruptible)
972 {
973 return( lck_rw_sleep(lock, LCK_SLEEP_EXCLUSIVE, event, interruptible));
974 }
975
976 lck_mtx_t *
977 mutex_alloc_EXT(
978 __unused unsigned short tag)
979 {
980 return(lck_mtx_alloc_init(&LockCompatGroup, LCK_ATTR_NULL));
981 }
982
983 void
984 mutex_free_EXT(
985 lck_mtx_t *mutex)
986 {
987 lck_mtx_free(mutex, &LockCompatGroup);
988 }
989
990 void
991 mutex_init_EXT(
992 lck_mtx_t *mutex,
993 __unused unsigned short tag)
994 {
995 lck_mtx_init(mutex, &LockCompatGroup, LCK_ATTR_NULL);
996 }
997
998 void
999 mutex_lock_EXT(
1000 lck_mtx_t *mutex)
1001 {
1002 lck_mtx_lock(mutex);
1003 }
1004
1005 boolean_t
1006 mutex_try_EXT(
1007 lck_mtx_t *mutex)
1008 {
1009 return(lck_mtx_try_lock(mutex));
1010 }
1011
1012 void
1013 mutex_unlock_EXT(
1014 lck_mtx_t *mutex)
1015 {
1016 lck_mtx_unlock(mutex);
1017 }
1018
1019 wait_result_t
1020 thread_sleep_mutex_EXT(
1021 event_t event,
1022 lck_mtx_t *mutex,
1023 wait_interrupt_t interruptible)
1024 {
1025 return( lck_mtx_sleep(mutex, LCK_SLEEP_DEFAULT, event, interruptible));
1026 }
1027
1028 wait_result_t
1029 thread_sleep_mutex_deadline_EXT(
1030 event_t event,
1031 lck_mtx_t *mutex,
1032 uint64_t deadline,
1033 wait_interrupt_t interruptible)
1034 {
1035 return( lck_mtx_sleep_deadline(mutex, LCK_SLEEP_DEFAULT, event, interruptible, deadline));
1036 }
1037
1038 void
1039 usimple_lock_EXT(
1040 lck_spin_t *lock)
1041 {
1042 lck_spin_lock(lock);
1043 }
1044
1045 void
1046 usimple_lock_init_EXT(
1047 lck_spin_t *lock,
1048 __unused unsigned short tag)
1049 {
1050 lck_spin_init(lock, &LockCompatGroup, LCK_ATTR_NULL);
1051 }
1052
1053 unsigned int
1054 usimple_lock_try_EXT(
1055 lck_spin_t *lock)
1056 {
1057 return(lck_spin_try_lock(lock));
1058 }
1059
1060 void
1061 usimple_unlock_EXT(
1062 lck_spin_t *lock)
1063 {
1064 lck_spin_unlock(lock);
1065 }
1066
1067 wait_result_t
1068 thread_sleep_usimple_lock_EXT(
1069 event_t event,
1070 lck_spin_t *lock,
1071 wait_interrupt_t interruptible)
1072 {
1073 return( lck_spin_sleep(lock, LCK_SLEEP_DEFAULT, event, interruptible));
1074 }
mirror of XNU