![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tape.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / class|
Return to tape.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / class |
1.1 root 1: /*++
2:
3: Copyright (c) 1991 Microsoft Corporation
4:
5: Module Name:
6:
7: tape.c
8:
9: Abstract:
10:
11: This is the tape class driver.
12:
13: Authors:
14:
15: Mike Glass
16: Hunter Small
17:
18: Environment:
19:
20: kernel mode only
21:
22: Revision History:
23:
24: --*/
25:
26: #include "ntddk.h"
27: #include "tape.h"
28:
29: //
30: // The following prototypes are the internal tape class routines.
31: //
32:
33: NTSTATUS
34: DriverEntry(
35: IN PDRIVER_OBJECT DriverObject,
36: IN PUNICODE_STRING RegistryPath
37: );
38:
39: VOID
40: UpdateTapeInformationInRegistry(
41: IN PDEVICE_OBJECT DeviceObject,
42: IN PSCSI_INQUIRY_DATA ScsiInquiryData,
43: IN ULONG PortNumber,
44: IN ULONG TapeNumber
45: );
46:
47: NTSTATUS
48: CreateTapeDeviceObject(
49: IN PDRIVER_OBJECT DriverObject,
50: IN PULONG DeviceCount,
51: IN PIO_SCSI_CAPABILITIES PortCapabilities,
52: IN PSCSI_INQUIRY_DATA LunInfo,
53: IN PDEVICE_OBJECT PortDeviceObject,
54: IN ULONG PortNumber
55: );
56:
57: BOOLEAN
58: FindScsiTapes(
59: IN PDRIVER_OBJECT DriverObject,
60: IN PDEVICE_OBJECT PortDeviceObject,
61: IN ULONG PortNumber
62: );
63:
64: VOID
65: SplitTapeRequest(
66: IN PDEVICE_OBJECT DeviceObject,
67: IN PIRP Irp,
68: IN ULONG MaximumBytes
69: );
70:
71: VOID
72: ScsiTapeError(
73: PDEVICE_OBJECT DeviceObject,
74: PSCSI_REQUEST_BLOCK Srb,
75: NTSTATUS *Status,
76: BOOLEAN *Retry
77: );
78:
79: NTSTATUS
80: ScsiTapeIoCompleteAssociated(
81: IN PDEVICE_OBJECT DeviceObject,
82: IN PIRP Irp,
83: IN PVOID Context
84: );
85:
86: #ifdef ALLOC_PRAGMA
87: #pragma alloc_text(init, DriverEntry)
88: #pragma alloc_text(init, FindScsiTapes)
89: #pragma alloc_text(init, CreateTapeDeviceObject)
90: #pragma alloc_text(init, UpdateTapeInformationInRegistry)
91: #endif
92:
93: //
94: // Start of code
95: //
96:
97:
98: NTSTATUS
99: DriverEntry(
100: IN PDRIVER_OBJECT DriverObject,
101: IN PUNICODE_STRING RegistryPath
102: )
103:
104: /*++
105:
106: Routine Description:
107:
108: This is the system initialization entry point for installable drivers.
109:
110: Arguments:
111:
112: DriverObject
113:
114: Return Value:
115:
116: NT Status
117:
118: --*/
119:
120: {
121: ULONG portNumber = 0;
122: PDEVICE_OBJECT portDeviceObject;
123: NTSTATUS status;
124: STRING deviceNameString;
125: UNICODE_STRING unicodeDeviceName;
126: PFILE_OBJECT fileObject;
127: CCHAR deviceNameBuffer[256];
128: BOOLEAN tapeDeviceFound = FALSE;
129:
130: DebugPrint((1,"\n\nSCSI Tape Class Driver\n"));
131:
132: //
133: // Update driver object with entry points.
134: //
135:
136: DriverObject->MajorFunction[IRP_MJ_READ] = ScsiTapeReadWrite;
137: DriverObject->MajorFunction[IRP_MJ_WRITE] = ScsiTapeReadWrite;
138: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ScsiTapeDeviceControl;
139: DriverObject->MajorFunction[IRP_MJ_CREATE] = ScsiTapeCreate;
140:
141: //
142: // Open port driver controller device objects by name.
143: //
144:
145: do {
146:
147: sprintf(deviceNameBuffer, "\\Device\\ScsiPort%d", portNumber);
148:
149: DebugPrint((2, "ScsiTapeInitialize: Open Port %s\n", deviceNameBuffer));
150:
151: RtlInitString(&deviceNameString, deviceNameBuffer);
152:
153: status = RtlAnsiStringToUnicodeString(&unicodeDeviceName,
154: &deviceNameString,
155: TRUE
156: );
157:
158: ASSERT(NT_SUCCESS(status));
159:
160:
161: status = IoGetDeviceObjectPointer(&unicodeDeviceName,
162: FILE_READ_ATTRIBUTES,
163: &fileObject,
164: &portDeviceObject);
165:
166: if (NT_SUCCESS(status)) {
167:
168: if (FindScsiTapes(DriverObject, portDeviceObject, portNumber)) {
169: tapeDeviceFound = TRUE;
170: }
171: }
172:
173: //
174: // Check next SCSI adapter.
175: //
176:
177: portNumber++;
178:
179: } while(NT_SUCCESS(status));
180:
181: return(tapeDeviceFound ? STATUS_SUCCESS: STATUS_NO_SUCH_DEVICE);
182:
183: } // end DriverEntry()
184:
185:
186: BOOLEAN
187: FindScsiTapes(
188: IN PDRIVER_OBJECT DriverObject,
189: IN PDEVICE_OBJECT PortDeviceObject,
190: IN ULONG PortNumber
191: )
192:
193: /*++
194:
195: Routine Description:
196:
197: Call into port driver to get configuration information to find
198: tape devices.
199:
200: Arguments:
201:
202: DriverObject
203: DeviceObject - Port driver device object.
204:
205: Return Value:
206:
207: TRUE if tape device(s) found.
208:
209: --*/
210:
211: {
212: PIO_SCSI_CAPABILITIES portCapabilities;
213: PULONG tapeCount;
214: PCHAR buffer;
215: PSCSI_INQUIRY_DATA lunInfo;
216: PSCSI_ADAPTER_BUS_INFO adapterInfo;
217: PINQUIRYDATA inquiryData;
218: PCONFIGURATION_INFORMATION configInfo;
219: NTSTATUS status;
220: ULONG scsiBus;
221: BOOLEAN tapeDeviceFound = FALSE;
222:
223: //
224: // Call port driver to get adapter capabilities.
225: //
226:
227: status = ScsiClassGetCapabilities(PortDeviceObject, &portCapabilities);
228:
229: if (!NT_SUCCESS(status)) {
230: DebugPrint((1, "FindScsiTapes: ScsiClassGetCabilities failed\n"));
231:
232: }
233:
234: //
235: // Call port driver to get inquiry information to find disks.
236: //
237:
238: status = ScsiClassGetInquiryData(PortDeviceObject, (PSCSI_ADAPTER_BUS_INFO *) &buffer);
239:
240: if (!NT_SUCCESS(status)) {
241: DebugPrint((1,"FindScsiDevices: ScsiClassGetInquiryData failed\n"));
242: return FALSE;
243: }
244:
245: configInfo = IoGetConfigurationInformation();
246:
247: tapeCount = &configInfo->TapeCount;
248:
249: adapterInfo = (PVOID) buffer;
250:
251: //
252: // For each SCSI bus this adapter supports ...
253: //
254:
255: for (scsiBus=0; scsiBus < (ULONG)adapterInfo->NumberOfBuses; scsiBus++) {
256:
257: //
258: // Get the SCSI bus scan data for this bus.
259: //
260:
261: lunInfo = (PVOID) (buffer + adapterInfo->BusData[scsiBus].InquiryDataOffset);
262:
263: //
264: // Search list for unclaimed disk devices.
265: //
266:
267: while (adapterInfo->BusData[scsiBus].InquiryDataOffset) {
268:
269: inquiryData = (PVOID)lunInfo->InquiryData;
270:
271: DebugPrint((3,
272: "FindScsiTapes: Inquiry data at %lx\n",
273: inquiryData));
274:
275: if ((inquiryData->DeviceType == SEQUENTIAL_ACCESS_DEVICE) &&
276: (!lunInfo->DeviceClaimed)) {
277:
278: if (TapeVerifyInquiry(lunInfo) == TRUE) {
279:
280: status = CreateTapeDeviceObject(DriverObject,
281: tapeCount,
282: portCapabilities,
283: lunInfo,
284: PortDeviceObject,
285: PortNumber);
286:
287: if (NT_SUCCESS(status)) {
288:
289: tapeDeviceFound = TRUE;
290:
291: //
292: // Increment tape count
293: //
294:
295: (*tapeCount)++;
296:
297: }
298: }
299: }
300:
301: //
302: // Get next LunInfo.
303: //
304:
305: if (lunInfo->NextInquiryDataOffset == 0) {
306: break;
307: }
308:
309: lunInfo = (PVOID) (buffer + lunInfo->NextInquiryDataOffset);
310:
311: }
312: }
313:
314: ExFreePool(buffer);
315: return tapeDeviceFound;
316:
317: } // end FindScsiTapes()
318:
319:
320: VOID
321: UpdateTapeInformationInRegistry(
322: IN PDEVICE_OBJECT DeviceObject,
323: IN PSCSI_INQUIRY_DATA ScsiInquiryData,
324: IN ULONG PortNumber,
325: IN ULONG TapeNumber
326: )
327:
328: /*++
329:
330: Routine Description:
331:
332: This routine has knowledge about the layout of the device map information
333: in the registry. It will update this information to include a value
334: entry specifying the dos device name that is assumed to get assigned
335: to this NT device name. For more information on this assigning of the
336: dos device name look in the drive support routine in the hal that assigns
337: all dos names. Since most version of tape firmware do not work and most
338: vendor did not bother to follow the specification the entire inquiry
339: information must also be stored in the registry so than someone can
340: figure out the firmware version.
341:
342: Arguments:
343:
344: DeviceObject - A pointer to the device object for the tape device.
345:
346: ScsiInquiryData - a pointer to the scsi inquiry data structure defined in
347: ntddscsi.h
348:
349: Return Value:
350:
351: None
352:
353: --*/
354:
355: {
356: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
357: NTSTATUS status;
358: OBJECT_ATTRIBUTES objectAttributes;
359: PUCHAR buffer;
360: STRING string;
361: UNICODE_STRING unicodeName;
362: UNICODE_STRING unicodeData;
363: HANDLE targetKey;
364: PINQUIRYDATA dataBuffer;
365: SCSI_REQUEST_BLOCK srb;
366: ULONG length;
367: PCDB cdb;
368:
369: buffer = ExAllocatePool(NonPagedPool, 1024);
370: dataBuffer = ExAllocatePool(NonPagedPoolCacheAligned, MAXIMUM_TAPE_INQUIRY_DATA);
371: if (buffer == NULL || dataBuffer == NULL) {
372:
373: if (buffer != NULL) {
374: ExFreePool(buffer);
375: }
376:
377: //
378: // There is not return value for this. Since this is done at
379: // claim device time (currently only system initialization) getting
380: // the registry information correct will be the least of the worries.
381: //
382:
383: return;
384: }
385: sprintf(buffer,
386: "\\Registry\\Machine\\Hardware\\DeviceMap\\Scsi\\Scsi Port %d\\Scsi Bus %d\\Target Id %d\\Logical Unit Id %d",
387: PortNumber,
388: ScsiInquiryData->PathId,
389: ScsiInquiryData->TargetId,
390: ScsiInquiryData->Lun);
391:
392: RtlInitString(&string, buffer);
393: status = RtlAnsiStringToUnicodeString(&unicodeName,
394: &string,
395: TRUE);
396: if (NT_SUCCESS(status)) {
397:
398: //
399: // Open the registry key for the scsi information for this
400: // scsibus, target, lun.
401: //
402:
403: InitializeObjectAttributes(&objectAttributes,
404: &unicodeName,
405: OBJ_CASE_INSENSITIVE,
406: NULL,
407: NULL);
408: status = ZwOpenKey(&targetKey,
409: KEY_READ | KEY_WRITE,
410: &objectAttributes);
411: RtlFreeUnicodeString(&unicodeName);
412:
413: if (NT_SUCCESS(status)) {
414:
415: //
416: // Now construct and attempt to create the registry value
417: // specifying the device name in the appropriate place in the
418: // device map.
419: //
420:
421: RtlInitUnicodeString(&unicodeName, L"DeviceName");
422:
423: sprintf(buffer, "Tape%d", TapeNumber);
424: RtlInitString(&string, buffer);
425: RtlAnsiStringToUnicodeString(&unicodeData,
426: &string,
427: TRUE);
428: if (NT_SUCCESS(status)) {
429: status = ZwSetValueKey(targetKey,
430: &unicodeName,
431: 0,
432: REG_SZ,
433: unicodeData.Buffer,
434: unicodeData.Length);
435: RtlFreeUnicodeString(&unicodeData);
436: }
437:
438: //
439: // Now get the full inquiry information for the device.
440: //
441:
442: RtlZeroMemory(&srb, SCSI_REQUEST_BLOCK_SIZE);
443:
444: //
445: // Set timeout value.
446: //
447:
448: srb.TimeOutValue = 2;
449:
450: srb.CdbLength = 6;
451:
452: cdb = (PCDB)srb.Cdb;
453:
454: //
455: // Set CDB operation code.
456: //
457:
458: cdb->CDB6INQUIRY.OperationCode = SCSIOP_INQUIRY;
459:
460: //
461: // Set CDB LUN.
462: //
463:
464: cdb->CDB6INQUIRY.LogicalUnitNumber = deviceExtension->Lun;
465:
466: //
467: // Set allocation length to inquiry data buffer size.
468: //
469:
470: cdb->CDB6INQUIRY.AllocationLength = MAXIMUM_TAPE_INQUIRY_DATA;
471:
472: status = ScsiClassSendSrbSynchronous(DeviceObject,
473: &srb,
474: dataBuffer,
475: MAXIMUM_TAPE_INQUIRY_DATA,
476: FALSE);
477:
478: if (SRB_STATUS(srb.SrbStatus) == SRB_STATUS_SUCCESS ||
479: SRB_STATUS(srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
480:
481: //
482: // Updated the length actually transfered.
483: //
484:
485: length = dataBuffer->AdditionalLength +
486: FIELD_OFFSET(INQUIRYDATA, Reserved);
487:
488: if (length > srb.DataTransferLength) {
489: length = srb.DataTransferLength;
490: }
491:
492: RtlInitUnicodeString(&unicodeName, L"InquiryData");
493:
494: status = ZwSetValueKey(targetKey,
495: &unicodeName,
496: 0,
497: REG_BINARY,
498: dataBuffer,
499: length);
500:
501: }
502:
503: ZwClose(targetKey);
504: }
505: }
506:
507: ExFreePool(buffer);
508: ExFreePool(dataBuffer);
509: }
510:
511:
512: NTSTATUS
513: CreateTapeDeviceObject(
514: IN PDRIVER_OBJECT DriverObject,
515: IN PULONG DeviceCount,
516: IN PIO_SCSI_CAPABILITIES PortCapabilities,
517: IN PSCSI_INQUIRY_DATA LunInfo,
518: IN PDEVICE_OBJECT PortDeviceObject,
519: IN ULONG PortNumber
520: )
521:
522: /*++
523:
524: Routine Description:
525:
526: This routine creates an object for the device and then searches
527: the device for partitions and creates an object for each partition.
528:
529: Arguments:
530:
531: DriverObject - Pointer to driver object created by system.
532: DeviceCount - Pointer to number of previously installed tapes.
533: PortCapabilities - Pointer to port capabilities structure
534: LunInfo - Pointer to Logical Unit Information structure.
535: PortDeviceObject - Pointer to device object of SCSI adapter.
536: PortNumber - Number of the SCSI port.
537:
538: Return Value:
539:
540: NTSTATUS
541:
542: --*/
543:
544: {
545: CCHAR deviceNameBuffer[64];
546: CCHAR dosNameBuffer[64];
547: STRING deviceNameString;
548: UNICODE_STRING unicodeString;
549: NTSTATUS status;
550: PDEVICE_OBJECT deviceObject;
551: ULONG requiredStackSize;
552: PDEVICE_EXTENSION deviceExtension;
553: PTAPE_DATA tapeData;
554: UCHAR pathId = LunInfo->PathId;
555: UCHAR targetId = LunInfo->TargetId;
556: UCHAR lun = LunInfo->Lun;
557: PVOID senseData;
558: STRING dosString;
559: UNICODE_STRING dosUnicodeString;
560:
561: DebugPrint((3,"CreateDeviceObject: Enter routine\n"));
562:
563: //
564: // Create device object for this device.
565: //
566:
567: sprintf(deviceNameBuffer,
568: "\\Device\\Tape%d",
569: *DeviceCount);
570:
571: RtlInitString(&deviceNameString,
572: deviceNameBuffer);
573:
574: DebugPrint((2,"CreateDeviceObjects: Create device object %s\n",
575: deviceNameBuffer));
576:
577: status = RtlAnsiStringToUnicodeString(&unicodeString,
578: &deviceNameString,
579: TRUE);
580:
581: ASSERT(NT_SUCCESS(status));
582:
583: status = IoCreateDevice(DriverObject,
584: DEVICE_EXTENSION_SIZE,
585: &unicodeString,
586: FILE_DEVICE_TAPE,
587: FILE_REMOVABLE_MEDIA,
588: FALSE,
589: &deviceObject);
590:
591: if (!NT_SUCCESS(status)) {
592: DebugPrint((1,"CreateDeviceObjects: Can not create device %s\n",
593: deviceNameBuffer));
594:
595: return status;
596: }
597:
598: //
599: // Claim the device.
600: //
601:
602: status = ScsiClassClaimDevice(
603: PortDeviceObject,
604: LunInfo,
605: FALSE,
606: &PortDeviceObject
607: );
608:
609: if (!NT_SUCCESS(status)) {
610: IoDeleteDevice(deviceObject);
611: return(status);
612: }
613:
614: //
615: // Create the dos port driver name.
616: //
617:
618: sprintf(dosNameBuffer,
619: "\\DosDevices\\TAPE%d",
620: *DeviceCount);
621:
622: RtlInitString(&dosString, dosNameBuffer);
623:
624: status = RtlAnsiStringToUnicodeString(&dosUnicodeString,
625: &dosString,
626: TRUE);
627:
628: if(!NT_SUCCESS(status)) {
629: dosUnicodeString.Buffer = NULL;
630: }
631:
632: if (dosUnicodeString.Buffer != NULL && unicodeString.Buffer != NULL) {
633: IoAssignArcName(&dosUnicodeString, &unicodeString);
634: }
635:
636: if (dosUnicodeString.Buffer != NULL) {
637: RtlFreeUnicodeString(&dosUnicodeString);
638: }
639:
640: if (unicodeString.Buffer != NULL ) {
641: RtlFreeUnicodeString(&unicodeString);
642: }
643:
644: //
645: // Indicate that IRPs should include MDLs.
646: //
647:
648: deviceObject->Flags |= DO_DIRECT_IO;
649:
650: //
651: // Set up required stack size in device object.
652: //
653:
654: deviceExtension = deviceObject->DeviceExtension;
655:
656: requiredStackSize = PortDeviceObject->StackSize + 1;
657:
658: deviceExtension->PortDeviceObject = PortDeviceObject;
659:
660: //
661: // Allocate spinlock for split request completion.
662: //
663:
664: KeInitializeSpinLock(&deviceExtension->SplitRequestSpinLock);
665:
666: deviceObject->StackSize = (CCHAR)requiredStackSize;
667:
668: //
669: // Save address of port driver capabilities.
670: //
671:
672: deviceExtension->PortCapabilities = PortCapabilities;
673:
674: //
675: // Save Current Partition number and inquiry data.
676: //
677:
678: tapeData = (PTAPE_DATA )(deviceExtension + 1 );
679:
680: tapeData->CurrentPartition = 0;
681:
682: tapeData->InquiryData = LunInfo;
683:
684: //
685: // Disable synchronous transfer for tape requests.
686: //
687:
688: deviceExtension->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
689:
690: //
691: // Allocate request sense buffer.
692: //
693:
694: senseData = ExAllocatePool(NonPagedPoolCacheAligned,
695: SENSE_BUFFER_SIZE);
696:
697: if (senseData == NULL) {
698:
699: //
700: // The buffer could not be allocated.
701: //
702:
703: IoDeleteDevice(deviceObject);
704:
705: return(STATUS_INSUFFICIENT_RESOURCES);
706: }
707:
708: //
709: // Set the sense data pointer in the device extension.
710: //
711:
712: deviceExtension->SenseData = senseData;
713:
714: //
715: // TargetId/LUN describes a device location on the SCSI bus.
716: // This information comes from the inquiry buffer.
717: //
718:
719: deviceExtension->PortNumber = (UCHAR) PortNumber;
720: deviceExtension->PathId = pathId;
721: deviceExtension->TargetId = targetId;
722: deviceExtension->Lun = lun;
723:
724: //
725: // Set timeout value in seconds.
726: //
727:
728: deviceExtension->TimeOutValue = 180;
729:
730: //
731: // Back pointer to device object.
732: //
733:
734: deviceExtension->DeviceObject = deviceObject;
735:
736: //
737: // Allocate buffer for drive geometry.
738: //
739:
740: deviceExtension->DiskGeometry =
741: ExAllocatePool(NonPagedPool, sizeof(DISK_GEOMETRY));
742:
743: if (!deviceExtension->DiskGeometry) {
744:
745: ExFreePool(senseData);
746:
747: //
748: // Release device.
749: //
750:
751: ScsiClassClaimDevice(PortDeviceObject,
752: LunInfo,
753: TRUE,
754: &PortDeviceObject);
755:
756:
757: IoDeleteDevice(deviceObject);
758: return(STATUS_INSUFFICIENT_RESOURCES);
759: }
760:
761: //
762: // Initialize fixed block size of 512 bytes.
763: //
764:
765: deviceExtension->DiskGeometry->BytesPerSector = 512;
766: deviceExtension->SectorShift = 9;
767:
768: //
769: // Set tape error handler.
770: //
771:
772: deviceExtension->ClassError = ScsiTapeError;
773:
774: //
775: // Add tape device number to registry
776: //
777:
778: UpdateTapeInformationInRegistry(deviceObject,
779: LunInfo,
780: PortNumber,
781: *DeviceCount);
782:
783: return STATUS_SUCCESS;
784:
785: } // end CreateTapeDeviceObject()
786:
787:
788: NTSTATUS
789: ScsiTapeReadWrite(
790: IN PDEVICE_OBJECT DeviceObject,
791: IN PIRP Irp
792: )
793:
794: /*++
795:
796: Routine Description:
797:
798: This is the tape class driver IO handler routine. It is the system entry
799: point for read and write requests. The number of bytes in the request are
800: checked against the maximum byte counts that the adapter supports and
801: requests are broken up into smaller sizes if necessary. Then the
802: device-specific handler is called.
803:
804: Arguments:
805:
806: DeviceObject
807: Irp - IO request
808:
809: Return Value:
810:
811: NT Status
812:
813: --*/
814:
815: {
816: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
817: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
818: ULONG transferPages;
819: ULONG transferByteCount =
820: currentIrpStack->Parameters.Read.Length;
821: LARGE_INTEGER startingOffset =
822: currentIrpStack->Parameters.Read.ByteOffset;
823: ULONG maximumTransferLength =
824: deviceExtension->PortCapabilities->MaximumTransferLength;
825: NTSTATUS status;
826:
827: DebugPrint((3,"ScsiTapeRead: Enter routine\n"));
828:
829: if (DeviceObject->Flags & DO_VERIFY_VOLUME &&
830: !(currentIrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME)) {
831:
832: //
833: // if DO_VERIFY_VOLUME bit is set
834: // in device object flags, fail request.
835: //
836:
837: DebugPrint((3,"ScsiTapeRead: Volume verfication needed\n"));
838:
839: Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
840: Irp->IoStatus.Information = 0;
841:
842: IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
843:
844: IoCompleteRequest(Irp, 0);
845:
846: return STATUS_VERIFY_REQUIRED;
847: }
848:
849: //
850: // Calculate number of pages in this transfer.
851: //
852:
853: transferPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(
854: MmGetMdlVirtualAddress(Irp->MdlAddress),
855: currentIrpStack->Parameters.Read.Length);
856:
857: //
858: // Check if request length is greater than the maximum number of
859: // bytes that the hardware can transfer.
860: //
861:
862: if (currentIrpStack->Parameters.Read.Length > maximumTransferLength ||
863: transferPages > deviceExtension->PortCapabilities->MaximumPhysicalPages) {
864:
865: DebugPrint((2,"ScsiTapeRead: Request greater than maximum\n"));
866: DebugPrint((2,"ScsiTapeRead: Maximum is %lx\n",
867: maximumTransferLength));
868: DebugPrint((2,"ScsiTapeRead: Byte count is %lx\n",
869: currentIrpStack->Parameters.Read.Length));
870:
871: transferPages =
872: deviceExtension->PortCapabilities->MaximumPhysicalPages - 1;
873:
874: if (maximumTransferLength > transferPages << PAGE_SHIFT ) {
875: maximumTransferLength = transferPages << PAGE_SHIFT;
876: }
877:
878: //
879: // Check that maximum transfer size is not zero.
880: //
881:
882: if (maximumTransferLength == 0) {
883: maximumTransferLength = PAGE_SIZE;
884: }
885:
886: //
887: // Mark IRP with status pending.
888: //
889:
890: IoMarkIrpPending(Irp);
891:
892: //
893: // Request greater than port driver maximum.
894: // Break up into smaller routines.
895: //
896:
897: SplitTapeRequest(DeviceObject, Irp, maximumTransferLength);
898:
899:
900: return STATUS_PENDING;
901: }
902:
903: //
904: // Build SRB and CDB for this IRP.
905: //
906:
907: status = TapeReadWrite(DeviceObject, Irp);
908:
909: if (status == STATUS_PENDING) {
910:
911: //
912: // Return the results of the call to the port driver.
913: //
914:
915: return IoCallDriver(deviceExtension->PortDeviceObject, Irp);
916:
917: } else {
918:
919: //
920: // Complete request.
921: //
922:
923: IoCompleteRequest(Irp, 0);
924:
925: return status;
926: }
927:
928: } // end ScsiTapeReadWrite()
929:
930:
931: NTSTATUS
932: ScsiTapeDeviceControl(
933: IN PDEVICE_OBJECT DeviceObject,
934: IN PIRP Irp
935: )
936:
937: /*++
938:
939: Routine Description:
940:
941: This routine is the dispatcher for device control requests. It
942: looks at the IOCTL code and calls the appropriate tape device
943: routine.
944:
945: Arguments:
946:
947: DeviceObject
948: Irp - Request packet
949:
950: Return Value:
951:
952: --*/
953:
954: {
955: PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
956: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
957: NTSTATUS status;
958: BOOLEAN retried = FALSE;
959:
960: DebugPrint((3,"ScsiTapeDeviceControl: Enter routine\n"));
961:
962: switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
963:
964: case IOCTL_TAPE_GET_DRIVE_PARAMS:
965:
966: //
967: // Validate buffer length.
968: //
969:
970: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
971: sizeof(TAPE_GET_DRIVE_PARAMETERS)) {
972:
973: status = STATUS_INFO_LENGTH_MISMATCH;
974: break;
975: }
976:
977: status = TapeGetDriveParameters(DeviceObject, Irp);
978: break;
979:
980: case IOCTL_TAPE_SET_DRIVE_PARAMS:
981:
982: //
983: // Validate buffer length.
984: //
985:
986: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
987: sizeof(TAPE_SET_DRIVE_PARAMETERS)) {
988:
989: status = STATUS_INFO_LENGTH_MISMATCH;
990: break;
991: }
992:
993: status = TapeSetDriveParameters(DeviceObject, Irp);
994: break;
995:
996: case IOCTL_TAPE_GET_MEDIA_PARAMS:
997:
998: //
999: // Validate buffer length.
1000: //
1001:
1002: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1003: sizeof(TAPE_GET_MEDIA_PARAMETERS)) {
1004:
1005: status = STATUS_INFO_LENGTH_MISMATCH;
1006: break;
1007: }
1008:
1009: status = TapeGetMediaParameters(DeviceObject, Irp);
1010: break;
1011:
1012: case IOCTL_TAPE_SET_MEDIA_PARAMS:
1013: {
1014: PTAPE_SET_MEDIA_PARAMETERS tapeSetMediaParams =
1015: Irp->AssociatedIrp.SystemBuffer;
1016: ULONG sectorShift;
1017:
1018: //
1019: // Validate buffer length.
1020: //
1021:
1022: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1023: sizeof(TAPE_SET_MEDIA_PARAMETERS)) {
1024:
1025: status = STATUS_INFO_LENGTH_MISMATCH;
1026: break;
1027: }
1028:
1029: //
1030: // Make sure the block size is a power of 2.
1031: //
1032:
1033: WHICH_BIT(tapeSetMediaParams->BlockSize, sectorShift);
1034:
1035: if (tapeSetMediaParams->BlockSize != (ULONG)(1 << sectorShift)) {
1036:
1037: status = STATUS_INVALID_PARAMETER;
1038: break;
1039: }
1040:
1041: status = TapeSetMediaParameters(DeviceObject, Irp);
1042:
1043: if (NT_SUCCESS(status)) {
1044:
1045: //
1046: // Set the block size in the device object.
1047: //
1048:
1049: deviceExtension->DiskGeometry->BytesPerSector =
1050: tapeSetMediaParams->BlockSize;
1051: deviceExtension->SectorShift = (UCHAR)sectorShift;
1052:
1053: }
1054:
1055: break;
1056:
1057: }
1058:
1059: case IOCTL_TAPE_CREATE_PARTITION:
1060:
1061: //
1062: // Validate buffer length.
1063: //
1064:
1065: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1066: sizeof(TAPE_CREATE_PARTITION)) {
1067:
1068: status = STATUS_INFO_LENGTH_MISMATCH;
1069: break;
1070: }
1071:
1072: status = TapeCreatePartition (DeviceObject, Irp);
1073: break;
1074:
1075: case IOCTL_TAPE_ERASE:
1076:
1077: //
1078: // Validate buffer length.
1079: //
1080:
1081: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1082: sizeof(TAPE_ERASE)) {
1083:
1084: status = STATUS_INFO_LENGTH_MISMATCH;
1085: break;
1086: }
1087:
1088: status = TapeErase(DeviceObject, Irp);
1089: break;
1090:
1091: case IOCTL_TAPE_PREPARE:
1092:
1093: //
1094: // Validate buffer length.
1095: //
1096:
1097: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1098: sizeof(TAPE_PREPARE)) {
1099:
1100: status = STATUS_INFO_LENGTH_MISMATCH;
1101: break;
1102: }
1103:
1104: status = TapePrepare(DeviceObject, Irp);
1105: break;
1106:
1107: case IOCTL_TAPE_WRITE_MARKS:
1108:
1109: //
1110: // Validate buffer length.
1111: //
1112:
1113: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1114: sizeof(TAPE_WRITE_MARKS)) {
1115:
1116: status = STATUS_INFO_LENGTH_MISMATCH;
1117: break;
1118: }
1119:
1120: status = TapeWriteMarks(DeviceObject, Irp);
1121: break;
1122:
1123: case IOCTL_TAPE_GET_POSITION:
1124:
1125: //
1126: // Validate buffer length.
1127: //
1128:
1129: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1130: sizeof(TAPE_GET_POSITION)) {
1131:
1132: status = STATUS_INFO_LENGTH_MISMATCH;
1133: break;
1134: }
1135:
1136: status = TapeGetPosition(DeviceObject, Irp);
1137: break;
1138:
1139: case IOCTL_TAPE_SET_POSITION:
1140:
1141: //
1142: // Validate buffer length.
1143: //
1144:
1145: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1146: sizeof(TAPE_SET_POSITION)) {
1147:
1148: status = STATUS_INFO_LENGTH_MISMATCH;
1149: break;
1150: }
1151:
1152: status = TapeSetPosition(DeviceObject, Irp);
1153: break;
1154:
1155: case IOCTL_TAPE_GET_STATUS:
1156:
1157: status = TapeGetStatus (DeviceObject, Irp);
1158: break;
1159:
1160: default:
1161:
1162: //
1163: // Pass the request to the common device control routine.
1164: //
1165:
1166: return(ScsiClassDeviceControl(DeviceObject, Irp));
1167:
1168: } // end switch()
1169:
1170: ASSERT(status != STATUS_VERIFY_REQUIRED);
1171:
1172: //
1173: // Complete the request.
1174: //
1175:
1176: Irp->IoStatus.Status = status;
1177: IoCompleteRequest(Irp, 2);
1178:
1179: return status;
1180:
1181: } // end ScsiScsiTapeDeviceControl()
1182:
1183:
1184: NTSTATUS
1185: ScsiTapeCreate (
1186: IN PDEVICE_OBJECT DeviceObject,
1187: IN PIRP Irp
1188: )
1189:
1190: /*++
1191:
1192: Routine Description:
1193:
1194: This routine handles CREATE/OPEN requests and does
1195: nothing more than return successful status.
1196:
1197: Arguments:
1198:
1199: DeviceObject
1200: Irp
1201:
1202: Return Value:
1203:
1204: NT Status
1205:
1206: --*/
1207:
1208: {
1209: UNREFERENCED_PARAMETER(DeviceObject);
1210:
1211: Irp->IoStatus.Status = STATUS_SUCCESS;
1212:
1213: IoCompleteRequest(Irp, 0);
1214:
1215: return STATUS_SUCCESS;
1216:
1217: } // end ScsiTapeCreate()
1218:
1219:
1220: VOID
1221: SplitTapeRequest(
1222: IN PDEVICE_OBJECT DeviceObject,
1223: IN PIRP Irp,
1224: IN ULONG MaximumBytes
1225: )
1226:
1227: /*++
1228:
1229: Routine Description:
1230:
1231: Break request into smaller requests.
1232: Each new request will be the maximum transfer
1233: size that the port driver can handle or if it
1234: is the final request, it may be the residual
1235: size.
1236:
1237: The number of IRPs required to process this
1238: request is written in the current stack of
1239: the original IRP. Then as each new IRP completes
1240: the count in the original IRP is decremented.
1241: When the count goes to zero, the original IRP
1242: is completed.
1243:
1244: Arguments:
1245:
1246: DeviceObject - Pointer to the device object
1247: Irp - Pointer to Irp
1248:
1249: Return Value:
1250:
1251: None.
1252:
1253: --*/
1254:
1255: {
1256: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1257: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
1258: PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
1259: ULONG irpCount;
1260: ULONG transferByteCount =
1261: currentIrpStack->Parameters.Read.Length;
1262: PSCSI_REQUEST_BLOCK srb;
1263: LARGE_INTEGER startingOffset =
1264: currentIrpStack->Parameters.Read.ByteOffset;
1265: ULONG dataLength = MaximumBytes;
1266: PVOID dataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
1267: INTERLOCKED_RESULT remainingIrps;
1268: BOOLEAN completeOriginalIrp = FALSE;
1269: NTSTATUS status;
1270: ULONG i;
1271:
1272: //
1273: // Caluculate number of requests to break this IRP into.
1274: //
1275:
1276: irpCount = (transferByteCount + MaximumBytes - 1) / MaximumBytes;
1277:
1278: DebugPrint((2, "SplitTapeRequest: Requires %d IRPs\n", irpCount));
1279:
1280: DebugPrint((2, "SplitTapeRequest: Original IRP %lx\n", Irp));
1281:
1282: //
1283: // If all partial transfers complete successfully then
1284: // the status is already set up.
1285: // Failing partial transfer IRP will set status to
1286: // error and bytes transferred to 0 during IoCompletion.
1287: // Setting bytes transferred to 0 if an IRP
1288: // fails allows asynchronous partial transfers. This is an
1289: // optimization for the successful case. As the irps complete
1290: // with partital or full transfers they will update the bytes
1291: // transfered. This is handle as a special case since a read or
1292: // write can succeed but on part of the data is transfered.
1293: //
1294:
1295: Irp->IoStatus.Status = STATUS_SUCCESS;
1296:
1297: //
1298: // Save number of IRPs to complete count on current stack
1299: // of original IRP.
1300: //
1301:
1302: nextIrpStack->Parameters.Others.Argument1 = (PVOID)irpCount;
1303:
1304: for (i = 0; i < irpCount; i++) {
1305:
1306: PIRP newIrp;
1307: PIO_STACK_LOCATION newIrpStack;
1308:
1309: //
1310: // Allocate new IRP.
1311: //
1312:
1313: newIrp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
1314:
1315: if (newIrp == NULL) {
1316:
1317: DebugPrint((1,"SplitTapeRequest: Can't allocate Irp\n"));
1318:
1319: //
1320: // Decrement count of outstanding partial requests.
1321: //
1322:
1323: remainingIrps = ExInterlockedDecrementLong(
1324: (PLONG)&nextIrpStack->Parameters.Others.Argument1,
1325: &deviceExtension->SplitRequestSpinLock);
1326:
1327: //
1328: // Check if any outstanding IRPs.
1329: //
1330:
1331: if (remainingIrps == ResultZero) {
1332: completeOriginalIrp = TRUE;
1333: }
1334:
1335: //
1336: // Update original IRP with failing status.
1337: //
1338:
1339: Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
1340: Irp->IoStatus.Information = 0;
1341:
1342: //
1343: // Keep going with this request as outstanding partials
1344: // may be in progress.
1345: //
1346:
1347: goto KeepGoing;
1348: }
1349:
1350: DebugPrint((2, "SplitTapeRequest: New IRP %lx\n", newIrp));
1351:
1352: //
1353: // Write MDL address to new IRP.
1354: // In the port driver the SRB data length
1355: // field is used as an offset into the MDL,
1356: // so the same MDL can be used for each partial
1357: // transfer. This saves having to build a new
1358: // MDL for each partial transfer.
1359: //
1360:
1361: newIrp->MdlAddress = Irp->MdlAddress;
1362:
1363: //
1364: // At this point there is no current stack.
1365: // IoSetNextIrpStackLocation will make the
1366: // first stack location the current stack
1367: // so that the SRB address can be written
1368: // there.
1369: //
1370:
1371: IoSetNextIrpStackLocation(newIrp);
1372:
1373: newIrpStack = IoGetCurrentIrpStackLocation(newIrp);
1374:
1375: newIrpStack->MajorFunction = currentIrpStack->MajorFunction;
1376:
1377: newIrpStack->Parameters.Read.Length = dataLength;
1378: newIrpStack->Parameters.Read.ByteOffset = startingOffset;
1379:
1380: newIrpStack->DeviceObject = DeviceObject;
1381:
1382: //
1383: // Build SRB and CDB.
1384: //
1385:
1386: status = TapeReadWrite(DeviceObject, newIrp);
1387:
1388: if (!NT_SUCCESS(status)) {
1389:
1390: DebugPrint((1,"SplitTapeRequest: TapeReadWrite failed\n"));
1391:
1392: //
1393: // Decrement count of outstanding partial requests.
1394: //
1395:
1396: remainingIrps =ExInterlockedDecrementLong(
1397: (PLONG)&nextIrpStack->Parameters.Others.Argument1,
1398: &deviceExtension->SplitRequestSpinLock);
1399:
1400: //
1401: // Check if any outstanding IRPs.
1402: //
1403:
1404: if (remainingIrps == ResultZero) {
1405: completeOriginalIrp = TRUE;
1406: }
1407:
1408: //
1409: // Update original IRP with failing status.
1410: //
1411:
1412: Irp->IoStatus.Status = status;
1413: Irp->IoStatus.Information = 0;
1414:
1415: //
1416: // Deallocate this partial IRP.
1417: //
1418:
1419: IoFreeIrp(newIrp);
1420:
1421: //
1422: // Keep going with this request as outstanding partials
1423: // may be in progress.
1424: //
1425:
1426: goto KeepGoing;
1427: }
1428:
1429: //
1430: // Adjust SRB for this partial transfer.
1431: //
1432:
1433: newIrpStack = IoGetNextIrpStackLocation(newIrp);
1434:
1435: srb = newIrpStack->Parameters.Others.Argument1;
1436:
1437: srb->DataBuffer = dataBuffer;
1438:
1439: //
1440: // Write original IRP address to new IRP.
1441: //
1442:
1443: newIrp->AssociatedIrp.MasterIrp = Irp;
1444:
1445: //
1446: // Set the completion routine to ScsiTapeIoCompleteAssociated.
1447: //
1448:
1449: IoSetCompletionRoutine(newIrp,
1450: ScsiTapeIoCompleteAssociated,
1451: srb,
1452: TRUE,
1453: TRUE,
1454: TRUE);
1455:
1456: //
1457: // Call port driver with new request.
1458: //
1459:
1460: status = IoCallDriver(deviceExtension->PortDeviceObject, newIrp);
1461:
1462: if (!NT_SUCCESS(status)) {
1463:
1464: DebugPrint((1,"SplitTapeRequest: IoCallDriver returned error\n"));
1465:
1466: //
1467: // Decrement count of outstanding partial requests.
1468: //
1469:
1470: remainingIrps = ExInterlockedDecrementLong(
1471: (PLONG)&nextIrpStack->Parameters.Others.Argument1,
1472: &deviceExtension->SplitRequestSpinLock);
1473:
1474: //
1475: // Check if any outstanding IRPs.
1476: //
1477:
1478: if (remainingIrps == ResultZero) {
1479: completeOriginalIrp = TRUE;
1480: }
1481:
1482: //
1483: // Update original IRP with failing status.
1484: //
1485:
1486: Irp->IoStatus.Status = status;
1487: Irp->IoStatus.Information = 0;
1488:
1489: //
1490: // Deallocate this partial IRP.
1491: //
1492:
1493: IoFreeIrp(newIrp);
1494: }
1495:
1496: KeepGoing:
1497:
1498: //
1499: // Set up for next request.
1500: //
1501:
1502: dataBuffer = (PCHAR)dataBuffer + MaximumBytes;
1503:
1504: transferByteCount -= MaximumBytes;
1505:
1506: if (transferByteCount > MaximumBytes) {
1507:
1508: dataLength = MaximumBytes;
1509:
1510: } else {
1511:
1512: dataLength = transferByteCount;
1513: }
1514:
1515: //
1516: // Adjust disk byte offset.
1517: //
1518:
1519: startingOffset = RtlLargeIntegerAdd(startingOffset, RtlConvertUlongToLargeInteger(MaximumBytes));
1520: }
1521:
1522: //
1523: // Check if original IRP should be completed.
1524: //
1525:
1526: if (completeOriginalIrp) {
1527:
1528: IoCompleteRequest(Irp, 0);
1529: }
1530:
1531: return;
1532:
1533: } // end SplitTapeRequest()
1534:
1535:
1536: VOID
1537: ScsiTapeError(
1538: PDEVICE_OBJECT DeviceObject,
1539: PSCSI_REQUEST_BLOCK Srb,
1540: NTSTATUS *Status,
1541: BOOLEAN *Retry
1542: )
1543:
1544: /*++
1545:
1546: Routine Description:
1547:
1548: When a request completes with error, the routine ScsiClassInterpretSenseInfo is
1549: called to determine from the sense data whether the request should be
1550: retried and what NT status to set in the IRP. Then this routine is called
1551: for tape requests to handle tape-specific errors and update the nt status
1552: and retry boolean.
1553:
1554: Arguments:
1555:
1556: DeviceObject - Supplies a pointer to the device object.
1557:
1558: Srb - Supplies a pointer to the failing Srb.
1559:
1560: Status - NT Status used to set the IRP's completion status.
1561:
1562: Retry - Indicates that this request should be retried.
1563:
1564: Return Value:
1565:
1566: None.
1567:
1568: --*/
1569:
1570: {
1571: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1572: PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
1573: PIRP irp = Srb->OriginalRequest;
1574: ULONG residualBlocks;
1575: LONG length;
1576:
1577: //
1578: // Never retry tape requests.
1579: //
1580:
1581: *Retry = FALSE;
1582:
1583: //
1584: // Check that request sense buffer is valid.
1585: //
1586:
1587: if (Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) {
1588:
1589: switch (senseBuffer->SenseKey & 0xf) {
1590:
1591: case SCSI_SENSE_UNIT_ATTENTION:
1592:
1593: switch (senseBuffer->AdditionalSenseCode) {
1594:
1595: case SCSI_ADSENSE_MEDIUM_CHANGED:
1596: DebugPrint((1,
1597: "InterpretSenseInfo: Media changed\n"));
1598:
1599: *Status = STATUS_MEDIA_CHANGED;
1600:
1601: break;
1602:
1603: default:
1604: DebugPrint((1,
1605: "InterpretSenseInfo: Bus reset\n"));
1606:
1607: *Status = STATUS_BUS_RESET;
1608:
1609: break;
1610:
1611: }
1612:
1613: break;
1614:
1615: case SCSI_SENSE_RECOVERED_ERROR:
1616:
1617: //
1618: // Check other indicators
1619: //
1620:
1621: if (senseBuffer->FileMark) {
1622:
1623: switch (senseBuffer->AdditionalSenseCodeQualifier) {
1624:
1625: case SCSI_SENSEQ_SETMARK_DETECTED :
1626:
1627: DebugPrint((1,
1628: "InterpretSenseInfo: Setmark detected\n"));
1629:
1630: *Status = STATUS_SETMARK_DETECTED;
1631: break ;
1632:
1633: case SCSI_SENSEQ_FILEMARK_DETECTED :
1634: default:
1635:
1636: DebugPrint((1,
1637: "InterpretSenseInfo: Filemark detected\n"));
1638:
1639: *Status = STATUS_FILEMARK_DETECTED;
1640: break ;
1641:
1642: }
1643:
1644: } else if ( senseBuffer->EndOfMedia ) {
1645:
1646: switch( senseBuffer->AdditionalSenseCodeQualifier ) {
1647:
1648: case SCSI_SENSEQ_BEGINNING_OF_MEDIA_DETECTED :
1649:
1650: DebugPrint((1,
1651: "InterpretSenseInfo: Beginning of media detected\n"));
1652:
1653: *Status = STATUS_BEGINNING_OF_MEDIA;
1654: break ;
1655:
1656: case SCSI_SENSEQ_END_OF_MEDIA_DETECTED :
1657: default:
1658:
1659: DebugPrint((1,
1660: "InterpretSenseInfo: End of media detected\n"));
1661:
1662: *Status = STATUS_END_OF_MEDIA;
1663: break ;
1664:
1665: }
1666: }
1667:
1668: break;
1669:
1670: case SCSI_SENSE_NO_SENSE:
1671:
1672: //
1673: // Check other indicators
1674: //
1675:
1676: if (senseBuffer->FileMark) {
1677:
1678: switch( senseBuffer->AdditionalSenseCodeQualifier ) {
1679:
1680: case SCSI_SENSEQ_SETMARK_DETECTED :
1681:
1682: DebugPrint((1,
1683: "InterpretSenseInfo: Setmark detected\n"));
1684:
1685: *Status = STATUS_SETMARK_DETECTED;
1686: break ;
1687:
1688: case SCSI_SENSEQ_FILEMARK_DETECTED :
1689: default:
1690:
1691: DebugPrint((1,
1692: "InterpretSenseInfo: Filemark detected\n"));
1693:
1694: *Status = STATUS_FILEMARK_DETECTED;
1695: break ;
1696: }
1697:
1698: } else if (senseBuffer->EndOfMedia) {
1699:
1700: switch(senseBuffer->AdditionalSenseCodeQualifier) {
1701:
1702: case SCSI_SENSEQ_BEGINNING_OF_MEDIA_DETECTED :
1703:
1704: DebugPrint((1,
1705: "InterpretSenseInfo: Beginning of media detected\n"));
1706:
1707: *Status = STATUS_BEGINNING_OF_MEDIA;
1708: break ;
1709:
1710: case SCSI_SENSEQ_END_OF_MEDIA_DETECTED :
1711: default:
1712:
1713: DebugPrint((1,
1714: "InterpretSenseInfo: End of media detected\n"));
1715:
1716: *Status = STATUS_END_OF_MEDIA;
1717: break;
1718:
1719: }
1720: }
1721:
1722: break;
1723:
1724: case SCSI_SENSE_BLANK_CHECK:
1725:
1726: DebugPrint((1,
1727: "InterpretSenseInfo: Media blank check\n"));
1728:
1729: *Status = STATUS_NO_DATA_DETECTED;
1730:
1731:
1732: break;
1733:
1734: case SCSI_SENSE_VOL_OVERFLOW:
1735:
1736: DebugPrint((1,
1737: "InterpretSenseInfo: End of Media Overflow\n"));
1738:
1739: *Status = STATUS_EOM_OVERFLOW;
1740:
1741:
1742: break;
1743:
1744: case SCSI_SENSE_NOT_READY:
1745:
1746: switch (senseBuffer->AdditionalSenseCode) {
1747:
1748: case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE:
1749:
1750: DebugPrint((1,
1751: "InterpretSenseInfo:"
1752: " No Media in device.\n"));
1753: *Status = STATUS_NO_MEDIA;
1754: break;
1755: }
1756:
1757: break;
1758:
1759: } // end switch
1760:
1761: //
1762: // Check if a filemark or setmark was encountered,
1763: // or an end-of-media or no-data condition exists.
1764: //
1765:
1766: if (NT_WARNING(*Status) &&
1767: (Srb->Cdb[0] == SCSIOP_WRITE6 || Srb->Cdb[0] == SCSIOP_READ6)) {
1768:
1769: //
1770: // Not all bytes were transfered. Update information field with
1771: // number of bytes transfered from sense buffer.
1772: //
1773:
1774: if (senseBuffer->Valid) {
1775: REVERSE_BYTES((PFOUR_BYTE)&residualBlocks,
1776: (PFOUR_BYTE)senseBuffer->Information);
1777: } else {
1778: residualBlocks = 0;
1779: }
1780:
1781: length = ((PCDB) Srb->Cdb)->CDB6READWRITETAPE.TransferLenLSB;
1782: length |= ((PCDB) Srb->Cdb)->CDB6READWRITETAPE.TransferLen << 8;
1783: length |= ((PCDB) Srb->Cdb)->CDB6READWRITETAPE.TransferLenMSB << 16;
1784:
1785: length -= residualBlocks;
1786:
1787: if (length < 0) {
1788:
1789: length = 0;
1790: *Status = STATUS_IO_DEVICE_ERROR;
1791: }
1792:
1793:
1794: length *= deviceExtension->DiskGeometry->BytesPerSector;
1795:
1796: //
1797: // If the miniport indicates fewer bytes were transfered then
1798: // use that value.
1799: //
1800:
1801: if ((ULONG) length > Srb->DataTransferLength) {
1802: length = (LONG) Srb->DataTransferLength;
1803: DebugPrint((1,"ScsiTapeError: Calculated length wronge using miniport length. \n"));
1804:
1805: }
1806:
1807: irp->IoStatus.Information = length;
1808:
1809: DebugPrint((1,"ScsiTapeError: Transfer Count: %lx\n", Srb->DataTransferLength));
1810: DebugPrint((1," Residual Bytes: %lx\n", residualBlocks * deviceExtension->DiskGeometry->BytesPerSector));
1811: DebugPrint((1," Irp IoStatus Information = %lx\n", irp->IoStatus.Information));
1812: }
1813:
1814: }
1815:
1816: //
1817: // Call tape device specific error handler.
1818: //
1819:
1820: TapeError(DeviceObject->DeviceExtension,
1821: Srb,
1822: Status,
1823: Retry);
1824:
1825: return;
1826:
1827: } // end ScsiTapeError()
1828:
1829: NTSTATUS
1830: ScsiTapeIoCompleteAssociated(
1831: IN PDEVICE_OBJECT DeviceObject,
1832: IN PIRP Irp,
1833: IN PVOID Context
1834: )
1835:
1836: /*++
1837:
1838: Routine Description:
1839:
1840: This routine executes when the port driver has completed a request.
1841: It looks at the SRB status in the completing SRB and if not success
1842: it checks for valid request sense buffer information. If valid, the
1843: info is used to update status with more precise message of type of
1844: error. This routine deallocates the SRB. This routine is used for
1845: requests which were build by split request. After it has processed
1846: the request it decrements the Irp count in the master Irp. If the
1847: count goes to zero then the master Irp is completed.
1848:
1849: Arguments:
1850:
1851: DeviceObject - Supplies the device object which represents the logical
1852: unit.
1853:
1854: Irp - Supplies the Irp which has completed.
1855:
1856: Context - Supplies a pointer to the SRB.
1857:
1858: Return Value:
1859:
1860: NT status
1861:
1862: --*/
1863:
1864: {
1865: PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
1866: PSCSI_REQUEST_BLOCK srb = Context;
1867: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1868: INTERLOCKED_RESULT irpCount;
1869: PIRP originalIrp = Irp->AssociatedIrp.MasterIrp;
1870: NTSTATUS status;
1871:
1872: //
1873: // Check SRB status for success of completing request.
1874: //
1875:
1876: if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {
1877:
1878: DebugPrint((2,"ScsiTapeIoCompleteAssociated: IRP %lx, SRB %lx", Irp, srb));
1879:
1880: //
1881: // Release the queue if it is frozen.
1882: //
1883:
1884: if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
1885: ScsiClassReleaseQueue(DeviceObject);
1886: }
1887:
1888: ScsiClassInterpretSenseInfo(
1889: DeviceObject,
1890: srb,
1891: irpStack->MajorFunction,
1892: irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL ? irpStack->Parameters.DeviceIoControl.IoControlCode : 0,
1893: MAXIMUM_RETRIES - ((ULONG)irpStack->Parameters.Others.Argument4),
1894: &status);
1895:
1896: //
1897: // Return the highest error that occurs. This way warning take precedence
1898: // over success and errors take precedence over errors.
1899: //
1900:
1901: if ((ULONG) status > (ULONG) originalIrp->IoStatus.Status) {
1902:
1903: //
1904: // Ignore any requests which were flushed.
1905: //
1906:
1907: if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_REQUEST_FLUSHED) {
1908:
1909: originalIrp->IoStatus.Status = status;
1910:
1911: }
1912:
1913: }
1914:
1915:
1916: } // end if (SRB_STATUS(srb->SrbStatus) ...
1917:
1918: //
1919: // Return SRB to nonpaged pool.
1920: //
1921:
1922: if (srb->SrbFlags & SRB_FLAGS_ALLOCATED_FROM_ZONE) {
1923:
1924: ExInterlockedFreeToZone( deviceExtension->SrbZone,
1925: srb,
1926: deviceExtension->SrbZoneSpinLock);
1927:
1928: } else {
1929:
1930: ExFreePool(srb);
1931:
1932: }
1933:
1934: DebugPrint((2, "ScsiTapeIoCompleteAssociated: Partial xfer IRP %lx\n", Irp));
1935:
1936: //
1937: // Get next stack location. This original request is unused
1938: // except to keep track of the completing partial IRPs so the
1939: // stack location is valid.
1940: //
1941:
1942: irpStack = IoGetNextIrpStackLocation(originalIrp);
1943:
1944: //
1945: // Increment the status information with number of bytes transfered.
1946: //
1947:
1948: ExInterlockedAddUlong(&originalIrp->IoStatus.Information,
1949: Irp->IoStatus.Information,
1950: &deviceExtension->SplitRequestSpinLock );
1951:
1952: //
1953: //
1954: // If any of the asynchronous partial transfer IRPs fail with an error
1955: // with an error then the original IRP will return 0 bytes transfered.
1956: // This is an optimization for successful transfers.
1957: //
1958:
1959: if (NT_ERROR(originalIrp->IoStatus.Status)) {
1960:
1961: originalIrp->IoStatus.Information = 0;
1962:
1963: //
1964: // Set the hard error if necessary.
1965: //
1966:
1967: if (IoIsErrorUserInduced(originalIrp->IoStatus.Status)) {
1968:
1969: //
1970: // Store DeviceObject for filesystem.
1971: //
1972:
1973: IoSetHardErrorOrVerifyDevice(originalIrp, DeviceObject);
1974:
1975: }
1976:
1977: }
1978:
1979: //
1980: // Decrement and get the count of remaining IRPs.
1981: //
1982:
1983: irpCount = ExInterlockedDecrementLong(
1984: (PLONG)&irpStack->Parameters.Others.Argument1,
1985: &deviceExtension->SplitRequestSpinLock);
1986:
1987: DebugPrint((2, "ScsiTapeIoCompleteAssociated: Partial IRPs left %d\n",
1988: irpCount));
1989:
1990: if (irpCount == ResultZero) {
1991:
1992:
1993: #if DBG
1994: irpStack = IoGetCurrentIrpStackLocation(originalIrp);
1995:
1996: if (originalIrp->IoStatus.Information != irpStack->Parameters.Read.Length) {
1997: DebugPrint((1, "ScsiTapeIoCompleteAssociated: Short transfer. Request length: %lx, Return length: %lx, Status: %lx\n",
1998: irpStack->Parameters.Read.Length, originalIrp->IoStatus.Information, originalIrp->IoStatus.Status));
1999: }
2000: #endif
2001: //
2002: // All partial IRPs have completed.
2003: //
2004:
2005: DebugPrint((2,
2006: "ScsiTapeIoCompleteAssociated: All partial IRPs complete %lx\n",
2007: originalIrp));
2008:
2009: IoCompleteRequest(originalIrp, IO_DISK_INCREMENT);
2010: }
2011:
2012: //
2013: // Deallocate IRP and indicate the I/O system should not attempt any more
2014: // processing.
2015: //
2016:
2017: IoFreeIrp(Irp);
2018:
2019: return STATUS_MORE_PROCESSING_REQUIRED;
2020:
2021: } // end ScsiTapeIoCompleteAssociated()
2022:
2023:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.