![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to SCSIDiskPrivate.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 SCSIDiskPrivate.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: * SCSIDiskPrivate.m - Implementation of Private methods for SCSIDisk class. ! 27: * ! 28: * HISTORY ! 29: * ! 30: * 30-Jul-98 Dan Markarian at Apple. See Radar 2260508, 2258860. If the ! 31: * SCSIDisk driver attempts to probe a non-zero LUN and a ! 32: * target exists on LUN 0 that is actively doing (tagged) I/O, ! 33: * the target may abort all commands with an overlapped command ! 34: * error, causing the original command to fail without completion. ! 35: * Suggested work-arounds (for MacOS X Server, release 1): probe ! 36: * only LUN 0. If a target is discovered, reserve all LUNs for ! 37: * that target. This code must be revisited for IOKit. ! 38: * ! 39: * ! 40: * 11-Feb-91 Doug Mitchell at NeXT ! 41: * Created. ! 42: */ ! 43: ! 44: #define MACH_USER_API 1 ! 45: #undef KERNEL_PRIVATE ! 46: ! 47: #import <sys/types.h> ! 48: #import <driverkit/SCSIDiskPrivate.h> ! 49: #import <driverkit/SCSIDiskTypes.h> ! 50: #import <driverkit/SCSIDiskThread.h> ! 51: #import <driverkit/SCSIDisk.h> ! 52: #import <driverkit/IODiskPartition.h> ! 53: #import <driverkit/scsiTypes.h> ! 54: #import <bsd/dev/scsireg.h> ! 55: #import <driverkit/xpr_mi.h> ! 56: #import <driverkit/return.h> ! 57: #import <driverkit/align.h> ! 58: #import <driverkit/generalFuncs.h> ! 59: #import <kernserv/prototypes.h> ! 60: #import <mach/mach_interface.h> ! 61: #import <machkit/NXLock.h> ! 62: ! 63: static int moveString(char *inp, char *outp, int inlength, int outlength); ! 64: ! 65: @implementation SCSIDisk(Private) ! 66: ! 67: /* ! 68: * One-time only initialization. ! 69: */ ! 70: - initResources ! 71: { ! 72: /* ! 73: * Radar 2005639: Initialize the instance with the ! 74: * compiled-in number of threads. ! 75: */ ! 76: #if defined(i386) || defined(hppa) ! 77: return ([self initResourcesWithThreadCount : NUM_SD_THREADS_MAX]); ! 78: #else ! 79: return ([self initResourcesWithThreadCount : NUM_SD_THREADS_MIN]); ! 80: #endif ! 81: } ! 82: ! 83: - initResourcesWithThreadCount ! 84: : (int) threadCount ! 85: { ! 86: int threadNum; ! 87: ! 88: queue_init(&_ioQueueDisk); ! 89: queue_init(&_ioQueueNodisk); ! 90: _ioQLock = [NXConditionLock alloc]; ! 91: [_ioQLock initWith:NO_WORK_AVAILABLE]; ! 92: ! 93: /* ! 94: * This gets re-init'd per updateReadyState by IODiskPartitionProbe:. ! 95: */ ! 96: [self setLastReadyState:IO_NotReady]; ! 97: _ejectLock = [NXConditionLock alloc]; ! 98: [_ejectLock initWith:0]; ! 99: _numDiskIos = 0; ! 100: _ejectPending = NO; ! 101: _isReserved = 0; ! 102: _isRegistered = 0; ! 103: ! 104: ! 105: /* ! 106: * Start up some I/O threads to perform the actual work of this device. ! 107: * FIXME - there should only be one thread if target does not ! 108: * implement command queueing, and more (at least two, max TBD) ! 109: * if target does implement command queueing. ! 110: */ ! 111: _numThreads = 0; ! 112: /* ! 113: * Radar 2005639: use the requested number of threads. ! 114: */ ! 115: for(threadNum=0; threadNum < threadCount; threadNum++) ! 116: { ! 117: _thread[threadNum] = IOForkThread((IOThreadFunc)sdIoThread, ! 118: self); ! 119: _numThreads++; ! 120: } ! 121: return self; ! 122: } ! 123: ! 124: /* ! 125: * Device-specific initialization. We just do enough here to do some ! 126: * I/O and to find out if the requested target/lun is a SCSI disk device. ! 127: * This function is "reusable" for a given instance of SCSIDisk; initResources ! 128: * must have been called exactly once prior to any use of this method. ! 129: */ ! 130: ! 131: #define DRIVE_TYPE_LENGTH 80 ! 132: ! 133: - (sdInitReturn_t)SCSIDiskInit :(int)iunit /* IODevice unit # */ ! 134: targetId : (u_char)Target ! 135: lun : (u_char)Lun ! 136: controller : controllerId ! 137: { ! 138: inquiry_reply_t inquiryData; ! 139: sc_status_t rtn; ! 140: char driveType[DRIVE_TYPE_LENGTH]; /* name from Inquiry */ ! 141: char *outp; ! 142: char deviceName[30]; ! 143: char location[IO_STRING_LENGTH]; ! 144: ! 145: xpr_sd("SCSIDiskInit: iunit %d target %d lun %d\n", ! 146: iunit, Target, Lun, 4,5); ! 147: ! 148: /* ! 149: * init common instance variables. ! 150: */ ! 151: _controller = controllerId; ! 152: _target = Target; ! 153: _lun = Lun; ! 154: [self setUnit:iunit]; ! 155: sprintf(deviceName, "sd%d", iunit); ! 156: [self setName:deviceName]; ! 157: ! 158: /* ! 159: * Try an Inquiry command. ! 160: */ ! 161: bzero(&inquiryData, sizeof(inquiry_reply_t)); ! 162: rtn = [self sdInquiry:&inquiryData]; ! 163: switch(rtn) { ! 164: case SR_IOST_GOOD: ! 165: break; ! 166: case SR_IOST_SELTO: ! 167: return(SDR_SELECTTO); ! 168: default: ! 169: return(SDR_ERROR); ! 170: } ! 171: ! 172: /* ! 173: * Is it a disk? ! 174: */ ! 175: if(inquiryData.ir_qual != DEVQUAL_OK) { ! 176: return(SDR_NOTADISK); ! 177: } ! 178: switch(inquiryData.ir_devicetype) { ! 179: case DEVTYPE_DISK: ! 180: case DEVTYPE_WORM: ! 181: case DEVTYPE_OPTICAL: ! 182: case DEVTYPE_CDROM: ! 183: break; ! 184: default: ! 185: return(SDR_NOTADISK); ! 186: } ! 187: ! 188: /* ! 189: * The top 3 bits (ir_qual) have to be 0, so throw 'em out. ! 190: */ ! 191: _inquiryDeviceType = inquiryData.ir_devicetype; ! 192: if(inquiryData.ir_removable) ! 193: [self setRemovable:1]; ! 194: ! 195: /* ! 196: * Compress multiple blanks out of the vendor id and product ID. ! 197: */ ! 198: outp = driveType; ! 199: outp += moveString((char *)&inquiryData.ir_vendorid, ! 200: outp, ! 201: 8, ! 202: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 203: if(*(outp - 1) != ' ') ! 204: *outp++ = ' '; ! 205: outp += moveString((char *)&inquiryData.ir_productid, ! 206: outp, ! 207: 16, ! 208: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 209: if(*(outp - 1) != ' ') ! 210: *outp++ = ' '; ! 211: outp += moveString((char *)&inquiryData.ir_revision, ! 212: outp, ! 213: 4, ! 214: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 215: *outp = '\0'; ! 216: [self setDriveName:driveType]; ! 217: sprintf(location,"Target %d LUN %d at %s", _target, _lun, ! 218: [controllerId name]); ! 219: [self setLocation:location]; ! 220: IOLog("%s: %s\n", deviceName, driveType); ! 221: ! 222: /* ! 223: * Do a Test Unit Ready to clear a possible Unit Attention condition. ! 224: * We don't care about the result. ! 225: */ ! 226: [self updateReadyState]; ! 227: ! 228: /* ! 229: * Start up motor. We'll ignore errors on this one too. ! 230: */ ! 231: [self scsiStartStop:SS_START inhibitRetry:YES]; ! 232: ! 233: /* ! 234: * Let's find out some more info. An error on the ! 235: * updatePhysicalParameters could mean no disk present; that's OK... ! 236: */ ! 237: [self setFormattedInternal:0]; // until we do a successful r/w ! 238: rtn = [self updatePhysicalParameters]; ! 239: if(rtn) { ! 240: xpr_sd("SCSIDiskInit: updatePhysicalParameters failed; " ! 241: "continuing\n", ! 242: 1,2,3,4,5); ! 243: } ! 244: ! 245: /* ! 246: * log device name. DiskObject will log block_size and capacity. ! 247: */ ! 248: ! 249: bzero(driveType, DRIVE_TYPE_LENGTH); ! 250: ! 251: /* ! 252: * Compress multiple blanks out of the vendor id and product ID. ! 253: */ ! 254: outp = driveType; ! 255: outp += moveString((char *)&inquiryData.ir_vendorid, ! 256: outp, ! 257: 8, ! 258: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 259: if(*(outp - 1) != ' ') ! 260: *outp++ = ' '; ! 261: outp += moveString((char *)&inquiryData.ir_productid, ! 262: outp, ! 263: 16, ! 264: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 265: if(*(outp - 1) != ' ') ! 266: *outp++ = ' '; ! 267: outp += moveString((char *)&inquiryData.ir_revision, ! 268: outp, ! 269: 32, ! 270: &driveType[DRIVE_TYPE_LENGTH] - outp); ! 271: *outp = '\0'; ! 272: [self setDriveName:driveType]; ! 273: sprintf(location,"Target %d LUN %d at %s", _target, _lun, ! 274: [controllerId name]); ! 275: [self setLocation:location]; ! 276: [super init]; ! 277: return(SDR_GOOD); ! 278: } ! 279: ! 280: /* ! 281: * Copy inp to outp for up to inlength input characters or outlength output ! 282: * characters. Compress multiple spaces and eliminate nulls. Returns number ! 283: * of characters copied to outp. ! 284: */ ! 285: static int moveString(char *inp, char *outp, int inlength, int outlength) ! 286: { ! 287: int lastCharSpace = 0; ! 288: char *outpStart = outp; ! 289: ! 290: while(inlength && outlength) { ! 291: switch(*inp) { ! 292: case '\0': ! 293: inp++; ! 294: inlength--; ! 295: continue; ! 296: case ' ': ! 297: if(lastCharSpace) { ! 298: inp++; ! 299: inlength--; ! 300: continue; ! 301: } ! 302: lastCharSpace = 1; ! 303: goto copyit; ! 304: default: ! 305: lastCharSpace = 0; ! 306: copyit: ! 307: *outp++ = *inp++; ! 308: inlength--; ! 309: outlength--; ! 310: break; ! 311: } ! 312: } ! 313: return(outp - outpStart); ! 314: } ! 315: ! 316: /* ! 317: * Free up local resources. ! 318: */ ! 319: - free ! 320: { ! 321: int threadNum; ! 322: sdBuf_t *sdBuf; ! 323: ! 324: xpr_sd("SCSIDisk free\n", 1,2,3,4,5); ! 325: ! 326: /* ! 327: * Send a "thread abort" command to each thread. ! 328: */ ! 329: sdBuf = [self allocSdBuf:NULL]; ! 330: sdBuf->command = SDOP_ABORT_THREAD; ! 331: sdBuf->needsDisk = 0; ! 332: for(threadNum=0; threadNum<_numThreads; threadNum++) { ! 333: [self enqueueSdBuf:sdBuf]; ! 334: } ! 335: [self freeSdBuf:sdBuf]; ! 336: ! 337: /* ! 338: * Release our target/lun reservation if we have one. ! 339: */ ! 340: if(_isReserved) { ! 341: #if 1 // Radar Fix #2260508 ! 342: /* ! 343: * LUN 0 will be unreserved. Unreserve ! 344: * all the non-zero LUNs first. ! 345: */ ! 346: [self releaseNonZeroLunsOnTarget:_target]; ! 347: #endif // Radar Fix #2260508 ! 348: [_controller releaseTarget:_target ! 349: lun:_lun ! 350: forOwner:self]; ! 351: } ! 352: [_ioQLock free]; ! 353: return([super free]); ! 354: } ! 355: ! 356: - (IOReturn) reacquireTarget ! 357: { ! 358: IOReturn ret = IO_R_NOT_OPEN; ! 359: ! 360: if(NO == _isReserved) { ! 361: ret = IO_R_SUCCESS; ! 362: _isReserved = YES; ! 363: if( [self isRemovable]) ! 364: [self setLastReadyState:IO_NotReady]; // cause a volCheck probe ! 365: else if( IO_Ready == [self updateReadyState]) { ! 366: id descr; ! 367: // duplicate the volCheck probe of IODiskPartition ! 368: [self updatePhysicalParameters]; ! 369: [self diskBecameReady]; ! 370: descr = [IODeviceDescription new]; ! 371: [descr setDirectDevice:self]; ! 372: if( NO == [IODiskPartition probe:descr]) ! 373: [descr free]; ! 374: } ! 375: } else ! 376: IOLog("SCSIDisk unexpected reacquireTarget\n"); ! 377: ! 378: return( ret); ! 379: } ! 380: ! 381: - (IOReturn) requestReleaseTarget ! 382: { ! 383: IOReturn ret = IO_R_NOT_OPEN; ! 384: id diskPart; ! 385: ! 386: if(_isReserved) { ! 387: if( _allowLoans) { ! 388: diskPart = [self nextLogicalDisk]; // a partition always exists ! 389: ! 390: ret = [diskPart requestRelease]; ! 391: if( ret) ! 392: return( ret); ! 393: ! 394: [self synchronizeCache]; ! 395: [self setLastReadyState:IO_Ready]; // stop volCheck activity ! 396: _isReserved = NO; ! 397: ret = IO_R_SUCCESS; ! 398: } ! 399: } else ! 400: IOLog("SCSIDisk unexpected requestReleaseTarget\n"); ! 401: ! 402: return( ret); ! 403: } ! 404: ! 405: - (IOReturn)getCharValues : (unsigned char *)parameterArray ! 406: forParameter : (IOParameterName)parameterName ! 407: count : (unsigned *)count // in/out ! 408: { ! 409: ! 410: if( 0 == strncmp("IOSCSIDiskAllowLoans", parameterName, strlen("IOSCSIDiskAllowLoans"))) ! 411: _allowLoans = 1; ! 412: else if( 0 == strncmp("IOSCSIDiskDisallowLoans", parameterName, strlen("IOSCSIDiskDisallowLoans"))) ! 413: _allowLoans = 0; ! 414: ! 415: else return( [super getCharValues:parameterArray ! 416: forParameter:parameterName ! 417: count:count]); ! 418: ! 419: return( IO_R_SUCCESS); ! 420: } ! 421: ! 422: /* ! 423: * Internal I/O routines. ! 424: */ ! 425: ! 426: /* ! 427: * Inquiry. inquiryReply does not have to be well aligned. ! 428: * Retries and error logging disabled. ! 429: */ ! 430: - (sc_status_t)sdInquiry : (inquiry_reply_t *)inquiryReply ! 431: { ! 432: IOSCSIRequest scsiReq; ! 433: cdb_6_t *cdbp = &scsiReq.cdb.cdb_c6; ! 434: sdBuf_t *sdBuf; ! 435: inquiry_reply_t *alignedReply; ! 436: void *freep; ! 437: int freecnt; ! 438: sc_status_t rtn; ! 439: IODMAAlignment dmaAlign; ! 440: ! 441: xpr_sd("sd%d sdInquiry\n", [self unit], 2,3,4,5); ! 442: ! 443: /* ! 444: * Get some well-aligned memory. ! 445: */ ! 446: alignedReply = [_controller allocateBufferOfLength: ! 447: sizeof(inquiry_reply_t) ! 448: actualStart:&freep ! 449: actualLength:&freecnt]; ! 450: bzero(alignedReply, sizeof(inquiry_reply_t)); ! 451: bzero(&scsiReq, sizeof(IOSCSIRequest)); ! 452: scsiReq.target = _target; ! 453: scsiReq.lun = _lun; ! 454: scsiReq.read = YES; ! 455: ! 456: /* ! 457: * Get appropriate alignment from controller. ! 458: */ ! 459: [_controller getDMAAlignment:&dmaAlign]; ! 460: if(dmaAlign.readLength > 1) { ! 461: scsiReq.maxTransfer = IOAlign(int, sizeof(inquiry_reply_t), ! 462: dmaAlign.readLength); ! 463: } ! 464: else { ! 465: scsiReq.maxTransfer = sizeof(inquiry_reply_t); ! 466: } ! 467: scsiReq.timeoutLength = SD_TIMEOUT_SIMPLE; ! 468: scsiReq.disconnect = 1; ! 469: ! 470: sdBuf = [self allocSdBuf:NULL]; ! 471: sdBuf->command = SDOP_CDB_READ; ! 472: sdBuf->scsiReq = &scsiReq; ! 473: sdBuf->buf = alignedReply; ! 474: sdBuf->client = IOVmTaskSelf(); ! 475: cdbp->c6_opcode = C6OP_INQUIRY; ! 476: cdbp->c6_lun = _lun; ! 477: cdbp->c6_len = sizeof(inquiry_reply_t); ! 478: sdBuf->needsDisk = 0; ! 479: sdBuf->retryDisable = 1; ! 480: ! 481: [self enqueueSdBuf:sdBuf]; ! 482: ! 483: if(scsiReq.driverStatus == SR_IOST_GOOD) { ! 484: unsigned required = (char *)(&alignedReply->ir_zero3) - ! 485: (char *)(alignedReply); ! 486: if(scsiReq.bytesTransferred < required) { ! 487: IOLog("%s: bad DMA Transfer count (%d) on Inquiry\n", ! 488: [self name], scsiReq.bytesTransferred); ! 489: rtn = SR_IOST_HW; ! 490: } ! 491: else { ! 492: /* ! 493: * Copy data back to caller's struct. Zero the ! 494: * portion of alignedReply which did not get valid ! 495: * data; the last flush out of the DMA pipe could ! 496: * have written trash to it (and our caller ! 497: * expects NULL data). ! 498: */ ! 499: unsigned zeroSize; ! 500: ! 501: zeroSize = sizeof(*alignedReply) - ! 502: scsiReq.bytesTransferred; ! 503: if(zeroSize) { ! 504: bzero((char *)alignedReply + ! 505: scsiReq.bytesTransferred, ! 506: zeroSize); ! 507: } ! 508: *inquiryReply = *alignedReply; ! 509: rtn = scsiReq.driverStatus; ! 510: } ! 511: } ! 512: else { ! 513: rtn = scsiReq.driverStatus; ! 514: } ! 515: IOFree(freep, freecnt); ! 516: xpr_sd("sdInquiry: returning %s\n", ! 517: IOFindNameForValue(rtn, IOScStatusStrings), ! 518: 2,3,4,5); ! 519: return rtn; ! 520: } ! 521: ! 522: /* ! 523: * Read Capacity. capacityReply does not have to be well aligned. Fails ! 524: * if disk not ready. ! 525: */ ! 526: - (sc_status_t)sdReadCapacity : (capacity_reply_t *)capacityReply ! 527: { ! 528: IOSCSIRequest scsiReq; ! 529: cdb_10_t *cdbp = &scsiReq.cdb.cdb_c10; ! 530: sdBuf_t *sdBuf; ! 531: capacity_reply_t *alignedReply; ! 532: void *freep; ! 533: int freecnt; ! 534: sc_status_t rtn; ! 535: IODMAAlignment dmaAlign; ! 536: ! 537: xpr_sd("sd%d sdReadCapacity\n", [self unit], 2,3,4,5); ! 538: ! 539: /* ! 540: * Get some well-aligned memory. ! 541: */ ! 542: alignedReply = [_controller allocateBufferOfLength: ! 543: sizeof(capacity_reply_t) ! 544: actualStart:&freep ! 545: actualLength:&freecnt]; ! 546: ! 547: bzero(&scsiReq, sizeof(IOSCSIRequest)); ! 548: scsiReq.target = _target; ! 549: scsiReq.lun = _lun; ! 550: scsiReq.read = YES; ! 551: ! 552: /* ! 553: * Get appropriate alignment from controller. ! 554: */ ! 555: [_controller getDMAAlignment:&dmaAlign]; ! 556: if(dmaAlign.readLength > 1) { ! 557: scsiReq.maxTransfer = IOAlign(int, sizeof(capacity_reply_t), ! 558: dmaAlign.readLength); ! 559: } ! 560: else { ! 561: scsiReq.maxTransfer = sizeof(capacity_reply_t); ! 562: } ! 563: scsiReq.timeoutLength = SD_TIMEOUT_SIMPLE; ! 564: scsiReq.disconnect = 1; ! 565: ! 566: sdBuf = [self allocSdBuf:NULL]; ! 567: sdBuf->command = SDOP_CDB_READ; ! 568: sdBuf->scsiReq = &scsiReq; ! 569: sdBuf->buf = alignedReply; ! 570: sdBuf->client = IOVmTaskSelf(); ! 571: cdbp->c10_opcode = C10OP_READCAPACITY; ! 572: cdbp->c10_lun = _lun; ! 573: sdBuf->needsDisk = 0; ! 574: ! 575: [self enqueueSdBuf:sdBuf]; ! 576: ! 577: if(scsiReq.driverStatus == SR_IOST_GOOD) { ! 578: #if !i386 ! 579: if(scsiReq.bytesTransferred != sizeof(capacity_reply_t)) { ! 580: IOLog("%s: bad DMA Transfer count (%d) on Read" ! 581: " Capacity\n", ! 582: [self name], scsiReq.bytesTransferred); ! 583: rtn = SR_IOST_HW; ! 584: } ! 585: else { ! 586: #else ! 587: { ! 588: #endif ! 589: /* ! 590: * Copy data back to caller's struct. ! 591: */ ! 592: *capacityReply = *alignedReply; ! 593: rtn = scsiReq.driverStatus; ! 594: } ! 595: } ! 596: else { ! 597: rtn = scsiReq.driverStatus; ! 598: } ! 599: IOFree(freep, freecnt); ! 600: xpr_sd("sdReadCapacity: returning %s\n", ! 601: IOFindNameForValue(rtn, IOScStatusStrings), ! 602: 2,3,4,5); ! 603: return rtn; ! 604: } ! 605: ! 606: ! 607: /* ! 608: * Mode Sense. ! 609: */ ! 610: - (sc_status_t)sdModeSense : (mode_sel_data_t *)modeSenseReply ! 611: { ! 612: IOSCSIRequest scsiReq; ! 613: cdb_6_t *cdbp = &scsiReq.cdb.cdb_c6; ! 614: sdBuf_t *sdBuf; ! 615: mode_sel_data_t *alignedReply; ! 616: void *freep; ! 617: int freecnt; ! 618: sc_status_t rtn; ! 619: IODMAAlignment dmaAlign; ! 620: ! 621: xpr_sd("sd%d sdModeSense\n", [self unit], 2,3,4,5); ! 622: ! 623: /* ! 624: * Get some well-aligned memory. ! 625: */ ! 626: alignedReply = [_controller allocateBufferOfLength: ! 627: sizeof(mode_sel_data_t) ! 628: actualStart:&freep ! 629: actualLength:&freecnt]; ! 630: ! 631: bzero(&scsiReq, sizeof(IOSCSIRequest)); ! 632: scsiReq.target = _target; ! 633: scsiReq.lun = _lun; ! 634: scsiReq.read = YES; ! 635: ! 636: /* ! 637: * Get appropriate alignment from controller. ! 638: */ ! 639: [_controller getDMAAlignment:&dmaAlign]; ! 640: if(dmaAlign.readLength > 1) { ! 641: scsiReq.maxTransfer = IOAlign(int, sizeof(mode_sel_data_t), ! 642: dmaAlign.readLength); ! 643: } ! 644: else { ! 645: scsiReq.maxTransfer = sizeof(mode_sel_data_t); ! 646: } ! 647: scsiReq.timeoutLength = SD_TIMEOUT_SIMPLE; ! 648: scsiReq.disconnect = 1; ! 649: ! 650: sdBuf = [self allocSdBuf:NULL]; ! 651: sdBuf->command = SDOP_CDB_READ; ! 652: sdBuf->scsiReq = &scsiReq; ! 653: sdBuf->buf = alignedReply; ! 654: sdBuf->client = IOVmTaskSelf(); ! 655: cdbp->c6_opcode = C6OP_MODESENSE; ! 656: cdbp->c6_lun = _lun; ! 657: cdbp->c6_len = sizeof(mode_sel_data_t); ! 658: sdBuf->needsDisk = 1; ! 659: ! 660: [self enqueueSdBuf:sdBuf]; ! 661: ! 662: if(scsiReq.driverStatus == SR_IOST_GOOD) { ! 663: ! 664: /* ! 665: * Copy data back to caller's struct. ! 666: */ ! 667: *modeSenseReply = *alignedReply; ! 668: rtn = scsiReq.driverStatus; ! 669: } ! 670: else { ! 671: rtn = scsiReq.driverStatus; ! 672: } ! 673: ! 674: IOFree(freep, freecnt); ! 675: ! 676: xpr_sd("sdModeSense: returning %s\n", ! 677: IOFindNameForValue(rtn, IOScStatusStrings), ! 678: 2,3,4,5); ! 679: return rtn; ! 680: } ! 681: ! 682: /* ! 683: * Read data; retries and error reporting disabled. Assumes disk is present. ! 684: */ ! 685: - (IOReturn)sdRawRead : (int)block ! 686: blockCnt:(int)blockCnt ! 687: buffer:(void *)buffer ! 688: { ! 689: sdBuf_t *sdBuf; ! 690: IOReturn rtn; ! 691: ! 692: xpr_sd("sdRawRead block %d cnt %d\n", block, blockCnt, 3,4,5); ! 693: sdBuf = [self allocSdBuf:NULL]; ! 694: sdBuf->command = SDOP_READ; ! 695: sdBuf->block = block; ! 696: sdBuf->blockCnt = blockCnt; ! 697: sdBuf->buf = buffer; ! 698: sdBuf->client = IOVmTaskSelf(); ! 699: sdBuf->needsDisk = 1; ! 700: sdBuf->retryDisable = 1; ! 701: rtn = [self enqueueSdBuf:sdBuf]; ! 702: [self freeSdBuf:sdBuf]; ! 703: xpr_sd("sdRawRead: returning %s\n", [self stringFromReturn:rtn], ! 704: 2,3,4,5); ! 705: return(rtn); ! 706: } ! 707: ! 708: /* ! 709: * Start, stop, eject. ! 710: */ ! 711: - (IOReturn)scsiStartStop : (startStop_t)cmd ! 712: inhibitRetry : (BOOL)inhibitRetry ! 713: { ! 714: IOSCSIRequest scsiReq; ! 715: sdBuf_t *sdBuf; ! 716: cdb_6_t *cdbp = &scsiReq.cdb.cdb_c6; ! 717: IOReturn rtn; ! 718: ! 719: xpr_sd("%s: scsiStartStop: cmd 0x%x\n", [self name], cmd,3,4,5); ! 720: ! 721: bzero(&scsiReq, sizeof(IOSCSIRequest)); ! 722: scsiReq.target = _target; ! 723: scsiReq.lun = _lun; ! 724: scsiReq.timeoutLength = SD_TIMEOUT_EJECT; ! 725: scsiReq.disconnect = 1; ! 726: ! 727: sdBuf = [self allocSdBuf:NULL]; ! 728: sdBuf->scsiReq = &scsiReq; ! 729: sdBuf->retryDisable = inhibitRetry ? 1 : 0; ! 730: sdBuf->needsDisk = 1; ! 731: ! 732: cdbp->c6_opcode = C6OP_STARTSTOP; ! 733: cdbp->c6_lun = _lun; ! 734: ! 735: switch(cmd) { ! 736: case SS_EJECT: ! 737: cdbp->c6_len = C6S_SS_EJECT; ! 738: sdBuf->command = SDOP_EJECT; ! 739: break; ! 740: case SS_STOP: ! 741: cdbp->c6_len = C6S_SS_STOP; ! 742: sdBuf->command = SDOP_CDB_WRITE; ! 743: break; ! 744: case SS_START: ! 745: cdbp->c6_len = C6S_SS_START; ! 746: sdBuf->command = SDOP_CDB_WRITE; ! 747: break; ! 748: } ! 749: ! 750: rtn = [self enqueueSdBuf:sdBuf]; ! 751: xpr_sd("%s scsiStartStop: returning %s\n", [self name], ! 752: [self stringFromReturn:rtn], 3,4,5); ! 753: [self freeSdBuf:sdBuf]; ! 754: return(rtn); ! 755: } ! 756: ! 757: /* ! 758: * Common read/write routine. ! 759: */ ! 760: - (IOReturn) deviceRwCommon : (sdOp_t)command ! 761: block: (u_int) deviceBlock ! 762: length : (u_int)length ! 763: buffer : (void *)buffer ! 764: client : (vm_task_t)client ! 765: pending : (void *)pending ! 766: actualLength : (u_int *)actualLength ! 767: { ! 768: sdBuf_t *sdBuf; ! 769: IOReturn rtn; ! 770: u_int blocksReq; ! 771: u_int block_size; ! 772: u_int dev_size; ! 773: ! 774: /* ! 775: * Note we have to 'fault in' a possible non-present disk in ! 776: * order to get its physical parameters... ! 777: */ ! 778: rtn = [self isDiskReady:YES]; ! 779: switch(rtn) { ! 780: case IO_R_SUCCESS: ! 781: break; ! 782: case IO_R_NO_DISK: ! 783: xpr_sd("%s deviceRwCommon: disk not present\n", ! 784: [self name], 2,3,4,5); ! 785: return(rtn); ! 786: default: ! 787: IOLog("%s deviceRwCommon: bogus return from isDiskReady " ! 788: "(%s)\n", ! 789: [self name], [self stringFromReturn:rtn]); ! 790: return(rtn); ! 791: } ! 792: ! 793: if(![self isFormatted]) ! 794: return(IO_R_UNFORMATTED); ! 795: block_size = [self blockSize]; ! 796: dev_size = [self diskSize]; ! 797: ! 798: /* ! 799: * Verify access and legal parameters. ! 800: */ ! 801: if(length % block_size) { ! 802: xpr_sd("deviceRwCommon: unaligned length\n", 1,2,3,4,5); ! 803: return(IO_R_INVALID); ! 804: } ! 805: blocksReq = length / block_size; ! 806: if((deviceBlock + blocksReq) > dev_size) { ! 807: if(deviceBlock >= dev_size) { ! 808: xpr_sd("deviceRwCommon: invalid " ! 809: "deviceBlock/byte count\n", 1,2,3,4,5); ! 810: return(IO_R_INVALID_ARG); ! 811: } ! 812: /* ! 813: * Truncate. ! 814: */ ! 815: blocksReq = dev_size - deviceBlock; ! 816: xpr_sd("deviceRwCommon: truncating to %d blocks\n", blocksReq, ! 817: 2,3,4,5); ! 818: } ! 819: sdBuf = [self allocSdBuf:pending]; ! 820: sdBuf->command = command; ! 821: sdBuf->block = deviceBlock; ! 822: sdBuf->blockCnt = blocksReq; ! 823: sdBuf->buf = buffer; ! 824: sdBuf->client = client; ! 825: sdBuf->needsDisk = 1; ! 826: rtn = [self enqueueSdBuf:sdBuf]; ! 827: if(pending == NULL) { ! 828: /* ! 829: * Sync I/O. ! 830: */ ! 831: *actualLength = sdBuf->bytesXfr; ! 832: [self freeSdBuf:sdBuf]; ! 833: } ! 834: return(rtn); ! 835: } ! 836: ! 837: /* ! 838: * -- Enqueue an sdBuf on _ioQueue<Disk,Nodisk> ! 839: * -- wake up one of the I/O threads ! 840: * -- wait for I/O complete (if sdBuf->pending == NULL) ! 841: */ ! 842: - (IOReturn)enqueueSdBuf:(sdBuf_t *)sdBuf ! 843: { ! 844: queue_head_t *q; ! 845: ! 846: #ifdef DDM_DEBUG ! 847: if(sdBuf->pending) { ! 848: xpr_sd("enqueueSdBuf: sdBuf 0x%x, ASYNC\n", sdBuf, 2,3,4,5); ! 849: } ! 850: else { ! 851: xpr_sd("enqueueSdBuf: sdBuf 0x%x, SYNC\n", sdBuf, 2,3,4,5); ! 852: } ! 853: #endif DDM_DEBUG ! 854: ! 855: sdBuf->status = IO_R_INVALID; ! 856: [_ioQLock lock]; ! 857: /* ! 858: * TBD - sort by disk block eventually. ! 859: */ ! 860: if(sdBuf->needsDisk) ! 861: q = &_ioQueueDisk; ! 862: else ! 863: q = &_ioQueueNodisk; ! 864: queue_enter(q, sdBuf, sdBuf_t *, link); ! 865: [_ioQLock unlockWith:WORK_AVAILABLE]; ! 866: if(sdBuf->pending != NULL) ! 867: return(IO_R_SUCCESS); ! 868: ! 869: /* ! 870: * wait for I/O complete. ! 871: */ ! 872: [sdBuf->waitLock lockWhen:YES]; ! 873: [sdBuf->waitLock unlockWith:NO]; // for easy reuse ! 874: xpr_sd("enqueueSdBuf: I/O Complete sdBuf 0x%x status %s\n", ! 875: sdBuf, [self stringFromReturn:sdBuf->status], 3,4,5); ! 876: return(sdBuf->status); ! 877: } ! 878: ! 879: /* ! 880: * Allocate and free sdBuf_t's. ! 881: * ! 882: * TBD - we might keep around a queue of free sdBuf_t's. ! 883: */ ! 884: - (sdBuf_t *)allocSdBuf : (void *)pending ! 885: { ! 886: sdBuf_t *sdBuf = IOMalloc(sizeof(sdBuf_t)); ! 887: ! 888: bzero(sdBuf, sizeof(sdBuf_t)); ! 889: if(pending == NULL) { ! 890: sdBuf->waitLock = [NXConditionLock alloc]; ! 891: [sdBuf->waitLock initWith:NO]; ! 892: } ! 893: else ! 894: sdBuf->pending = pending; ! 895: return(sdBuf); ! 896: } ! 897: ! 898: - (void)freeSdBuf : (sdBuf_t *)sdBuf ! 899: { ! 900: if(!sdBuf->pending) { ! 901: [sdBuf->waitLock free]; ! 902: } ! 903: IOFree(sdBuf, sizeof(sdBuf_t)); ! 904: } ! 905: ! 906: #if 1 // Radar Fix #2260508 ! 907: - (void) reserveNonZeroLunsOnTarget : (int) target ! 908: { ! 909: // ! 910: // Reserves all non-zero LUNs for the specified target. If a given ! 911: // LUN is already reserved by someone else, reserveTarget is smart ! 912: // enough to leave it alone and reject our reservation request (no ! 913: // errors are logged). ! 914: // ! 915: // Assumptions: ! 916: // o _controller instance variable is already set ! 917: // ! 918: ! 919: unsigned char tempLun; ! 920: ! 921: for (tempLun = 1; tempLun < SCSI_NLUNS; tempLun++) ! 922: { ! 923: [_controller reserveTarget:target lun:tempLun forOwner:self]; ! 924: } ! 925: } ! 926: ! 927: - (void) releaseNonZeroLunsOnTarget : (int) target ! 928: { ! 929: // ! 930: // Unreserves all non-zero LUNs for the specified target. If a given ! 931: // LUN has been reserved by someone other than us, the releaseTarget ! 932: // method is smart enough to leave the LUN reserved (however, an error ! 933: // will be logged). ! 934: // ! 935: // Assumptions: ! 936: // o _controller instance variable is already set ! 937: // ! 938: ! 939: unsigned char tempLun; ! 940: ! 941: // Release the luns in reverse order to avoid a problem when another ! 942: // client is simultaneously trying to acquire the luns. (This is, ! 943: // of course, impossible, but it can't hurt to be suspicious.) ! 944: ! 945: for (tempLun = SCSI_NLUNS - 1; tempLun >= 1; tempLun--) ! 946: { ! 947: [_controller releaseTarget:target lun:tempLun forOwner:self]; ! 948: } ! 949: } ! 950: #endif // Radar Fix #2260508 ! 951: ! 952: @end ! 953: ! 954: ! 955:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.