![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.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 main.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: main.c
9:
10: Abstract:
11:
12: This is the tape class driver.
13:
14: Revision History:
15:
16:
17:
18:
19: --*/
20:
21: //
22: // Includes
23: //
24:
25: #include <ntddk.h>
26: #include <ntddtape.h> // tape device driver I/O control codes
27: #include <ntiologc.h>
28: #include "common.h"
29: #include "q117.h"
30: #include "cms.h"
31: #include "protos.h"
32: #include "hilevel.h"
33: #include "q117log.h"
34:
35: //
36: // Protos for entry points
37: //
38:
39: NTSTATUS
40: q117CreateNumericKey(
41: IN HANDLE Root,
42: IN ULONG Name,
43: IN PWSTR Prefix,
44: OUT PHANDLE NewKey
45: );
46:
47: NTSTATUS
48: q117CreateRegistryInfo(
49: IN ULONG TapeNumber,
50: IN PUNICODE_STRING RegistryPath,
51: IN PQ117_CONTEXT Context
52: );
53:
54: #ifdef ALLOC_PRAGMA
55: #pragma alloc_text(init,q117Initialize)
56: #endif
57:
58:
59: //
60: // Start of code
61: //
62:
63:
64: NTSTATUS
65: q117Initialize(
66: IN PDRIVER_OBJECT DriverObject,
67: IN PDEVICE_OBJECT q117iDeviceObject,
68: IN PUNICODE_STRING RegistryPath,
69: PADAPTER_OBJECT AdapterObject,
70: ULONG NumberOfMapRegisters
71: )
72:
73: /*++
74:
75: Routine Description:
76:
77: This routine initializes the SCSI Tape class driver.
78:
79: Arguments:
80:
81: DriverObject
82:
83: Return Value:
84:
85: NT Status
86:
87: --*/
88:
89: {
90: PDEVICE_OBJECT q117DeviceObject;
91: NTSTATUS status;
92: UNICODE_STRING ntUnicodeString;
93: UCHAR ntNameBuffer[256];
94: STRING ntNameString;
95: BOOLEAN tapeDeviceFound = FALSE;
96: PQ117_CONTEXT context;
97: ULONG tapeNumber;
98: STRING dosString;
99: UNICODE_STRING dosUnicodeString;
100: CCHAR dosNameBuffer[64];
101:
102: //
103: // Build the unicode name for the floppy tape.
104: //
105: tapeNumber = IoGetConfigurationInformation()->TapeCount;
106:
107: sprintf(ntNameBuffer,
108: "\\Device\\Tape%d",
109: tapeNumber);
110:
111: RtlInitString(&ntNameString, ntNameBuffer);
112:
113: status = RtlAnsiStringToUnicodeString(
114: &ntUnicodeString,
115: &ntNameString,
116: TRUE );
117:
118: if (!NT_SUCCESS(status)) {
119: return(status);
120: }
121:
122: //
123: // Create a device object for this floppy drive.
124: //
125:
126: status = IoCreateDevice(
127: DriverObject,
128: sizeof( struct _Q117_CONTEXT ),
129: &ntUnicodeString,
130: FILE_DEVICE_UNKNOWN,
131: FILE_REMOVABLE_MEDIA,
132: FALSE,
133: &q117DeviceObject );
134:
135:
136: if (!NT_SUCCESS(status)) {
137: return(status);
138: }
139:
140: //
141: // Create the DOS port driver name.
142: //
143:
144: sprintf(dosNameBuffer,
145: "\\DosDevices\\TAPE%d",
146: tapeNumber);
147:
148: RtlInitString(&dosString, dosNameBuffer);
149:
150: status = RtlAnsiStringToUnicodeString(&dosUnicodeString,
151: &dosString,
152: TRUE);
153:
154: if (!NT_SUCCESS(status)) {
155:
156: dosUnicodeString.Buffer = NULL;
157:
158: } else {
159:
160: IoAssignArcName(&dosUnicodeString, &ntUnicodeString);
161:
162: }
163:
164: RtlFreeUnicodeString(&ntUnicodeString);
165:
166: if (dosUnicodeString.Buffer != NULL) {
167:
168: RtlFreeUnicodeString(&dosUnicodeString);
169:
170: }
171:
172:
173: //
174: // Increment system tape count.
175: //
176: ++IoGetConfigurationInformation()->TapeCount;
177:
178: //
179: // Get device extension address.
180: //
181:
182: context = q117DeviceObject->DeviceExtension;
183: context->q117iDeviceObject = q117iDeviceObject;
184:
185: //
186: // Allocate memory for the filer
187: //
188:
189: status = q117AllocatePermanentMemory(
190: context,
191: AdapterObject,
192: NumberOfMapRegisters
193: );
194:
195: if (status) {
196: IoDeleteDevice(q117DeviceObject);
197: return status;
198: }
199:
200: //
201: // Indicate MDLs required.
202: //
203:
204: q117DeviceObject->Flags = DO_DIRECT_IO;
205:
206: status = q117CreateRegistryInfo(tapeNumber, RegistryPath, context);
207:
208: q117RdsInitReed();
209:
210: return status;
211:
212: } // end Q117Initialize()
213:
214: NTSTATUS
215: q117CreateRegistryInfo(
216: IN ULONG TapeNumber,
217: IN PUNICODE_STRING RegistryPath,
218: IN PQ117_CONTEXT Context
219: )
220:
221: /*++
222:
223: Routine Description:
224:
225: This function adds Tape\Unit x to the devicemap and puts the Id info
226: and type info values in it.
227:
228: Arguments:
229:
230: tapeNumber - unit number of the tape (current tape count)
231:
232: Context - current context of the driver (this is used to
233: identify the device).
234:
235:
236: Return Value:
237:
238: Returns the status of the operation.
239:
240: --*/
241:
242: {
243: HANDLE lunKey;
244: HANDLE unitKey;
245: UNICODE_STRING ntUnicodeString;
246: UCHAR ntNameBuffer[80];
247: STRING ntNameString;
248: UNICODE_STRING name;
249: OBJECT_ATTRIBUTES objectAttributes;
250: ULONG disposition;
251: NTSTATUS status;
252:
253: //
254: // Create the Tape key in the device map.
255: //
256:
257: RtlInitUnicodeString(
258: &name,
259: L"\\Registry\\Machine\\Hardware\\DeviceMap\\Tape"
260: );
261:
262: //
263: // Initialize the object for the key.
264: //
265:
266: InitializeObjectAttributes( &objectAttributes,
267: &name,
268: OBJ_CASE_INSENSITIVE,
269: NULL,
270: (PSECURITY_DESCRIPTOR) NULL );
271:
272: //
273: // Create the key or open it.
274: //
275:
276: status = ZwCreateKey(&lunKey,
277: KEY_READ | KEY_WRITE,
278: &objectAttributes,
279: 0,
280: (PUNICODE_STRING) NULL,
281: REG_OPTION_VOLATILE,
282: &disposition );
283:
284: if (!NT_SUCCESS(status)) {
285: return status;
286: }
287:
288: status = q117CreateNumericKey(lunKey, TapeNumber, L"Unit ", &unitKey);
289:
290: ZwClose(lunKey);
291:
292: if (!NT_SUCCESS(status)) {
293: return status;
294: }
295:
296:
297: //
298: // Add Identifier value.
299: //
300:
301: RtlInitUnicodeString(&name, L"Identifier");
302:
303: status = ZwSetValueKey(
304: unitKey,
305: &name,
306: 0,
307: REG_SZ,
308: L"QIC-40/QIC-80 floppy tape drive",
309: sizeof(L"QIC-40/QIC-80 floppy tape drive")
310: );
311:
312: if ( NT_SUCCESS(status) ) {
313: //
314: // Add driver value.
315: //
316:
317: RtlInitUnicodeString(&name, L"Driver");
318:
319: status = ZwSetValueKey(
320: unitKey,
321: &name,
322: 0,
323: REG_SZ,
324: RegistryPath->Buffer,
325: RegistryPath->Length
326: );
327: }
328:
329: if ( NT_SUCCESS(status) ) {
330: //
331: // Add DeviceName value.
332: //
333:
334: RtlInitUnicodeString(&name, L"DeviceName");
335:
336: sprintf(ntNameBuffer,
337: "Tape%d",
338: TapeNumber);
339:
340: RtlInitString(&ntNameString, ntNameBuffer);
341:
342: status = RtlAnsiStringToUnicodeString(&ntUnicodeString,
343: &ntNameString,
344: TRUE);
345:
346: status = ZwSetValueKey(
347: unitKey,
348: &name,
349: 0,
350: REG_SZ,
351: ntUnicodeString.Buffer,
352: ntUnicodeString.Length
353: );
354:
355: RtlFreeUnicodeString(&ntUnicodeString);
356: }
357:
358: if ( NT_SUCCESS(status) ) {
359: //
360: // Add UniqueID
361: //
362:
363: RtlInitUnicodeString(&name, L"UniqueId");
364:
365: status = ZwSetValueKey(
366: unitKey,
367: &name,
368: 0,
369: REG_SZ,
370: L"",
371: 0
372: );
373: }
374:
375:
376: ZwClose(unitKey);
377:
378: return status;
379:
380: } // end q117CreateRegistryInfo
381:
382: NTSTATUS
383: q117CreateNumericKey(
384: IN HANDLE Root,
385: IN ULONG Name,
386: IN PWSTR Prefix,
387: OUT PHANDLE NewKey
388: )
389:
390: /*++
391:
392: Routine Description:
393:
394: This function creates a registry key. The name of the key is a string
395: version of numeric value passed in.
396:
397: Arguments:
398:
399: RootKey - Supplies a handle to the key where the new key should be inserted.
400:
401: Name - Supplies the numeric value to name the key.
402:
403: Prefix - Supplies a prefix name to add to name.
404:
405: NewKey - Returns the handle for the new key.
406:
407: Return Value:
408:
409: Returns the status of the operation.
410:
411: --*/
412:
413: {
414:
415: UNICODE_STRING string;
416: UNICODE_STRING stringNum;
417: OBJECT_ATTRIBUTES objectAttributes;
418: WCHAR bufferNum[16];
419: WCHAR buffer[64];
420: ULONG disposition;
421: NTSTATUS status;
422:
423: //
424: // Copy the Prefix into a string.
425: //
426:
427: string.Length = 0;
428: string.MaximumLength=64;
429: string.Buffer = buffer;
430:
431: RtlInitUnicodeString(&stringNum, Prefix);
432:
433: RtlCopyUnicodeString(&string, &stringNum);
434:
435: //
436: // Create a port number key entry.
437: //
438:
439: stringNum.Length = 0;
440: stringNum.MaximumLength = 16;
441: stringNum.Buffer = bufferNum;
442:
443: status = RtlIntegerToUnicodeString(Name, 10, &stringNum);
444:
445: if (!NT_SUCCESS(status)) {
446: return status;
447: }
448:
449: //
450: // Append the prefix and the numeric name.
451: //
452:
453: RtlAppendUnicodeStringToString(&string, &stringNum);
454:
455: InitializeObjectAttributes( &objectAttributes,
456: &string,
457: OBJ_CASE_INSENSITIVE,
458: Root,
459: (PSECURITY_DESCRIPTOR) NULL );
460:
461: status = ZwCreateKey(NewKey,
462: KEY_READ | KEY_WRITE,
463: &objectAttributes,
464: 0,
465: (PUNICODE_STRING) NULL,
466: REG_OPTION_VOLATILE,
467: &disposition );
468:
469: return(status);
470:
471: } // end q117CreateNumericKey
472:
473: NTSTATUS
474: q117Read(
475: IN PDEVICE_OBJECT DeviceObject,
476: IN PIRP Irp
477: )
478:
479: /*++
480:
481: Routine Description:
482:
483: This is the tape class driver IO handler routine.
484:
485: Arguments:
486:
487: DeviceObject
488: Irp - IO request
489:
490: Return Value:
491:
492: NT Status
493:
494: --*/
495:
496: {
497:
498: PIO_STACK_LOCATION currentIrpStack;
499: KIRQL currentIrql;
500: STATUS status;
501: NTSTATUS ntStatus;
502: PVOID usrBuf;
503: PQ117_CONTEXT context;
504: ULONG amount;
505: BOOLEAN endOfVolume = FALSE;
506:
507:
508: context = DeviceObject->DeviceExtension;
509: currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
510:
511: status = NoErr;
512: ntStatus = STATUS_SUCCESS;
513:
514: //
515: // If this is the first read, find the NT volume and read
516: if (context->CurrentOperation.Type == NoOperation) {
517:
518: ntStatus = q117OpenForRead(
519: context->CurrentOperation.BytesRead,
520: context,
521: DeviceObject);
522:
523: if (ntStatus == STATUS_NO_DATA_DETECTED) {
524:
525: //
526: // Flag no bytes read (end of media, end of data, etc.)
527: //
528:
529: ntStatus = STATUS_SUCCESS;
530: Irp->IoStatus.Information = 0;
531: endOfVolume = TRUE;
532:
533: }
534:
535: }
536:
537:
538: if (NT_SUCCESS(ntStatus)) {
539:
540: //
541: // Return the results of the call to the port driver.
542: //
543: usrBuf = MmGetSystemAddressForMdl(Irp->MdlAddress);
544:
545: //
546: // Check to see if user is asking for more data than is there
547: // (bytes on tape - current offset)
548: //
549:
550: amount = currentIrpStack->Parameters.Read.Length;
551:
552: ntStatus = q117ConvertStatus(
553: DeviceObject,
554: q117ReadTape(usrBuf,&amount,context)
555: );
556:
557: //
558: // Set the amount read to the amount we copied out of the buffer
559: //
560: Irp->IoStatus.Information = amount;
561:
562: CheckedDump(QIC117SHOWTD,("%x=Read(%x) - Status: %x\n",amount,currentIrpStack->Parameters.Read.Length, status));
563:
564: }
565:
566: if (endOfVolume && NT_SUCCESS(ntStatus)) {
567:
568: status = STATUS_NO_DATA_DETECTED;
569:
570: }
571:
572: Irp->IoStatus.Status = ntStatus;
573:
574: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
575: IoCompleteRequest(Irp, 0);
576: KeLowerIrql(currentIrql);
577:
578: return ntStatus;
579:
580:
581: } // end Q117Read()
582:
583:
584: NTSTATUS
585: q117Write(
586: IN PDEVICE_OBJECT DeviceObject,
587: IN PIRP Irp
588: )
589:
590: /*++
591:
592: Routine Description:
593:
594: This is the tape class driver IO handler routine.
595:
596: Arguments:
597:
598: DeviceObject
599: Irp - IO request
600:
601: Return Value:
602:
603: NT Status
604:
605: --*/
606:
607: {
608:
609: PIO_STACK_LOCATION currentIrpStack;
610: KIRQL currentIrql;
611: STATUS status;
612: NTSTATUS ntStatus;
613: PVOID usrBuf;
614: PQ117_CONTEXT context;
615:
616: context = DeviceObject->DeviceExtension;
617: currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
618:
619: //
620: // Make sure we are in write mode
621: //
622: status = q117OpenForWrite(context);
623:
624: if (!status) {
625:
626: //
627: // Return the results of the call to the port driver.
628: //
629: usrBuf = MmGetSystemAddressForMdl(Irp->MdlAddress);
630:
631: status = q117WriteTape(usrBuf,currentIrpStack->Parameters.Write.Length,context);
632: //
633: // Set the amount written to the amount we copied out of the buffer
634: //
635: if (!status || status == EarlyWarning)
636: Irp->IoStatus.Information = currentIrpStack->Parameters.Write.Length;
637: }
638:
639: ntStatus = q117ConvertStatus(DeviceObject, status);
640:
641: Irp->IoStatus.Status = ntStatus;
642:
643: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
644: IoCompleteRequest(Irp, 0);
645: KeLowerIrql(currentIrql);
646:
647: return ntStatus;
648:
649: } // end Q117Write()
650:
651: NTSTATUS
652: q117ConvertStatus(
653: IN PDEVICE_OBJECT DeviceObject,
654: IN STATUS Status
655: )
656: {
657: NTSTATUS ntStatus;
658: PQ117_CONTEXT context;
659: BOOLEAN suppressLog = FALSE;
660:
661: context = DeviceObject->DeviceExtension;
662:
663: switch(Status) {
664: case NoVols:
665: case InvalVol:
666: case EndOfVol:
667: // or maybe STATUS_END_OF_RECORDED_DATA?
668: ntStatus = STATUS_NO_DATA_DETECTED;
669: suppressLog = TRUE;
670: break;
671:
672: case EarlyWarning:
673: ntStatus = STATUS_END_OF_MEDIA;
674: suppressLog = TRUE;
675: break;
676:
677: case NoTape:
678: ntStatus = STATUS_NO_MEDIA_IN_DEVICE;
679: break;
680:
681: case NoErr:
682: ntStatus = STATUS_SUCCESS;
683: break;
684:
685: #ifndef NO_MARKS
686: case FileMark:
687: case LongFileMark:
688: case ShortFileMark:
689: ntStatus = STATUS_FILEMARK_DETECTED;
690: suppressLog = TRUE;
691: break;
692:
693: case SetMark:
694: ntStatus = STATUS_SETMARK_DETECTED;
695: suppressLog = TRUE;
696: break;
697: #endif
698:
699: case UnknownFormat:
700: case Unformat:
701: case BadFmt:
702: ntStatus = STATUS_UNRECOGNIZED_MEDIA;
703: break;
704:
705: case FMemErr:
706: ntStatus = STATUS_INSUFFICIENT_RESOURCES;
707: break;
708:
709: case WProt:
710: ntStatus = STATUS_MEDIA_WRITE_PROTECTED;
711: break;
712:
713: case NewCart:
714: ntStatus = STATUS_MEDIA_CHANGED;
715: break;
716:
717: case UpdErr:
718: case BadTape:
719: ntStatus = STATUS_DATA_ERROR;
720: break;
721:
722: case RdncUnsc:
723: ntStatus = STATUS_CRC_ERROR;
724: break;
725:
726: default:
727: CheckedDump(QIC117DBGP,("Error %d reported\n",Status));
728: ntStatus = (NTSTATUS)(STATUS_SEVERITY_WARNING << 30);
729: ntStatus |= (FILE_DEVICE_TAPE << 16) & 0x3fff0000;
730: ntStatus |= Status & 0x0000ffff;
731:
732: }
733:
734: if (Status != NoErr && !suppressLog) {
735: NTSTATUS logStatus = q117MapStatus(Status);
736:
737: if (logStatus != QIC117_NOTAPE) {
738: CheckedDump(QIC117SHOWTD,("Error %d logged\n",Status));
739:
740: q117LogError(
741: DeviceObject,
742: context->ErrorSequence++,
743: context->MajorFunction,
744: 0,
745: Status,
746: ntStatus,
747: logStatus
748: );
749: }
750:
751: } else {
752: #if DBG
753: if (Status) {
754: CheckedDump(QIC117SHOWTD,("Error %d reported to API\n",Status));
755: }
756: #endif
757: }
758:
759: return ntStatus;
760: }
761:
762: NTSTATUS q117MapStatus(
763: IN STATUS Status
764: )
765: {
766: NTSTATUS mapped;
767:
768: switch(Status) {
769: case UnusTape:
770: mapped = QIC117_UNUSTAPE;
771: break;
772: case BadTape:
773: mapped = QIC117_BADTAPE;
774: break;
775: case FMemErr:
776: mapped = QIC117_FMEMERR;
777: break;
778: case TapeFull:
779: mapped = QIC117_TAPEFULL;
780: break;
781: case VolFull:
782: mapped = QIC117_VOLFULL;
783: break;
784: case RdncUnsc:
785: mapped = QIC117_RDNCUNSC;
786: break;
787: case EndOfVol:
788: mapped = QIC117_ENDOFVOL;
789: break;
790: case FCodeErr:
791: mapped = QIC117_FCODEERR;
792: break;
793: case UpdErr:
794: mapped = QIC117_UPDERR;
795: break;
796: case InvalVol:
797: mapped = QIC117_INVALVOL;
798: break;
799: case NoVols:
800: mapped = QIC117_NOVOLS;
801: break;
802: case Unformat:
803: mapped = QIC117_UNFORMAT;
804: break;
805: case UnknownFormat:
806: mapped = QIC117_UNKNOWNFORMAT;
807: break;
808: case BadBlk:
809: mapped = QIC117_BADBLK;
810: break;
811: case EndTapeErr:
812: mapped = QIC117_ENDTAPEERR;
813: break;
814: case DriveFlt:
815: mapped = QIC117_DRIVEFLT;
816: break;
817: case WProt:
818: mapped = QIC117_WPROT;
819: break;
820: case NoTape:
821: mapped = QIC117_NOTAPE;
822: break;
823: case SeekErr:
824: mapped = QIC117_SEEKERR;
825: break;
826: case NoDrive:
827: mapped = QIC117_NODRIVE;
828: break;
829: case InvalCmd:
830: mapped = QIC117_INVALCMD;
831: break;
832: case CodeErr:
833: mapped = QIC117_CODEERR;
834: break;
835: case NECFlt:
836: mapped = QIC117_NECFLT;
837: break;
838: case NoFDC:
839: mapped = QIC117_NOFDC;
840: break;
841: case BadFmt:
842: mapped = QIC117_BADFMT;
843: break;
844: case CmdFlt:
845: mapped = QIC117_CMDFLT;
846: break;
847: case BadNEC:
848: mapped = QIC117_BADNEC;
849: break;
850: case BadReq:
851: mapped = QIC117_BADREQ;
852: break;
853: case TooFast:
854: mapped = QIC117_TOOFAST;
855: break;
856: case NoData:
857: mapped = QIC117_NODATA;
858: break;
859: case DAbort:
860: mapped = QIC117_DABORT;
861: break;
862: case TapeFlt:
863: mapped = QIC117_TAPEFLT;
864: break;
865: case UnspRate:
866: mapped = QIC117_UNSPRATE;
867: break;
868: case Already:
869: mapped = QIC117_ALREADY;
870: break;
871: case TooNoisy:
872: mapped = QIC117_TOONOISY;
873: break;
874: case TimeOut:
875: mapped = QIC117_TIMEOUT;
876: break;
877: case BadMark:
878: mapped = QIC117_BADMARK;
879: break;
880: case NewCart:
881: mapped = QIC117_NEWCART;
882: break;
883: case WrongFmt:
884: mapped = QIC117_WRONGFMT;
885: break;
886: case FmtMisMatch:
887: mapped = QIC117_FMTMISMATCH;
888: break;
889: case IncompTapeFmt:
890: mapped = QIC117_INCOMPTAPEFMT;
891: break;
892: case SCSIFmtMsmtch:
893: mapped = QIC117_SCSIFMTMSMTCH;
894: break;
895: case QIC40InEagle:
896: mapped = QIC117_QIC40INEAGLE;
897: break;
898: case QIC80InEagle:
899: mapped = QIC117_QIC80INEAGLE;
900: break;
901: case ControllerBusy:
902: mapped = QIC117_CONTROLLERBUSY;
903: break;
904: case InQue:
905: mapped = QIC117_INQUE;
906: break;
907: case SplitRequests:
908: mapped = QIC117_SPLITREQUESTS;
909: break;
910: case EarlyWarning:
911: mapped = QIC117_EARLYWARNING;
912: break;
913: default:
914: mapped = QIC117_BOGUS;
915: }
916: return mapped;
917: }
918:
919: NTSTATUS
920: q117DeviceControl(
921: IN PDEVICE_OBJECT DeviceObject,
922: IN PIRP Irp
923: )
924:
925: /*++
926:
927: Routine Description:
928:
929: This routine is the dispatcher for device control requests. It
930: looks at the IOCTL code and calls the appropriate tape device
931: routine.
932:
933: Arguments:
934:
935: DeviceObject
936: Irp - Request packet
937:
938: Return Value:
939:
940: --*/
941:
942: {
943: PIO_STACK_LOCATION irpStack;
944: KIRQL currentIrql;
945: NTSTATUS status;
946: PQ117_CONTEXT context;
947:
948: context = DeviceObject->DeviceExtension;
949: irpStack = IoGetCurrentIrpStackLocation(Irp);
950:
951: status = 0;
952:
953: CheckedDump(QIC117SHOWPOLL,("Curmark: %x TotalMarks: %x\n", context->CurrentMark, context->MarkArray.TotalMarks));
954:
955: switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
956:
957: case IOCTL_TAPE_GET_DRIVE_PARAMS:
958:
959: status = q117IoCtlGetDriveParameters(DeviceObject, Irp);
960: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_GET_DRIVE_PARAMS done"));
961: break;
962:
963: case IOCTL_TAPE_SET_DRIVE_PARAMS:
964:
965: status = q117IoCtlSetDriveParameters(DeviceObject, Irp);
966: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_SET_DRIVE_PARAMS done"));
967: break;
968:
969: case IOCTL_TAPE_GET_MEDIA_PARAMS:
970:
971: status = q117IoCtlGetMediaParameters(DeviceObject, Irp);
972: CheckedDump(QIC117SHOWPOLL,("IOCTL_TAPE_GET_MEDIA_PARAMS done"));
973: break;
974:
975: case IOCTL_TAPE_SET_MEDIA_PARAMS:
976:
977: status = q117IoCtlSetMediaParameters(DeviceObject, Irp);
978: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_SET_MEDIA_PARAMS done\n"));
979: break;
980:
981: case IOCTL_TAPE_CREATE_PARTITION:
982:
983: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_CREATE_PARTITION attempted\n"));
984: status = STATUS_INVALID_DEVICE_REQUEST;
985: break;
986:
987: case IOCTL_TAPE_ERASE:
988:
989: status = q117IoCtlErase(DeviceObject, Irp);
990: CheckedDump(QIC117SHOWTD,("Curmark: %x TotalMarks: %x\n", context->CurrentMark, context->MarkArray.TotalMarks));
991: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_ERASE done"));
992: break;
993:
994: case IOCTL_TAPE_PREPARE:
995:
996: status = q117IoCtlPrepare(DeviceObject, Irp);
997: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_PREPARE done"));
998: break;
999:
1000: case IOCTL_TAPE_WRITE_MARKS:
1001:
1002: status = q117IoCtlWriteMarks(DeviceObject, Irp);
1003: CheckedDump(QIC117SHOWTD,("Curmark: %x TotalMarks: %x\n", context->CurrentMark, context->MarkArray.TotalMarks));
1004: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_WRITE_MARKS done"));
1005: break;
1006:
1007: case IOCTL_TAPE_GET_POSITION:
1008:
1009: status = q117IoCtlGetPosition(DeviceObject, Irp);
1010: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_GET_POSITION done"));
1011: break;
1012:
1013: case IOCTL_TAPE_SET_POSITION:
1014:
1015: status = q117IoCtlSetPosition(DeviceObject, Irp);
1016: CheckedDump(QIC117SHOWTD,("Curmark: %x TotalMarks: %x\n", context->CurrentMark, context->MarkArray.TotalMarks));
1017: CheckedDump(QIC117SHOWTD,("IOCTL_TAPE_SET_POSITION done"));
1018: break;
1019:
1020: case IOCTL_TAPE_GET_STATUS:
1021:
1022: status = q117IoCtlGetStatus (DeviceObject, Irp);
1023: CheckedDump(QIC117SHOWPOLL,("IOCTL_TAPE_GET_STATUS done"));
1024: break;
1025:
1026: case IOCTL_CMS_WRITE_ABS_BLOCK:
1027:
1028: status = q117IoCtlWriteAbs(DeviceObject, Irp);
1029: CheckedDump(QIC117SHOWTD,("IOCTL_CMS_WRITE_ABS_BLOCK done"));
1030: break;
1031:
1032: case IOCTL_CMS_READ_ABS_BLOCK:
1033:
1034: status = q117IoCtlReadAbs(DeviceObject, Irp);
1035: CheckedDump(QIC117SHOWTD,("IOCTL_CMS_READ_ABS_BLOCK done"));
1036: break;
1037:
1038:
1039: default:
1040:
1041: status = STATUS_INVALID_DEVICE_REQUEST;
1042:
1043: } // end switch()
1044:
1045: //
1046: // Complete the request.
1047: //
1048:
1049: CheckedDump(QIC117SHOWTD,(" -- Status: %x\n",status));
1050: Irp->IoStatus.Status = status;
1051:
1052: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
1053: IoCompleteRequest(Irp, 2);
1054: KeLowerIrql(currentIrql);
1055:
1056: return status;
1057:
1058: } // end Q117DeviceControl()
1059:
1060:
1061: NTSTATUS
1062: q117Create (
1063: IN PDEVICE_OBJECT DeviceObject,
1064: IN PIRP Irp
1065: )
1066:
1067: /*++
1068:
1069: Routine Description:
1070:
1071: This routine handles CREATE/OPEN requests and does
1072: nothing more than return successful status.
1073:
1074: Arguments:
1075:
1076: DeviceObject
1077: Irp
1078:
1079: Return Value:
1080:
1081: NT Status
1082:
1083: --*/
1084:
1085: {
1086: KIRQL currentIrql;
1087: PQ117_CONTEXT context;
1088: NTSTATUS ntStatus;
1089:
1090: context = DeviceObject->DeviceExtension;
1091:
1092: if (!context->DriverOpened) {
1093:
1094: ntStatus = q117ConvertStatus(DeviceObject, q117Start(context));
1095:
1096: //
1097: // If everything went OK, then flag that the driver is now open
1098: //
1099: if (NT_SUCCESS(ntStatus)) {
1100: context->DriverOpened = TRUE;
1101: } else {
1102: q117Stop(context);
1103: }
1104:
1105: } else {
1106:
1107: ntStatus = STATUS_DEVICE_BUSY;
1108:
1109: }
1110:
1111: Irp->IoStatus.Status = ntStatus;
1112:
1113: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
1114: IoCompleteRequest(Irp, 0);
1115: KeLowerIrql(currentIrql);
1116:
1117: return ntStatus;
1118:
1119: } // end Q117Create()
1120:
1121: NTSTATUS
1122: q117Close (
1123: IN PDEVICE_OBJECT DeviceObject,
1124: IN PIRP Irp
1125: )
1126:
1127: /*++
1128:
1129: Routine Description:
1130:
1131:
1132: Arguments:
1133:
1134: DeviceObject
1135: Irp
1136:
1137: Return Value:
1138:
1139: NT Status
1140:
1141: --*/
1142:
1143: {
1144: KIRQL currentIrql;
1145: PQ117_CONTEXT context;
1146: NTSTATUS ntStatus;
1147:
1148: context = DeviceObject->DeviceExtension;
1149:
1150: ntStatus = q117ConvertStatus(DeviceObject, q117Stop(context));
1151:
1152: context->DriverOpened = FALSE;
1153:
1154: Irp->IoStatus.Status = ntStatus;
1155:
1156: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
1157: IoCompleteRequest(Irp, 0);
1158: KeLowerIrql(currentIrql);
1159:
1160: return ntStatus;
1161:
1162: } // end Q117Close()
1163:
1164: VOID
1165: q117LogError(
1166: IN PDEVICE_OBJECT DeviceObject,
1167: IN ULONG SequenceNumber,
1168: IN UCHAR MajorFunctionCode,
1169: IN UCHAR RetryCount,
1170: IN ULONG UniqueErrorValue,
1171: IN NTSTATUS FinalStatus,
1172: IN NTSTATUS SpecificIOStatus
1173: )
1174:
1175: /*++
1176:
1177: Routine Description:
1178:
1179: This routine allocates an error log entry, copies the supplied data
1180: to it, and requests that it be written to the error log file.
1181:
1182: Arguments:
1183:
1184: DeviceObject - a pointer to the device object associated with the
1185: device that had the error.
1186:
1187: SequenceNumber - A ulong value that is unique to an IRP over the
1188: life of the irp in this driver - 0 generally means an error not
1189: associated with an irp.
1190:
1191: MajorFunctionCode - If there is an error associated with the irp,
1192: this is the major function code of that irp.
1193:
1194: RetryCount - The number of times a particular operation has been
1195: retried.
1196:
1197: UniqueErrorValue - A unique long word that identifies the particular
1198: call to this function.
1199:
1200: FinalStatus - The final status given to the irp that was associated
1201: with this error. If this log entry is being made during one of
1202: the retries this value will be STATUS_SUCCESS.
1203:
1204: SpecificIOStatus - The IO status for a particular error.
1205:
1206: Return Value:
1207:
1208: None.
1209:
1210: --*/
1211:
1212: {
1213: PIO_ERROR_LOG_PACKET errorLogEntry;
1214:
1215: errorLogEntry = IoAllocateErrorLogEntry(
1216: DeviceObject,
1217: sizeof(IO_ERROR_LOG_PACKET)
1218: );
1219:
1220: if ( errorLogEntry != NULL ) {
1221: errorLogEntry->ErrorCode = SpecificIOStatus;
1222: errorLogEntry->SequenceNumber = SequenceNumber;
1223: errorLogEntry->MajorFunctionCode = MajorFunctionCode;
1224: errorLogEntry->RetryCount = RetryCount;
1225: errorLogEntry->UniqueErrorValue = UniqueErrorValue;
1226: errorLogEntry->FinalStatus = FinalStatus;
1227: errorLogEntry->DumpDataSize = 0;
1228: IoWriteErrorLogEntry(errorLogEntry);
1229:
1230: }
1231:
1232: }
1233: #ifdef NOT_NOW
1234:
1235: VOID
1236: q117Cancel(
1237: IN PDEVICE_OBJECT DeviceObject,
1238: IN PIRP Irp
1239: )
1240:
1241: /*++
1242:
1243: Routine Description:
1244:
1245: This routine is called from the I/O system when a request is cancelled.
1246:
1247: N.B. The cancel spinlock is already held upon entry to this routine.
1248:
1249: Arguments:
1250:
1251: DeviceObject - Pointer to class device object.
1252:
1253: Irp - Pointer to the request packet to be cancelled.
1254:
1255: Return Value:
1256:
1257: None.
1258:
1259: --*/
1260:
1261: {
1262:
1263: CheckedDump(QIC117INFO,("q117Cancel: enter\n"));
1264:
1265: if (Irp == DeviceObject->CurrentIrp) {
1266:
1267: //
1268: // The current request is being cancelled. Set the CurrentIrp to
1269: // null and release the cancel spinlock before starting the next packet.
1270: //
1271:
1272: DeviceObject->CurrentIrp = NULL;
1273: IoReleaseCancelSpinLock(Irp->CancelIrql);
1274: IoStartNextPacket(DeviceObject, TRUE);
1275:
1276: } else {
1277:
1278: //
1279: // Cancel a request in the device queue. Remove it from queue and
1280: // release the cancel spinlock.
1281: //
1282:
1283: if (TRUE != KeRemoveEntryDeviceQueue(
1284: &DeviceObject->DeviceQueue,
1285: &Irp->Tail.Overlay.DeviceQueueEntry
1286: )) {
1287: CheckedDump(QIC117SHOWTD,(
1288: "q117Cancel: Irp 0x%x not in device queue?!?\n",
1289: Irp
1290: ));
1291: }
1292: IoReleaseCancelSpinLock(Irp->CancelIrql);
1293: }
1294:
1295: //
1296: // Complete the request with STATUS_CANCELLED.
1297: //
1298:
1299: Irp->IoStatus.Status = STATUS_CANCELLED;
1300: Irp->IoStatus.Information = 0;
1301: IoCompleteRequest (Irp, IO_NO_INCREMENT);
1302:
1303: CheckedDump(QIC117INFO,("q117Cancel: exit\n"));
1304:
1305: return;
1306: }
1307: #endif
1308:
1309: NTSTATUS
1310: q117Cleanup(
1311: IN PDEVICE_OBJECT DeviceObject,
1312: IN PIRP Irp
1313: )
1314:
1315: /*++
1316:
1317: Routine Description:
1318:
1319: This routine is the dispatch routine for cleanup requests.
1320: All queued q117 requests are completed with STATUS_CANCELLED,
1321: and the lower level driver's queue is cleared.
1322:
1323: Arguments:
1324:
1325: DeviceObject - Pointer to class device object.
1326:
1327: Irp - Pointer to the request packet.
1328:
1329: Return Value:
1330:
1331: Status is returned.
1332:
1333: --*/
1334:
1335: {
1336: KIRQL currentIrql;
1337: KIRQL cancelIrql;
1338: PKDEVICE_QUEUE_ENTRY packet;
1339: PIRP currentIrp;
1340:
1341: CheckedDump(QIC117INFO,("q117Cleanup: enter\n"));
1342:
1343: /* clear everything from the low-level driver */
1344: q117ClearQueue(
1345: DeviceObject->DeviceExtension
1346: );
1347: //
1348: // Raise IRQL to DISPATCH_LEVEL.
1349: //
1350:
1351: KeRaiseIrql(DISPATCH_LEVEL, ¤tIrql);
1352:
1353: //
1354: // Acquire the cancel spinlock.
1355: //
1356:
1357: IoAcquireCancelSpinLock(&cancelIrql);
1358:
1359: //
1360: // Complete all queued requests with STATUS_CANCELLED.
1361: // Start with the real CurrentIrp, and run down the list of requests in the
1362: // device queue. Be sure to set the real CurrentIrp to NULL, so that
1363: // the interrupt service callback routine won't attempt to complete it.
1364: //
1365:
1366: currentIrp = DeviceObject->CurrentIrp;
1367: DeviceObject->CurrentIrp = NULL;
1368:
1369: while (currentIrp != NULL) {
1370:
1371: //
1372: // Remove the CurrentIrp from the cancellable state.
1373: //
1374: //
1375:
1376: IoSetCancelRoutine(currentIrp, NULL);
1377:
1378: //
1379: // Set Status to CANCELLED, release the cancel spinlock,
1380: // and complete the request. Note that the IRQL is reset to
1381: // DISPATCH_LEVEL when we release the cancel spinlock.
1382: //
1383:
1384: currentIrp->IoStatus.Status = STATUS_CANCELLED;
1385: currentIrp->IoStatus.Information = 0;
1386:
1387: IoReleaseCancelSpinLock(cancelIrql);
1388: IoCompleteRequest(currentIrp, IO_NO_INCREMENT);
1389:
1390: //
1391: // Reacquire the cancel spinlock.
1392: //
1393:
1394: IoAcquireCancelSpinLock(&cancelIrql);
1395:
1396: //
1397: // Dequeue the next packet (IRP) from the device work queue.
1398: //
1399:
1400: packet = KeRemoveDeviceQueue(&DeviceObject->DeviceQueue);
1401: if (packet != NULL) {
1402: currentIrp =
1403: CONTAINING_RECORD(packet, IRP, Tail.Overlay.DeviceQueueEntry);
1404: } else {
1405: currentIrp = (PIRP) NULL;
1406: }
1407: } // end while
1408:
1409: //
1410: // Release the cancel spinlock and lower IRQL.
1411: //
1412:
1413: IoReleaseCancelSpinLock(cancelIrql);
1414: KeLowerIrql(currentIrql);
1415:
1416: //
1417: // Complete the cleanup request with STATUS_SUCCESS.
1418: //
1419:
1420: Irp->IoStatus.Status = STATUS_SUCCESS;
1421: Irp->IoStatus.Information = 0;
1422: IoCompleteRequest (Irp, IO_NO_INCREMENT);
1423:
1424: CheckedDump(QIC117INFO,("q117Cleanup: exit\n"));
1425:
1426: return(STATUS_SUCCESS);
1427:
1428: }
1429:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.