![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ioctl.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 ioctl.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: ioctl.c
9:
10: Abstract:
11:
12: Tape IOCTL support for NT Backup aplication.
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 "common.h"
28: #include "q117.h"
29: #include "protos.h"
30: #include "cms.h"
31:
32:
33: NTSTATUS
34: q117IoCtlGetPosition (
35: IN PDEVICE_OBJECT DeviceObject,
36: IN PIRP Irp
37: )
38: /*++
39:
40: Routine Description:
41:
42:
43:
44: Arguments:
45:
46: DeviceObject
47:
48:
49: Return Value:
50:
51: NT Status
52:
53: --*/
54:
55: {
56: PQ117_CONTEXT context;
57: PTAPE_GET_POSITION currentPosition;
58: PLARGE_INTEGER offset;
59:
60: context = DeviceObject->DeviceExtension;
61: currentPosition = Irp->AssociatedIrp.SystemBuffer;
62:
63: Irp->IoStatus.Information = sizeof(TAPE_GET_POSITION);
64:
65: //
66: // signal no partition support
67: //
68: currentPosition->Partition = 0;
69:
70: //
71: // Fill in the CurrentOperation.Position based on the mode
72: //
73: offset = ¤tPosition->Offset;
74:
75: offset->HighPart = (LONG)0;
76:
77:
78: switch (context->CurrentOperation.Type) {
79:
80: case BackupInProgress:
81: offset->LowPart = context->CurrentOperation.BytesOnTape;
82: break;
83:
84: case RestoreInProgress:
85: offset->LowPart = context->CurrentOperation.BytesRead;
86: break;
87:
88: case NoOperation:
89: offset->LowPart = context->CurrentOperation.BytesRead;
90: break;
91:
92: }
93: offset->LowPart /= BLOCK_SIZE;
94:
95: CheckedDump(QIC117SHOWTD,("%d=GetPosition()",currentPosition->Offset.LowPart));
96:
97: return STATUS_SUCCESS;
98: }
99:
100: NTSTATUS
101: q117IoCtlGetMediaParameters (
102: IN PDEVICE_OBJECT DeviceObject,
103: IN PIRP Irp
104: )
105: /*++
106:
107: Routine Description:
108:
109:
110:
111: Arguments:
112:
113: DeviceObject
114:
115:
116: Return Value:
117:
118: NT Status
119:
120: --*/
121:
122: {
123: PQ117_CONTEXT context;
124: NTSTATUS ntStatus;
125:
126: context = DeviceObject->DeviceExtension;
127:
128: //
129: // Make sure there is a tape in the drive and that the tape information
130: // has been loaded
131: //
132: if (context->CurrentOperation.Type == NoOperation) {
133:
134: ntStatus = q117ConvertStatus(DeviceObject, q117CheckNewTape(context));
135:
136: } else {
137:
138: ntStatus = STATUS_SUCCESS;
139:
140: }
141:
142:
143: if ( NT_SUCCESS( ntStatus ) ) {
144: //
145: // Copy already formed (by q117CheckNewTape) information into callers buffer
146: //
147: Irp->IoStatus.Information = sizeof(TAPE_GET_MEDIA_PARAMETERS);
148:
149: *(PTAPE_GET_MEDIA_PARAMETERS)Irp->AssociatedIrp.SystemBuffer =
150: *context->CurrentTape.MediaInfo;
151:
152: }
153:
154: return ntStatus;
155: }
156:
157: NTSTATUS
158: q117IoCtlSetMediaParameters (
159: IN PDEVICE_OBJECT DeviceObject,
160: IN PIRP Irp
161: )
162: /*++
163:
164: Routine Description:
165:
166:
167:
168: Arguments:
169:
170: DeviceObject
171:
172:
173: Return Value:
174:
175: NT Status
176:
177: --*/
178:
179: {
180: PQ117_CONTEXT context;
181: PTAPE_SET_MEDIA_PARAMETERS setMedia;
182:
183: context = DeviceObject->DeviceExtension;
184:
185: setMedia = (PTAPE_SET_MEDIA_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
186:
187: CheckedDump((QIC117SHOWTD | QIC117WARN),("SetDriveParameters not implemented yet\n"));
188: CheckedDump(QIC117SHOWTD,("BlockSize: %x",setMedia->BlockSize));
189:
190: if (setMedia->BlockSize != BLOCK_SIZE)
191: return STATUS_INVALID_PARAMETER;
192: else
193: return STATUS_SUCCESS;
194: }
195:
196: NTSTATUS
197: q117IoCtlGetDriveParameters (
198: IN PDEVICE_OBJECT DeviceObject,
199: IN PIRP Irp
200: )
201: /*++
202:
203: Routine Description:
204:
205:
206:
207: Arguments:
208:
209: DeviceObject
210:
211:
212: Return Value:
213:
214: NT Status
215:
216: --*/
217:
218: {
219: PQ117_CONTEXT context;
220: PTAPE_GET_DRIVE_PARAMETERS driveInfo;
221:
222: context = DeviceObject->DeviceExtension;
223:
224: //
225: // Copy already formed (by q117CheckNewTape) information into callers buffer
226: //
227: //
228: driveInfo = (PTAPE_GET_DRIVE_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
229: Irp->IoStatus.Information = sizeof(TAPE_GET_DRIVE_PARAMETERS);
230:
231: driveInfo->ECC = TRUE;
232: driveInfo->Compression = FALSE;
233: driveInfo->DataPadding = FALSE;
234: driveInfo->ReportSetmarks = TRUE;
235: driveInfo->DefaultBlockSize = BLOCK_SIZE;
236: driveInfo->MaximumBlockSize = BLOCK_SIZE;
237: driveInfo->MinimumBlockSize = BLOCK_SIZE;
238: driveInfo->MaximumPartitionCount = 0;
239: driveInfo->FeaturesLow =
240: TAPE_DRIVE_ERASE_SHORT |
241: TAPE_DRIVE_ERASE_BOP_ONLY |
242: TAPE_DRIVE_TAPE_CAPACITY |
243: TAPE_DRIVE_TAPE_REMAINING |
244: TAPE_DRIVE_FIXED_BLOCK |
245: TAPE_DRIVE_WRITE_PROTECT |
246: TAPE_DRIVE_ECC |
247: TAPE_DRIVE_COMPRESSION |
248: TAPE_DRIVE_REPORT_SMKS |
249: TAPE_DRIVE_GET_ABSOLUTE_BLK |
250: TAPE_DRIVE_GET_LOGICAL_BLK;
251: driveInfo->FeaturesHigh =
252: TAPE_DRIVE_LOAD_UNLOAD |
253: TAPE_DRIVE_TENSION |
254: TAPE_DRIVE_LOCK_UNLOCK |
255: TAPE_DRIVE_ABSOLUTE_BLK |
256: TAPE_DRIVE_LOGICAL_BLK |
257: TAPE_DRIVE_END_OF_DATA |
258: TAPE_DRIVE_RELATIVE_BLKS |
259: TAPE_DRIVE_FILEMARKS |
260: TAPE_DRIVE_SEQUENTIAL_FMKS |
261: TAPE_DRIVE_SETMARKS |
262: TAPE_DRIVE_SEQUENTIAL_SMKS |
263: TAPE_DRIVE_REVERSE_POSITION |
264: TAPE_DRIVE_WRITE_SETMARKS |
265: TAPE_DRIVE_WRITE_FILEMARKS |
266: TAPE_DRIVE_FORMAT;
267:
268: driveInfo->FeaturesHigh &= ~TAPE_DRIVE_HIGH_FEATURES;
269:
270: return STATUS_SUCCESS;
271: }
272:
273: NTSTATUS
274: q117IoCtlSetDriveParameters (
275: IN PDEVICE_OBJECT DeviceObject,
276: IN PIRP Irp
277: )
278: /*++
279:
280: Routine Description:
281:
282:
283:
284: Arguments:
285:
286: DeviceObject
287:
288:
289: Return Value:
290:
291: NT Status
292:
293: --*/
294:
295: {
296: PQ117_CONTEXT context;
297: PTAPE_SET_DRIVE_PARAMETERS driveInfo;
298: NTSTATUS ntStatus;
299:
300: context = DeviceObject->DeviceExtension;
301:
302: //
303: // Copy already formed (by q117CheckNewTape) information into callers buffer
304: //
305: //
306: driveInfo = (PTAPE_SET_DRIVE_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
307:
308: CheckedDump((QIC117SHOWTD | QIC117WARN),("SetDriveParameters not implemented yet\n"));
309: CheckedDump(QIC117SHOWTD,("ECC: %x",driveInfo->ECC));
310: CheckedDump(QIC117SHOWTD,("Compression: %x",driveInfo->Compression));
311: CheckedDump(QIC117SHOWTD,("DataPadding: %x",driveInfo->DataPadding));
312: CheckedDump(QIC117SHOWTD,("ReportSetmarks: %x",driveInfo->ReportSetmarks));
313: ntStatus = STATUS_SUCCESS;
314: if (!driveInfo->ECC ||
315: driveInfo->Compression ||
316: driveInfo->DataPadding ||
317: !driveInfo->ReportSetmarks) {
318:
319: ntStatus = STATUS_INVALID_DEVICE_REQUEST;
320: }
321:
322: return ntStatus;
323: }
324:
325: NTSTATUS
326: q117IoCtlWriteMarks (
327: IN PDEVICE_OBJECT DeviceObject,
328: IN PIRP Irp
329: )
330: /*++
331:
332: Routine Description:
333:
334: Handle user request to write tape mark
335:
336: Arguments:
337:
338: DeviceObject
339:
340:
341: Return Value:
342:
343: NT Status
344:
345: --*/
346:
347: {
348: #ifndef NO_MARKS
349:
350: PQ117_CONTEXT context;
351: PTAPE_WRITE_MARKS tapeMarks = Irp->AssociatedIrp.SystemBuffer;
352: ULONG numMarks;
353: NTSTATUS ntStatus;
354: ULONG type;
355:
356: context = DeviceObject->DeviceExtension;
357:
358: //
359: // Make sure we are in write mode
360: //
361: ntStatus = q117ConvertStatus(DeviceObject, q117OpenForWrite(context));
362:
363: numMarks = tapeMarks->Count;
364: type = tapeMarks->Type;
365:
366: //
367: // Don't allow long/short filemarks
368: //
369: switch(type) {
370: case TAPE_LONG_FILEMARKS:
371: case TAPE_SHORT_FILEMARKS:
372: ntStatus = STATUS_INVALID_DEVICE_REQUEST;
373: }
374:
375: //
376: // Put as many marks as the user asked for, in the mark array
377: //
378: while (numMarks && NT_SUCCESS( ntStatus )) {
379:
380: context->MarkArray.MarkEntry[
381: context->MarkArray.TotalMarks].Type = tapeMarks->Type;
382:
383: context->MarkArray.MarkEntry[
384: context->MarkArray.TotalMarks].Offset =
385: context->CurrentOperation.BytesOnTape;
386:
387: --numMarks;
388:
389: ++context->MarkArray.TotalMarks;
390: ++context->CurrentMark;
391:
392: //
393: // Always make the (last mark) huge so we don't have to check
394: // for the end of the table in the rest of the code.
395: //
396: context->MarkArray.MarkEntry[
397: context->MarkArray.TotalMarks].Offset = 0xffffffff;
398:
399: //
400: // For each mark, write a "fake" block on the tape. This
401: // is due to the ntBackup program assuming that a filemark
402: // takes a block
403: //
404:
405: ntStatus = q117ConvertStatus(
406: DeviceObject,
407: q117WriteTape(NULL,BLOCK_SIZE,context)
408: );
409: }
410:
411: return ntStatus;
412:
413: #else
414:
415: return STATUS_INVALID_DEVICE_REQUEST;
416:
417: #endif
418: }
419:
420: NTSTATUS
421: q117IoCtlSetPosition (
422: IN PDEVICE_OBJECT DeviceObject,
423: IN PIRP Irp
424: )
425: /*++
426:
427: Routine Description:
428:
429:
430:
431: Arguments:
432:
433: DeviceObject
434:
435:
436: Return Value:
437:
438: NT Status
439:
440: --*/
441:
442: {
443: PQ117_CONTEXT context;
444: PTAPE_SET_POSITION tapePosition = Irp->AssociatedIrp.SystemBuffer;
445: STATUS status;
446: NTSTATUS ntStatus;
447: IO_REQUEST ioreq;
448: ULONG offset;
449: #ifndef NO_MARKS
450: int x = 0;
451: #endif
452:
453: context = DeviceObject->DeviceExtension;
454:
455: status = NoErr;
456: ntStatus = STATUS_SUCCESS;
457:
458: if (context->CurrentOperation.Type != NoOperation) {
459: switch(context->CurrentOperation.Type) {
460:
461: case BackupInProgress:
462: status = q117EndWriteOperation(context);
463: break;
464:
465: case RestoreInProgress:
466: if (
467: tapePosition->Method == TAPE_REWIND
468: ) {
469: status = q117EndReadOperation(context);
470: }
471:
472: break;
473: }
474: }
475:
476: context->CurrentOperation.Position = tapePosition->Method;
477: switch(tapePosition->Method) {
478:
479: case TAPE_REWIND:
480:
481: CheckedDump(QIC117INFO,("Rewind()\n"));
482: status = q117DoCmd(&ioreq, DEject, NULL, context);
483:
484: // context->TapeStatus.Status |= TAPE_STATUS_BEGINNING_OF_MEDIA;
485: // context->TapeStatus.Status &= ~TAPE_STATUS_END_OF_MEDIA;
486:
487: context->CurrentOperation.BytesRead = 0;
488:
489: #ifndef NO_MARKS
490: context->CurrentMark = 0;
491: #endif
492: break;
493:
494: case TAPE_LOGICAL_BLOCK:
495: case TAPE_ABSOLUTE_BLOCK:
496:
497: CheckedDump(QIC117SHOWTD,(
498: "%s SeekBlock(%d)\n",
499: tapePosition->Method==TAPE_LOGICAL_BLOCK?"Logical":"Absolute",
500: tapePosition->Offset.LowPart
501: ));
502:
503: offset = (tapePosition->Offset.LowPart)*BLOCK_SIZE;
504:
505: ntStatus = q117SeekToOffset(offset, context, DeviceObject);
506:
507: break;
508:
509: case TAPE_SPACE_END_OF_DATA:
510: //
511: // This will be taken care of when backup starts
512: // by using the context->CurrentOperation.Position
513: //
514: // It is assumed that this function will only be called prior
515: // to a backup operation only.
516:
517: CheckedDump(QIC117SHOWTD,("SeekEOD()\n"));
518: context->CurrentOperation.BytesRead =
519: context->ActiveVolume.DataSize;
520:
521: #ifndef NO_MARKS
522: context->CurrentMark = context->MarkArray.TotalMarks;
523: #endif
524:
525: // context->TapeStatus.Status |= TAPE_STATUS_END_OF_MEDIA;
526: // context->TapeStatus.Status &= ~TAPE_STATUS_BEGINNING_OF_MEDIA;
527: break;
528:
529:
530: case TAPE_SPACE_RELATIVE_BLOCKS:
531:
532:
533: CheckedDump(QIC117SHOWTD,("SeekRelBlock(%d)\n",tapePosition->Offset.LowPart));
534: //
535: // Convert relative offset into absolute
536: //
537: offset = (LONG)context->CurrentOperation.BytesRead +
538: ((LONG)tapePosition->Offset.LowPart*BLOCK_SIZE);
539:
540: //
541: // Perform absolute seek.
542: //
543: ntStatus = q117SeekToOffset(offset,context, DeviceObject);
544:
545: break;
546:
547: #ifndef NO_MARKS
548: case TAPE_SPACE_SETMARKS:
549: ++x;
550: case TAPE_SPACE_FILEMARKS:
551: ++x;
552: case TAPE_SPACE_SEQUENTIAL_FMKS:
553: ++x;
554: case TAPE_SPACE_SEQUENTIAL_SMKS:
555: if (1) {
556: static char *type[4] = {"SequentialSet","SequentialFile","File","Set"};
557:
558: CheckedDump(QIC117SHOWTD,("Seek%sMark(%d)\n",type[x],tapePosition->Offset.LowPart));
559: }
560: ntStatus = q117FindMark(tapePosition->Method,
561: tapePosition->Offset.LowPart, context, DeviceObject);
562: break;
563: #else
564: case TAPE_SPACE_SETMARKS:
565: case TAPE_SPACE_FILEMARKS:
566: case TAPE_SPACE_SEQUENTIAL_FMKS:
567: case TAPE_SPACE_SEQUENTIAL_SMKS:
568: #endif
569: default:
570: CheckedDump(QIC117DBGP,("TAPE: Position: Invalid Position Code (%x)\n",
571: tapePosition->Method));
572:
573: ntStatus = STATUS_INVALID_DEVICE_REQUEST;
574: break;
575:
576: } // end switch(tapePosition->Method)
577:
578: if (status)
579: ntStatus = q117ConvertStatus(DeviceObject, status);
580:
581: return ntStatus;
582:
583: }
584:
585: #ifndef NO_MARKS
586: NTSTATUS
587: q117FindMark(
588: ULONG Type,
589: LONG Number,
590: PQ117_CONTEXT Context,
591: IN PDEVICE_OBJECT DeviceObject
592: )
593:
594: /*++
595:
596: Routine Description:
597:
598:
599:
600: Arguments:
601:
602:
603: Return Value:
604:
605: NT Status
606:
607: --*/
608:
609: {
610: NTSTATUS ntStatus;
611: BOOLEAN forwardSeek;
612:
613: ntStatus = STATUS_SUCCESS;
614:
615: //
616: // Convert the SetPosition commands into WriteMark types
617: //
618: switch(Type) {
619:
620: case TAPE_SPACE_SEQUENTIAL_FMKS:
621:
622: //
623: // If sequential mark, then always start from the first mark.
624: //
625: Context->CurrentMark = 0;
626:
627: case TAPE_SPACE_FILEMARKS:
628:
629: Type = TAPE_FILEMARKS;
630: break;
631:
632: case TAPE_SPACE_SEQUENTIAL_SMKS:
633:
634: //
635: // If sequential mark, then always start from the first mark.
636: //
637: Context->CurrentMark = 0;
638:
639: case TAPE_SPACE_SETMARKS:
640:
641: Type = TAPE_SETMARKS;
642: break;
643:
644: }
645:
646: if (Number > 0) {
647: forwardSeek = TRUE;
648: } else {
649: forwardSeek = FALSE;
650: }
651:
652:
653: //
654: // Now seek the appropriate amount
655: //
656: while (NT_SUCCESS( ntStatus ) && Number != 0) {
657:
658: if (forwardSeek) {
659:
660: if (Context->CurrentMark >= Context->MarkArray.TotalMarks) {
661:
662: ntStatus = STATUS_END_OF_MEDIA;
663:
664: } else {
665:
666: if (Context->MarkArray.MarkEntry[Context->CurrentMark].Type ==
667: Type) {
668:
669: //
670: // If we found one, decrement the count
671: //
672:
673: --Number;
674:
675:
676: //
677: // Don't increment the current mark on the last one we
678: // find. This is because current mark points to
679: // the mark we are going to hit next.
680: //
681:
682: if (Number) {
683:
684: ++Context->CurrentMark;
685: }
686:
687: } else {
688:
689: ++Context->CurrentMark;
690:
691: }
692: }
693:
694: } else {
695:
696: if (Context->CurrentMark == 0) {
697:
698: ntStatus = STATUS_END_OF_MEDIA;
699:
700: } else {
701:
702: --Context->CurrentMark;
703:
704: if (Context->MarkArray.MarkEntry[Context->CurrentMark].Type ==
705: Type) {
706:
707: ++Number;
708:
709: }
710:
711: }
712:
713: }
714:
715: }
716:
717: if (NT_SUCCESS( ntStatus )) {
718:
719: if (Context->CurrentMark >= Context->MarkArray.TotalMarks) {
720:
721: ntStatus = STATUS_END_OF_MEDIA;
722:
723: } else {
724:
725: //
726: // Seek to proper location. Note: forward seek
727: // seeks to block after file mark (successive read will return
728: // block after filemark.
729: // A backward seek will position at the filemark. The next read
730: // will return filemark found, and successive reads will read
731: // data after the mark)
732: //
733: ntStatus = q117SeekToOffset(
734: Context->MarkArray.MarkEntry[Context->CurrentMark].Offset+
735: (forwardSeek?BLOCK_SIZE:0),
736: Context,
737: DeviceObject
738: );
739:
740: }
741:
742: }
743:
744: return ntStatus;
745: }
746: #endif
747:
748: NTSTATUS
749: q117SeekToOffset(
750: ULONG Offset,
751: PQ117_CONTEXT Context,
752: IN PDEVICE_OBJECT DeviceObject
753: )
754:
755: /*++
756:
757: Routine Description:
758:
759: Seek to specified offset on the tape (absolute offset from 0) in bytes
760:
761: Arguments:
762:
763: Offset - Bytes from begining of the volume to seek.
764:
765: Return Value:
766:
767: NT Status
768:
769: --*/
770:
771: {
772: NTSTATUS ntStatus;
773:
774:
775: CheckedDump(QIC117SHOWTD,("Absolute seek: %x\n",Offset));
776:
777: ntStatus = STATUS_SUCCESS;
778:
779: //
780: // If not in read mode, switch into read mode
781: //
782: if (Context->CurrentOperation.Type == NoOperation) {
783:
784: ntStatus = q117OpenForRead(0, Context, DeviceObject);
785:
786: //
787: // if there is no data on the tape
788: //
789: if (ntStatus == STATUS_NO_DATA_DETECTED) {
790: return ntStatus;
791: }
792:
793: Context->CurrentOperation.Type = RestoreInProgress;
794: }
795:
796:
797: if (Offset < Context->CurrentOperation.BytesRead) {
798:
799: //
800: // Backward seek, so stop current operation,
801: // rewind to begining of volume, and drop
802: // through to a forward seek.
803: //
804:
805: ntStatus = q117ConvertStatus(
806: DeviceObject,
807: q117EndReadOperation(Context)
808: );
809:
810: if (NT_SUCCESS(ntStatus)) {
811:
812: ntStatus = q117OpenForRead(0, Context, DeviceObject);
813:
814: //
815: // if there is no data on the tape
816: //
817: if (ntStatus == STATUS_NO_DATA_DETECTED) {
818: return ntStatus;
819: }
820:
821: Context->CurrentOperation.Type = RestoreInProgress;
822: }
823: }
824:
825:
826: if (NT_SUCCESS(ntStatus)) {
827: //
828: // Forward seek only (if we were doing a backward seek, the operation
829: // has been re-started this point and BytesRead == 0)
830: //
831: Offset -= Context->CurrentOperation.BytesRead;
832:
833: //
834: // Skip to the appropriate place
835: //
836: ntStatus = q117ConvertStatus(
837: DeviceObject,
838: q117SkipBlock(&Offset, Context)
839: );
840:
841: }
842:
843: return ntStatus;
844: }
845:
846: NTSTATUS
847: q117IoCtlErase (
848: IN PDEVICE_OBJECT DeviceObject,
849: IN PIRP Irp
850: )
851: /*++
852:
853: Routine Description:
854:
855:
856:
857: Arguments:
858:
859: DeviceObject
860:
861:
862: Return Value:
863:
864: NT Status
865:
866: --*/
867:
868: {
869: PQ117_CONTEXT context;
870: NTSTATUS ntStatus;
871: STATUS status;
872:
873: context = DeviceObject->DeviceExtension;
874:
875: //
876: // Complete any operation in progress
877: //
878: switch(context->CurrentOperation.Type) {
879:
880: case BackupInProgress:
881: status = q117EndWriteOperation(context);
882: break;
883:
884: case RestoreInProgress:
885: status = q117EndReadOperation(context);
886: break;
887: }
888:
889: //
890: // Make sure there is a tape in the drive and that the tape information
891: // has been loaded
892: //
893: ntStatus = q117ConvertStatus(
894: DeviceObject,
895: q117CheckNewTape(context));
896:
897: if ( NT_SUCCESS( ntStatus ) ) {
898: //
899: // Don't allow an erase if write protected
900: //
901: if (context->CurrentTape.MediaInfo->WriteProtected) {
902: return STATUS_MEDIA_WRITE_PROTECTED;
903: }
904:
905: //
906: // Erase the tape
907: //
908: status = q117EraseQ(context);
909:
910: ntStatus = q117ConvertStatus(DeviceObject, status);
911: }
912:
913: return ntStatus;
914: }
915:
916: NTSTATUS
917: q117IoCtlPrepare (
918: IN PDEVICE_OBJECT DeviceObject,
919: IN PIRP Irp
920: )
921: /*++
922:
923: Routine Description:
924:
925:
926:
927: Arguments:
928:
929: DeviceObject
930:
931:
932: Return Value:
933:
934: NT Status
935:
936: --*/
937:
938: {
939: PQ117_CONTEXT context;
940: NTSTATUS ntStatus;
941: STATUS status;
942: PTAPE_PREPARE tapePrepare;
943: IO_REQUEST ioreq;
944: QIC40_VENDOR_UNIQUE vendorUnique;
945: LONG numberBad;
946:
947: context = DeviceObject->DeviceExtension;
948:
949: status = NoErr;
950:
951: //
952: // Complete any operation in progress
953: //
954: switch(context->CurrentOperation.Type) {
955:
956: case BackupInProgress:
957: status = q117EndWriteOperation(context);
958: break;
959:
960: case RestoreInProgress:
961: status = q117EndReadOperation(context);
962: break;
963: }
964:
965: //
966: // All prepare except LOCK and UNLOCK operations rewind the media.
967: //
968: tapePrepare = Irp->AssociatedIrp.SystemBuffer;
969:
970: if ((tapePrepare->Operation != TAPE_LOCK) &&
971: (tapePrepare->Operation != TAPE_UNLOCK)) {
972: context->CurrentOperation.BytesRead = 0;
973: context->CurrentOperation.Position = 0;
974: #ifndef NO_MARKS
975: context->CurrentMark = 0;
976: #endif
977: }
978:
979:
980: if (status) {
981: return q117ConvertStatus(DeviceObject, status);
982: }
983:
984: ntStatus = STATUS_SUCCESS;
985:
986: switch (tapePrepare->Operation) {
987:
988: case TAPE_LOAD:
989: CheckedDump(QIC117SHOWTD,("TAPE_LOAD ... "));
990: ntStatus = q117ConvertStatus(DeviceObject, q117CheckNewTape(context));
991: break;
992:
993: case TAPE_UNLOAD:
994:
995: //
996: // Just rewind the tape
997: //
998: CheckedDump(QIC117SHOWTD,("TAPE_UNLOAD ... "));
999: ntStatus = q117ConvertStatus (
1000: DeviceObject,
1001: q117DoCmd(&ioreq, DEject, NULL, context) );
1002:
1003: break;
1004:
1005: case TAPE_TENSION:
1006:
1007: CheckedDump(QIC117SHOWTD,("TAPE_TENSION ... "));
1008: ntStatus = q117ConvertStatus (
1009: DeviceObject,
1010: q117DoCmd(&ioreq, DReten, NULL, context) );
1011:
1012: break;
1013:
1014: case TAPE_UNLOCK:
1015: CheckedDump(QIC117SHOWTD,("UN"));
1016: case TAPE_LOCK:
1017: CheckedDump(QIC117SHOWTD,("LOCK TAPE ..."));
1018:
1019: //
1020: // These commands mean nothing for a QIC-40 drive. However, the current
1021: // operation will be flushed allowing user to remove cartridge.
1022: //
1023: break;
1024:
1025: case TAPE_FORMAT:
1026: CheckedDump(QIC117SHOWTD,("TAPE_FORMAT ... "));
1027:
1028: ntStatus = q117ConvertStatus (
1029: DeviceObject,
1030: q117Format(
1031: &numberBad,
1032: TRUE,
1033: &vendorUnique,
1034: context ) );
1035: break;
1036:
1037: default:
1038: CheckedDump(QIC117SHOWTD,("INVALID ... "));
1039:
1040: ntStatus = STATUS_INVALID_DEVICE_REQUEST;
1041:
1042: } // end switch (tapePrepare->Operation)
1043:
1044: return ntStatus;
1045: }
1046:
1047: NTSTATUS
1048: q117IoCtlGetStatus (
1049: IN PDEVICE_OBJECT DeviceObject,
1050: IN PIRP Irp
1051: )
1052: /*++
1053:
1054: Routine Description:
1055:
1056:
1057:
1058: Arguments:
1059:
1060: DeviceObject
1061:
1062:
1063: Return Value:
1064:
1065: NT Status
1066:
1067: --*/
1068:
1069: {
1070: PQ117_CONTEXT context;
1071: // PTAPE_STATUS tapeStatus;
1072: STATUS status;
1073:
1074: context = DeviceObject->DeviceExtension;
1075:
1076:
1077: //
1078: // Complete any operation in progress
1079: //
1080: switch(context->CurrentOperation.Type) {
1081:
1082: case BackupInProgress:
1083: status = NoErr;
1084: break;
1085:
1086: case RestoreInProgress:
1087: status = NoErr;
1088: break;
1089:
1090: case NoOperation:
1091: status = q117CheckNewTape(context);
1092: break;
1093:
1094: default:
1095: status = FCodeErr;
1096:
1097: }
1098:
1099: //tapeStatus = Irp->UserBuffer;
1100:
1101: //
1102: // Is this supported in the tape API ?????
1103: //
1104: // *tapeStatus = context->TapeStatus;
1105:
1106: //
1107: // Reset media changed flag.
1108: //
1109: // context->TapeStatus.Status &= ~TAPE_STATUS_MEDIA_CHANGED;
1110:
1111: return q117ConvertStatus(DeviceObject, status);
1112: }
1113:
1114: NTSTATUS
1115: q117IoCtlReadAbs (
1116: IN PDEVICE_OBJECT DeviceObject,
1117: IN PIRP Irp
1118: )
1119: /*++
1120:
1121: Routine Description:
1122:
1123:
1124:
1125: Arguments:
1126:
1127: DeviceObject
1128:
1129:
1130: Return Value:
1131:
1132: NT Status
1133:
1134: --*/
1135:
1136: {
1137: PQ117_CONTEXT context;
1138: PSEGMENT_BUFFER bufferInfo;
1139: PVOID scrbuf;
1140: PIO_REQUEST ioreq;
1141: PCMS_RW_ABS readWrite;
1142: STATUS status;
1143: ULONG len;
1144: PIO_STACK_LOCATION irpStack;
1145:
1146: context = DeviceObject->DeviceExtension;
1147: readWrite = Irp->AssociatedIrp.SystemBuffer;
1148: irpStack = IoGetCurrentIrpStackLocation(Irp);
1149:
1150: scrbuf = q117GetFreeBuffer(&bufferInfo,context);
1151:
1152: status=q117IssIOReq(
1153: scrbuf,
1154: DRead,
1155: readWrite->Block,
1156: bufferInfo,
1157: context
1158: );
1159:
1160: if (!status) {
1161:
1162: //
1163: // Wait for data to be written
1164: //
1165: ioreq=q117Dequeue(WaitForItem,context);
1166:
1167: status = ioreq->Status;
1168:
1169: }
1170:
1171: readWrite->Status = status;
1172:
1173: len = BYTES_PER_SECTOR*readWrite->Count;
1174:
1175: if (len > irpStack->Parameters.DeviceIoControl.OutputBufferLength) {
1176:
1177: len = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
1178:
1179: }
1180:
1181: RtlMoveMemory(
1182: readWrite+1,
1183: scrbuf,
1184: len
1185: );
1186:
1187: Irp->IoStatus.Information = sizeof(CMS_RW_ABS)+len;
1188:
1189: return q117ConvertStatus(DeviceObject, status);
1190:
1191:
1192: }
1193:
1194: NTSTATUS
1195: q117IoCtlWriteAbs (
1196: IN PDEVICE_OBJECT DeviceObject,
1197: IN PIRP Irp
1198: )
1199: /*++
1200:
1201: Routine Description:
1202:
1203:
1204:
1205: Arguments:
1206:
1207: DeviceObject
1208:
1209:
1210: Return Value:
1211:
1212: NT Status
1213:
1214: --*/
1215:
1216: {
1217: PQ117_CONTEXT context;
1218: PSEGMENT_BUFFER bufferInfo;
1219: PVOID scrbuf;
1220: PIO_REQUEST ioreq;
1221: PCMS_RW_ABS readWrite;
1222: STATUS status;
1223:
1224: context = DeviceObject->DeviceExtension;
1225: readWrite = Irp->AssociatedIrp.SystemBuffer;
1226:
1227: scrbuf = q117GetFreeBuffer(&bufferInfo,context);
1228:
1229: RtlMoveMemory(
1230: scrbuf,
1231: readWrite+1,
1232: BYTES_PER_SECTOR*readWrite->Count
1233: );
1234:
1235: status = q117IssIOReq(
1236: scrbuf,
1237: DWrite,
1238: readWrite->Block,
1239: bufferInfo,
1240: context);
1241:
1242: if (!status) {
1243:
1244: //
1245: // Wait for data to be written
1246: //
1247: ioreq=q117Dequeue(WaitForItem,context);
1248:
1249: status = ioreq->Status;
1250:
1251: }
1252:
1253: readWrite->Status = status;
1254:
1255: return q117ConvertStatus(DeviceObject, status);
1256:
1257: }
1258:
1259: STATUS
1260: q117CheckNewTape (
1261: PQ117_CONTEXT Context
1262: )
1263: /*++
1264:
1265: Routine Description:
1266:
1267: This routine checks for new tape and reads header if necessary
1268:
1269: Arguments:
1270:
1271: Context - Current context information
1272:
1273: Return Value:
1274:
1275: NT Status
1276:
1277: --*/
1278:
1279: {
1280: STATUS stat;
1281: IO_REQUEST ioreq;
1282: PTAPE_HEADER header;
1283: VOLUME_TABLE_ENTRY tempVolume;
1284: UCHAR tapeType;
1285: BOOLEAN found;
1286: BOOLEAN notNt;
1287: USHORT volumesRead;
1288: DRIVE_CAPACITY driveCapacity;
1289: SEGMENT curseg;
1290:
1291:
1292: //
1293: // Check to see if there is a tape in the drive
1294: //
1295: stat = q117DoCmd(&ioreq, DGetCart, &tapeType, Context);
1296:
1297: //
1298: // If we found a tape and need to read the header and volume tables,
1299: // do it now.
1300: //
1301: if (stat == NewCart) {
1302: // Context->TapeStatus.Status |= TAPE_STATUS_MEDIA_CHANGED;
1303: }
1304:
1305: if (stat == NewCart ||
1306: (stat == NoErr && Context->CurrentTape.State == NeedInfoLoaded) ) {
1307:
1308: CheckedDump(QIC117SHOWTD,("New Cart Detected\n"));
1309:
1310: //
1311: // Check to see if there is a tape in the drive
1312: //
1313:
1314: stat = q117DoCmd(&ioreq, DClearNewCart, NULL, Context);
1315:
1316: if (stat) {
1317: return stat;
1318: }
1319:
1320: //
1321: // Saw new cart, so set need loaded flag
1322: //
1323: Context->CurrentTape.State = NeedInfoLoaded;
1324:
1325: // clear no media flag and end of media flag
1326: // Context->TapeStatus.Status &=
1327: // ~(TAPE_STATUS_NO_MEDIA|TAPE_STATUS_END_OF_MEDIA);
1328:
1329: // Set bom and device ready.
1330: // Context->TapeStatus.Status |=
1331: // TAPE_STATUS_DEVICE_READY|TAPE_STATUS_BEGINNING_OF_MEDIA;
1332:
1333: //
1334: // Check to see if tape is write protected
1335: //
1336: if (stat = q117DoCmd(&ioreq, DSndWPro, NULL, Context)) {
1337:
1338: if (stat != WProt) {
1339: return stat;
1340: }
1341:
1342: }
1343:
1344: Context->CurrentTape.MediaInfo->WriteProtected = (stat == WProt);
1345: if (stat == WProt) {
1346: // Context->TapeStatus.Status |= TAPE_STATUS_WRITE_PROTECTED;
1347: }
1348:
1349: //
1350: // Check to see if drive is formatted
1351: //
1352: stat = q117DoCmd(&ioreq, DGetCap, &driveCapacity, Context);
1353:
1354: if (stat) {
1355: return stat;
1356: }
1357:
1358: //
1359: // If tape not referenced.
1360: //
1361: if (driveCapacity.referenced == FALSE) {
1362: return BadFmt;
1363: }
1364:
1365: //
1366: // Check to see if tape is correct format
1367: //
1368: stat = q117DoCmd(&ioreq, DChkFmt, NULL, Context);
1369:
1370: if (stat) {
1371: if (stat == WrongFmt) {
1372: Context->CurrentTape.MediaInfo->WriteProtected =
1373: TRUE;
1374: stat = NoErr;
1375: } else {
1376: return stat;
1377: }
1378: }
1379:
1380: //
1381: // Now read the tape header (and bad sector map)
1382: //
1383: if (stat = q117LoadTape(&header,Context)) {
1384: return stat;
1385: }
1386: CheckedDump(QIC117SHOWTD,("LoadTape successful\n"));
1387:
1388: //
1389: // If this capacity not supported by this drive,
1390: // (i.e.. Pegasus cart in a QIC-40 drive)
1391: // return invalid format
1392: //
1393: if (header->FormatCode != driveCapacity.TapeFormatCode) {
1394: return BadFmt;
1395: }
1396:
1397: //
1398: // Copy over bad sector map, etc.
1399: //
1400: RtlMoveMemory(
1401: Context->CurrentTape.TapeHeader,
1402: header,
1403: sizeof(*Context->CurrentTape.TapeHeader) );
1404:
1405: //
1406: // Now scan volume list and get last volume on tape as well as the
1407: // NT volume (if one exists
1408: //
1409:
1410: if (stat = q117SelectTD(Context))
1411: return stat;
1412:
1413: volumesRead = 0;
1414:
1415: found = FALSE;
1416:
1417: do {
1418: /* get a volume directory from the tape (if error then)*/
1419: stat = q117ReadVolumeEntry(&tempVolume,Context);
1420:
1421: if (stat && (stat != EndOfVol))
1422: return stat;
1423:
1424: if (!stat) {
1425: volumesRead++;
1426:
1427: //
1428: // For now, let the system find ANY volume type and select
1429: // it. This will allow NT Backup software to read the
1430: // volume and detect that it is a non-nt format.
1431: // To do this, the if statement is removed, allowing
1432: // the first volume found, be the one that we select.
1433: //
1434: if (!(tempVolume.VendorSpecific &&
1435: tempVolume.Vendor.cms_QIC40.OpSysType == OP_WINDOWS_NT)) {
1436:
1437: Context->CurrentOperation.BytesOnTape =
1438: Context->CurrentOperation.BytesRead = 0;
1439:
1440: notNt = TRUE;
1441:
1442: #ifndef NO_MARKS
1443: Context->MarkArray.TotalMarks = 0;
1444: Context->CurrentMark = Context->MarkArray.TotalMarks;
1445: Context->MarkArray.MarkEntry[Context->CurrentMark].Offset =
1446: 0xffffffff;
1447: #endif
1448:
1449: /* force the data size to be the entire backup */
1450: tempVolume.DataSize = 0;
1451: curseg = tempVolume.StartSegment;
1452: while (curseg <= tempVolume.EndingSegment) {
1453:
1454: tempVolume.DataSize +=
1455: q117GoodDataBytes(
1456: curseg,
1457: Context);
1458: ++curseg;
1459:
1460:
1461: }
1462:
1463: } else {
1464:
1465: notNt = FALSE;
1466:
1467: }
1468: found = TRUE;
1469: Context->ActiveVolume = tempVolume;
1470: }
1471:
1472: } while (!stat && volumesRead < Context->CurrentTape.MaximumVolumes);
1473:
1474: if (stat = q117EndRest(Context))
1475: return(stat);
1476:
1477: //
1478: // If we did not find a volume, then signal others that
1479: // the ActiveVolume information is invalid.
1480: //
1481: if (!found)
1482: Context->ActiveVolumeNumber = 0;
1483:
1484: //
1485: // Zero out bytes saved (incase user trys to read)
1486: // Also set CurrentOperation.BytesRead to zero (start of tape)
1487: //
1488: Context->CurrentOperation.BytesOnTape =
1489: Context->CurrentOperation.BytesRead = 0;
1490:
1491: //
1492: // Flag that we have done everything
1493: //
1494: Context->CurrentTape.State = TapeInfoLoaded;
1495:
1496: #ifndef NO_MARKS
1497:
1498: //
1499: // Read the mark list from the active volume
1500: //
1501: if (found && !notNt) {
1502:
1503: stat = q117GetMarks(Context);
1504:
1505: }
1506:
1507: #endif
1508:
1509: //
1510: // If no more pressing error, return NewCart
1511: // so application can be aware of the new insertion.
1512: //
1513: if (stat == NoErr) {
1514: stat = NewCart;
1515: }
1516:
1517: } else {
1518:
1519: if (stat == NoTape) {
1520: // Context->TapeStatus.Status |= TAPE_STATUS_NO_MEDIA;
1521: Context->ActiveVolumeNumber = 0;
1522: Context->CurrentOperation.BytesOnTape =
1523: Context->CurrentOperation.BytesRead = 0;
1524:
1525: #ifndef NO_MARKS
1526: Context->MarkArray.TotalMarks = 0;
1527: Context->CurrentMark = Context->MarkArray.TotalMarks;
1528: Context->MarkArray.MarkEntry[Context->CurrentMark].Offset =
1529: 0xffffffff;
1530: #endif
1531:
1532: }
1533:
1534: }
1535:
1536: return stat;
1537: }
1538:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.