![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IODrive.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOStorage|
Return to IODrive.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOStorage |
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: #include <IOKit/assert.h> ! 24: #include <IOKit/IOLib.h> ! 25: #include <IOKit/IOMemoryDescriptor.h> ! 26: #include <IOKit/storage/IODrive.h> ! 27: ! 28: #define super IOStorage ! 29: OSDefineMetaClass(IODrive, IOStorage) ! 30: OSDefineAbstractStructors(IODrive, IOStorage) ! 31: ! 32: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 33: ! 34: const UInt32 kPollerInterval = 1000; // (ms, 1 second) ! 35: ! 36: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 37: ! 38: bool IODrive::init(OSDictionary * properties = 0) ! 39: { ! 40: // ! 41: // Initialize this object's minimal state. ! 42: // ! 43: ! 44: if (super::init(properties) == false) return false; ! 45: ! 46: _deblockerLockForRMWs = IOLockAlloc(); ! 47: _openClients = OSSet::withCapacity(2); ! 48: ! 49: for (unsigned index = 0; index < kStatisticsCount; index++) ! 50: _statistics[index] = OSNumber::withNumber(0ULL, 64); ! 51: ! 52: if (_deblockerLockForRMWs == 0 || _openClients == 0) return false; ! 53: ! 54: for (unsigned index = 0; index < kStatisticsCount; index++) ! 55: if (_statistics[index] == 0) return false; ! 56: ! 57: IOLockInit(_deblockerLockForRMWs); ! 58: ! 59: // ! 60: // Create the standard drive registry properties. ! 61: // ! 62: ! 63: OSDictionary * statistics = OSDictionary::withCapacity(kStatisticsCount); ! 64: ! 65: if (statistics == 0) return false; ! 66: ! 67: statistics->setObject( kIODriveStatisticsBytesRead, ! 68: _statistics[kStatisticsBytesRead] ); ! 69: statistics->setObject( kIODriveStatisticsBytesWritten, ! 70: _statistics[kStatisticsBytesWritten] ); ! 71: statistics->setObject( kIODriveStatisticsReadErrors, ! 72: _statistics[kStatisticsReadErrors] ); ! 73: statistics->setObject( kIODriveStatisticsWriteErrors, ! 74: _statistics[kStatisticsWriteErrors] ); ! 75: statistics->setObject( kIODriveStatisticsLatentReadTime, ! 76: _statistics[kStatisticsLatentReadTime] ); ! 77: statistics->setObject( kIODriveStatisticsLatentWriteTime, ! 78: _statistics[kStatisticsLatentWriteTime] ); ! 79: statistics->setObject( kIODriveStatisticsReads, ! 80: _statistics[kStatisticsReads] ); ! 81: statistics->setObject( kIODriveStatisticsWrites, ! 82: _statistics[kStatisticsWrites] ); ! 83: statistics->setObject( kIODriveStatisticsReadRetries, ! 84: _statistics[kStatisticsReadRetries] ); ! 85: statistics->setObject( kIODriveStatisticsWriteRetries, ! 86: _statistics[kStatisticsWriteRetries] ); ! 87: statistics->setObject( kIODriveStatisticsTotalReadTime, ! 88: _statistics[kStatisticsTotalReadTime] ); ! 89: statistics->setObject( kIODriveStatisticsTotalWriteTime, ! 90: _statistics[kStatisticsTotalWriteTime] ); ! 91: ! 92: setProperty(kIODriveStatistics, statistics); ! 93: ! 94: return true; ! 95: } ! 96: ! 97: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 98: ! 99: bool IODrive::start(IOService * provider) ! 100: { ! 101: // ! 102: // This method is called once we have been attached to the provider object. ! 103: // ! 104: ! 105: // Instruct our subclass to prepare the drive for operation. ! 106: ! 107: if (handleStart(provider) == false) return false; ! 108: ! 109: // Initiate the poller mechanism if it is required. ! 110: ! 111: if (isMediaEjectable() && isMediaPollRequired() && !isMediaPollExpensive()) ! 112: { ! 113: lockForArbitration(); // (disable opens/closes; a recursive lock) ! 114: ! 115: if (!isOpen() && !isInactive()) ! 116: schedulePoller(); // (schedule the poller, increments retain) ! 117: ! 118: unlockForArbitration(); // (enable opens/closes; a recursive lock) ! 119: } ! 120: ! 121: // Register this object so it can be found via notification requests. It is ! 122: // not being registered to have I/O Kit attempt to have drivers match on it, ! 123: // which is the reason most other services are registered -- that's not the ! 124: // intention of this registerService call. ! 125: ! 126: registerService(); ! 127: ! 128: return true; ! 129: } ! 130: ! 131: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 132: ! 133: void IODrive::stop(IOService * provider) ! 134: { ! 135: // ! 136: // This method is called before we are detached from the provider object. ! 137: // ! 138: ! 139: // Halt the poller mechanism if it is required. ! 140: ! 141: if (isMediaEjectable() && isMediaPollRequired() && !isMediaPollExpensive()) ! 142: unschedulePoller(); // (unschedule the poller) ! 143: ! 144: // Instruct our subclass to stop the drive. ! 145: ! 146: handleStop(provider); ! 147: ! 148: super::stop(provider); ! 149: } ! 150: ! 151: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 152: ! 153: void IODrive::free() ! 154: { ! 155: // ! 156: // Free all of this object's outstanding resources. ! 157: // ! 158: ! 159: if (_deblockerLockForRMWs) IOLockFree(_deblockerLockForRMWs); ! 160: if (_openClients) _openClients->release(); ! 161: ! 162: for (unsigned index = 0; index < kStatisticsCount; index++) ! 163: if (_statistics[index]) _statistics[index]->release(); ! 164: ! 165: super::free(); ! 166: } ! 167: ! 168: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 169: ! 170: bool IODrive::handleOpen(IOService * client, ! 171: IOOptionBits options, ! 172: void * argument) ! 173: { ! 174: // ! 175: // The handleOpen method grants or denies permission to access this object ! 176: // to an interested client. The argument is an IOStorageAccess value that ! 177: // specifies the level of access desired -- reader or reader-writer. ! 178: // ! 179: // This method can be invoked to upgrade or downgrade the access level for ! 180: // an existing client as well. The previous access level will prevail for ! 181: // upgrades that fail, of course. A downgrade should never fail. If the ! 182: // new access level should be the same as the old for a given client, this ! 183: // method will do nothing and return success. In all cases, one, singular ! 184: // close-per-client is expected for all opens-per-client received. ! 185: // ! 186: // We are guaranteed that no other opens or closes will be processed until ! 187: // we make our decision, change our state, and return from this method. ! 188: // ! 189: ! 190: IOStorageAccess access = (IOStorageAccess) (int) argument; ! 191: ! 192: assert(client); ! 193: assert(access != kAccessNone); ! 194: ! 195: // Handle the first open on removable media in a special case. ! 196: ! 197: if (isMediaEjectable() && _openClients->getCount() == 0) ! 198: { ! 199: // Halt the poller if it is active and this is the drive's first open. ! 200: ! 201: if (isMediaPollRequired() && !isMediaPollExpensive()) ! 202: unschedulePoller(); // (unschedule the poller) ! 203: ! 204: // Lock down the media while we have opens on this drive object. The ! 205: // arbitration lock is held during the operation -- however we assume ! 206: // the extra length of time will not be an issue for now. ! 207: ! 208: if (lockMedia(true) != kIOReturnSuccess) ! 209: IOLog("%s: Unable to lock down removable media.\n", getName()); ! 210: } ! 211: ! 212: // Process the open. ! 213: ! 214: _openClients->setObject(client); // (works for up/downgrade case) ! 215: ! 216: return true; ! 217: } ! 218: ! 219: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 220: ! 221: bool IODrive::handleIsOpen(const IOService * client) const ! 222: { ! 223: // ! 224: // The handleIsOpen method determines whether the specified client, or any ! 225: // client if none is specificed, presently has an open on this object. ! 226: // ! 227: // We are guaranteed that no other opens or closes will be processed until ! 228: // we return from this method. ! 229: // ! 230: ! 231: if (client) ! 232: return _openClients->containsObject(client); ! 233: else ! 234: return (_openClients->getCount() != 0); ! 235: } ! 236: ! 237: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 238: ! 239: void IODrive::handleClose(IOService * client, IOOptionBits options) ! 240: { ! 241: // ! 242: // The handleClose method drops the incoming client's access to this object. ! 243: // ! 244: // We are guaranteed that no other opens or closes will be processed until ! 245: // we change our state and return from this method. ! 246: // ! 247: ! 248: assert(client); ! 249: ! 250: // Process the close. ! 251: ! 252: _openClients->removeObject(client); ! 253: ! 254: // Handle the last close on removable media in a special case. ! 255: ! 256: if (isMediaEjectable() && _openClients->getCount() == 0) ! 257: { ! 258: // Unlock the media in the drive. The arbitration lock is held during ! 259: // the operation -- however we assume the extra length of time will not ! 260: // be an issue for now. ! 261: ! 262: if (lockMedia(false) != kIOReturnSuccess) ! 263: IOLog("%s: Unable to unlock removable media.\n", getName()); ! 264: ! 265: // Reactivate the poller. ! 266: ! 267: if (isMediaPollRequired() && !isMediaPollExpensive() && !isInactive()) ! 268: schedulePoller(); // (schedule the poller, increments retain) ! 269: } ! 270: } ! 271: ! 272: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 273: ! 274: void IODrive::read(IOService * /* client */, ! 275: UInt64 byteStart, ! 276: IOMemoryDescriptor * buffer, ! 277: IOStorageCompletion completion) ! 278: { ! 279: // ! 280: // Read data from the storage object at the specified byte offset into the ! 281: // specified buffer, asynchronously. When the read completes, the caller ! 282: // will be notified via the specified completion action. ! 283: // ! 284: // The buffer will be retained for the duration of the read. ! 285: // ! 286: // Note that the read passes through several other methods before being ! 287: // passed to executeRequest. The first is deblockRequest, which aligns ! 288: // the request with the media's block boundaries; the second is prepare- ! 289: // Request which prepares the memory involved in the transfer (involves ! 290: // wiring, virtual-to-physical mapping, and breakup of the memory range ! 291: // based on the controller's and/or drive's constraints). ! 292: // ! 293: ! 294: UInt64 mediaBlockSize = getMediaBlockSize(); ! 295: ! 296: // State our assumptions. ! 297: ! 298: assert(buffer->getDirection() == kIODirectionIn); ! 299: ! 300: // If the request is aligned with the media's block boundaries, we can ! 301: // short-circuit the deblocker and call prepareRequest directly. ! 302: ! 303: if ( (byteStart % mediaBlockSize) == 0 && ! 304: (buffer->getLength() % mediaBlockSize) == 0 ) ! 305: { ! 306: prepareRequest(byteStart, buffer, completion); ! 307: return; ! 308: } ! 309: ! 310: deblockRequest(byteStart, buffer, completion); ! 311: } ! 312: ! 313: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 314: ! 315: void IODrive::write(IOService * /* client */, ! 316: UInt64 byteStart, ! 317: IOMemoryDescriptor * buffer, ! 318: IOStorageCompletion completion) ! 319: { ! 320: // ! 321: // Write data into the storage object at the specified byte offset from the ! 322: // specified buffer, asynchronously. When the write completes, the caller ! 323: // will be notified via the specified completion action. ! 324: // ! 325: // The buffer will be retained for the duration of the write. ! 326: // ! 327: // Note that the write passes through several other methods before being ! 328: // passed to executeRequest. The first is deblockRequest, which aligns ! 329: // the request with the media's block boundaries; the second is prepare- ! 330: // Request which prepares the memory involved in the transfer (involves ! 331: // wiring, virtual-to-physical mapping, and breakup of the memory range ! 332: // based on the controller's and/or drive's constraints). ! 333: // ! 334: ! 335: UInt64 mediaBlockSize = getMediaBlockSize(); ! 336: ! 337: // State our assumptions. ! 338: ! 339: assert(buffer->getDirection() == kIODirectionOut); ! 340: ! 341: // If the request is aligned with the media's block boundaries, we can ! 342: // short-circuit the deblocker and call prepareRequest directly. ! 343: ! 344: if ( (byteStart % mediaBlockSize) == 0 && ! 345: (buffer->getLength() % mediaBlockSize) == 0 ) ! 346: { ! 347: prepareRequest(byteStart, buffer, completion); ! 348: return; ! 349: } ! 350: ! 351: deblockRequest(byteStart, buffer, completion); ! 352: } ! 353: ! 354: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 355: ! 356: void IODrive::addToBytesTransferred(UInt64 bytesTransferred, ! 357: UInt64 totalTime, // (ns) ! 358: UInt64 latentTime, // (ns) ! 359: bool isWrite) ! 360: { ! 361: // ! 362: // Update the total number of bytes transferred, the total transfer time, ! 363: // and the total latency time for this drive -- used for statistics. ! 364: // ! 365: ! 366: if (isWrite) ! 367: { ! 368: _statistics[kStatisticsWrites]->addValue(1); ! 369: _statistics[kStatisticsBytesWritten]->addValue(bytesTransferred); ! 370: _statistics[kStatisticsTotalWriteTime]->addValue(totalTime); ! 371: _statistics[kStatisticsLatentWriteTime]->addValue(latentTime); ! 372: if (bytesTransferred <= getMediaBlockSize()) ! 373: _statistics[kStatisticsSingleBlockWrites]->addValue(1); ! 374: } ! 375: else ! 376: { ! 377: _statistics[kStatisticsReads]->addValue(1); ! 378: _statistics[kStatisticsBytesRead]->addValue(bytesTransferred); ! 379: _statistics[kStatisticsTotalReadTime]->addValue(totalTime); ! 380: _statistics[kStatisticsLatentReadTime]->addValue(latentTime); ! 381: if (bytesTransferred <= getMediaBlockSize()) ! 382: _statistics[kStatisticsSingleBlockReads]->addValue(1); ! 383: } ! 384: } ! 385: ! 386: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 387: ! 388: void IODrive::incrementRetries(bool isWrite) ! 389: { ! 390: // ! 391: // Update the total retry count -- used for statistics. ! 392: // ! 393: ! 394: if (isWrite) ! 395: _statistics[kStatisticsWriteRetries]->addValue(1); ! 396: else ! 397: _statistics[kStatisticsReadRetries]->addValue(1); ! 398: } ! 399: ! 400: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 401: ! 402: void IODrive::incrementErrors(bool isWrite) ! 403: { ! 404: // ! 405: // Update the total error count -- used for statistics. ! 406: // ! 407: ! 408: if (isWrite) ! 409: _statistics[kStatisticsWriteErrors]->addValue(1); ! 410: else ! 411: _statistics[kStatisticsReadErrors]->addValue(1); ! 412: } ! 413: ! 414: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 415: ! 416: UInt32 IODrive::getStatistics(UInt64 * statistics, ! 417: UInt32 statisticsMaxCount) const ! 418: { ! 419: // ! 420: // Ask the drive to report its operating statistics. The statistics are ! 421: // described by the IODrive::Statistics indices. This routine fills the ! 422: // caller's buffer, up to the maximum count specified if the real number ! 423: // of statistics would overflow the buffer. The return value indicates ! 424: // the actual number of statistics copied to the buffer. ! 425: // ! 426: // If the statistics buffer is not supplied or if the maximum count is ! 427: // zero, the routine returns the proposed count of statistics instead. ! 428: // ! 429: ! 430: if (statistics == 0) ! 431: return kStatisticsCount; ! 432: ! 433: UInt32 statisticsCount = min(kStatisticsCount, statisticsMaxCount); ! 434: ! 435: for (unsigned index = 0; index < statisticsCount; index++) ! 436: statistics[index] = _statistics[index]->unsigned64BitValue(); ! 437: ! 438: return statisticsCount; ! 439: } ! 440: ! 441: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 442: ! 443: UInt64 IODrive::getStatistic(Statistics statistic) const ! 444: { ! 445: // ! 446: // Ask the drive to report one of its operating statistics. ! 447: // ! 448: ! 449: if ((UInt32) statistic >= kStatisticsCount) return 0; ! 450: ! 451: return _statistics[statistic]->unsigned64BitValue(); ! 452: } ! 453: ! 454: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 455: ! 456: void IODrive::prepareRequest(UInt64 byteStart, ! 457: IOMemoryDescriptor * buffer, ! 458: IOStorageCompletion completion) ! 459: { ! 460: // ! 461: // The prepareRequest method prepares the memory involved in the transfer. ! 462: // The memory will be wired down, physically mapped, and broken up based ! 463: // on the controller's and drive's constraints. ! 464: // ! 465: // This method is part of a sequence of methods that are called for each ! 466: // read or write request. The first is deblockRequest, which aligns the ! 467: // request at the media's block boundaries; the second is prepareRequest, ! 468: // which prepares the buffer involved in the transfer; and the third is ! 469: // executeRequest, which implements the actual transfer from the drive. ! 470: // ! 471: ! 472: executeRequest(byteStart, buffer, completion); ! 473: return; ! 474: } ! 475: ! 476: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 477: ! 478: void IODrive::schedulePoller() ! 479: { ! 480: // ! 481: // Schedule the poller mechanism. ! 482: // ! 483: // This method assumes that the arbitration lock is held. ! 484: // ! 485: ! 486: AbsoluteTime deadline; ! 487: ! 488: retain(); ! 489: ! 490: clock_interval_to_deadline(kPollerInterval, kMillisecondScale, &deadline); ! 491: thread_call_func_delayed(poller, this, deadline); ! 492: } ! 493: ! 494: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 495: ! 496: void IODrive::unschedulePoller() ! 497: { ! 498: // ! 499: // Unschedule the poller mechanism. ! 500: // ! 501: // This method assumes that the arbitration lock is held. ! 502: // ! 503: ! 504: if (thread_call_func_cancel(poller, this, true)) release(); ! 505: } ! 506: ! 507: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 508: ! 509: void IODrive::poller(void * target, void *) ! 510: { ! 511: // ! 512: // This method is the timeout handler for the poller mechanism. It polls ! 513: // for media and reschedules another timeout if the drive is still closed. ! 514: // ! 515: ! 516: IODrive * drive = (IODrive *) target; ! 517: ! 518: drive->pollMedia(); ! 519: ! 520: drive->lockForArbitration(); // (disable opens/closes; a recursive lock) ! 521: ! 522: if (!drive->isOpen() && !drive->isInactive()) ! 523: drive->schedulePoller(); // (schedule the poller, increments retain) ! 524: ! 525: drive->unlockForArbitration(); // (enable opens/closes; a recursive lock) ! 526: ! 527: drive->release(); // (drop the retain associated with this poll) ! 528: } ! 529: ! 530: // ----------------------------------------------------------------------------- ! 531: // Deblocker Implementation ! 532: ! 533: IODrive::DeblockerContext * IODrive::deblockerContextAllocate() ! 534: { ! 535: // ! 536: // Allocate a deblocker context structure. It comes preinitialized with ! 537: // a block-sized scratch buffer and an associated memory descriptor, but ! 538: // is otherwise uninitialized. ! 539: // ! 540: // A future implementation may recycle deblocker context structures here ! 541: // as an optimization. ! 542: // ! 543: ! 544: DeblockerContext * deblockerContext = IONew(DeblockerContext, 1); ! 545: UInt64 mediaBlockSize = getMediaBlockSize(); ! 546: ! 547: if (deblockerContext) ! 548: { ! 549: deblockerContext->blockBufferPtr = IONew(UInt8, mediaBlockSize); ! 550: ! 551: if (deblockerContext->blockBufferPtr) ! 552: { ! 553: deblockerContext->blockBuffer = IOMemoryDescriptor::withAddress( ! 554: /* address */ deblockerContext->blockBufferPtr, ! 555: /* withLength */ (vm_size_t) mediaBlockSize, ! 556: /* withDirection */ kIODirectionNone ); ! 557: ! 558: if (deblockerContext->blockBuffer) return deblockerContext; ! 559: ! 560: IODelete(deblockerContext->blockBufferPtr, UInt8, mediaBlockSize); ! 561: } ! 562: IODelete(deblockerContext, DeblockerContext, 1); ! 563: } ! 564: ! 565: return 0; // (failure) ! 566: } ! 567: ! 568: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 569: ! 570: void IODrive::deblockerContextFree(IODrive::DeblockerContext * deblockerContext) ! 571: { ! 572: // ! 573: // Deallocate a deblocker context structure. The block-sized scratch ! 574: // buffer and memory descriptor is automatically deallocated as well. ! 575: // ! 576: ! 577: assert(deblockerContext->blockBuffer && deblockerContext->blockBufferPtr); ! 578: ! 579: if (deblockerContext->middleBuffer) ! 580: deblockerContext->middleBuffer->release(); ! 581: ! 582: deblockerContext->blockBuffer->release(); ! 583: IODelete(deblockerContext->blockBufferPtr, UInt8, getMediaBlockSize()); ! 584: IODelete(deblockerContext, DeblockerContext, 1); ! 585: } ! 586: ! 587: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 588: ! 589: void IODrive::deblockRequest(UInt64 byteStart, ! 590: IOMemoryDescriptor * buffer, ! 591: IOStorageCompletion completion) ! 592: { ! 593: // ! 594: // The deblockRequest method checks to see if the incoming request rests ! 595: // on the media's block boundaries, and if not, deblocks it. Deblocking ! 596: // involves breaking up the request into sub-requests that rest on block ! 597: // boundaries, and performing the appropriate unaligned byte copies from ! 598: // the scratch buffer into into the client's request buffer. ! 599: // ! 600: // This method is part of a sequence of methods that are called for each ! 601: // read or write request. The first is deblockRequest, which aligns the ! 602: // request at the media's block boundaries; the second is prepareRequest, ! 603: // which prepares the memory involved in the transfer; and the third is ! 604: // executeRequest, which implements the actual transfer from the drive. ! 605: // ! 606: // The current implementation of deblockRequest is asynchronous. ! 607: // ! 608: // A diagram and description of the key players: ! 609: // ____ _______________ ______ ______ _______________ ____ ! 610: // ... | | ... | | ... ! 611: // ____|_______________|______ ______|_______________|____ ! 612: // ^ ^ ! 613: // |\___/|\_______/|\_____________/|\_____/| ! 614: // | | | | | | | | | ! 615: // | | | | | | | | |_ byteStart + byteCount ! 616: // | | | | | | | |_ _ _ bytesFinal ! 617: // | | | | | | |_ _ _ _ _ BLOCK BOUNDARY ! 618: // | | | | | | ! 619: // | | | | | |_ _ _ _ _ _ _ _ _ bytesMiddle ! 620: // | | | | |_ _ _ _ _ _ _ _ _ _ _ _ _ BLOCK BOUNDARY ! 621: // | | | | ! 622: // | | | |__ _ _ _ _ _ _ _ _ _ _ _ _ _ _ bytesStart ! 623: // | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ byteStart ! 624: // | |__ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ offsetStart ! 625: // |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ BLOCK BOUNDARY ! 626: // ! 627: // byteStart = the start of transfer, absolute position on media ! 628: // offsetStart = unaligned offset into the first block, zero if aligned ! 629: // bytesStart = unaligned bytecount for the first block, zero if aligned ! 630: // bytesMiddle = aligned byte count for the middle blocks, zero if none ! 631: // bytesFinal = unaligned byte count for the last block, zero if aligned ! 632: // ! 633: ! 634: UInt64 byteCount = buffer->getLength(); ! 635: DeblockerContext * context = deblockerContextAllocate(); ! 636: bool isWrite = (buffer->getDirection() == kIODirectionOut); ! 637: UInt64 mediaBlockSize = getMediaBlockSize(); ! 638: ! 639: if (context == 0) ! 640: { ! 641: complete(completion, kIOReturnNoMemory); ! 642: return; ! 643: } ! 644: ! 645: // ! 646: // This implementation of the deblocker permits only one read-modify-write ! 647: // at any given time. Note that other write requests can, and do, proceed ! 648: // simultaneously so long as they do not require the deblocker -- refer to ! 649: // the read() and the write() routines for the decision logic. ! 650: // ! 651: ! 652: if (isWrite) IOTakeLock(_deblockerLockForRMWs); ! 653: ! 654: // ! 655: // We split up our calculation logic into two distinct cases: ! 656: // (a) all one block transfers with an unaligned end; ! 657: // (b) all one block transfers with an aligned end and > 2 block transfers ! 658: // ! 659: ! 660: context->offsetStart = byteStart % mediaBlockSize; ! 661: ! 662: if (context->offsetStart + byteCount < mediaBlockSize) // (not '<=') ! 663: { ! 664: context->bytesStart = byteCount; ! 665: context->bytesFinal = 0; ! 666: context->bytesMiddle = 0; ! 667: } ! 668: else // (case b) ! 669: { ! 670: context->bytesStart = (context->offsetStart) ? ! 671: (mediaBlockSize - context->offsetStart) : 0; ! 672: context->bytesFinal = (context->offsetStart + byteCount) % ! 673: mediaBlockSize; ! 674: context->bytesMiddle = byteCount - context->bytesStart - ! 675: context->bytesFinal; ! 676: } ! 677: ! 678: assert(context->bytesMiddle % mediaBlockSize == 0); ! 679: ! 680: // ! 681: // We set the deblock phase to "begin" and pass control to an internal ! 682: // completion routine, which implements the deblocking state machine. ! 683: // ! 684: ! 685: context->phase = (isWrite) ? kPhaseBeginRMW : kPhaseBegin; ! 686: context->bytesTransferred = 0; ! 687: ! 688: context->originalRequest.byteStart = byteStart; ! 689: context->originalRequest.buffer = buffer; ! 690: context->originalRequest.buffer->retain(); // (retain the original buffer) ! 691: context->originalRequest.completion = completion; ! 692: ! 693: if (context->bytesMiddle) // (very bad things) ! 694: { ! 695: context->middleBuffer = IOMemoryDescriptor::withSubRange( ! 696: /* descriptor */ context->originalRequest.buffer, ! 697: /* withOffset */ context->bytesStart, ! 698: /* withLength */ context->bytesMiddle, ! 699: /* withDirection */ context->originalRequest.buffer->getDirection() ); ! 700: assert(context->middleBuffer); ! 701: } ! 702: else ! 703: { ! 704: context->middleBuffer = 0; ! 705: } ! 706: ! 707: context->subrequest.buffer = 0; ! 708: context->subrequest.byteStart = 0; ! 709: context->subrequest.completion.target = this; ! 710: context->subrequest.completion.action = deblockerCompletion; ! 711: context->subrequest.completion.parameter = context; ! 712: ! 713: deblockerCompletion(this, context, kIOReturnSuccess, 0); ! 714: return; ! 715: } ! 716: ! 717: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ! 718: ! 719: void IODrive::deblockerCompletion(void * target, ! 720: void * parameter, ! 721: IOReturn status, ! 722: UInt64 actualByteCount) ! 723: { ! 724: // ! 725: // This is the completion routine for the aligned deblocker subrequests. ! 726: // It performs work on the just-completed phase, if any, transitions to ! 727: // the next phase, then builds and issues a transfer for the next phase. ! 728: // ! 729: // ! 730: // For write storage requests, the state machine proceeds as follows: ! 731: // ! 732: // kPhaseBeginRMW --> { kPhaseStartRM --> kPhaseStartW } --> ! 733: // { kPhaseMiddleW } --> { kPhaseFinalRM --> kPhaseFinalW } --> kPhaseDone ! 734: // ! 735: // For read storage requests, the state machine proceeds as follows: ! 736: // ! 737: // kPhaseBegin --> { kPhaseStart } --> { kPhaseMiddle } --> { kPhaseFinal } ! 738: // --> kPhaseDone ! 739: // ! 740: // { } denotes skippable states ! 741: // ! 742: ! 743: DeblockerContext * context = (DeblockerContext *) parameter; ! 744: IODirection direction = kIODirectionIn; ! 745: IODrive * drive = (IODrive *) target; ! 746: UInt64 mediaBlockSize = drive->getMediaBlockSize(); ! 747: ! 748: // ! 749: // Complete the work necessary for the just-completed transfer, if any. ! 750: // Note that we go out of our way to squeeze every good byte through to ! 751: // the disk, even if the transfer failed half way through. ! 752: // ! 753: // A note for future developers: be mindful that we haven't checked the ! 754: // returned actual byte count and status yet. ! 755: // ! 756: ! 757: switch (context->phase) ! 758: { ! 759: case kPhaseStart: // - - - - - - - - - - - - - - - - - - - - - - - - - - ! 760: { ! 761: UInt64 bytesToCopy; ! 762: ! 763: // Ensure a sufficient amount of the block was read. ! 764: ! 765: if (actualByteCount > context->offsetStart) ! 766: { ! 767: // Copy the slice of data to be read from the scratch buffer, ! 768: // or the subset thereof if the actual transfer came up short. ! 769: ! 770: bytesToCopy = min(context->bytesStart, ! 771: actualByteCount - context->offsetStart); ! 772: ! 773: bytesToCopy = context->originalRequest.buffer->writeBytes( ! 774: context->bytesTransferred, ! 775: context->blockBufferPtr + context->offsetStart, ! 776: (UInt32)bytesToCopy); ! 777: ! 778: // Bring the total number of bytes transferred up to date. ! 779: ! 780: context->bytesTransferred += bytesToCopy; ! 781: ! 782: // If the actual transfer came up short (due to writeBytes), ! 783: // set an error status. ! 784: ! 785: if (bytesToCopy < context->bytesStart && ! 786: status == kIOReturnSuccess) ! 787: { ! 788: status = kIOReturnNoSpace; // (writeBytes failure) ! 789: } ! 790: } ! 791: } break; ! 792: ! 793: case kPhaseMiddle: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 794: { ! 795: // Bring the total number of bytes transferred up to date. ! 796: ! 797: context->bytesTransferred += actualByteCount; ! 798: } break; ! 799: ! 800: case kPhaseFinal: // - - - - - - - - - - - - - - - - - - - - - - - - - - ! 801: { ! 802: UInt64 bytesToCopy = min(context->bytesFinal, actualByteCount); ! 803: ! 804: // Ensure at least some amount of the block was read. ! 805: ! 806: if (bytesToCopy) ! 807: { ! 808: // Copy the slice of data to be read from the scratch buffer, ! 809: // or the subset thereof if the actual transfer came up short. ! 810: ! 811: bytesToCopy = context->originalRequest.buffer->writeBytes( ! 812: context->bytesTransferred, ! 813: context->blockBufferPtr, ! 814: (UInt32)bytesToCopy); ! 815: ! 816: // Bring the total number of bytes transferred up to date. ! 817: ! 818: context->bytesTransferred += bytesToCopy; ! 819: ! 820: // If the actual transfer came up short (due to writeBytes), ! 821: // set an error status. ! 822: ! 823: if (bytesToCopy < context->bytesFinal && ! 824: status == kIOReturnSuccess) ! 825: { ! 826: status = kIOReturnNoSpace; // (writeBytes failure) ! 827: } ! 828: } ! 829: } break; ! 830: ! 831: case kPhaseStartRM: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 832: { ! 833: // Ensure the entire block was read into the scratch buffer. ! 834: ! 835: if (actualByteCount == mediaBlockSize) ! 836: { ! 837: // Copy the slice of data to be written into the scratch buffer. ! 838: ! 839: if (context->originalRequest.buffer->readBytes( ! 840: context->bytesTransferred, ! 841: context->blockBufferPtr + context->offsetStart, ! 842: (UInt32)context->bytesStart) != (UInt32)context->bytesStart) ! 843: { ! 844: status = kIOReturnInternalError; // (readBytes failure) ! 845: } ! 846: } ! 847: } break; ! 848: ! 849: case kPhaseStartW: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 850: { ! 851: // Ensure the entire block was written and bring total number of ! 852: // bytes transferred up to date. ! 853: ! 854: if (actualByteCount == mediaBlockSize) ! 855: { ! 856: // Bring the total number of bytes transferred up to date. ! 857: context->bytesTransferred += context->bytesStart; ! 858: } ! 859: } break; ! 860: ! 861: case kPhaseMiddleW: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 862: { ! 863: // Bring the total number of bytes transferred up to date. ! 864: context->bytesTransferred += actualByteCount; ! 865: } break; ! 866: ! 867: case kPhaseFinalRM: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 868: { ! 869: // Ensure the entire block was read into the scratch buffer. ! 870: ! 871: if (actualByteCount == mediaBlockSize) ! 872: { ! 873: // Copy the slice of data to be written into the scratch buffer. ! 874: ! 875: if (context->originalRequest.buffer->readBytes( ! 876: context->bytesTransferred, ! 877: context->blockBufferPtr, ! 878: (UInt32)context->bytesFinal) != (UInt32)context->bytesFinal) ! 879: { ! 880: status = kIOReturnInternalError; // (readBytes failure) ! 881: } ! 882: } ! 883: } break; ! 884: ! 885: case kPhaseFinalW: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 886: { ! 887: // Ensure the entire block was written and bring total number of ! 888: // bytes transferred up to date. ! 889: ! 890: if (actualByteCount == mediaBlockSize) ! 891: { ! 892: // Bring the total number of bytes transferred up to date. ! 893: context->bytesTransferred += context->bytesFinal; ! 894: } ! 895: } break; ! 896: ! 897: default: ! 898: { ! 899: // Nothing to do. ! 900: } break; ! 901: } ! 902: ! 903: // ! 904: // Fail the original transfer if an error was detected. ! 905: // ! 906: ! 907: if (context->phase != kPhaseBegin && context->phase != kPhaseBeginRMW) ! 908: { ! 909: assert( status != kIOReturnSuccess || ! 910: actualByteCount == context->subrequest.buffer->getLength() ); ! 911: ! 912: if ( status != kIOReturnSuccess || ! 913: actualByteCount != context->subrequest.buffer->getLength() ) ! 914: { ! 915: // Unlock the RMW-lock, to allow the next RMW to proceed. ! 916: if (context->originalRequest.buffer->getDirection() == ! 917: kIODirectionOut) ! 918: IOUnlock(drive->_deblockerLockForRMWs); ! 919: ! 920: // Release the retain we placed on the request buffer. ! 921: context->originalRequest.buffer->release(); ! 922: ! 923: // Complete the request. ! 924: drive->complete(context->originalRequest.completion, ! 925: status, ! 926: context->bytesTransferred); ! 927: ! 928: // Release the deblocker context structure. ! 929: drive->deblockerContextFree(context); ! 930: return; ! 931: } ! 932: } ! 933: ! 934: // ! 935: // Transistion to the next phase of the unaligned transfer. ! 936: // ! 937: ! 938: switch (context->phase) ! 939: { ! 940: case kPhaseBegin: ! 941: if (context->bytesStart) { context->phase = kPhaseStart; break; } ! 942: case kPhaseStart: ! 943: if (context->bytesMiddle) { context->phase = kPhaseMiddle; break; } ! 944: case kPhaseMiddle: ! 945: if (context->bytesFinal) { context->phase = kPhaseFinal; break; } ! 946: case kPhaseFinal: ! 947: context->phase = kPhaseDone; ! 948: break; ! 949: ! 950: case kPhaseBeginRMW: ! 951: if (context->bytesStart) { context->phase = kPhaseStartRM; break; } ! 952: case kPhaseStartW: ! 953: if (context->bytesMiddle) ! 954: { ! 955: context->phase = kPhaseMiddleW; ! 956: direction = kIODirectionOut; ! 957: break; ! 958: } ! 959: case kPhaseMiddleW: ! 960: if (context->bytesFinal) { context->phase = kPhaseFinalRM; break; } ! 961: case kPhaseFinalW: ! 962: context->phase = kPhaseDone; ! 963: break; ! 964: ! 965: case kPhaseStartRM: ! 966: context->phase = kPhaseStartW; ! 967: direction = kIODirectionOut; ! 968: break; ! 969: case kPhaseFinalRM: ! 970: context->phase = kPhaseFinalW; ! 971: direction = kIODirectionOut; ! 972: break; ! 973: ! 974: default: ! 975: assert(0); ! 976: break; ! 977: } ! 978: ! 979: // ! 980: // Build and execute the transfer for the new phase. ! 981: // ! 982: ! 983: switch (context->phase) ! 984: { ! 985: case kPhaseStart: // - - - - - - - - - - - - - - - - - - - - - - - - - - ! 986: case kPhaseStartRM: ! 987: case kPhaseStartW: ! 988: context->subrequest.byteStart = context->originalRequest.byteStart - ! 989: context->offsetStart; ! 990: context->subrequest.buffer = context->blockBuffer; ! 991: ! 992: context->subrequest.buffer->initWithAddress( ! 993: /* address */ context->blockBufferPtr, ! 994: /* withLength */ mediaBlockSize, ! 995: /* withDirection */ direction ); ! 996: break; ! 997: ! 998: case kPhaseMiddle: // - - - - - - - - - - - - - - - - - - - - - - - - - ! 999: case kPhaseMiddleW: ! 1000: context->subrequest.byteStart = context->originalRequest.byteStart + ! 1001: context->bytesStart; ! 1002: context->subrequest.buffer = context->middleBuffer; ! 1003: ! 1004: assert(context->middleBuffer); // (to fix) ! 1005: break; ! 1006: ! 1007: case kPhaseFinal: // - - - - - - - - - - - - - - - - - - - - - - - - - - ! 1008: case kPhaseFinalRM: ! 1009: case kPhaseFinalW: ! 1010: context->subrequest.byteStart = context->originalRequest.byteStart + ! 1011: context->bytesStart + ! 1012: context->bytesMiddle; ! 1013: context->subrequest.buffer = context->blockBuffer; ! 1014: ! 1015: context->subrequest.buffer->initWithAddress( ! 1016: /* address */ context->blockBufferPtr, ! 1017: /* withLength */ mediaBlockSize, ! 1018: /* withDirection */ direction ); ! 1019: break; ! 1020: ! 1021: case kPhaseDone: // - - - - - - - - - - - - - - - - - - - - - - - - - - ! 1022: ! 1023: // Unlock the RMW-lock, to allow the next RMW to proceed. ! 1024: if (context->originalRequest.buffer->getDirection() == ! 1025: kIODirectionOut) ! 1026: IOUnlock(drive->_deblockerLockForRMWs); ! 1027: ! 1028: // Release the retain we placed on the request buffer. ! 1029: context->originalRequest.buffer->release(); ! 1030: ! 1031: // Complete the request. ! 1032: drive->complete(context->originalRequest.completion, ! 1033: kIOReturnSuccess, ! 1034: context->bytesTransferred); ! 1035: ! 1036: // Release the deblocker context structure. ! 1037: drive->deblockerContextFree(context); ! 1038: return; ! 1039: ! 1040: default: ! 1041: assert(0); ! 1042: break; ! 1043: } ! 1044: ! 1045: // (presuming completion.target/action/parameter are unchanged) ! 1046: ! 1047: drive->prepareRequest(context->subrequest.byteStart, ! 1048: context->subrequest.buffer, ! 1049: context->subrequest.completion); ! 1050: return; ! 1051: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.