![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AMD_SCSI.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / AMDPCSCSIDriver / AMDPCSCSIDriver_reloc.tproj|
Return to AMD_SCSI.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / DriverKit / AMDPCSCSIDriver / AMDPCSCSIDriver_reloc.tproj |
1.1 ! root 1: /* ! 2: * AMD_SCSI.m - top-level module for AMD 53C974/79C974 PCI SCSI driver. ! 3: * ! 4: * HISTORY ! 5: * 21 Oct 94 Doug Mitchell at NeXT ! 6: * Created. ! 7: */ ! 8: ! 9: #import "AMD_SCSI.h" ! 10: #import "AMD_Private.h" ! 11: #import "AMD_x86.h" ! 12: #import "AMD_Chip.h" ! 13: #import "AMD_ddm.h" ! 14: #import "AMD_Regs.h" ! 15: #import <mach/message.h> ! 16: #import <driverkit/generalFuncs.h> ! 17: #import <driverkit/interruptMsg.h> ! 18: #import <driverkit/align.h> ! 19: #import <driverkit/kernelDriver.h> ! 20: #import <kernserv/prototypes.h> ! 21: ! 22: static void AMDTimeout(void *arg); ! 23: ! 24: /* ! 25: * Template for command message sent to the I/O thread. ! 26: */ ! 27: static msg_header_t cmdMessageTemplate = { ! 28: 0, // msg_unused ! 29: 1, // msg_simple ! 30: sizeof(msg_header_t), // msg_size ! 31: MSG_TYPE_NORMAL, // msg_type ! 32: PORT_NULL, // msg_local_port ! 33: PORT_NULL, // msg_remote_port - TO ! 34: // BE FILLED IN ! 35: IO_COMMAND_MSG // msg_id ! 36: }; ! 37: ! 38: /* ! 39: * Template for timeout message. ! 40: */ ! 41: static msg_header_t timeoutMsgTemplate = { ! 42: 0, // msg_unused ! 43: 1, // msg_simple ! 44: sizeof(msg_header_t), // msg_size ! 45: MSG_TYPE_NORMAL, // msg_type ! 46: PORT_NULL, // msg_local_port ! 47: PORT_NULL, // msg_remote_port - TO ! 48: // BE FILLED IN ! 49: IO_TIMEOUT_MSG // msg_id ! 50: }; ! 51: ! 52: ! 53: @implementation AMD_SCSI ! 54: ! 55: /* ! 56: * Create and initialize one instance of AMD_SCSI. The work is done by ! 57: * architecture- and chip-specific modules. ! 58: */ ! 59: + (BOOL)probe:deviceDescription ! 60: { ! 61: AMD_SCSI *inst = [self alloc]; ! 62: ! 63: ! 64: if([inst archInit:deviceDescription] == nil) { ! 65: return NO; ! 66: } ! 67: else { ! 68: return YES; ! 69: } ! 70: } ! 71: ! 72: - free ! 73: { ! 74: commandBuf cmdBuf; ! 75: ! 76: /* ! 77: * First kill the I/O thread if running. ! 78: */ ! 79: if(ioThreadRunning) { ! 80: cmdBuf.op = CO_Abort; ! 81: cmdBuf.scsiReq = NULL; ! 82: [self executeCmdBuf:&cmdBuf]; ! 83: } ! 84: ! 85: if(commandLock) { ! 86: [commandLock free]; ! 87: } ! 88: if(mdlFree) { ! 89: IOFree(mdlFree, MDL_SIZE * 2 * sizeof(vm_address_t)); ! 90: } ! 91: return [super free]; ! 92: } ! 93: ! 94: /* ! 95: * Our max DMA size is 64 K, derived from using 18 MDL entries (note the ! 96: * first and last entries can refer to chunks as small as 4 bytes). ! 97: */ ! 98: - (unsigned)maxDmaSize ! 99: { ! 100: return AMD_DMA_PAGE_SIZE * (MDL_SIZE - 2); ! 101: } ! 102: ! 103: /* ! 104: * Return required DMA alignment for current architecture. ! 105: */ ! 106: - (void)getDMAAlignment : (IODMAAlignment *)alignment; ! 107: { ! 108: alignment->readStart = AMD_READ_START_ALIGN; ! 109: alignment->writeStart = AMD_WRITE_START_ALIGN; ! 110: alignment->readLength = AMD_READ_LENGTH_ALIGN; ! 111: alignment->writeLength = AMD_WRITE_LENGTH_ALIGN; ! 112: } ! 113: ! 114: /* ! 115: * Statistics support. ! 116: */ ! 117: - (unsigned int) numQueueSamples ! 118: { ! 119: return totalCommands; ! 120: } ! 121: ! 122: ! 123: - (unsigned int) sumQueueLengths ! 124: { ! 125: return queueLenTotal; ! 126: } ! 127: ! 128: ! 129: - (unsigned int) maxQueueLength ! 130: { ! 131: return maxQueueLen; ! 132: } ! 133: ! 134: ! 135: - (void)resetStats ! 136: { ! 137: totalCommands = 0; ! 138: queueLenTotal = 0; ! 139: maxQueueLen = 0; ! 140: } ! 141: ! 142: /* ! 143: * Do a SCSI command, as specified by an IOSCSIRequest. All the ! 144: * work is done by the I/O thread. ! 145: */ ! 146: - (sc_status_t) executeRequest : (IOSCSIRequest *)scsiReq ! 147: buffer : (void *)buffer ! 148: client : (vm_task_t)client ! 149: { ! 150: commandBuf cmdBuf; ! 151: ! 152: ddm_exp("executeRequest: cmdBuf 0x%x maxTransfer 0x%x\n", ! 153: &cmdBuf, scsiReq->maxTransfer,3,4,5); ! 154: ! 155: bzero(&cmdBuf, sizeof(commandBuf)); ! 156: cmdBuf.op = CO_Execute; ! 157: cmdBuf.scsiReq = scsiReq; ! 158: cmdBuf.buffer = buffer; ! 159: cmdBuf.client = client; ! 160: scsiReq->driverStatus = SR_IOST_INVALID; ! 161: ! 162: [self executeCmdBuf:&cmdBuf]; ! 163: ! 164: ddm_exp("executeRequest: cmdBuf 0x%x complete; driverStatus %s\n", ! 165: &cmdBuf, IOFindNameForValue(scsiReq->driverStatus, ! 166: IOScStatusStrings), 3,4,5); ! 167: return cmdBuf.scsiReq->driverStatus; ! 168: } ! 169: ! 170: ! 171: /* ! 172: * Reset the SCSI bus. All the work is done by the I/O thread. ! 173: */ ! 174: - (sc_status_t)resetSCSIBus ! 175: { ! 176: commandBuf cmdBuf; ! 177: ! 178: ddm_exp("resetSCSIBus: cmdBuf 0x%x\n", &cmdBuf, 2,3,4,5); ! 179: ! 180: cmdBuf.op = CO_Reset; ! 181: cmdBuf.scsiReq = NULL; ! 182: [self executeCmdBuf:&cmdBuf]; ! 183: ddm_exp("resetSCSIBus: cmdBuf 0x%x DONE\n", &cmdBuf, 2,3,4,5); ! 184: return SR_IOST_GOOD; // can not fail ! 185: } ! 186: ! 187: /* ! 188: * The following 6 methods are all called from the I/O thread in ! 189: * IODirectDevice. ! 190: */ ! 191: ! 192: /* ! 193: * Called from the I/O thread when it receives an interrupt message. ! 194: * Currently all work is done by chip-specific module; maybe we should ! 195: * put this method there.... ! 196: */ ! 197: - (void)interruptOccurred ! 198: { ! 199: #if DDM_DEBUG ! 200: /* ! 201: * calculate interrupt service time if enabled. ! 202: */ ! 203: ns_time_t startTime, endTime, elapsedNs; ! 204: unsigned elapsedUs = 0; ! 205: ! 206: if(IODDMMasks[AMD_DDM_INDEX] & DDM_INTR) { ! 207: IOGetTimestamp(&startTime); ! 208: } ! 209: ddm_thr("interruptOccurred: TOP\n", 1,2,3,4,5); ! 210: #endif DDM_DEBUG ! 211: ! 212: [self hwInterrupt]; ! 213: ! 214: #if DDM_DEBUG ! 215: if(IODDMMasks[AMD_DDM_INDEX] & DDM_INTR) { ! 216: IOGetTimestamp(&endTime); ! 217: elapsedNs = endTime - startTime; ! 218: elapsedUs = (unsigned)((elapsedNs + 999ULL) / 1000ULL); ! 219: } ! 220: ddm_intr("interruptOccurred: DONE; elapsed time %d us\n", ! 221: elapsedUs, 2,3,4,5); ! 222: #endif DDM_DEBUG ! 223: } ! 224: ! 225: /* ! 226: * These three should not occur; they are here as error traps. All three are ! 227: * called out from the I/O thread upon receipt of messages which it should ! 228: * not be seeing. ! 229: */ ! 230: - (void)interruptOccurredAt:(int)localNum ! 231: { ! 232: IOLog("%s: interruptOccurredAt:%d\n", [self name], localNum); ! 233: } ! 234: ! 235: - (void)otherOccurred:(int)id ! 236: { ! 237: IOLog("%s: otherOccurred:%d\n", [self name], id); ! 238: } ! 239: ! 240: - (void)receiveMsg ! 241: { ! 242: IOLog("%s: receiveMsg\n", [self name]); ! 243: ! 244: /* ! 245: * We have to let IODirectDevice take care of this (i.e., dequeue the ! 246: * bogus message). ! 247: */ ! 248: [super receiveMsg]; ! 249: } ! 250: ! 251: /* ! 252: * Used in -timeoutOccurred to determine if specified cmdBuf has timed out. ! 253: * Returns YES if timeout, else NO. ! 254: */ ! 255: static inline BOOL ! 256: isCmdTimedOut(commandBuf *cmdBuf, ns_time_t now) ! 257: { ! 258: IOSCSIRequest *scsiReq; ! 259: ns_time_t expire; ! 260: ! 261: scsiReq = cmdBuf->scsiReq; ! 262: expire = cmdBuf->startTime + ! 263: (1000000000ULL * (unsigned long long)scsiReq->timeoutLength); ! 264: return ((now > expire) ? YES : NO); ! 265: } ! 266: ! 267: /* ! 268: * Called from the I/O thread when it receives a timeout ! 269: * message. We send these messages ourself from AMDTimeout(). ! 270: */ ! 271: - (void)timeoutOccurred ! 272: { ! 273: ns_time_t now; ! 274: BOOL cmdTimedOut = NO; ! 275: commandBuf *cmdBuf; ! 276: commandBuf *nextCmdBuf; ! 277: ! 278: ddm_thr("timeoutOccurred: TOP\n", 1,2,3,4,5); ! 279: IOGetTimestamp(&now); ! 280: ! 281: /* ! 282: * Scan activeCmd and disconnectQ looking for tardy I/Os. ! 283: */ ! 284: if(activeCmd) { ! 285: cmdBuf = activeCmd; ! 286: if(isCmdTimedOut(cmdBuf, now)) { ! 287: ddm_thr("activeCmd TIMEOUT, cmd 0x%x\n", ! 288: cmdBuf, 2,3,4,5); ! 289: activeCmd = NULL; ! 290: ASSERT(cmdBuf->scsiReq != NULL); ! 291: cmdBuf->scsiReq->driverStatus = SR_IOST_IOTO; ! 292: [self ioComplete:cmdBuf]; ! 293: cmdTimedOut = YES; ! 294: } ! 295: } ! 296: ! 297: cmdBuf = (commandBuf *)queue_first(&disconnectQ); ! 298: while(!queue_end(&disconnectQ, (queue_entry_t)cmdBuf)) { ! 299: if(isCmdTimedOut(cmdBuf, now)) { ! 300: ddm_thr("disconnected cmd TIMEOUT, cmd 0x%x\n", ! 301: cmdBuf, 2,3,4,5); ! 302: ! 303: /* ! 304: * Remove cmdBuf from disconnectQ and ! 305: * complete it. ! 306: */ ! 307: nextCmdBuf = (commandBuf *)queue_next(&cmdBuf->link); ! 308: queue_remove(&disconnectQ, cmdBuf, commandBuf *, link); ! 309: ASSERT(cmdBuf->scsiReq != NULL); ! 310: cmdBuf->scsiReq->driverStatus = SR_IOST_IOTO; ! 311: [self ioComplete:cmdBuf]; ! 312: cmdBuf = nextCmdBuf; ! 313: cmdTimedOut = YES; ! 314: } ! 315: else { ! 316: cmdBuf = (commandBuf *)queue_next(&cmdBuf->link); ! 317: } ! 318: } ! 319: ! 320: /* ! 321: * Reset bus. This also completes all I/Os in disconnectQ with ! 322: * status CS_Reset. ! 323: */ ! 324: if(cmdTimedOut) { ! 325: [self logRegs]; ! 326: [self threadResetBus:NULL]; ! 327: } ! 328: ddm_thr("timeoutOccurred: DONE\n", 1,2,3,4,5); ! 329: } ! 330: ! 331: /* ! 332: * Process all commands in commandQ. At most one of these will become ! 333: * activeCmd. The remainder of CO_Execute commands go to pendingQ. Other ! 334: * types of commands are executed immediately. ! 335: */ ! 336: - (void)commandRequestOccurred ! 337: { ! 338: commandBuf *cmdBuf; ! 339: commandBuf *pendCmd; ! 340: ! 341: ddm_thr("commandRequestOccurred: top\n", 1,2,3,4,5); ! 342: [commandLock lock]; ! 343: while(!queue_empty(&commandQ)) { ! 344: cmdBuf = (commandBuf *) queue_first(&commandQ); ! 345: queue_remove(&commandQ, cmdBuf, commandBuf *, link); ! 346: [commandLock unlock]; ! 347: ! 348: switch(cmdBuf->op) { ! 349: case CO_Reset: ! 350: /* ! 351: * Note all active and disconnected commands will ! 352: * be terminted. ! 353: */ ! 354: [self threadResetBus:"Reset Command Received"]; ! 355: [self ioComplete:cmdBuf]; ! 356: break; ! 357: ! 358: case CO_Abort: ! 359: /* ! 360: * 1. Abort all active, pending, and disconnected ! 361: * commands. ! 362: * 2. Notify caller of completion. ! 363: * 3. Self-terminate. ! 364: */ ! 365: [self swAbort:SR_IOST_INT]; ! 366: pendCmd = (commandBuf *)queue_first(&pendingQ); ! 367: while(!queue_end(&pendingQ, ! 368: (queue_entry_t)pendCmd)) { ! 369: pendCmd->scsiReq->driverStatus = SR_IOST_INT; ! 370: [self ioComplete:pendCmd]; ! 371: pendCmd = (commandBuf *) ! 372: queue_next(&pendCmd->link); ! 373: } ! 374: [cmdBuf->cmdLock lock]; ! 375: [cmdBuf->cmdLock unlockWith:CMD_COMPLETE]; ! 376: IOExitThread(); ! 377: /* not reached */ ! 378: ! 379: case CO_Execute: ! 380: [self threadExecuteRequest:cmdBuf]; ! 381: break; ! 382: ! 383: } ! 384: [commandLock lock]; ! 385: } ! 386: [commandLock unlock]; ! 387: ddm_thr("commandRequestOccurred: DONE\n", 1,2,3,4,5); ! 388: return; ! 389: } ! 390: ! 391: /* ! 392: * Power management methods. All we care about is power off, when we must ! 393: * reset the SCSI bus due to the Compaq BIOS's lack of a SCSI reset, which ! 394: * causes a hang if we have set up targets for sync data transfer mode. ! 395: */ ! 396: - (IOReturn)getPowerState:(PMPowerState *)state_p ! 397: { ! 398: ddm_exp("getPowerState called\n", 1,2,3,4,5); ! 399: return IO_R_UNSUPPORTED; ! 400: } ! 401: ! 402: - (IOReturn)setPowerState:(PMPowerState)state ! 403: { ! 404: #ifdef DEBUG ! 405: IOLog("%s: received setPowerState: with %x\n", [self name], ! 406: (unsigned)state); ! 407: #endif DEBUG ! 408: if (state == PM_OFF) { ! 409: [self scsiReset]; ! 410: return IO_R_SUCCESS; ! 411: } ! 412: return IO_R_UNSUPPORTED; ! 413: } ! 414: ! 415: - (IOReturn)getPowerManagement:(PMPowerManagementState *)state_p ! 416: { ! 417: ddm_exp("getPowerManagement called\n", 1,2,3,4,5); ! 418: return IO_R_UNSUPPORTED; ! 419: } ! 420: ! 421: - (IOReturn)setPowerManagement:(PMPowerManagementState)state ! 422: { ! 423: ddm_exp("setPowerManagement called\n", 1,2,3,4,5); ! 424: return IO_R_UNSUPPORTED; ! 425: } ! 426: ! 427: #if AMD_ENABLE_GET_SET ! 428: ! 429: - (IOReturn)setIntValues:(unsigned *)parameterArray ! 430: forParameter:(IOParameterName)parameterName ! 431: count:(unsigned int)count ! 432: { ! 433: if(strcmp(parameterName, AMD_AUTOSENSE) == 0) { ! 434: if (count != 1) { ! 435: return IO_R_INVALID_ARG; ! 436: } ! 437: autoSenseEnable = (parameterArray[0] ? 1 : 0); ! 438: IOLog("%s: autoSense %s\n", [self name], ! 439: (autoSenseEnable ? "Enabled" : "Disabled")); ! 440: return IO_R_SUCCESS; ! 441: } ! 442: else if(strcmp(parameterName, AMD_CMD_QUEUE) == 0) { ! 443: if (count != 1) { ! 444: return IO_R_INVALID_ARG; ! 445: } ! 446: cmdQueueEnable = (parameterArray[0] ? 1 : 0); ! 447: IOLog("%s: cmdQueue %s\n", [self name], ! 448: (cmdQueueEnable ? "Enabled" : "Disabled")); ! 449: return IO_R_SUCCESS; ! 450: } ! 451: else if(strcmp(parameterName, AMD_SYNC) == 0) { ! 452: if (count != 1) { ! 453: return IO_R_INVALID_ARG; ! 454: } ! 455: syncModeEnable = (parameterArray[0] ? 1 : 0); ! 456: IOLog("%s: syncMode %s\n", [self name], ! 457: (syncModeEnable ? "Enabled" : "Disabled")); ! 458: return IO_R_SUCCESS; ! 459: } ! 460: else if(strcmp(parameterName, AMD_FAST_SCSI) == 0) { ! 461: if (count != 1) { ! 462: return IO_R_INVALID_ARG; ! 463: } ! 464: fastModeEnable = (parameterArray[0] ? 1 : 0); ! 465: IOLog("%s: fastMode %s\n", [self name], ! 466: (fastModeEnable ? "Enabled" : "Disabled")); ! 467: return IO_R_SUCCESS; ! 468: } ! 469: else if(strcmp(parameterName, AMD_RESET_TARGETS) == 0) { ! 470: int target; ! 471: perTargetData *perTargetPtr; ! 472: ! 473: if (count != 0) { ! 474: return IO_R_INVALID_ARG; ! 475: } ! 476: ! 477: /* ! 478: * Re-enable sync and command queueing. The ! 479: * disable bits persist after a reset. ! 480: */ ! 481: for(target=0; target<SCSI_NTARGETS; target++) { ! 482: perTargetPtr = &perTarget[target]; ! 483: perTargetPtr->cmdQueueDisable = 0; ! 484: perTargetPtr->syncDisable = 0; ! 485: perTargetPtr->maxQueue = 0; ! 486: } ! 487: IOLog("%s: Per Target disable flags cleared\n", [self name]); ! 488: return IO_R_SUCCESS; ! 489: } ! 490: else { ! 491: return [super setIntValues:parameterArray ! 492: forParameter:parameterName ! 493: count:count]; ! 494: } ! 495: } ! 496: ! 497: - (IOReturn)getIntValues : (unsigned *)parameterArray ! 498: forParameter : (IOParameterName)parameterName ! 499: count : (unsigned *)count; // in/out ! 500: { ! 501: if(strcmp(parameterName, AMD_AUTOSENSE) == 0) { ! 502: if(*count != 1) { ! 503: return IO_R_INVALID_ARG; ! 504: } ! 505: parameterArray[0] = autoSenseEnable; ! 506: return IO_R_SUCCESS; ! 507: } ! 508: else if(strcmp(parameterName, AMD_CMD_QUEUE) == 0) { ! 509: if(*count != 1) { ! 510: return IO_R_INVALID_ARG; ! 511: } ! 512: parameterArray[0] = cmdQueueEnable; ! 513: return IO_R_SUCCESS; ! 514: } ! 515: else if(strcmp(parameterName, AMD_SYNC) == 0) { ! 516: if(*count != 1) { ! 517: return IO_R_INVALID_ARG; ! 518: } ! 519: parameterArray[0] = syncModeEnable; ! 520: return IO_R_SUCCESS; ! 521: } ! 522: else if(strcmp(parameterName, AMD_FAST_SCSI) == 0) { ! 523: if(*count != 1) { ! 524: return IO_R_INVALID_ARG; ! 525: } ! 526: parameterArray[0] = fastModeEnable; ! 527: return IO_R_SUCCESS; ! 528: } ! 529: else { ! 530: return [super getIntValues : parameterArray ! 531: forParameter : parameterName ! 532: count : count]; ! 533: ! 534: } ! 535: } ! 536: ! 537: ! 538: #endif AMD_ENABLE_GET_SET ! 539: ! 540: @end /* AMD_SCSI */ ! 541: ! 542: @implementation AMD_SCSI(Private) ! 543: ! 544: /* ! 545: * Private chip- and architecture-independent methods. ! 546: */ ! 547: ! 548: /* ! 549: * Pass one commandBuf to the I/O thread; wait for completion. ! 550: * Normal completion status is in cmdBuf->scsiReq->driverStatus; ! 551: * a non-zero return from this function indicates a Mach IPC error. ! 552: * ! 553: * This method allocates and frees cmdBuf->cmdLock. ! 554: */ ! 555: - (IOReturn)executeCmdBuf : (commandBuf *)cmdBuf ! 556: { ! 557: msg_header_t msg = cmdMessageTemplate; ! 558: kern_return_t krtn; ! 559: IOReturn rtn = IO_R_SUCCESS; ! 560: ! 561: cmdBuf->cmdPendingSense = NULL; ! 562: cmdBuf->active = 0; ! 563: cmdBuf->cmdLock = [[NXConditionLock alloc] initWith:CMD_PENDING]; ! 564: [commandLock lock]; ! 565: queue_enter(&commandQ, cmdBuf, commandBuf *, link); ! 566: [commandLock unlock]; ! 567: ! 568: /* ! 569: * Create a Mach message and send it in order to wake up the ! 570: * I/O thread. ! 571: */ ! 572: msg.msg_remote_port = interruptPortKern; ! 573: krtn = msg_send_from_kernel(&msg, MSG_OPTION_NONE, 0); ! 574: if(krtn) { ! 575: IOLog("%s: msg_send_from_kernel() returned %d\n", ! 576: [self name], krtn); ! 577: rtn = IO_R_IPC_FAILURE; ! 578: goto out; ! 579: } ! 580: ! 581: /* ! 582: * Wait for I/O complete. ! 583: */ ! 584: ddm_exp("executeCmdBuf: waiting for completion on cmdBuf 0x%x\n", ! 585: cmdBuf, 2,3,4,5); ! 586: [cmdBuf->cmdLock lockWhen:CMD_COMPLETE]; ! 587: out: ! 588: [cmdBuf->cmdLock free]; ! 589: return rtn; ! 590: } ! 591: ! 592: /* ! 593: * Abort all active and disconnected commands with specified status. No ! 594: * hardware action. Currently used by threadResetBus and during processing ! 595: * of a CO_Abort command. ! 596: */ ! 597: - (void)swAbort : (sc_status_t)status ! 598: { ! 599: commandBuf *cmdBuf; ! 600: commandBuf *nextCmdBuf; ! 601: ! 602: ddm_thr("swAbort\n", 1,2,3,4,5); ! 603: if(activeCmd) { ! 604: activeCmd->scsiReq->driverStatus = status; ! 605: [self ioComplete:activeCmd]; ! 606: activeCmd = NULL; ! 607: } ! 608: cmdBuf = (commandBuf *)queue_first(&disconnectQ); ! 609: while(!queue_end(&disconnectQ, (queue_entry_t)cmdBuf)) { ! 610: queue_remove(&disconnectQ, cmdBuf, commandBuf *, link); ! 611: nextCmdBuf = (commandBuf *) ! 612: queue_next(&cmdBuf->link); ! 613: cmdBuf->scsiReq->driverStatus = status; ! 614: [self ioComplete:cmdBuf]; ! 615: cmdBuf = nextCmdBuf; ! 616: } ! 617: #ifdef DEBUG ! 618: /* ! 619: * activeArray "should be" empty...if not, make sure it is for debug. ! 620: */ ! 621: { ! 622: int target, lun; ! 623: int active; ! 624: ! 625: for(target=0; target<SCSI_NTARGETS; target++) { ! 626: for(lun=0; lun<SCSI_NLUNS; lun++) { ! 627: active = activeArray[target][lun]; ! 628: if(active) { ! 629: IOLog("swAbort: activeArray[%d][%d] = %d\n", ! 630: target, lun, active); ! 631: activeCount -= active; ! 632: activeArray[target][lun] = 0; ! 633: } ! 634: } ! 635: } ! 636: if(activeCount != 0) { ! 637: IOLog("swAbort: activeCount = %d\n", activeCount); ! 638: activeCount = 0; ! 639: } ! 640: } ! 641: #endif DEBUG ! 642: } ! 643: ! 644: /* ! 645: * Abort all active and disconnected commands with status SR_IOST_RESET. ! 646: * Reset hardware and SCSI bus. If there is a command in pendingQ, start ! 647: * it up. ! 648: */ ! 649: - (void)threadResetBus : (const char *)reason ! 650: { ! 651: [self swAbort:SR_IOST_RESET]; ! 652: [self hwReset : reason]; ! 653: [self busFree]; ! 654: } ! 655: ! 656: /* ! 657: * Commence processing of the specified command. ! 658: * ! 659: * If activeCmd is non-NULL or cmdBufOK says we can't process this command, ! 660: * we just enqueue the command on the end of pendingQ. ! 661: */ ! 662: - (void)threadExecuteRequest : (commandBuf *)cmdBuf ! 663: { ! 664: #if DDM_DEBUG ! 665: unsigned char target = cmdBuf->scsiReq->target; ! 666: unsigned char lun = cmdBuf->scsiReq->lun; ! 667: #endif DDM_DEBUG ! 668: ! 669: if(activeCmd != NULL) { ! 670: ddm_thr("threadExecuteRequest: ACTIVE; adding 0x%x to " ! 671: "pendingQ\n", cmdBuf, 2,3,4,5); ! 672: queue_enter(&pendingQ, cmdBuf, commandBuf *, link); ! 673: return; ! 674: } ! 675: else if([self cmdBufOK:cmdBuf] == NO) { ! 676: ddm_thr("threadExecuteRequest: !cmdBufOK; adding 0x%x to " ! 677: "pendingQ\n", cmdBuf, 2,3,4,5); ! 678: queue_enter(&pendingQ, cmdBuf, commandBuf *, link); ! 679: return; ! 680: } ! 681: ! 682: ddm_thr("calling hwStart: cmdBuf 0x%x activeArray[%d][%d] = %d\n", ! 683: cmdBuf, target, lun, activeArray[target][lun], 5); ! 684: ! 685: switch([self hwStart:cmdBuf]) { ! 686: case HWS_OK: // cool ! 687: case HWS_BUSY: // h/w can't take cmd now ! 688: break; ! 689: case HWS_REJECT: // hw ready for new cmd ! 690: ddm_thr("threadExecuteRequest: calling busFree\n", 1,2,3,4,5); ! 691: [self busFree]; ! 692: } ! 693: ! 694: ddm_thr("threadExecuteRequest(0x%x): DONE\n", cmdBuf, 2,3,4,5); ! 695: } ! 696: ! 697: /* ! 698: * Methods called by hardware-dependent modules. ! 699: */ ! 700: ! 701: #if TEST_QUEUE_FULL ! 702: int testQueueFull; ! 703: #endif TEST_QUEUE_FULL ! 704: ! 705: /* ! 706: * Called when a transaction associated with cmdBuf is complete. Notify ! 707: * waiting thread. If cmdBuf->scsiReq exists (i.e., this is not a reset ! 708: * or an abort), scsiReq->driverStatus must be valid. If cmdBuf is active, ! 709: * caller must remove from activeCmd. We decrement activeArray[][] counter ! 710: * if appropriate. ! 711: */ ! 712: - (void)ioComplete:(commandBuf *)cmdBuf ! 713: { ! 714: ns_time_t currentTime; ! 715: IOSCSIRequest *scsiReq = cmdBuf->scsiReq; ! 716: int target; ! 717: int lun; ! 718: ! 719: if(cmdBuf->cmdPendingSense != NULL) { ! 720: /* ! 721: * This was an autosense request. ! 722: */ ! 723: ! 724: commandBuf *origCmdBuf = cmdBuf->cmdPendingSense; ! 725: esense_reply_t *alignedSense = cmdBuf->buffer; ! 726: ! 727: ASSERT(cmdBuf->scsiReq != NULL); ! 728: ddm_thr("autosense buf 0x%x complete for cmd 0x%x sense " ! 729: "key 0x%x\n", ! 730: cmdBuf, origCmdBuf, alignedSense->er_sensekey, 4,5); ! 731: if(cmdBuf->scsiReq->driverStatus == SR_IOST_GOOD) { ! 732: /* ! 733: * Copy aligned sense data to caller's buffer. ! 734: */ ! 735: alignedSense = cmdBuf->buffer; ! 736: origCmdBuf->scsiReq->senseData = *alignedSense; ! 737: origCmdBuf->scsiReq->driverStatus = SR_IOST_CHKSV; ! 738: } ! 739: else { ! 740: IOLog("AMD53C974: Autosense request for target %d" ! 741: " FAILED (%s)\n", ! 742: cmdBuf->scsiReq->target, ! 743: IOFindNameForValue(scsiReq->driverStatus, ! 744: IOScStatusStrings)); ! 745: origCmdBuf->scsiReq->driverStatus = SR_IOST_CHKSNV; ! 746: } ! 747: ! 748: /* ! 749: * Free all of the allocated memory associated with ! 750: * this autosense request. ! 751: */ ! 752: [self deactivateCmd:cmdBuf]; ! 753: IOFree(cmdBuf->scsiReq, sizeof(*cmdBuf->scsiReq)); ! 754: IOFree(cmdBuf->unalignedSense, ! 755: sizeof(esense_reply_t) + (2 * AMD_READ_START_ALIGN)); ! 756: IOFree(cmdBuf, sizeof(commandBuf)); ! 757: ! 758: /* ! 759: * Now complete the I/O for the original commandBuf. ! 760: */ ! 761: [origCmdBuf->cmdLock lock]; ! 762: [origCmdBuf->cmdLock unlockWith:YES]; ! 763: return; ! 764: } ! 765: if(scsiReq != NULL) { ! 766: IOGetTimestamp(¤tTime); ! 767: scsiReq->totalTime = currentTime - cmdBuf->startTime; ! 768: scsiReq->bytesTransferred = ! 769: scsiReq->maxTransfer - cmdBuf->currentByteCount; ! 770: ! 771: /* ! 772: * Catch bad SCSI status now. ! 773: */ ! 774: if(scsiReq->driverStatus == SR_IOST_GOOD) { ! 775: #if TEST_QUEUE_FULL ! 776: if(testQueueFull && ! 777: (activeArray[scsiReq->target][scsiReq->lun] > 1)) { ! 778: scsiReq->scsiStatus = STAT_QUEUE_FULL; ! 779: testQueueFull = 0; ! 780: } ! 781: #endif TEST_QUEUE_FULL ! 782: switch(scsiReq->scsiStatus) { ! 783: case STAT_GOOD: ! 784: break; ! 785: case STAT_CHECK: ! 786: if(autoSenseEnable) { ! 787: /* ! 788: * Generate an autosense request, enqueue ! 789: * on pendingQ. ! 790: */ ! 791: [self generateAutoSense:cmdBuf]; ! 792: if(cmdBuf->active) { ! 793: [self deactivateCmd:cmdBuf]; ! 794: } ! 795: return; ! 796: } ! 797: else { ! 798: scsiReq->driverStatus = SR_IOST_CHKSNV; ! 799: } ! 800: break; ! 801: ! 802: case STAT_QUEUE_FULL: ! 803: /* ! 804: * Avoid notifying client of this condition; ! 805: * update perTarget.maxQueue and place this ! 806: * request on pendingQ. We'll try this ! 807: * again when we ioComplete at least one ! 808: * command in this target's queue. ! 809: */ ! 810: if(cmdBuf->queueTag == QUEUE_TAG_NONTAGGED) { ! 811: /* ! 812: * Huh? We're not doing command ! 813: * queueing... ! 814: */ ! 815: scsiReq->driverStatus = SR_IOST_BADST; ! 816: break; ! 817: } ! 818: target = scsiReq->target; ! 819: lun = scsiReq->lun; ! 820: if(cmdBuf->active) { ! 821: [self deactivateCmd:cmdBuf]; ! 822: } ! 823: perTarget[target].maxQueue = ! 824: activeArray[target][lun]; ! 825: ddm_thr("Target %d QUEUE FULL, maxQueue %d\n", ! 826: target, perTarget[target].maxQueue, ! 827: 3,4,5); ! 828: queue_enter(&pendingQ, cmdBuf, commandBuf *, ! 829: link); ! 830: return; ! 831: ! 832: default: ! 833: scsiReq->driverStatus = SR_IOST_BADST; ! 834: break; ! 835: } ! 836: } ! 837: } ! 838: if(cmdBuf->active) { ! 839: /* ! 840: * Note that the active flag is false for non-CO_Execute ! 841: * commands and commands aborted from pendingQ. ! 842: */ ! 843: [self deactivateCmd:cmdBuf]; ! 844: } ! 845: ! 846: #if DDM_DEBUG ! 847: { ! 848: const char *status; ! 849: unsigned moved; ! 850: ! 851: if(scsiReq != NULL) { ! 852: status = IOFindNameForValue(scsiReq->driverStatus, ! 853: IOScStatusStrings); ! 854: moved = scsiReq->bytesTransferred; ! 855: } ! 856: else { ! 857: status = "Complete"; ! 858: moved = 0; ! 859: } ! 860: ddm_thr("ioComplete: cmdBuf 0x%x status %s bytesXfr 0x%x\n", ! 861: cmdBuf, status, moved,4,5); ! 862: } ! 863: #endif DDM_DEBUG ! 864: ! 865: [cmdBuf->cmdLock lock]; ! 866: [cmdBuf->cmdLock unlockWith:YES]; ! 867: } ! 868: ! 869: /* ! 870: * Generate autosense request for specified cmdBuf, place it ! 871: * at head of pendingQ. ! 872: */ ! 873: - (void)generateAutoSense : (commandBuf *)cmdBuf ! 874: { ! 875: IOSCSIRequest *scsiReq = cmdBuf->scsiReq; ! 876: commandBuf *senseCmdBuf; ! 877: IOSCSIRequest *senseScsiReq; ! 878: cdb_6_t *cdbp; ! 879: ! 880: senseCmdBuf = IOMalloc(sizeof(commandBuf)); ! 881: senseScsiReq = IOMalloc(sizeof(IOSCSIRequest)); ! 882: bzero(senseCmdBuf, sizeof(commandBuf)); ! 883: bzero(senseScsiReq, sizeof(IOSCSIRequest)); ! 884: ! 885: /* ! 886: * commandBuf fields.... ! 887: */ ! 888: senseCmdBuf->cmdPendingSense = cmdBuf; ! 889: senseCmdBuf->op = CO_Execute; ! 890: senseCmdBuf->scsiReq = senseScsiReq; ! 891: ! 892: /* ! 893: * Get aligned sense buffer. ! 894: */ ! 895: senseCmdBuf->unalignedSense = IOMalloc(sizeof(esense_reply_t) + ! 896: (2 * AMD_READ_START_ALIGN)); ! 897: senseCmdBuf->buffer = IOAlign(void *, ! 898: senseCmdBuf->unalignedSense, ! 899: AMD_READ_START_ALIGN); ! 900: senseCmdBuf->client = IOVmTaskSelf(); ! 901: ! 902: /* ! 903: * Now IOSCSIRequest fields for request sense. ! 904: */ ! 905: senseScsiReq->target = scsiReq->target; ! 906: senseScsiReq->lun = scsiReq->lun; ! 907: senseScsiReq->read = YES; ! 908: senseScsiReq->maxTransfer = sizeof(esense_reply_t); ! 909: senseScsiReq->timeoutLength = 10; ! 910: senseScsiReq->disconnect = 0; ! 911: ! 912: cdbp = &senseScsiReq->cdb.cdb_c6; ! 913: cdbp->c6_opcode = C6OP_REQSENSE; ! 914: cdbp->c6_lun = scsiReq->lun; ! 915: cdbp->c6_len = sizeof(esense_reply_t); ! 916: senseScsiReq->driverStatus = SR_IOST_INVALID; ! 917: ! 918: /* ! 919: * This goes at the head of pendingQ; hopefully it'll be the ! 920: * next command out to the bus. ! 921: */ ! 922: ddm_thr("generateAutoSense: autosense buf 0x%x enqueued for " ! 923: "cmdBuf 0x%x\n", senseCmdBuf, cmdBuf, 3,4,5); ! 924: queue_enter_first(&pendingQ, senseCmdBuf, commandBuf *, link); ! 925: ! 926: } ! 927: ! 928: /* ! 929: * I/O associated with activeCmd has disconnected. Place it on disconnectQ ! 930: * and enable another transaction. ! 931: */ ! 932: - (void)disconnect ! 933: { ! 934: ddm_thr("DISCONNECT: cmdBuf 0x%x target %d lun %d tag %d\n", ! 935: activeCmd, activeCmd->scsiReq->target, ! 936: activeCmd->scsiReq->lun, activeCmd->queueTag, 5); ! 937: queue_enter(&disconnectQ, ! 938: activeCmd, ! 939: commandBuf *, ! 940: link); ! 941: #if DDM_DEBUG ! 942: if((activeCmd->currentByteCount != activeCmd->scsiReq->maxTransfer) && ! 943: (activeCmd->currentByteCount != 0)) { ! 944: ddm_thr("disconnect after partial DMA (max 0x%d curr 0x%x)\n", ! 945: activeCmd->scsiReq->maxTransfer, ! 946: activeCmd->currentByteCount, 3,4,5); ! 947: } ! 948: #endif DDM_DEBUG ! 949: /* ! 950: * Record this time so that activeCmd can be billed for ! 951: * disconnect latency at reselect time. ! 952: */ ! 953: IOGetTimestamp(&activeCmd->disconnectTime); ! 954: activeCmd = NULL; ! 955: /* [self busFree]; NO! fsm does this at end of hwInterrupt! */ ! 956: } ! 957: ! 958: /* ! 959: * Specified target, lun, and queueTag is trying to reselect. If we have ! 960: * a commandBuf for this TLQ nexus on disconnectQ, remove it, make it the ! 961: * current activeCmd, and return YES. Else return NO. ! 962: * A value of zero for queueTag indicates a nontagged command (zero is never ! 963: * used as the queue tag value for a tagged command). ! 964: */ ! 965: - (BOOL)reselect : (unsigned char)target_id ! 966: lun : (unsigned char)lun ! 967: queueTag : (unsigned char)queueTag ! 968: { ! 969: commandBuf *cmdBuf; ! 970: IOSCSIRequest *scsiReq; ! 971: ns_time_t currentTime; ! 972: ! 973: cmdBuf = (commandBuf *)queue_first(&disconnectQ); ! 974: while(!queue_end(&disconnectQ, (queue_t)cmdBuf)) { ! 975: ! 976: scsiReq = cmdBuf->scsiReq; ! 977: if((scsiReq->target == target_id) && ! 978: (scsiReq->lun == lun) && ! 979: (cmdBuf->queueTag == queueTag)) { ! 980: ddm_thr("RESELECT: target %d lun %d tag %d FOUND;" ! 981: "cmdBuf 0x%x\n", ! 982: target_id, lun, queueTag, cmdBuf, 5); ! 983: queue_remove(&disconnectQ, ! 984: cmdBuf, ! 985: commandBuf *, ! 986: link); ! 987: activeCmd = cmdBuf; ! 988: ! 989: /* ! 990: * Bill this operation for latency time. ! 991: */ ! 992: IOGetTimestamp(¤tTime); ! 993: scsiReq->latentTime += ! 994: (currentTime - activeCmd->disconnectTime); ! 995: return(YES); ! 996: } ! 997: /* ! 998: * Try next element in queue. ! 999: */ ! 1000: cmdBuf = (commandBuf *)cmdBuf->link.next; ! 1001: } ! 1002: ! 1003: /* ! 1004: * Hmm...this is not good! We don't want to talk to this target. ! 1005: */ ! 1006: IOLog("%s: ILLEGAL RESELECT target %d lun %d tag %d\n", ! 1007: [self name], target_id, lun, queueTag); ! 1008: return(NO); ! 1009: } ! 1010: ! 1011: /* ! 1012: * Determine if activeArray[][], maxQueue, cmdQueueEnable, and a ! 1013: * command's target and lun show that it's OK to start processing cmdBuf. ! 1014: * Returns YES if copacetic. ! 1015: */ ! 1016: - (BOOL)cmdBufOK : (commandBuf *)cmdBuf ! 1017: { ! 1018: IOSCSIRequest *scsiReq = cmdBuf->scsiReq; ! 1019: unsigned target = scsiReq->target; ! 1020: unsigned lun = scsiReq->lun; ! 1021: unsigned char active; ! 1022: unsigned char maxQ; ! 1023: ! 1024: active = activeArray[target][lun]; ! 1025: if(active == 0) { ! 1026: /* ! 1027: * Trivial quiescent case, always OK. ! 1028: */ ! 1029: return YES; ! 1030: } ! 1031: if((cmdQueueEnable == 0) || ! 1032: (perTarget[target].cmdQueueDisable)) { ! 1033: /* ! 1034: * No command queueing (either globally or for this target), ! 1035: * only one at a time. ! 1036: */ ! 1037: return NO; ! 1038: } ! 1039: maxQ = perTarget[target].maxQueue; ! 1040: if(maxQ == 0) { ! 1041: /* ! 1042: * We don't know what the target's limit is; go for it. ! 1043: */ ! 1044: return YES; ! 1045: } ! 1046: if(active >= maxQ) { ! 1047: /* ! 1048: * T/L's queue full; hold off. ! 1049: */ ! 1050: return NO; ! 1051: } ! 1052: else { ! 1053: return YES; ! 1054: } ! 1055: } ! 1056: ! 1057: /* ! 1058: * The bus has gone free. Start up a command from pendingQ, if any, and ! 1059: * if allowed by cmdQueueEnable and activeArray[][]. ! 1060: */ ! 1061: - (void)busFree ! 1062: { ! 1063: commandBuf *cmdBuf; ! 1064: ! 1065: ASSERT(activeCmd == NULL); ! 1066: if(queue_empty(&pendingQ)) { ! 1067: ddm_thr("busFree: pendingQ empty\n", 1,2,3,4,5); ! 1068: return; ! 1069: } ! 1070: ! 1071: /* ! 1072: * Attempt to find a commandBuf in pendingQ which we are in a position ! 1073: * to process. ! 1074: */ ! 1075: cmdBuf = (commandBuf *)queue_first(&pendingQ); ! 1076: while(!queue_end(&pendingQ, (queue_entry_t)cmdBuf)) { ! 1077: if([self cmdBufOK:cmdBuf]) { ! 1078: queue_remove(&pendingQ, cmdBuf, commandBuf *, link); ! 1079: ddm_thr("busFree: starting pending cmd 0x%x\n", cmdBuf, ! 1080: 2,3,4,5); ! 1081: [self threadExecuteRequest:cmdBuf]; ! 1082: return; ! 1083: } ! 1084: else { ! 1085: cmdBuf = (commandBuf *)queue_next(&cmdBuf->link); ! 1086: } ! 1087: } ! 1088: ddm_thr("busFree: pendingQ non-empty, no commands available\n", ! 1089: 1,2,3,4,5); ! 1090: } ! 1091: ! 1092: /* ! 1093: * Abort activeCmd (if any) and any disconnected I/Os (if any) and reset ! 1094: * the bus due to gross hardware failure. ! 1095: * If activeCmd is valid, its scsiReq->driverStatus will be set to 'status'. ! 1096: */ ! 1097: - (void)hwAbort : (sc_status_t)status ! 1098: reason : (const char *)reason ! 1099: { ! 1100: if(activeCmd) { ! 1101: activeCmd->scsiReq->driverStatus = status; ! 1102: [self ioComplete:activeCmd]; ! 1103: activeCmd = NULL; ! 1104: } ! 1105: [self logRegs]; ! 1106: [self threadResetBus:reason]; ! 1107: } ! 1108: ! 1109: /* ! 1110: * Called by chip level to indicate that a command has gone out to the ! 1111: * hardware. ! 1112: */ ! 1113: - (void)activateCommand : (commandBuf *)cmdBuf ! 1114: { ! 1115: unsigned char target; ! 1116: unsigned char lun; ! 1117: ! 1118: /* ! 1119: * Start timeout timer for this I/O. The timer request is cancelled ! 1120: * in ioComplete. ! 1121: */ ! 1122: cmdBuf->timeoutPort = interruptPortKern; ! 1123: #if LONG_TIMEOUT ! 1124: cmdBuf->scsiReq->timeoutLength = OUR_TIMEOUT; ! 1125: #endif LONG_TIMEOUT ! 1126: IOScheduleFunc(AMDTimeout, cmdBuf, cmdBuf->scsiReq->timeoutLength); ! 1127: ! 1128: /* ! 1129: * This is the only place where an activeArray[][] counter is ! 1130: * incremented (and, hence, the only place where cmdBuf->active is ! 1131: * set). The only other place activeCmd is set to non-NULL ! 1132: * is in reselect:lun:queueTag. ! 1133: */ ! 1134: activeCmd = cmdBuf; ! 1135: target = cmdBuf->scsiReq->target; ! 1136: lun = cmdBuf->scsiReq->lun; ! 1137: activeArray[target][lun]++; ! 1138: activeCount++; ! 1139: cmdBuf->active = 1; ! 1140: ! 1141: /* ! 1142: * Accumulate statistics. ! 1143: */ ! 1144: maxQueueLen = MAX(maxQueueLen, activeCount); ! 1145: queueLenTotal += activeCount; ! 1146: totalCommands++; ! 1147: ddm_thr("activateCommand: cmdBuf 0x%x target %d lun %d\n", ! 1148: cmdBuf, target, lun, 4,5); ! 1149: } ! 1150: ! 1151: /* ! 1152: * Remove specified cmdBuf from "active" status. Update activeArray, ! 1153: * activeCount, and unschedule pending timer. ! 1154: */ ! 1155: - (void)deactivateCmd : (commandBuf *)cmdBuf ! 1156: { ! 1157: IOSCSIRequest *scsiReq = cmdBuf->scsiReq; ! 1158: int target, lun; ! 1159: ! 1160: ASSERT(scsiReq != NULL); ! 1161: target = scsiReq->target; ! 1162: lun = scsiReq->lun; ! 1163: ddm_thr("deactivate cmdBuf 0x%x target %d lun %d activeArray %d\n", ! 1164: cmdBuf, target, lun, activeArray[target][lun], 5); ! 1165: ASSERT(activeArray[target][lun] != 0); ! 1166: activeArray[target][lun]--; ! 1167: ASSERT(activeCount != 0); ! 1168: activeCount--; ! 1169: ! 1170: /* ! 1171: * Cancel pending timeout request. Commands which timed out don't ! 1172: * have a timer request pending anymore. ! 1173: */ ! 1174: if(scsiReq->driverStatus != SR_IOST_IOTO) { ! 1175: IOUnscheduleFunc(AMDTimeout, cmdBuf); ! 1176: } ! 1177: cmdBuf->active = 0; ! 1178: } ! 1179: ! 1180: @end /* AMD_SCSI(Private) */ ! 1181: ! 1182: /* ! 1183: * Handle timeouts. We just send a timeout message to the I/O thread ! 1184: * so it wakes up. ! 1185: */ ! 1186: static void AMDTimeout(void *arg) ! 1187: { ! 1188: commandBuf *cmdBuf = arg; ! 1189: msg_header_t msg = timeoutMsgTemplate; ! 1190: ! 1191: ddm_err("AMDTimeout: cmdBuf 0x%x target %d\n", cmdBuf, ! 1192: cmdBuf->scsiReq->target, 3,4,5); ! 1193: if(!cmdBuf->active) { ! 1194: /* ! 1195: * Should never happen... ! 1196: */ ! 1197: IOLog("AMD53C974: Timeout on non-active cmdBuf\n"); ! 1198: return; ! 1199: } ! 1200: msg.msg_remote_port = cmdBuf->timeoutPort; ! 1201: IOLog("AMD53C974: SCSI Timeout\n"); ! 1202: (void) msg_send_from_kernel(&msg, MSG_OPTION_NONE, 0); ! 1203: } ! 1204:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.