![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mapbad.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117|
Return to mapbad.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117 |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1993 - Colorado Memory Systems, Inc. ! 4: All Rights Reserved ! 5: ! 6: Module Name: ! 7: ! 8: mapbad.c ! 9: ! 10: Abstract: ! 11: ! 12: These routines map out bad blocks. ! 13: ! 14: Revision History: ! 15: ! 16: ! 17: ! 18: ! 19: --*/ ! 20: ! 21: // ! 22: // include files ! 23: // ! 24: ! 25: #include <ntddk.h> ! 26: #include <ntddtape.h> ! 27: #include "common.h" ! 28: #include "q117.h" ! 29: #include "protos.h" ! 30: ! 31: #define SECTOR_POINTER(i,x) (((UBYTE *)ioArray[i].Data)+(x)*BYTES_PER_SECTOR) ! 32: ! 33: void ! 34: q117RotateData( ! 35: IN OUT PQ117_CONTEXT Context, ! 36: IN PIO_REQUEST IoArray, ! 37: IN int IoLast, ! 38: IN int ShiftAmount ! 39: ); ! 40: ! 41: ! 42: STATUS ! 43: q117MapBadBlock ( ! 44: IN PIO_REQUEST IoRequest, ! 45: OUT PVOID *DataPointer, ! 46: IN OUT USHORT *BytesLeft, ! 47: IN OUT SEGMENT *CurrentSegment, ! 48: IN OUT USHORT *Remainder, ! 49: IN OUT PQ117_CONTEXT Context ! 50: ) ! 51: ! 52: /*++ ! 53: ! 54: Routine Description: ! 55: ! 56: Moves existing blocks out of bad sector area and into other ! 57: segments (that already have data in them). ! 58: ! 59: Arguments: ! 60: ! 61: IoRequest - ! 62: ! 63: DataPointer - ! 64: ! 65: BytesLeft - ! 66: ! 67: CurrentSegment - ! 68: ! 69: Remainder - ! 70: ! 71: Context - ! 72: ! 73: Return Value: ! 74: ! 75: ! 76: ! 77: --*/ ! 78: ! 79: { ! 80: IO_REQUEST ioArray[UNIX_MAXBFS]; ! 81: LONG queueItemsUsed; ! 82: LONG i; ! 83: UCHAR newBadSectors; ! 84: UCHAR overflowSectors; ! 85: LONG cur_bad; ! 86: ULONG oldBadSectorMap; ! 87: ULONG currentIndex; ! 88: LONG ret; ! 89: SEGMENT currentSegment; ! 90: USHORT bytesBad; ! 91: ! 92: // ! 93: // get current queue position ! 94: // ! 95: currentIndex = q117GetQueueIndex(Context); ! 96: ! 97: // ! 98: // get the current queue list (and clear queue) ! 99: // ! 100: queueItemsUsed = 0; ! 101: ioArray[queueItemsUsed++] = *IoRequest; ! 102: CheckedDump(QIC117SHOWTD,("Re-mapping: %x ", ioArray[0].Block)); ! 103: ! 104: while (!q117QueueEmpty(Context)) { ! 105: ! 106: ioArray[queueItemsUsed++] = *q117Dequeue(FlushItem, Context); ! 107: CheckedDump(QIC117SHOWTD,("%x " , ! 108: ioArray[queueItemsUsed-1].Block)); ! 109: ! 110: } ! 111: CheckedDump(QIC117SHOWTD,("\n")); ! 112: ! 113: q117ClearQueue(Context); ! 114: ! 115: // ! 116: // write out current buffer ! 117: // ! 118: Context->CurrentOperation.UpdateBadMap = TRUE; ! 119: bytesBad = overflowSectors = 0; ! 120: currentSegment = BLOCK_TO_SEGMENT(IoRequest->Block); ! 121: cur_bad = q117CountBits(Context, currentSegment, 0l); ! 122: ! 123: while (newBadSectors = q117CountBits(NULL, 0, ! 124: (~(oldBadSectorMap = ! 125: q117ReadBadSectorList(Context, currentSegment))) & ! 126: ioArray[0].BadList)) { ! 127: ! 128: ! 129: CheckedDump(QIC117SHOWTD | QIC117SHOWBAD,("Current: %x New: %x\n" , ! 130: oldBadSectorMap, ! 131: ioArray[0].BadList ! 132: )); ! 133: ! 134: // ! 135: // add bits to bad sector map and set global flag to update bad ! 136: // sector map ! 137: // ! 138: ret = q117UpdateBadMap(Context, currentSegment, ioArray[0].BadList); ! 139: if (ret != NoErr) { ! 140: return(ret); ! 141: } ! 142: ! 143: // ! 144: // update total number of mapped out sectors ! 145: // ! 146: cur_bad += newBadSectors; ! 147: bytesBad += newBadSectors * BYTES_PER_SECTOR; ! 148: overflowSectors += newBadSectors; ! 149: ! 150: if (cur_bad+ECC_BLOCKS_PER_SEGMENT >= BLOCKS_PER_SEGMENT) { ! 151: // ! 152: // fake a write (because all data blocks are bad) ! 153: // ! 154: ioArray[0].BadList = 0; ! 155: ! 156: } else { ! 157: ! 158: // ! 159: // move extra data out of the way of correction sectors ! 160: // ! 161: CheckedDump(QIC117SHOWTD,("moving %x to %x (%x bytes)\n" , ! 162: DATA_BLOCKS_PER_SEGMENT-cur_bad, ! 163: BLOCKS_PER_SEGMENT-overflowSectors, ! 164: bytesBad)); ! 165: ! 166: RtlMoveMemory( ! 167: SECTOR_POINTER(0,BLOCKS_PER_SEGMENT-overflowSectors), ! 168: SECTOR_POINTER(0,DATA_BLOCKS_PER_SEGMENT-cur_bad), ! 169: bytesBad); ! 170: ! 171: // ! 172: // compute error correction and write out smaller chunk of data ! 173: // ! 174: q117IssIOReq( ! 175: ioArray[0].Data, ! 176: DWrite, ! 177: ioArray[0].Block, ! 178: ioArray[0].BufferInfo, ! 179: Context); ! 180: ! 181: IoRequest = q117Dequeue(WaitForItem, Context); ! 182: ! 183: if (IoRequest->Status && IoRequest->Status != BadBlk) { ! 184: return(IoRequest->Status); ! 185: } ! 186: ! 187: ! 188: // ! 189: // Get new bad sectors (if any) ! 190: // ! 191: ioArray[0].BadList = IoRequest->BadList; ! 192: ! 193: // ! 194: // move data back to contiguous form ! 195: // ! 196: CheckedDump(QIC117SHOWTD,("moving %x to %x (%x bytes)\n" , ! 197: BLOCKS_PER_SEGMENT-overflowSectors, ! 198: DATA_BLOCKS_PER_SEGMENT-cur_bad, ! 199: bytesBad)); ! 200: ! 201: RtlMoveMemory( ! 202: SECTOR_POINTER(0,DATA_BLOCKS_PER_SEGMENT-cur_bad), ! 203: SECTOR_POINTER(0,BLOCKS_PER_SEGMENT-overflowSectors), ! 204: bytesBad); ! 205: } ! 206: ! 207: } // end of while ! 208: ! 209: // ! 210: // move bytes mapped out into start of current segment ! 211: // ! 212: if (cur_bad+ECC_BLOCKS_PER_SEGMENT < BLOCKS_PER_SEGMENT) { ! 213: ! 214: CheckedDump(QIC117SHOWTD,("moving %x to %x (%x bytes)\n" , ! 215: DATA_BLOCKS_PER_SEGMENT-cur_bad, ! 216: 0, ! 217: bytesBad)); ! 218: ! 219: RtlMoveMemory( ! 220: SECTOR_POINTER(0,0), ! 221: SECTOR_POINTER(0,DATA_BLOCKS_PER_SEGMENT-cur_bad), ! 222: bytesBad); ! 223: ! 224: } ! 225: ! 226: // ! 227: // We need to skip segments with no data area (less than 4 good segments) ! 228: // ! 229: while ((*BytesLeft = q117GoodDataBytes(*CurrentSegment,Context)) <= 0) { ! 230: ++(*CurrentSegment); ! 231: } ! 232: ! 233: // ! 234: // if we hit the end of the tape or we are in the directory ! 235: // ! 236: if (*CurrentSegment == Context->CurrentOperation.LastSegment) { ! 237: // ! 238: // if fill data >= number of new bad sectors then continue ! 239: // ! 240: if (Context->CurrentOperation.BytesZeroFilled < bytesBad) { ! 241: // ! 242: // update the bad sector map and return BadBlk detected ! 243: // ! 244: if (ret = q117DoUpdateBad(Context)) ! 245: return(ret); ! 246: else ! 247: return(BadBlk); ! 248: } ! 249: } ! 250: ! 251: // ! 252: // if insufficient space in next good segment then error out ! 253: // ! 254: if (bytesBad > *BytesLeft) { ! 255: // ! 256: // update the bad sector map and return BadBlk detected ! 257: // ! 258: if (ret = q117DoUpdateBad(Context)) ! 259: return(ret); ! 260: else ! 261: return(BadBlk); ! 262: } ! 263: ! 264: // ! 265: // if more than one item was queued, move all previous data ! 266: // out of queue 0 and put overflow into queue 0. ! 267: // ! 268: ! 269: if (queueItemsUsed > 1) { ! 270: ! 271: // ! 272: // Rotate the memory through the ! 273: // buffers leaving the most recent data in the item 0 ! 274: // ! 275: q117RotateData( ! 276: Context, ! 277: ioArray, ! 278: queueItemsUsed-1, ! 279: overflowSectors ! 280: ); ! 281: } ! 282: ! 283: // ! 284: // set current queue position back (and re-queue data) ! 285: // ! 286: q117SetQueueIndex(currentIndex, Context); ! 287: ! 288: for (i=1;i<queueItemsUsed;++i) ! 289: q117IssIOReq((PVOID)NULL,DWrite,ioArray[i].Block,NULL,Context); ! 290: ! 291: // ! 292: // set the current data pointer and bytes left in buffer ! 293: // ! 294: ! 295: if (Context->CurrentOperation.BytesZeroFilled) { ! 296: ! 297: if (Context->CurrentOperation.BytesZeroFilled >= bytesBad) { ! 298: Context->CurrentOperation.BytesZeroFilled -= bytesBad; ! 299: *Remainder = 0; ! 300: } else { ! 301: *Remainder = bytesBad - Context->CurrentOperation.BytesZeroFilled; ! 302: } ! 303: ! 304: } else { ! 305: ! 306: *Remainder = bytesBad; ! 307: ! 308: } ! 309: ! 310: *DataPointer = (UCHAR *)ioArray[0].Data + *Remainder; ! 311: *BytesLeft -= *Remainder; ! 312: ! 313: return(NoErr); ! 314: } ! 315: ! 316: STATUS ! 317: q117UpdateBadMap( ! 318: IN OUT PQ117_CONTEXT Context, ! 319: IN SEGMENT Segment, ! 320: IN ULONG BadSectors ! 321: ) ! 322: ! 323: /*++ ! 324: ! 325: Routine Description: ! 326: ! 327: if bitmap bad sector map, or in bad sectors ! 328: else ! 329: make badsectors bitmap into a list of sectors ! 330: and merge them into the existing bad sector map. ! 331: ! 332: Arguments: ! 333: ! 334: IoRequest - ! 335: ! 336: DataPointer - ! 337: ! 338: BytesLeft - ! 339: ! 340: CurrentSegment - ! 341: ! 342: Remainder - ! 343: ! 344: Context - ! 345: ! 346: Return Value: ! 347: ! 348: ! 349: ! 350: --*/ ! 351: ! 352: { ! 353: BAD_LIST badList[BLOCKS_PER_SEGMENT]; ! 354: ULONG curSector; ! 355: ULONG newSector; ! 356: USHORT insertionPoint = 0; ! 357: USHORT listEnd = 0; ! 358: USHORT currentSectorIndex = 0; ! 359: UCHAR newCount; ! 360: ! 361: #if DBG ! 362: ! 363: USHORT i,j; ! 364: ULONG tmpSector; ! 365: ! 366: #endif ! 367: ! 368: if (Context->CurrentTape.TapeFormatCode == QIC_FORMAT) { ! 369: ! 370: Context->CurrentTape.BadMapPtr->BadSectors[Segment] |= ! 371: BadSectors; ! 372: ! 373: } else { ! 374: ! 375: newCount = q117CountBits(NULL, 0, ! 376: (~(q117ReadBadSectorList(Context, Segment))) & ! 377: BadSectors); ! 378: ! 379: CheckedDump(QIC117SHOWBAD,( "UpdateBadMap newCount = %d\n", newCount)); ! 380: ! 381: // Convert bad sector map (bit field) into a list of sectors ! 382: // that need to be inserted into the list ! 383: q117BadMapToBadList(Segment, ! 384: ((~(q117ReadBadSectorList(Context, Segment))) & ! 385: BadSectors), badList); ! 386: ! 387: // Get first entry to add ! 388: newSector = q117BadListEntryToSector(badList[currentSectorIndex].ListEntry); ! 389: ! 390: // Get first entry in table ! 391: curSector = q117BadListEntryToSector(Context->CurrentTape.BadMapPtr->BadList[listEnd++].ListEntry); ! 392: ! 393: // While entry in table valid, and not at end of the list ! 394: while (curSector && (listEnd < MAX_BAD_LIST) ) { ! 395: ! 396: // If entry less than new item, then increment insertionPoint ! 397: if (newSector > curSector) { ! 398: ! 399: insertionPoint++; ! 400: ! 401: } ! 402: ! 403: // Get next sector ! 404: curSector = q117BadListEntryToSector(Context->CurrentTape.BadMapPtr->BadList[listEnd++].ListEntry); ! 405: } ! 406: ! 407: // ! 408: // Now, list end will be the real end of list ! 409: // and insertionPoint will be the point at which the first ! 410: // sector int the new sector list needs to be added. ! 411: // ! 412: listEnd--; ! 413: ! 414: #if DBG ! 415: ! 416: CheckedDump(QIC117SHOWBAD,( "\n\nQ117 BSL: BSL to add ---\n")); ! 417: for (i=0; i < newCount; i++) { ! 418: tmpSector = q117BadListEntryToSector(badList[i].ListEntry); ! 419: CheckedDump(QIC117SHOWBAD,( " %08lx",tmpSector)); ! 420: if (!((i+1) % 5)) { ! 421: CheckedDump(QIC117SHOWBAD,( "\n")); ! 422: } ! 423: } ! 424: CheckedDump(QIC117SHOWBAD,( "\n")); ! 425: ! 426: #endif ! 427: ! 428: // make sure there is enough room for the new items ! 429: if ((listEnd + newCount) >= MAX_BAD_LIST) { ! 430: ! 431: return(UnusTape); ! 432: ! 433: } ! 434: ! 435: // ! 436: // While more sectors to merge ! 437: // ! 438: while (currentSectorIndex < newCount) { ! 439: ! 440: newSector = q117BadListEntryToSector( ! 441: badList[currentSectorIndex].ListEntry ! 442: ); ! 443: ! 444: // ! 445: // get new insertion point (skip any lessor sectors). First ! 446: // time through, this will already be done. ! 447: // ! 448: ! 449: while (insertionPoint <= listEnd) { ! 450: ! 451: // ! 452: // Get sector at insertionPoint ! 453: // ! 454: curSector = q117BadListEntryToSector( ! 455: Context->CurrentTape.BadMapPtr-> ! 456: BadList[insertionPoint].ListEntry ! 457: ); ! 458: ! 459: // ! 460: // if new sector is bigger than the current sector ! 461: // get the next one ! 462: // ! 463: if (newSector > curSector) { ! 464: ! 465: ++insertionPoint; ! 466: ! 467: } else { ! 468: ! 469: // We found our next insertion point ! 470: break; ! 471: ! 472: } ! 473: ! 474: } ! 475: ! 476: // ! 477: // If the sector we need to add is not the same as the current ! 478: // sector at the insertionPoint or we are past the end of the ! 479: // current list, then we need to add the sector ! 480: // to the list. ! 481: // NOTE: curSector will not be valid at end of list, but ! 482: // we don't care. ! 483: // ! 484: ! 485: if (curSector != newSector || insertionPoint > listEnd) { ! 486: ! 487: // ! 488: // make space for the new entry (if inserting) ! 489: // ! 490: if (listEnd >= insertionPoint) { ! 491: RtlMoveMemory( ! 492: Context->CurrentTape.BadMapPtr-> ! 493: BadList[insertionPoint+1].ListEntry, ! 494: Context->CurrentTape.BadMapPtr-> ! 495: BadList[insertionPoint].ListEntry, ! 496: ((ULONG)(listEnd - insertionPoint + 1) ! 497: * LIST_ENTRY_SIZE) ! 498: ); ! 499: ! 500: } ! 501: ! 502: // ! 503: // add the new entry ! 504: // ! 505: RtlMoveMemory( ! 506: Context->CurrentTape.BadMapPtr-> ! 507: BadList[insertionPoint].ListEntry, ! 508: badList[currentSectorIndex].ListEntry, ! 509: LIST_ENTRY_SIZE); ! 510: ! 511: ++insertionPoint; ! 512: ! 513: // ! 514: // we just made our list bigger ! 515: // ! 516: ++listEnd; ! 517: ! 518: } ! 519: ! 520: // ! 521: // Now get next sector to add ! 522: // ! 523: ++currentSectorIndex; ! 524: ! 525: } ! 526: ! 527: #if DBG ! 528: ! 529: CheckedDump(QIC117SHOWBAD,( "\n\nQ117 BSL: New BSL ------\n")); ! 530: for (i=0; i < listEnd; i++) { ! 531: tmpSector = q117BadListEntryToSector(Context->CurrentTape.BadMapPtr->BadList[i].ListEntry); ! 532: CheckedDump(QIC117SHOWBAD,( " %08lx",tmpSector)); ! 533: if (!((i+1) % 5)) { ! 534: CheckedDump(QIC117SHOWBAD,( "\n")); ! 535: } ! 536: } ! 537: CheckedDump(QIC117SHOWBAD,( "\n")); ! 538: ! 539: #endif ! 540: ! 541: } ! 542: ! 543: return(NoErr); ! 544: } ! 545: ! 546: VOID ! 547: q117BadMapToBadList( ! 548: IN SEGMENT Segment, ! 549: IN ULONG BadSectors, ! 550: IN BAD_LIST_PTR BadListPtr ! 551: ) ! 552: ! 553: /*++ ! 554: ! 555: Routine Description: ! 556: ! 557: Arguments: ! 558: ! 559: IoRequest - ! 560: ! 561: DataPointer - ! 562: ! 563: BytesLeft - ! 564: ! 565: CurrentSegment - ! 566: ! 567: Remainder - ! 568: ! 569: Context - ! 570: ! 571: Return Value: ! 572: ! 573: ! 574: ! 575: --*/ ! 576: ! 577: { ! 578: USHORT listIndex = 0; ! 579: ULONG sector; ! 580: ! 581: CheckedDump(QIC117SHOWBAD,( "BadMapToList Segment -> %08lx\n",Segment)); ! 582: sector = (ULONG)((Segment * BLOCKS_PER_SEGMENT) + 1); ! 583: ! 584: while (BadSectors && ! 585: (listIndex < BLOCKS_PER_SEGMENT)) { ! 586: ! 587: if (BadSectors & 1l) { ! 588: ! 589: BadListPtr[listIndex].ListEntry[0] = (UBYTE)(sector & 0xff); ! 590: BadListPtr[listIndex].ListEntry[1] = (UBYTE)((sector >> 8) & 0xff); ! 591: BadListPtr[listIndex].ListEntry[2] = (UBYTE)((sector >> 16) & 0xff); ! 592: CheckedDump(QIC117SHOWBAD,( "BadMapToList -> %08lx\n",sector)); ! 593: listIndex++; ! 594: ! 595: } ! 596: ! 597: sector++; ! 598: BadSectors >>= 1; ! 599: } ! 600: ! 601: if (listIndex < BLOCKS_PER_SEGMENT) { ! 602: ! 603: BadListPtr[listIndex].ListEntry[0] = (UBYTE)0; ! 604: BadListPtr[listIndex].ListEntry[1] = (UBYTE)0; ! 605: BadListPtr[listIndex].ListEntry[2] = (UBYTE)0; ! 606: ! 607: } ! 608: ! 609: return; ! 610: } ! 611: ! 612: ULONG ! 613: q117BadListEntryToSector( ! 614: IN UCHAR *ListEntry ! 615: ) ! 616: ! 617: /*++ ! 618: ! 619: Routine Description: ! 620: ! 621: Arguments: ! 622: ! 623: IoRequest - ! 624: ! 625: DataPointer - ! 626: ! 627: BytesLeft - ! 628: ! 629: CurrentSegment - ! 630: ! 631: Remainder - ! 632: ! 633: Context - ! 634: ! 635: Return Value: ! 636: ! 637: ! 638: ! 639: --*/ ! 640: ! 641: { ! 642: ULONG sector = 0l; ! 643: ! 644: #ifndef i386 ! 645: ! 646: sector = (UBYTE)ListEntry[2]; ! 647: sector <<= 8; ! 648: sector |= (UBYTE)ListEntry[1]; ! 649: sector <<= 8; ! 650: sector |= (UBYTE)ListEntry[0]; ! 651: ! 652: return(sector); ! 653: ! 654: #else ! 655: ! 656: return((0x00FFFFFF & *(ULONG *)ListEntry)); ! 657: ! 658: #endif ! 659: ! 660: } ! 661: ! 662: void ! 663: q117RotateData( ! 664: IN OUT PQ117_CONTEXT Context, ! 665: IN PIO_REQUEST IoArray, ! 666: IN int IoLast, ! 667: IN int ShiftAmount ! 668: ) ! 669: /*++ ! 670: ! 671: Routine Description: ! 672: ! 673: This routine shifts the data around _ShiftAmount_ times, by one ! 674: sector. ! 675: ! 676: Sample: ! 677: ! 678: IoArray[ 0 1 2 3 ! 679: data sector 0 1 2 3 4 5 6 7 8 ! 680: ! 681: Step 1: data 0 shifted up ! 682: ! 683: IoArray[ 0 1 2 3 ! 684: data sector 0 0 1 2 3 4 5 6 7 8 ! 685: s d ! 686: ! 687: Step 2: source copied to dest ! 688: ! 689: IoArray[ 0 1 2 3 ! 690: data sector 8 0 1 2 3 4 5 6 7 8 ! 691: d s ! 692: ! 693: Step 3: pointers decremented (source wraps) and source copied to dest ! 694: ! 695: IoArray[ 0 1 2 3 ! 696: data sector 8 0 1 2 3 4 5 6 7 7 ! 697: d s ! 698: ! 699: Step 4: pointers decremented and source copied to dest ! 700: ! 701: IoArray[ 0 1 2 3 ! 702: data sector 8 0 1 2 3 4 5 6 6 7 ! 703: d s ! 704: ! 705: ! 706: Step 5: pointers decremented and source copied to dest ! 707: ! 708: IoArray[ 0 1 2 3 ! 709: data sector 8 0 1 2 3 4 5 5 6 7 ! 710: d s ! 711: ! 712: ! 713: Step 6: pointers decremented and source copied to dest ! 714: ! 715: IoArray[ 0 1 2 3 ! 716: data sector 8 0 1 2 3 4 4 5 6 7 ! 717: d s ! 718: ! 719: ! 720: Step 7: pointers decremented and source copied to dest ! 721: ! 722: IoArray[ 0 1 2 3 ! 723: data sector 8 0 1 2 3 3 4 5 6 7 ! 724: d s ! 725: ! 726: ! 727: Step 8: pointers decremented and source copied to dest ! 728: ! 729: IoArray[ 0 1 2 3 ! 730: data sector 8 0 1 2 2 3 4 5 6 7 ! 731: d s ! 732: ! 733: Step 9: pointers decremented and source copied to dest ! 734: ! 735: IoArray[ 0 1 2 3 ! 736: data sector 8 0 1 1 2 3 4 5 6 7 ! 737: d s ! 738: ! 739: Step 10: pointers decremented and source copied to dest ! 740: ! 741: IoArray[ 0 1 2 3 ! 742: data sector 8 0 0 1 2 3 4 5 6 7 ! 743: d s ! 744: ! 745: Step 10: pointers decremented and source copied to dest ! 746: ! 747: IoArray[ 0 1 2 3 ! 748: data sector 8 8 0 1 2 3 4 5 6 7 ! 749: s d ! 750: ! 751: Step 11: process starts over at step 2 ! 752: ! 753: Step 12: data in buffer 0 shifted back down. ! 754: ! 755: ! 756: ! 757: Arguments: ! 758: ! 759: Return Value: ! 760: ! 761: ! 762: ! 763: --*/ ! 764: { ! 765: UCHAR *finish; ! 766: UCHAR *source; ! 767: int sourceSize; ! 768: int sourceIndex; ! 769: UCHAR *destination; ! 770: int destinationSize; ! 771: int destinationIndex; ! 772: int loop; ! 773: ! 774: // ! 775: // Shift over by one (possibly into ECC area to allow for a non ! 776: // destructive rotate. This will be shifted back after operation ! 777: // ! 778: RtlMoveMemory((UCHAR *)IoArray[0].Data + BYTES_PER_SECTOR, IoArray[0].Data, ! 779: ShiftAmount * BYTES_PER_SECTOR); ! 780: ! 781: for (loop = 0; loop < ShiftAmount; ++loop) { ! 782: ! 783: // ! 784: // Begin by overwriting area we just moved out of (see above move) ! 785: // ! 786: ! 787: destination = IoArray[0].Data; ! 788: destinationSize = BYTES_PER_SECTOR; ! 789: destinationIndex = 0; ! 790: ! 791: // ! 792: // source points to last sector in queue ! 793: // ! 794: sourceIndex = IoLast; ! 795: sourceSize = ! 796: q117GoodDataBytes( ! 797: BLOCK_TO_SEGMENT(IoArray[sourceIndex].Block), ! 798: Context ! 799: ); ! 800: source = (UCHAR *)IoArray[sourceIndex].Data + sourceSize ! 801: - BYTES_PER_SECTOR; ! 802: ! 803: finish = source; ! 804: ! 805: do { ! 806: ! 807: // ! 808: // shift the data ! 809: // ! 810: CheckedDump(QIC117SHOWTD,("shifting %x-%x[%x]{%x} to %x-%x[%x]\n" , ! 811: sourceIndex, IoArray[sourceIndex].Block, ! 812: sourceSize - BYTES_PER_SECTOR, ! 813: (ULONG *)source, ! 814: destinationIndex, IoArray[destinationIndex].Block, ! 815: destinationSize - BYTES_PER_SECTOR)); ! 816: ! 817: RtlMoveMemory(destination, source, BYTES_PER_SECTOR); ! 818: ! 819: // ! 820: // Decrement the pointer ! 821: // ! 822: destinationSize -= BYTES_PER_SECTOR; ! 823: destination -= BYTES_PER_SECTOR; ! 824: ! 825: if (destinationSize == 0) { ! 826: ! 827: if (destinationIndex == 0) { ! 828: ! 829: destinationIndex = IoLast; ! 830: ! 831: } else { ! 832: ! 833: --destinationIndex; ! 834: ! 835: } ! 836: ! 837: if (destinationIndex == 0) { ! 838: ! 839: destinationSize = (ShiftAmount+1) * BYTES_PER_SECTOR; ! 840: ! 841: } else { ! 842: ! 843: destinationSize = ! 844: q117GoodDataBytes( ! 845: BLOCK_TO_SEGMENT(IoArray[destinationIndex].Block), ! 846: Context ! 847: ); ! 848: ! 849: } ! 850: destination = (UCHAR *)IoArray[destinationIndex].Data ! 851: + destinationSize ! 852: - BYTES_PER_SECTOR; ! 853: } ! 854: ! 855: // ! 856: // Decrement the pointer ! 857: // ! 858: sourceSize -= BYTES_PER_SECTOR; ! 859: source -= BYTES_PER_SECTOR; ! 860: ! 861: // ! 862: // If we hit the begining of the buffer, ! 863: // go to the previous buffer. ! 864: // ! 865: if (sourceSize == 0) { ! 866: ! 867: if (sourceIndex == 0) { ! 868: ! 869: sourceIndex = IoLast; ! 870: ! 871: } else { ! 872: ! 873: --sourceIndex; ! 874: ! 875: } ! 876: ! 877: if (sourceIndex == 0) { ! 878: ! 879: sourceSize = (ShiftAmount+1) * BYTES_PER_SECTOR; ! 880: ! 881: } else { ! 882: ! 883: sourceSize = ! 884: q117GoodDataBytes( ! 885: BLOCK_TO_SEGMENT(IoArray[sourceIndex].Block), ! 886: Context ! 887: ); ! 888: ! 889: } ! 890: source = (UCHAR *)IoArray[sourceIndex].Data + sourceSize ! 891: - BYTES_PER_SECTOR; ! 892: } ! 893: ! 894: } while (source != finish); ! 895: ! 896: } ! 897: ! 898: // ! 899: // move the data back to the start of the buffer ! 900: // ! 901: RtlMoveMemory( ! 902: (UCHAR *)IoArray[0].Data, ! 903: (UCHAR *)IoArray[0].Data + BYTES_PER_SECTOR, ! 904: ShiftAmount * BYTES_PER_SECTOR ! 905: ); ! 906: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.