![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unixThread.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / Examples / UnixDisk|
Return to unixThread.m CVS log | Up to [Apple Darwin 0.x] / driverkit / Examples / UnixDisk |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* unixThread.m 1.0 02/07/91 (c) 1991 NeXT
25: *
26: * unixThread.m - unixDisk Device Thread support.
27: *
28: * HISTORY
29: * 07-Feb-91 Doug Mitchell at NeXT
30: * Created.
31: */
32:
33: #import <bsd/sys/types.h>
34: #import <mach/cthreads.h>
35: #import <driverkit/IODevice.h>
36: #import "unixDisk.h"
37: #import "unixThread.h"
38: #import "unixDiskUxpr.h"
39: #import <driverkit/generalFuncs.h>
40: #import <machkit/NXLock.h>
41:
42: static void unixThreadDequeue(IOQueue_t *ioQ,
43: BOOL needs_disk,
44: int threadNum);
45:
46: @implementation unixDisk(Thread)
47:
48: /*
49: * Enqueue an IOBuf on an IOQueue and wake up anyone (i.e., an I/O thread)
50: * who might be waiting for the IOBuf.
51: */
52: - (void) enqueueIoBuf : (IOBuf_t *)buf
53: needs_disk : (BOOL)needs_disk
54: {
55: queue_head_t *q;
56:
57: if(needs_disk)
58: q = &IOQueue.q_disk;
59: else
60: q = &IOQueue.q_nodisk;
61: [IOQueue.qlock lock];
62: queue_enter(q, buf, IOBuf_t *, ioChain);
63: [IOQueue.qlock unlockWith:WORK_AVAILABLE];
64: xpr_ud("enqueueIoBuf: exiting. IOBuf 0x%x needs_disk %s\n",
65: buf, needs_disk ? (int)"TRUE" : (int)"FALSE", 3,4,5);
66: }
67:
68: /*
69: * Wakeup up I/O threads. Used for 'diskBecameReady' notification.
70: */
71: - (void)ioThreadWakeup
72: {
73: [IOQueue.qlock lock];
74: [IOQueue.qlock unlockWith:WORK_AVAILABLE];
75: }
76:
77: /*
78: * Unlock IOQueue.qlock, updating condition variable as appropriate.
79: */
80: - (void)unlockIOQueue
81: {
82: int queue_state;
83: IODiskReadyState lastReady = [self lastReadyState];
84:
85: /*
86: * There's still work to do when:
87: * -- q_nodisk non-empty, or
88: * -- q_disk non-empty and we "really" have a disk.
89: */
90:
91: if((!queue_empty(&IOQueue.q_nodisk)) ||
92: ((!queue_empty(&IOQueue.q_disk)) &&
93: (lastReady != IO_NoDisk) &&
94: (lastReady != IO_Ejecting) &&
95: (!IOQueue.ejectPending)
96: )
97: ) {
98: queue_state = WORK_AVAILABLE;
99: }
100: else
101: queue_state = NO_WORK_AVAILABLE;
102: [IOQueue.qlock unlockWith:queue_state];
103: }
104:
105: @end
106:
107: /*
108: * I/O thread. 'n' copies of this are IOForkThread()'d in the init:sender:
109: * method. This handles IOBufs which have been enqueued by exported methods
110: * (like read: and write:).
111: *
112: * This thread merely loops doing the following:
113: * -- get an IOBuf off of the IOQueue.
114: * -- perform the task specified in IOBuf->command.
115: * -- if async request, ioComplete: the result, else
116: * wakeup the waiting thread.
117: */
118:
119: volatile void unix_thread(IOQueue_t *ioQ)
120: {
121: int threadNum;
122: IODiskReadyState lastReady;
123:
124: /*
125: * First assign ourself a thread number.
126: */
127: [ioQ->qlock lock];
128: threadNum = ioQ->numThreads++;
129: [ioQ->qlock unlock];
130: xpr_uth("unix_thread %d: starting\n", threadNum, 2,3,4,5);
131: while(1) {
132:
133: /*
134: * Wait for something to do. Keep the lock until we
135: * dequeue something.
136: */
137: [ioQ->qlock lockWhen:WORK_AVAILABLE];
138:
139: /*
140: * Service all requests which do not need a disk.
141: */
142: xpr_uth("unix_thread: servicing q_nodisk\n", 1,2,3,4,5);
143: while(!queue_empty(&ioQ->q_nodisk))
144: unixThreadDequeue(ioQ, NO, threadNum);
145:
146: /*
147: * Now service all requests which need a disk, if our disk
148: * is present.
149: */
150: xpr_uth("unix_thread: servicing q_disk\n", 1,2,3,4,5);
151: while((!queue_empty(&ioQ->q_disk)) &&
152: ([ioQ->device lastReadyState] != IO_NoDisk) &&
153: ([ioQ->device lastReadyState] != IO_Ejecting) &&
154: (!ioQ->ejectPending)) {
155: unixThreadDequeue(ioQ, YES, threadNum);
156: }
157:
158: /*
159: * If we have work to do in q_disk but we don't have a disk,
160: * ask volCheck to put up a panel. In either case, when we
161: * unlock ioQ.qlock for the last time, update its
162: * condition variable as appropriate so we and the other
163: * I/O threads working on this IOQueue know whether or not
164: * to sleep.
165: */
166: lastReady = [ioQ->device lastReadyState];
167: if((!queue_empty(&ioQ->q_disk)) &&
168: ((lastReady == IO_NoDisk) || ioQ->ejectPending)) {
169: [ioQ->device unlockIOQueue];
170: xpr_uth("unix_thread: volCheckRequest()\n", 1,2,3,4,5);
171: volCheckRequest(ioQ->device,
172: [ioQ->device diskType]);
173: }
174: else {
175: [ioQ->device unlockIOQueue];
176: }
177: }
178: /* NOT REACHED */
179: }
180:
181: /*
182: * Process a request at the head of one of the queues in *ioQ.
183: * ioQ->qlock must be held on entry; it will still be held on exit (though we
184: * release it when doing a command dispatch).
185: */
186: static void unixThreadDequeue(IOQueue_t *ioQ,
187: BOOL needs_disk,
188: int threadNum)
189: {
190: queue_head_t *q;
191: IOBuf_t *IOBuf;
192:
193: if(needs_disk)
194: q = &ioQ->q_disk;
195: else
196: q = &ioQ->q_nodisk;
197: if(queue_empty(q)) {
198: IOLog("unixThreadDequeue: Empty queue!\n");
199: return;
200: }
201: IOBuf = (IOBuf_t *)queue_first(q);
202: queue_remove(q,
203: IOBuf,
204: IOBuf_t *,
205: ioChain);
206:
207: /*
208: * For proper timing of the call to volCheckEjecting, we have to
209: * determine right now - while the queue is locked - whether this
210: * is an eject command. If so, the call to volCheckEjecting() will
211: * prevent other I/O threads from attempting to perform I/Os from
212: * q_disk.
213: *
214: * The numDiskIos counter allows the thread doing an eject command
215: * to wait for all other pending Disk I/Os to complete before doing
216: * the eject.
217: *
218: * We also have to keep that cruft ejectPending flag around, since
219: * the call to volCheckEjecting() doesn't result in an immediate
220: * update of lastReadyState...
221: */
222: if(needs_disk) {
223: [ioQ->ejectLock lock];
224: ioQ->numDiskIos++;
225: if(IOBuf->command == @selector(deviceEject:threadNum:)) {
226: ioQ->ejectPending = TRUE;
227: volCheckEjecting(IOBuf->device,
228: [IOBuf->device diskType]);
229: }
230: [ioQ->ejectLock unlockWith:ioQ->numDiskIos];
231: }
232:
233: [ioQ->qlock unlock];
234: xpr_uth("unix_thread %d: IOBuf 0x%x received\n",
235: threadNum, IOBuf, 3,4,5);
236: [IOBuf->device perform:IOBuf->command
237: with:(id)IOBuf
238: with:(id)threadNum];
239: [ioQ->qlock lock];
240: if(needs_disk) {
241: /*
242: * Enable possible waiting eject command.
243: */
244: [ioQ->ejectLock lock];
245: ioQ->numDiskIos--;
246: [ioQ->ejectLock unlockWith:ioQ->numDiskIos];
247: }
248: }
249:
250: /* end of IOThread.m */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.