![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sync_lock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to sync_lock.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: *
25: */
26: /*
27: * File: kern/sync_lock.c
28: * Author: Joseph CaraDonna
29: *
30: * Contains RT distributed lock synchronization services.
31: */
32:
33: #include <kern/etap_macros.h>
34: #include <kern/misc_protos.h>
35: #include <kern/sync_lock.h>
36: #include <kern/sched_prim.h>
37: #include <kern/ipc_kobject.h>
38: #include <kern/ipc_sync.h>
39: #include <kern/etap_macros.h>
40: #include <kern/thread.h>
41: #include <kern/task.h>
42: #include <ipc/ipc_port.h>
43: #include <ipc/ipc_space.h>
44:
45: /*
46: * Ulock ownership MACROS
47: *
48: * Assumes: ulock internal lock is held
49: */
50:
51: #define ulock_ownership_set(ul, th) \
52: MACRO_BEGIN \
53: thread_act_t _th_act; \
54: _th_act = (th)->top_act; \
55: act_lock(_th_act); \
56: enqueue (&_th_act->held_ulocks, (queue_entry_t) (ul)); \
57: act_unlock(_th_act); \
58: (ul)->holder = _th_act; \
59: MACRO_END
60:
61: #define ulock_ownership_clear(ul) \
62: MACRO_BEGIN \
63: thread_act_t _th_act; \
64: _th_act = (ul)->holder; \
65: if (_th_act->active) { \
66: act_lock(_th_act); \
67: remqueue(&_th_act->held_ulocks, \
68: (queue_entry_t) (ul)); \
69: act_unlock(_th_act); \
70: } else { \
71: remqueue(&_th_act->held_ulocks, \
72: (queue_entry_t) (ul)); \
73: } \
74: (ul)->holder = THR_ACT_NULL; \
75: MACRO_END
76:
77: /*
78: * Lock set ownership MACROS
79: */
80:
81: #define lock_set_ownership_set(ls, t) \
82: MACRO_BEGIN \
83: task_lock((t)); \
84: enqueue_head(&(t)->lock_set_list, (queue_entry_t) (ls));\
85: (t)->lock_sets_owned++; \
86: task_unlock((t)); \
87: (ls)->owner = (t); \
88: MACRO_END
89:
90: #define lock_set_ownership_clear(ls, t) \
91: MACRO_BEGIN \
92: task_lock((t)); \
93: remqueue(&(t)->lock_set_list, (queue_entry_t) (ls)); \
94: (t)->lock_sets_owned--; \
95: task_unlock((t)); \
96: MACRO_END
97:
98: unsigned int lock_set_event;
99: #define LOCK_SET_EVENT ((event_t)&lock_set_event)
100:
101: unsigned int lock_set_handoff;
102: #define LOCK_SET_HANDOFF ((event_t)&lock_set_handoff)
103:
104: /*
105: * ROUTINE: lock_set_create [exported]
106: *
107: * Creates a lock set.
108: * The port representing the lock set is returned as a parameter.
109: */
110: kern_return_t
111: lock_set_create (
112: task_t task,
113: lock_set_t *new_lock_set,
114: int n_ulocks,
115: int policy)
116: {
117: lock_set_t lock_set = LOCK_SET_NULL;
118: ulock_t ulock;
119: int size;
120: int x;
121:
122: *new_lock_set = LOCK_SET_NULL;
123:
124: if (task == TASK_NULL || n_ulocks <= 0 || policy > SYNC_POLICY_MAX)
125: return KERN_INVALID_ARGUMENT;
126:
127: size = sizeof(struct lock_set) + (sizeof(struct ulock) * (n_ulocks-1));
128: lock_set = (lock_set_t) kalloc (size);
129:
130: if (lock_set == LOCK_SET_NULL)
131: return KERN_RESOURCE_SHORTAGE;
132:
133:
134: lock_set_lock_init(lock_set);
135: lock_set->n_ulocks = n_ulocks;
136: lock_set->ref_count = 1;
137:
138: /*
139: * Create and initialize the lock set port
140: */
141: lock_set->port = ipc_port_alloc_kernel();
142: if (lock_set->port == IP_NULL) {
143: /* This will deallocate the lock set */
144: lock_set_dereference(lock_set);
145: return KERN_RESOURCE_SHORTAGE;
146: }
147:
148: ipc_kobject_set (lock_set->port,
149: (ipc_kobject_t) lock_set,
150: IKOT_LOCK_SET);
151:
152: /*
153: * Initialize each ulock in the lock set
154: */
155:
156: for (x=0; x < n_ulocks; x++) {
157: ulock = (ulock_t) &lock_set->ulock_list[x];
158: ulock_lock_init(ulock);
159: ulock->lock_set = lock_set;
160: ulock->holder = THR_ACT_NULL;
161: ulock->blocked = FALSE;
162: ulock->unstable = FALSE;
163: ulock->ho_wait = FALSE;
164: wait_queue_init(&ulock->wait_queue, policy);
165: }
166:
167: lock_set_ownership_set(lock_set, task);
168:
169: lock_set->active = TRUE;
170: *new_lock_set = lock_set;
171:
172: return KERN_SUCCESS;
173: }
174:
175: /*
176: * ROUTINE: lock_set_destroy [exported]
177: *
178: * Destroys a lock set. This call will only succeed if the
179: * specified task is the SAME task name specified at the lock set's
180: * creation.
181: *
182: * NOTES:
183: * - All threads currently blocked on the lock set's ulocks are awoken.
184: * - These threads will return with the KERN_LOCK_SET_DESTROYED error.
185: */
186: kern_return_t
187: lock_set_destroy (task_t task, lock_set_t lock_set)
188: {
189: thread_t thread;
190: ulock_t ulock;
191: int i;
192:
193: if (task == TASK_NULL || lock_set == LOCK_SET_NULL)
194: return KERN_INVALID_ARGUMENT;
195:
196: if (lock_set->owner != task)
197: return KERN_INVALID_RIGHT;
198:
199: lock_set_lock(lock_set);
200: if (!lock_set->active) {
201: lock_set_unlock(lock_set);
202: return KERN_LOCK_SET_DESTROYED;
203: }
204:
205: /*
206: * Deactivate lock set
207: */
208: lock_set->active = FALSE;
209:
210: /*
211: * If a ulock is currently held in the target lock set:
212: *
213: * 1) Wakeup all threads blocked on the ulock (if any). Threads
214: * may be blocked waiting normally, or waiting for a handoff.
215: * Blocked threads will return with KERN_LOCK_SET_DESTROYED.
216: *
217: * 2) ulock ownership is cleared.
218: * The thread currently holding the ulock is revoked of its
219: * ownership.
220: */
221: for (i = 0; i < lock_set->n_ulocks; i++) {
222: ulock = &lock_set->ulock_list[i];
223:
224: ulock_lock(ulock);
225:
226: if (ulock->accept_wait) {
227: ulock->accept_wait = FALSE;
228: wait_queue_wakeup_one(&ulock->wait_queue,
229: LOCK_SET_HANDOFF,
230: THREAD_RESTART);
231: }
232:
233: if (ulock->holder) {
234: if (ulock->blocked) {
235: ulock->blocked = FALSE;
236: wait_queue_wakeup_all(&ulock->wait_queue,
237: LOCK_SET_EVENT,
238: THREAD_RESTART);
239: }
240: if (ulock->ho_wait) {
241: ulock->ho_wait = FALSE;
242: wait_queue_wakeup_one(&ulock->wait_queue,
243: LOCK_SET_HANDOFF,
244: THREAD_RESTART);
245: }
246: ulock_ownership_clear(ulock);
247: }
248:
249: ulock_unlock(ulock);
250: }
251:
252: lock_set_unlock(lock_set);
253: lock_set_ownership_clear(lock_set, task);
254:
255: /*
256: * Deallocate
257: *
258: * Drop the lock set reference, which inturn destroys the
259: * lock set structure if the reference count goes to zero.
260: */
261:
262: ipc_port_dealloc_kernel(lock_set->port);
263: lock_set_dereference(lock_set);
264:
265: return KERN_SUCCESS;
266: }
267:
268: kern_return_t
269: lock_acquire (lock_set_t lock_set, int lock_id)
270: {
271: ulock_t ulock;
272:
273: if (lock_set == LOCK_SET_NULL)
274: return KERN_INVALID_ARGUMENT;
275:
276: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
277: return KERN_INVALID_ARGUMENT;
278:
279: retry:
280: lock_set_lock(lock_set);
281: if (!lock_set->active) {
282: lock_set_unlock(lock_set);
283: return KERN_LOCK_SET_DESTROYED;
284: }
285:
286: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
287: ulock_lock(ulock);
288: lock_set_unlock(lock_set);
289:
290: /*
291: * Block the current thread if the lock is already held.
292: */
293:
294: if (ulock->holder != THR_ACT_NULL) {
295: int wait_result;
296:
297: lock_set_unlock(lock_set);
298:
299: if (ulock->holder == current_act()) {
300: ulock_unlock(ulock);
301: return KERN_LOCK_OWNED_SELF;
302: }
303:
304: ulock->blocked = TRUE;
305: wait_queue_assert_wait(&ulock->wait_queue,
306: LOCK_SET_EVENT,
307: THREAD_ABORTSAFE);
308: ulock_unlock(ulock);
309:
310: /*
311: * Block - Wait for lock to become available.
312: */
313:
314: wait_result = thread_block((void (*)(void))0);
315:
316: /*
317: * Check the result status:
318: *
319: * Check to see why thread was woken up. In all cases, we
320: * already have been removed from the queue.
321: */
322: switch (wait_result) {
323: case THREAD_AWAKENED:
324: /* lock transitioned from old locker to us */
325: /* he already made us owner */
326: return (ulock->unstable) ? KERN_LOCK_UNSTABLE :
327: KERN_SUCCESS;
328:
329: case THREAD_INTERRUPTED:
330: return KERN_ABORTED;
331:
332: case THREAD_RESTART:
333: goto retry; /* probably a dead lock_set */
334:
335: default:
336: panic("lock_acquire\n");
337: }
338: }
339:
340: /*
341: * Assign lock ownership
342: */
343: ulock_ownership_set(ulock, current_thread());
344: ulock_unlock(ulock);
345:
346: return (ulock->unstable) ? KERN_LOCK_UNSTABLE : KERN_SUCCESS;
347: }
348:
349: kern_return_t
350: lock_release (lock_set_t lock_set, int lock_id)
351: {
352: ulock_t ulock;
353:
354: if (lock_set == LOCK_SET_NULL)
355: return KERN_INVALID_ARGUMENT;
356:
357: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
358: return KERN_INVALID_ARGUMENT;
359:
360: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
361:
362: return (lock_release_internal(ulock, current_act()));
363: }
364:
365: kern_return_t
366: lock_try (lock_set_t lock_set, int lock_id)
367: {
368: ulock_t ulock;
369:
370:
371: if (lock_set == LOCK_SET_NULL)
372: return KERN_INVALID_ARGUMENT;
373:
374: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
375: return KERN_INVALID_ARGUMENT;
376:
377:
378: lock_set_lock(lock_set);
379: if (!lock_set->active) {
380: lock_set_unlock(lock_set);
381: return KERN_LOCK_SET_DESTROYED;
382: }
383:
384: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
385: ulock_lock(ulock);
386: lock_set_unlock(lock_set);
387:
388: /*
389: * If the lock is already owned, we return without blocking.
390: *
391: * An ownership status is returned to inform the caller as to
392: * whether it already holds the lock or another thread does.
393: */
394:
395: if (ulock->holder != THR_ACT_NULL) {
396: lock_set_unlock(lock_set);
397:
398: if (ulock->holder == current_act()) {
399: ulock_unlock(ulock);
400: return KERN_LOCK_OWNED_SELF;
401: }
402:
403: ulock_unlock(ulock);
404: return KERN_LOCK_OWNED;
405: }
406:
407: /*
408: * Add the ulock to the lock set's held_ulocks list.
409: */
410:
411: ulock_ownership_set(ulock, current_thread());
412: ulock_unlock(ulock);
413:
414: return (ulock->unstable) ? KERN_LOCK_UNSTABLE : KERN_SUCCESS;
415: }
416:
417: kern_return_t
418: lock_make_stable (lock_set_t lock_set, int lock_id)
419: {
420: ulock_t ulock;
421:
422:
423: if (lock_set == LOCK_SET_NULL)
424: return KERN_INVALID_ARGUMENT;
425:
426: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
427: return KERN_INVALID_ARGUMENT;
428:
429:
430: lock_set_lock(lock_set);
431: if (!lock_set->active) {
432: lock_set_unlock(lock_set);
433: return KERN_LOCK_SET_DESTROYED;
434: }
435:
436: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
437: ulock_lock(ulock);
438: lock_set_unlock(lock_set);
439:
440: if (ulock->holder != current_act()) {
441: ulock_unlock(ulock);
442: return KERN_INVALID_RIGHT;
443: }
444:
445: ulock->unstable = FALSE;
446: ulock_unlock(ulock);
447:
448: return KERN_SUCCESS;
449: }
450:
451: /*
452: * ROUTINE: lock_make_unstable [internal]
453: *
454: * Marks the lock as unstable.
455: *
456: * NOTES:
457: * - All future acquisitions of the lock will return with a
458: * KERN_LOCK_UNSTABLE status, until the lock is made stable again.
459: */
460: kern_return_t
461: lock_make_unstable (ulock_t ulock, thread_act_t thr_act)
462: {
463: lock_set_t lock_set;
464:
465:
466: lock_set = ulock->lock_set;
467: lock_set_lock(lock_set);
468: if (!lock_set->active) {
469: lock_set_unlock(lock_set);
470: return KERN_LOCK_SET_DESTROYED;
471: }
472:
473: ulock_lock(ulock);
474: lock_set_unlock(lock_set);
475:
476: if (ulock->holder != thr_act) {
477: ulock_unlock(ulock);
478: return KERN_INVALID_RIGHT;
479: }
480:
481: ulock->unstable = TRUE;
482: ulock_unlock(ulock);
483:
484: return KERN_SUCCESS;
485: }
486:
487: /*
488: * ROUTINE: lock_release_internal [internal]
489: *
490: * Releases the ulock.
491: * If any threads are blocked waiting for the ulock, one is woken-up.
492: *
493: */
494: kern_return_t
495: lock_release_internal (ulock_t ulock, thread_act_t thr_act)
496: {
497: lock_set_t lock_set;
498: int result;
499:
500:
501: if ((lock_set = ulock->lock_set) == LOCK_SET_NULL)
502: return KERN_INVALID_ARGUMENT;
503:
504: lock_set_lock(lock_set);
505: if (!lock_set->active) {
506: lock_set_unlock(lock_set);
507: return KERN_LOCK_SET_DESTROYED;
508: }
509: ulock_lock(ulock);
510: lock_set_unlock(lock_set);
511:
512: if (ulock->holder != thr_act) {
513: ulock_unlock(ulock);
514: lock_set_unlock(lock_set);
515: return KERN_INVALID_RIGHT;
516: }
517:
518: /*
519: * If we have a hint that threads might be waiting,
520: * try to transfer the lock ownership to a waiting thread
521: * and wake it up.
522: */
523: if (ulock->blocked) {
524: wait_queue_t wq = &ulock->wait_queue;
525: thread_t thread;
526: spl_t s;
527:
528: s = splsched();
529: wait_queue_lock(wq);
530: thread = wait_queue_wakeup_identity_locked(wq,
531: LOCK_SET_EVENT,
532: THREAD_AWAKENED,
533: TRUE);
534: /* wait_queue now unlocked, thread locked */
535:
536: if (thread != THREAD_NULL) {
537: /*
538: * JMM - These ownership transfer macros have a
539: * locking/race problem. To keep the thread from
540: * changing states on us (nullifying the ownership
541: * assignment) we need to keep the thread locked
542: * during the assignment. But we can't because the
543: * macros take an activation lock, which is a mutex.
544: * Since this code was already broken before I got
545: * here, I will leave it for now.
546: */
547: thread_unlock(thread);
548:
549: /*
550: * Transfer ulock ownership
551: * from the current thread to the acquisition thread.
552: */
553: ulock_ownership_clear(ulock);
554: ulock_ownership_set(ulock, thread);
555: ulock_unlock(ulock);
556:
557: return KERN_SUCCESS;
558: } else {
559: ulock->blocked = FALSE;
560: }
561: }
562:
563: /*
564: * Disown ulock
565: */
566: ulock_ownership_clear(ulock);
567: ulock_unlock(ulock);
568:
569: return KERN_SUCCESS;
570: }
571:
572: kern_return_t
573: lock_handoff (lock_set_t lock_set, int lock_id)
574: {
575: ulock_t ulock;
576: int wait_result;
577:
578:
579: if (lock_set == LOCK_SET_NULL)
580: return KERN_INVALID_ARGUMENT;
581:
582: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
583: return KERN_INVALID_ARGUMENT;
584:
585: retry:
586: lock_set_lock(lock_set);
587:
588: if (!lock_set->active) {
589: lock_set_unlock(lock_set);
590: return KERN_LOCK_SET_DESTROYED;
591: }
592:
593: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
594: ulock_lock(ulock);
595: lock_set_unlock(lock_set);
596:
597: if (ulock->holder != current_act()) {
598: ulock_unlock(ulock);
599: lock_set_unlock(lock_set);
600: return KERN_INVALID_RIGHT;
601: }
602:
603: /*
604: * If the accepting thread (the receiver) is already waiting
605: * to accept the lock from the handoff thread (the sender),
606: * then perform the hand-off now.
607: */
608:
609: if (ulock->accept_wait) {
610: wait_queue_t wq = &ulock->wait_queue;
611: thread_t thread;
612: spl_t s;
613:
614: /*
615: * See who the lucky devil is, if he is still there waiting.
616: */
617: s = splsched();
618: wait_queue_lock(wq);
619: thread = wait_queue_wakeup_identity_locked(
620: wq,
621: LOCK_SET_HANDOFF,
622: THREAD_AWAKENED,
623: TRUE);
624: /* wait queue unlocked, thread locked */
625:
626: /*
627: * Transfer lock ownership
628: */
629: if (thread != THREAD_NULL) {
630: /*
631: * JMM - These ownership transfer macros have a
632: * locking/race problem. To keep the thread from
633: * changing states on us (nullifying the ownership
634: * assignment) we need to keep the thread locked
635: * during the assignment. But we can't because the
636: * macros take an activation lock, which is a mutex.
637: * Since this code was already broken before I got
638: * here, I will leave it for now.
639: */
640: thread_unlock(thread);
641: splx(s);
642:
643: ulock_ownership_clear(ulock);
644: ulock_ownership_set(ulock, thread);
645: ulock->accept_wait = FALSE;
646: ulock_unlock(ulock);
647: return KERN_SUCCESS;
648: } else {
649:
650: /*
651: * OOPS. The accepting thread must have been aborted.
652: * and is racing back to clear the flag that says is
653: * waiting for an accept. He will clear it when we
654: * release the lock, so just fall thru and wait for
655: * the next accept thread (that's the way it is
656: * specified).
657: */
658: splx(s);
659: }
660: }
661:
662: /*
663: * Indicate that there is a hand-off thread waiting, and then wait
664: * for an accepting thread.
665: */
666: ulock->ho_wait = TRUE;
667: wait_queue_assert_wait(&ulock->wait_queue,
668: LOCK_SET_HANDOFF,
669: THREAD_ABORTSAFE);
670: ulock_unlock(ulock);
671:
672: ETAP_SET_REASON(current_thread(), BLOCKED_ON_LOCK_HANDOFF);
673: wait_result = thread_block((void (*)(void))0);
674:
675: /*
676: * If the thread was woken-up via some action other than
677: * lock_handoff_accept or lock_set_destroy (i.e. thread_terminate),
678: * then we need to clear the ulock's handoff state.
679: */
680: switch (wait_result) {
681:
682: case THREAD_AWAKENED:
683: return KERN_SUCCESS;
684:
685: case THREAD_INTERRUPTED:
686: ulock_lock(ulock);
687: assert(ulock->holder == current_act());
688: ulock->ho_wait = FALSE;
689: ulock_unlock(ulock);
690: return KERN_ABORTED;
691:
692: case THREAD_RESTART:
693: goto retry;
694:
695: default:
696: panic("lock_handoff");
697: }
698: }
699:
700: kern_return_t
701: lock_handoff_accept (lock_set_t lock_set, int lock_id)
702: {
703: ulock_t ulock;
704: int wait_result;
705:
706:
707: if (lock_set == LOCK_SET_NULL)
708: return KERN_INVALID_ARGUMENT;
709:
710: if (lock_id < 0 || lock_id >= lock_set->n_ulocks)
711: return KERN_INVALID_ARGUMENT;
712:
713: retry:
714: lock_set_lock(lock_set);
715: if (!lock_set->active) {
716: lock_set_unlock(lock_set);
717: return KERN_LOCK_SET_DESTROYED;
718: }
719:
720: ulock = (ulock_t) &lock_set->ulock_list[lock_id];
721: ulock_lock(ulock);
722: lock_set_unlock(lock_set);
723:
724: /*
725: * If there is another accepting thread that beat us, just
726: * return with an error.
727: */
728: if (ulock->accept_wait) {
729: ulock_unlock(ulock);
730: return KERN_ALREADY_WAITING;
731: }
732:
733: if (ulock->holder == current_act()) {
734: ulock_unlock(ulock);
735: return KERN_LOCK_OWNED_SELF;
736: }
737:
738: /*
739: * If the handoff thread (the sender) is already waiting to
740: * hand-off the lock to the accepting thread (the receiver),
741: * then perform the hand-off now.
742: */
743: if (ulock->ho_wait) {
744: wait_queue_t wq = &ulock->wait_queue;
745: thread_t thread;
746: spl_t s;
747:
748: /*
749: * See who the lucky devil is, if he is still there waiting.
750: */
751: assert(ulock->holder != THR_ACT_NULL);
752: thread = ulock->holder->thread;
753:
754: wait_queue_lock(wq);
755: if (wait_queue_wakeup_thread_locked(wq,
756: LOCK_SET_HANDOFF,
757: thread,
758: THREAD_AWAKENED,
759: /* unlock? */ TRUE) == KERN_SUCCESS) {
760: /*
761: * Holder thread was still waiting to give it
762: * away. Take over ownership.
763: */
764: ulock_ownership_clear(ulock);
765: ulock_ownership_set(ulock, current_thread());
766: ulock->ho_wait = FALSE;
767: ulock_unlock(ulock);
768: return (ulock->unstable) ? KERN_LOCK_UNSTABLE :
769: KERN_SUCCESS;
770: }
771:
772: /*
773: * OOPS. The owner was aborted out of the handoff.
774: * He will clear his own flag when he gets back.
775: * in the meantime, we will wait as if we didn't
776: * even see his flag (by falling thru).
777: */
778: }
779:
780: ulock->accept_wait = TRUE;
781: wait_queue_assert_wait(&ulock->wait_queue,
782: LOCK_SET_HANDOFF,
783: THREAD_ABORTSAFE);
784: ulock_unlock(ulock);
785:
786: ETAP_SET_REASON(current_thread(), BLOCKED_ON_LOCK_HANDOFF);
787: wait_result = thread_block((void (*)(void))0);
788:
789: /*
790: * If the thread was woken-up via some action other than
791: * lock_handoff_accept or lock_set_destroy (i.e. thread_terminate),
792: * then we need to clear the ulock's handoff state.
793: */
794: switch (wait_result) {
795:
796: case THREAD_AWAKENED:
797: return KERN_SUCCESS;
798:
799: case THREAD_INTERRUPTED:
800: ulock_lock(ulock);
801: ulock->accept_wait = FALSE;
802: ulock_unlock(ulock);
803: return KERN_ABORTED;
804:
805: case THREAD_RESTART:
806: goto retry;
807:
808: default:
809: panic("lock_handoff_accept");
810: }
811: }
812:
813: /*
814: * Routine: lock_set_reference
815: *
816: * Take out a reference on a lock set. This keeps the data structure
817: * in existence (but the lock set may be deactivated).
818: */
819: void
820: lock_set_reference(lock_set_t lock_set)
821: {
822: lock_set_lock(lock_set);
823: lock_set->ref_count++;
824: lock_set_unlock(lock_set);
825: }
826:
827: /*
828: * Routine: lock_set_dereference
829: *
830: * Release a reference on a lock set. If this is the last reference,
831: * the lock set data structure is deallocated.
832: */
833: void
834: lock_set_dereference(lock_set_t lock_set)
835: {
836: int ref_count;
837: int size;
838:
839: lock_set_lock(lock_set);
840: ref_count = --(lock_set->ref_count);
841: lock_set_unlock(lock_set);
842:
843: if (ref_count == 0) {
844: size = sizeof(struct lock_set) +
845: (sizeof(struct ulock) * (lock_set->n_ulocks - 1));
846: kfree((vm_offset_t) lock_set, size);
847: }
848: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.