![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOLocks.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IOLocks.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
1.1 root 1: /*
2: * Copyright (c) 1998-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: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: *
27: */
28:
29:
30: #include <IOKit/system.h>
31:
32: #include <IOKit/IOReturn.h>
33: #include <IOKit/IOLib.h>
34: #include <IOKit/assert.h>
35:
36: extern "C" {
37: #include <kern/simple_lock.h>
38: #include <machine/machine_routines.h>
39:
40: IOLock * IOLockAlloc( void )
41: {
42: return( mutex_alloc(ETAP_IO_AHA) );
43: }
44:
45: void IOLockFree( IOLock * lock)
46: {
47: mutex_free( lock );
48: }
49:
50: void IOLockInitWithState( IOLock * lock, IOLockState state)
51: {
52: mutex_init( lock, ETAP_IO_AHA);
53:
54: if( state == kIOLockStateLocked)
55: IOLockLock( lock);
56: }
57:
58: struct _IORecursiveLock {
59: mutex_t * mutex;
60: thread_t thread;
61: UInt32 count;
62: };
63:
64: IORecursiveLock * IORecursiveLockAlloc( void )
65: {
66: _IORecursiveLock * lock;
67:
68: lock = IONew( _IORecursiveLock, 1);
69: if( !lock)
70: return( 0 );
71:
72: lock->mutex = mutex_alloc(ETAP_IO_AHA);
73: if( lock->mutex) {
74: lock->thread = 0;
75: lock->count = 0;
76: } else {
77: IODelete( lock, _IORecursiveLock, 1);
78: lock = 0;
79: }
80:
81: return( (IORecursiveLock *) lock );
82: }
83:
84: void IORecursiveLockFree( IORecursiveLock * _lock )
85: {
86: _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
87:
88: mutex_free( lock->mutex );
89: IODelete( lock, _IORecursiveLock, 1);
90: }
91:
92: void IORecursiveLockLock( IORecursiveLock * _lock)
93: {
94: _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
95:
96: if( lock->thread == IOThreadSelf())
97: lock->count++;
98: else {
99: _mutex_lock( lock->mutex );
100: assert( lock->thread == 0 );
101: assert( lock->count == 0 );
102: lock->thread = IOThreadSelf();
103: lock->count = 1;
104: }
105: }
106:
107: boolean_t IORecursiveLockTry( IORecursiveLock * _lock)
108: {
109: _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
110:
111: if( lock->thread == IOThreadSelf()) {
112: lock->count++;
113: return( true );
114: } else {
115: if( _mutex_try( lock->mutex )) {
116: assert( lock->thread == 0 );
117: assert( lock->count == 0 );
118: lock->thread = IOThreadSelf();
119: lock->count = 1;
120: return( true );
121: }
122: }
123: return( false );
124: }
125:
126: void IORecursiveLockUnlock( IORecursiveLock * _lock)
127: {
128: _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
129:
130: assert( lock->thread == IOThreadSelf() );
131:
132: if( 0 == (--lock->count)) {
133: lock->thread = 0;
134: mutex_unlock( lock->mutex );
135: }
136: }
137:
138: boolean_t IORecursiveLockHaveLock( const IORecursiveLock * _lock)
139: {
140: _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
141:
142: return( lock->thread == IOThreadSelf());
143: }
144:
145: /*
146: * Complex (read/write) lock operations
147: */
148:
149: IORWLock * IORWLockAlloc( void )
150: {
151: IORWLock * lock;
152:
153: lock = lock_alloc( true, ETAP_IO_AHA, ETAP_IO_AHA);
154:
155: return( lock);
156: }
157:
158: void IORWLockFree( IORWLock * lock)
159: {
160: lock_free( lock );
161: }
162:
163:
164: /*
165: * Spin locks
166: */
167:
168: IOSimpleLock * IOSimpleLockAlloc( void )
169: {
170: IOSimpleLock * lock;
171:
172: lock = (IOSimpleLock *) IOMalloc( sizeof(IOSimpleLock));
173: if( lock)
174: IOSimpleLockInit( lock );
175:
176: return( lock );
177: }
178:
179: void IOSimpleLockInit( IOSimpleLock * lock)
180: {
181: simple_lock_init( (simple_lock_t) lock, ETAP_IO_AHA );
182: }
183:
184: void IOSimpleLockFree( IOSimpleLock * lock )
185: {
186: IOFree( lock, sizeof(IOSimpleLock));
187: }
188:
189: } /* extern "C" */
190:
191:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.