![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to SCSIDiskThread.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel|
Return to SCSIDiskThread.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel |
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: /* Copyright (c) 1991 NeXT Computer, Inc. All rights reserved.
25: *
26: * SCSIDiskThread.m - Implementation of SCSIDisk I/O thread and its associated
27: * methods. All communication with the SCSIController object
28: * is done here.
29: *
30: * HISTORY
31: * 04-Mar-91 Doug Mitchell at NeXT
32: * Created.
33: */
34:
35: /*
36: * Enforce clean driverkit implementation.
37: */
38: #define MACH_USER_API 1
39: #undef KERNEL_PRIVATE
40:
41: #import <sys/types.h>
42: #import <kernserv/prototypes.h>
43: #import <driverkit/SCSIDiskPrivate.h>
44: #import <driverkit/SCSIDiskTypes.h>
45: #import <driverkit/SCSIDiskThread.h>
46: #import <driverkit/SCSIStructInlines.h>
47: #import <bsd/dev/scsireg.h>
48: #import <driverkit/xpr_mi.h>
49: #import <driverkit/volCheck.h>
50: #import <driverkit/kernelDiskMethods.h>
51: #import <kern/assert.h>
52: #import <machkit/NXLock.h>
53: #import <driverkit/align.h>
54:
55: static void sdThreadDequeue(SCSIDisk *sdp,
56: BOOL needs_disk);
57:
58: @implementation SCSIDisk(Thread)
59:
60: /*
61: * Execute one I/O, as specified in sdBuf. Called out from an I/O thread.
62: *
63: * This is certainly the most complicated part of the SCSIDisk object; all
64: * retry logic is done here. It's kind of big. Maybe we can break this up
65: * a little bit.
66: */
67: - (void)doSdBuf : (sdBuf_t *)sdBuf
68: {
69: IOSCSIRequest scsiReq;
70: sc_status_t scrtn = SR_IOST_INVALID;
71: IOReturn iortn;
72: esense_reply_t senseReply;
73: const char *name = [self name];
74:
75: xpr_sd("sd%d doSdBuf: sdBuf 0x%x\n", [self unit], sdBuf, 3,4,5);
76:
77: /*
78: * Initialize retry counters.
79: */
80: sdBuf->busy_retry = SD_RETRY_BUSY;
81: sdBuf->norm_retry = SD_RETRY_NORM;
82: sdBuf->notRdy_retry = SD_RETRY_NOTRDY;
83:
84: while(sdBuf->busy_retry && sdBuf->norm_retry && sdBuf->notRdy_retry) {
85:
86: /*
87: * Set up a scsiReq to pass to the controller.
88: */
89: scrtn = [self setupScsiReq:sdBuf scsiReq:&scsiReq];
90: if(scrtn)
91: return;
92:
93:
94: /*
95: * Go for it.
96: */
97: senseReply.er_ibvalid = 0; // for error logging
98: scrtn = [_controller executeRequest:&scsiReq
99: buffer:sdBuf->buf
100: client:sdBuf->client];
101: xpr_sd("sd%d: CDB Complete: sdBuf 0x%x driverStatus "
102: "%s scsiStatus"
103: " 0x%x\n", [self unit], sdBuf,
104: IOFindNameForValue(scsiReq.driverStatus,
105: IOScStatusStrings),
106: scsiReq.scsiStatus, 5);
107: if(scrtn == SR_IOST_GOOD) {
108: if((sdBuf->command == SDOP_READ) ||
109: (sdBuf->command == SDOP_WRITE)) {
110: /*
111: * Make sure the we moved the number of
112: * bytes we wanted to. Note we skip this
113: * test for SDOP_CDB_xxx - that's the
114: * user's problem.
115: */
116: u_int block_size = [self blockSize];
117: if((sdBuf->blockCnt * block_size) !=
118: scsiReq.bytesTransferred) {
119: if(--sdBuf->norm_retry <= 0) {
120: IOLog("%s: TRANSFER COUNT ERROR; "
121: " FATAL.\n", name);
122: [self logOpInfo:sdBuf
123: sense:&senseReply];
124: scrtn = SR_IOST_BCOUNT;
125: goto abort;
126: }
127: IOLog("%s: TRANSFER COUNT ERROR. "
128: " Expected = %d Received %d; "
129: "Retrying.\n", name,
130: sdBuf->blockCnt * block_size,
131: sdBuf->bytesXfr);
132: [self logOpInfo:sdBuf sense:NULL];
133: goto do_retry;
134: }
135: }
136:
137: /*
138: * Success. Log statistics.
139: */
140: if(_isRegistered) {
141: switch(sdBuf->command) {
142: case SDOP_READ:
143: [self addToBytesRead:
144: scsiReq.bytesTransferred
145: totalTime:scsiReq.totalTime
146: latentTime:scsiReq.latentTime];
147: break;
148: case SDOP_WRITE:
149: [self addToBytesWritten:
150: scsiReq.bytesTransferred
151: totalTime:scsiReq.totalTime
152: latentTime:scsiReq.latentTime];
153: break;
154: }
155: }
156:
157: /*
158: * All right, we're done.
159: */
160: break;
161: }
162:
163: if(sdBuf->retryDisable)
164: goto abort;
165:
166: /*
167: * What seems to be the problem?
168: */
169: switch(scrtn) {
170: case SR_IOST_SELTO: /* selection timeout */
171: case SR_IOST_ALIGN: /* DMA alignment */
172: case SR_IOST_BCOUNT: /* DMA overrun */
173: case SR_IOST_CMDREJ: /* command reject */
174: case SR_IOST_MEMALL: /* malloc error */
175: case SR_IOST_MEMF: /* memory failure */
176: case SR_IOST_IPCFAIL: /* IPC failure */
177: case SR_IOST_INT: /* internal error */
178: case SR_IOST_VOLNA: /* volume not available */
179: case SR_IOST_INVALID: /* our mistake */
180: case SR_IOST_WP: /* write protect */
181:
182: /*
183: * These are not retriable.
184: */
185: IOLog("%s: %s : FATAL ERROR\n", name,
186: IOFindNameForValue(scrtn, IOScStatusStrings));
187: [self logOpInfo:sdBuf sense:&senseReply];
188:
189: goto abort;
190:
191: case SR_IOST_BADST:
192: case SR_IOST_CHKSV:
193: case SR_IOST_CHKSNV:
194: /*
195: * The only weird SCSI status values we know how to
196: * deal with are "Busy" and "Check Status".
197: */
198: switch(scsiReq.scsiStatus) {
199: case STAT_BUSY:
200: if(--sdBuf->busy_retry <= 0) {
201: IOLog("%s: BUSY STATUS; FATAL.\n",
202: name);
203: [self logOpInfo:sdBuf
204: sense:&senseReply];
205: goto abort;
206: }
207: IOLog("%s: BUSY STATUS; Retrying.\n", name);
208: IOSleep(SD_BUSY_SLEEP * 1000);
209: break;
210:
211: case STAT_CHECK:
212: /*
213: * Do a request sense to find out why.
214: */
215: if(scrtn == SR_IOST_CHKSV) {
216: /*
217: * We already have sense data.
218: */
219: senseReply = scsiReq.senseData;
220: }
221: else {
222: scrtn = [self reqSense:&senseReply];
223: if(scrtn) {
224: IOLog("%s: REQUEST SENSE ERROR; "
225: " FATAL.\n", name);
226: goto abort;
227: }
228: }
229:
230:
231: /*
232: * OK, we have valid sense data.
233: */
234: switch(senseReply.er_sensekey) {
235: case SENSE_NOTREADY:
236: if(--sdBuf->notRdy_retry <= 0) {
237: IOLog("%s: NOT READY; "
238: "FATAL.\n", name);
239: /*
240: * FIXME - do we tell volCheck
241: * about this??
242: */
243: [self logOpInfo:sdBuf
244: sense:&senseReply];
245: goto abort;
246: }
247: IOLog("%s: NOT READY; Retrying.\n",
248: name);
249: [self logOpInfo:sdBuf
250: sense:&senseReply];
251: IOSleep(SD_NOTRDY_SLEEP * 1000);
252: break;
253:
254: case SENSE_NOSENSE: // I don't
255: // trust this!
256: case SENSE_RECOVERED: // or this
257: case SENSE_MEDIA:
258: case SENSE_HARDWARE:
259: if(--sdBuf->norm_retry <= 0) {
260: IOLog("%s: %s; FATAL.\n", name,
261: IOFindNameForValue(senseReply.
262: er_sensekey,
263: IOSCSISenseStrings));
264: [self logOpInfo:sdBuf
265: sense:&senseReply];
266: goto abort;
267: }
268: IOLog("%s: %s; Retrying.\n", name,
269: IOFindNameForValue(senseReply.
270: er_sensekey,
271: IOSCSISenseStrings));
272: [self logOpInfo:sdBuf
273: sense:&senseReply];
274: break;
275:
276: case SENSE_UNITATTENTION:
277: /*
278: * TBD - when we figure out how
279: * to handle removable media...
280: */
281: if(--sdBuf->norm_retry <= 0) {
282: IOLog("%s: UNIT ATTENTION;"
283: " FATAL.\n", name);
284: [self logOpInfo:sdBuf
285: sense:&senseReply];
286: goto abort;
287: }
288: IOLog("%s: UNIT ATTENTION; "
289: "Retrying.\n", name);
290: [self logOpInfo:sdBuf
291: sense:&senseReply];
292: break;
293:
294: case SENSE_DATAPROTECT:
295: /*
296: * Not retryable, but at least we have
297: * a unique error code.
298: */
299: IOLog("%s: WRITE PROTECTED. FATAL"
300: ".\n", name);
301: [self logOpInfo:sdBuf
302: sense:&senseReply];
303: scrtn = SR_IOST_WP;
304: goto abort;
305:
306: default:
307: /*
308: * All others fatal.
309: */
310: IOLog("%s: %s; FATAL.\n", name,
311: IOFindNameForValue(senseReply.
312: er_sensekey,
313: IOSCSISenseStrings));
314: [self logOpInfo:sdBuf
315: sense:&senseReply];
316: scrtn = SR_IOST_CHKSV;
317: goto abort;
318: } /* switch sense key */
319: break; /* from case STAT_CHECK */
320:
321: default:
322: /*
323: * Sorry, no can do.
324: */
325: IOLog("%s: BOGUS SCSI STATUS (0x%x): "
326: "FATAL.\n", name, scsiReq.scsiStatus);
327: [self logOpInfo:sdBuf
328: sense:&senseReply];
329: scrtn = SR_IOST_BADST;
330: goto abort;
331:
332: } /* switch scsiStatus */
333: break; /* from case SR_IOST_BADST */
334:
335: default:
336: /*
337: * Well, what the hey. retry.
338: */
339: if(--sdBuf->norm_retry <= 0) {
340: IOLog("%s: %s; FATAL.\n", name,
341: IOFindNameForValue(scrtn, IOScStatusStrings));
342: [self logOpInfo:sdBuf
343: sense:&senseReply];
344: goto abort;
345: }
346: IOLog("%s: %s; Retrying.\n", name,
347: IOFindNameForValue(scrtn, IOScStatusStrings));
348: [self logOpInfo:sdBuf
349: sense:&senseReply];
350: break;
351: } /* switch scrtn */
352: do_retry:
353: /*
354: * Retrying. log this with IODisk.
355: */
356: if(_isRegistered) {
357: switch(sdBuf->command) {
358: case SDOP_READ:
359: [self incrementReadRetries];
360: break;
361: case SDOP_WRITE:
362: [self incrementWriteRetries];
363: break;
364: default:
365: [self incrementOtherRetries];
366: break;
367: }
368: }
369: } /* main retry loop */
370:
371: abort:
372:
373: /*
374: * We've either successfuly executed the command or have given up.
375: * Transfer appropriate return values to sdBuf and sdIoComplete the
376: * result.
377: */
378: if((sdBuf->busy_retry == 0) ||
379: (sdBuf->norm_retry == 0) ||
380: (sdBuf->notRdy_retry == 0)) {
381: iortn = IO_R_IO;
382: }
383: else if(scrtn) {
384: iortn = [_controller returnFromScStatus:scrtn];
385: }
386: else {
387: iortn = IO_R_SUCCESS;
388: }
389: if(iortn && _isRegistered) {
390: /*
391: * All fatal errors must be logged with IODisk.
392: */
393: switch(sdBuf->command) {
394: case SDOP_READ:
395: [self incrementReadErrors];
396: break;
397: case SDOP_WRITE:
398: [self incrementWriteErrors];
399: break;
400: default:
401: if(!sdBuf->retryDisable) {
402: [self incrementOtherErrors];
403: }
404: break;
405: }
406: }
407: if(sdBuf->scsiReq) {
408: /*
409: * This implies SDOP_CDB_{READ,WRITE}.
410: */
411: sdBuf->scsiReq->driverStatus = scsiReq.driverStatus;
412: sdBuf->scsiReq->scsiStatus = scsiReq.scsiStatus;
413: sdBuf->scsiReq->bytesTransferred = scsiReq.bytesTransferred;
414:
415: /*
416: * Don't forget to copy over the sense data if the controller
417: * has provided it to us. We do not copy sense data that we
418: * manually requested for our own purposes in SCSIDisk.
419: */
420: if (scsiReq.driverStatus == SR_IOST_CHKSV)
421: sdBuf->scsiReq->senseData = scsiReq.senseData;
422: }
423: #if 0
424: else if(iortn == IO_R_SUCCESS) {
425: /*
426: * We know we can read this thing.
427: */
428: [self setFormattedInternal:1];
429: }
430: #endif 0
431: sdBuf->bytesXfr = scsiReq.bytesTransferred;
432: sdBuf->status = iortn;
433: [self sdIoComplete:sdBuf];
434: return;
435: }
436:
437: /*
438: * Log info about current operation for retry/error reporting.
439: */
440: - (void)logOpInfo : (sdBuf_t *)sdBuf
441: sense : (esense_reply_t *)senseReply
442: {
443: char opString[40];
444: char blockString[80];
445:
446: blockString[0] = '\0';
447: switch(sdBuf->command) {
448: case SDOP_READ:
449: strcpy(opString, "Read");
450: goto logBlock;
451: case SDOP_WRITE:
452: strcpy(opString, "Write");
453: logBlock:
454: if(senseReply && senseReply->er_ibvalid) {
455: /*
456: * Get block # from sense data
457: */
458: unsigned blockInErr;
459:
460: blockInErr = scsi_error_info(senseReply);
461: sprintf(blockString, "block:%d", blockInErr);
462: }
463: else {
464: /*
465: * Just report starting block # and length.
466: */
467: sprintf(blockString, "block:%d blockCount:%d",
468: sdBuf->block, sdBuf->blockCnt);
469: }
470: break;
471:
472: case SDOP_CDB_READ:
473: case SDOP_CDB_WRITE:
474: strcpy(opString,
475: IOFindNameForValue(sdBuf->scsiReq->cdb.cdb_opcode,
476: IOSCSIOpcodeStrings));
477: break;
478:
479: case SDOP_EJECT:
480: strcpy(opString, "Eject");
481: break;
482:
483: default:
484: /*
485: * The remainder should not result in disk errors...
486: */
487: panic("Bogus op in logOpInfo");
488: }
489: IOLog(" target:%d lun:%d op:%s %s\n", _target, _lun,
490: opString, blockString);
491: return;
492: }
493:
494: /*
495: * generate a CDB for a read or write operation. Assumes that *cdbp has
496: * already been zero'd.
497: */
498: - (void)genRwCdb : (cdb_t *)cdbp
499: readFlag : (BOOL)readFlag
500: block : (u_int)block
501: blockCnt : (u_int)blockCnt
502: {
503: cdb_10_t *cdb = &cdbp->cdb_c10;
504: unsigned short blockCntS = blockCnt;
505:
506: if (readFlag)
507: scsi_readextended_setup(cdb, _lun, block, blockCntS);
508: else
509: scsi_writeextended_setup(cdb, _lun, block, blockCntS);
510: }
511:
512: /*
513: * Set up a scsiReq for a given sdBuf_t to pass to the controller. Only used
514: * inside of I/O thread.
515: */
516: - (sc_status_t)setupScsiReq:(sdBuf_t *)sdBuf
517: scsiReq:(IOSCSIRequest *)scsiReq
518: {
519: u_int block_size;
520:
521: block_size = [self blockSize];
522: bzero(scsiReq, sizeof(IOSCSIRequest));
523: scsiReq->target = _target;
524: scsiReq->lun = _lun;
525: switch(sdBuf->command) {
526: case SDOP_READ:
527: scsiReq->read = YES;
528: [self genRwCdb:&scsiReq->cdb
529: readFlag : YES
530: block : sdBuf->block
531: blockCnt : sdBuf->blockCnt];
532: goto rw_common;
533:
534: case SDOP_WRITE:
535: scsiReq->read = NO;
536: [self genRwCdb:&scsiReq->cdb
537: readFlag : NO
538: block : sdBuf->block
539: blockCnt : sdBuf->blockCnt];
540: rw_common:
541: sdBuf->scsiReq = NULL;
542: scsiReq->maxTransfer = sdBuf->blockCnt * block_size;
543: scsiReq->timeoutLength = SD_TIMEOUT_RW;
544: scsiReq->disconnect = 1;
545: break;
546:
547: case SDOP_EJECT:
548: case SDOP_CDB_READ:
549: case SDOP_CDB_WRITE:
550: if((sdBuf->scsiReq->target != _target) ||
551: (sdBuf->scsiReq->lun != _lun)) {
552: /*
553: * Ooops, can't allow this!
554: */
555: sdBuf->scsiReq->driverStatus = SR_IOST_CMDREJ;
556: sdBuf->status = IO_R_INVALID_ARG;
557: [self sdIoComplete:sdBuf];
558: return(SR_IOST_CMDREJ);
559: }
560: /*
561: * Otherwise, we'll allow just about anything.
562: */
563: *scsiReq = *sdBuf->scsiReq;
564: break;
565: default:
566: ASSERT(0);
567: break;
568: }
569: return(SR_IOST_GOOD);
570: }
571:
572: /*
573: * Execute a request sense command within the I/O thread. esenseReply
574: * does not have to be aligned.
575: */
576: - (sc_status_t)reqSense : (esense_reply_t *)esenseReply
577: {
578: IOSCSIRequest scsiReq;
579: sc_status_t rtn;
580: cdb_6_t *cdbp = &scsiReq.cdb.cdb_c6;
581: esense_reply_t *alignedReply;
582: void *freep;
583: int freeCnt;
584: IODMAAlignment dmaAlign;
585:
586: xpr_sd("sd%d reqSense\n", [self unit], 2,3,4,5);
587:
588: /*
589: * Get some well-aligned memory.
590: */
591: alignedReply = [_controller allocateBufferOfLength:
592: sizeof(esense_reply_t)
593: actualStart:&freep
594: actualLength:&freeCnt];
595: bzero(&scsiReq, sizeof(IOSCSIRequest));
596:
597: cdbp->c6_opcode = C6OP_REQSENSE;
598: cdbp->c6_lun = _lun;
599: cdbp->c6_len = sizeof(esense_reply_t);
600: scsiReq.target = _target;
601: scsiReq.lun = _lun;
602: scsiReq.read = YES;
603:
604: /*
605: * Get appropriate alignment from controller.
606: */
607: [_controller getDMAAlignment:&dmaAlign];
608: if(dmaAlign.readLength > 1) {
609: scsiReq.maxTransfer = IOAlign(int, sizeof(esense_reply_t),
610: dmaAlign.readLength);
611: }
612: else {
613: scsiReq.maxTransfer = sizeof(esense_reply_t);
614: }
615: scsiReq.timeoutLength = SD_TIMEOUT_SIMPLE;
616: scsiReq.disconnect = 1;
617: rtn = [_controller executeRequest:&scsiReq
618: buffer:alignedReply
619: client:IOVmTaskSelf()];
620: /*
621: * Copy data back to caller's struct.
622: */
623:
624: *esenseReply = *alignedReply;
625: IOFree(freep, freeCnt);
626: xpr_sd("sd%d reqSense: returning %d\n", [self unit], rtn, 3,4,5);
627:
628: return(rtn);
629: }
630:
631: /*
632: * Either wake up the thread which is waiting on the sdBuf, or send an
633: * ioComplete back to client. sdBuf->status must be valid.
634: */
635: - (void)sdIoComplete : (sdBuf_t *)sdBuf
636: {
637: xpr_sd("%s sdIoComplete: sdBuf 0x%x status %s\n",
638: [self name], sdBuf,
639: [self stringFromReturn:sdBuf->status], 4,5);
640: if(sdBuf->pending) {
641:
642: /*
643: * Async I/O complete. This will change with RO support.
644: */
645: int dirRead = 0;
646:
647: switch(sdBuf->command) {
648: case SDOP_READ:
649: case SDOP_CDB_READ:
650: dirRead = 1;
651: break;
652: default:
653: break;
654: }
655: [self completeTransfer : sdBuf->pending
656: withStatus : sdBuf->status
657: actualLength : sdBuf->bytesXfr];
658: [self freeSdBuf:sdBuf];
659: }
660: else {
661: /*
662: * Sync I/O. Just wake up the waiting thread.
663: */
664: [sdBuf->waitLock unlockWith:YES];
665: }
666: }
667:
668: /*
669: * Unlock ioQLock, updating condition variable as appropriate.
670: */
671: - (void)unlockIoQLock
672: {
673: int queue_state;
674: IODiskReadyState lastReady = [self lastReadyState];
675:
676: /*
677: * There's still work to do when:
678: * -- ioQueueNodisk non-empty, or
679: * -- ioQueueDisk non-empty and we "really" have a disk.
680: */
681:
682: if((!queue_empty(&_ioQueueNodisk)) ||
683: ((!queue_empty(&_ioQueueDisk)) &&
684: (lastReady != IO_NoDisk) &&
685: (lastReady != IO_Ejecting) &&
686: (!_ejectPending)
687: )
688: ) {
689: queue_state = WORK_AVAILABLE;
690: }
691: else
692: queue_state = NO_WORK_AVAILABLE;
693: [_ioQLock unlockWith:queue_state];
694:
695: if (queue_state == WORK_AVAILABLE)
696: (void) thread_block();
697: }
698:
699:
700: /*
701: * I/O thread. Each one of these sits around waiting for work to do on
702: * ioQueue; when something appears, the thread grabs it, creates an
703: * appropriate scsiReq, invokes the proper controller method, and
704: * handles a possible error condition (including retries).
705: */
706:
707: volatile void sdIoThread(id me)
708: {
709: SCSIDisk *sdp = (SCSIDisk *)me;
710: IODiskReadyState lastReady;
711:
712: xpr_sd("sdIoThread unit %d: STARTING\n", [sdp unit], 2,3,4,5);
713:
714: while(1) {
715: /*
716: * Wait for some work to do. Keep the ioQLock until we
717: * dequeue something.
718: */
719: xpr_sd("sdIoThread: waiting for work\n", 1,2,3,4,5);
720: [sdp->_ioQLock lockWhen:WORK_AVAILABLE];
721:
722: /*
723: * Service all requests which do not need a disk.
724: */
725: xpr_sd("sdIoThread: servicing q_nodisk\n", 1,2,3,4,5);
726: while(!queue_empty(&sdp->_ioQueueNodisk))
727: sdThreadDequeue(sdp, NO);
728:
729: /*
730: * Now service all requests which need a disk, if our disk
731: * is present. We still hold ioQLock.
732: */
733: xpr_sd("sdIoThread: servicing q_disk\n", 1,2,3,4,5);
734: while((!queue_empty(&sdp->_ioQueueDisk)) &&
735: ([sdp lastReadyState] != IO_NoDisk) &&
736: ([sdp lastReadyState] != IO_Ejecting) &&
737: (!sdp->_ejectPending)) {
738: sdThreadDequeue(sdp, YES);
739: }
740:
741: /*
742: * If we have work to do in ioQueueDisk but we don't have
743: * a disk, ask volCheck to put up a panel. In either case,
744: * when we unlock ioQueueLock for the last time, update its
745: * condition variable as appropriate so we and the other
746: * I/O threads know whether or not to sleep.
747: */
748:
749: lastReady = [sdp lastReadyState];
750: if((!queue_empty(&sdp->_ioQueueDisk)) &&
751: ((lastReady == IO_NotReady && [sdp isRemovable]) ||
752: (lastReady == IO_NoDisk) || sdp->_ejectPending)) {
753: [sdp unlockIoQLock];
754: xpr_sd("sdIoThread: volCheckRequest()\n", 1,2,3,4,5);
755: volCheckRequest(sdp, PR_DRIVE_SCSI);
756: }
757: else {
758: [sdp unlockIoQLock];
759: }
760: } /* while 1 */
761:
762: /* NOT REACHED */
763: }
764:
765: /*
766: * Process a request at the head of one of the IOQueues.
767: * ioQLock must be held on entry; it will still be held on exit.
768: */
769: static void sdThreadDequeue(SCSIDisk *sdp,
770: BOOL needs_disk)
771: {
772: queue_head_t *q;
773: sdBuf_t *sdBuf;
774:
775: if(needs_disk)
776: q = &sdp->_ioQueueDisk;
777: else
778: q = &sdp->_ioQueueNodisk;
779: if(queue_empty(q)) {
780: IOLog("sdThreadDequeue: Empty queue!\n");
781: return;
782: }
783: sdBuf = (sdBuf_t *)queue_first(q);
784: queue_remove(q,
785: sdBuf,
786: sdBuf_t *,
787: link);
788:
789: /*
790: * In case of an eject command, we have to ensure right now - while
791: * the queue is locked - that no other threads attempt any
792: * "needs disk" type of I/Os. That's what the ejectPending flag is
793: * for; we can't rely on the volCheck thread setting our
794: * lastReadyState to RS_EJECTING for another second or so...
795: *
796: * The numDiskIos counter allows the thread doing an eject command
797: * to wait for all other pending Disk I/Os to complete before doing
798: * the eject.
799: */
800: if(needs_disk) {
801: [sdp->_ejectLock lock];
802: sdp->_numDiskIos++;
803: if(sdBuf->command == SDOP_EJECT) {
804: sdp->_ejectPending = YES;
805: volCheckEjecting(sdp, PR_DRIVE_SCSI);
806: }
807: [sdp->_ejectLock unlockWith:sdp->_numDiskIos];
808: }
809:
810: /*
811: * Execute command specified in sdBuf. We hold _ioQLock.
812: */
813:
814: xpr_sd("sdThreadDequeue: sdBuf 0x%x received\n", sdBuf, 2,3,4,5);
815: switch(sdBuf->command) {
816: case SDOP_ABORT:
817: /*
818: * Ah hah, we have to ioComplete all of the sdBufs in
819: * ioQueueDisk.
820: */
821: {
822: sdBuf_t *abortBuf;
823: queue_head_t *q = &sdp->_ioQueueDisk;
824:
825: while(!queue_empty(q)) {
826: abortBuf = (sdBuf_t *)queue_first(q);
827: queue_remove(q, abortBuf, sdBuf_t *, link);
828: [sdp->_ioQLock unlock];
829: abortBuf->status = IO_R_NO_DISK;
830: if(abortBuf->scsiReq)
831: abortBuf->scsiReq->driverStatus = SR_IOST_VOLNA;
832: [sdp sdIoComplete:abortBuf];
833: [sdp->_ioQLock lock];
834: }
835:
836: /*
837: * and ioComplete the abort command itself.
838: */
839: sdBuf->status = IO_R_SUCCESS;
840: [sdp sdIoComplete:sdBuf];
841: }
842: break;
843:
844: case SDOP_PROBEDISK:
845: /*
846: * If we got this far, the disk is present. ioComplete
847: * immediately. (If disk was not present, we would have
848: * disposed of this in case SDOP_ABORT.)
849: */
850: sdBuf->status = IO_R_SUCCESS;
851: [sdp sdIoComplete:sdBuf];
852: break;
853:
854: case SDOP_EJECT:
855: /*
856: * Wait until we're the only thread executing.
857: */
858: [sdp->_ioQLock unlock];
859: [sdp->_ejectLock lockWhen:1];
860: [sdp->_ejectLock unlock];
861: [sdp doSdBuf:sdBuf];
862: [sdp->_ioQLock lock];
863: break;
864:
865: case SDOP_READ:
866: case SDOP_WRITE:
867: case SDOP_CDB_READ:
868: case SDOP_CDB_WRITE:
869: /*
870: * We don't want to hold this lock while executing this
871: * command...
872: */
873: [sdp->_ioQLock unlock];
874: [sdp doSdBuf:sdBuf];
875: [sdp->_ioQLock lock];
876: break;
877:
878: case SDOP_ABORT_THREAD:
879: /*
880: * I/O complete this before we die.
881: */
882: [sdp->_ioQLock unlock];
883: sdBuf->status = IO_R_SUCCESS;
884: [sdp sdIoComplete:sdBuf];
885: xpr_sd("%s: calling IOExitThread()\n", [sdp name],
886: 2,3,4,5);
887: IOExitThread();
888: break;
889: }
890:
891: if(needs_disk) {
892: /*
893: * Enable possible waiting eject command.
894: */
895: [sdp->_ejectLock lock];
896: sdp->_numDiskIos--;
897: [sdp->_ejectLock unlockWith:sdp->_numDiskIos];
898: }
899: }
900:
901: @end
902:
903:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.