![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stdrvr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to stdrvr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 root 1: /*++
2:
3: Copyright (c) 1989-1993 Microsoft Corporation
4:
5: Module Name:
6:
7: stdrvr.c
8:
9: Abstract:
10:
11: This module contains code which defines the NT Sample
12: transport provider's device object.
13:
14: Environment:
15:
16: Kernel mode
17:
18: Revision History:
19:
20:
21: --*/
22:
23: #include "st.h"
24:
25:
26: //
27: // This is a list of all the device contexts that ST owns,
28: // used while unloading.
29: //
30:
31: LIST_ENTRY StDeviceList = {0,0}; // initialized for real at runtime.
32:
33:
34:
35: //
36: // Forward declaration of various routines used in this module.
37: //
38:
39: NTSTATUS
40: DriverEntry(
41: IN PDRIVER_OBJECT DriverObject,
42: IN PUNICODE_STRING RegistryPath
43: );
44:
45: VOID
46: StUnload(
47: IN PDRIVER_OBJECT DriverObject
48: );
49:
50: NTSTATUS
51: StConfigureTransport (
52: IN PUNICODE_STRING RegistryPath,
53: IN PCONFIG_DATA * ConfigData
54: );
55:
56: VOID
57: StFreeConfigurationInfo (
58: IN PCONFIG_DATA ConfigurationInfo
59: );
60:
61: NTSTATUS
62: StDeviceControl(
63: IN PDEVICE_OBJECT DeviceObject,
64: IN PIRP Irp,
65: IN PIO_STACK_LOCATION IrpSp
66: );
67:
68: NTSTATUS
69: StOpenAddress(
70: IN PDEVICE_OBJECT DeviceObject,
71: IN PIRP Irp,
72: IN PIO_STACK_LOCATION IrpSp
73: );
74:
75: NTSTATUS
76: StCloseAddress(
77: IN PDEVICE_OBJECT DeviceObject,
78: IN PIRP Irp,
79: IN PIO_STACK_LOCATION IrpSp
80: );
81:
82: NTSTATUS
83: StOpenConnection(
84: IN PDEVICE_OBJECT DeviceObject,
85: IN PIRP Irp,
86: IN PIO_STACK_LOCATION IrpSp
87: );
88:
89: NTSTATUS
90: StCloseConnection(
91: IN PDEVICE_OBJECT DeviceObject,
92: IN PIRP Irp,
93: IN PIO_STACK_LOCATION IrpSp
94: );
95:
96: NTSTATUS
97: StTdiAccept(
98: IN PIRP Irp
99: );
100:
101: NTSTATUS
102: StTdiConnect(
103: IN PIRP Irp
104: );
105:
106: NTSTATUS
107: StTdiDisconnect(
108: IN PIRP Irp
109: );
110:
111: NTSTATUS
112: StTdiDisassociateAddress (
113: IN PIRP Irp
114: );
115:
116: NTSTATUS
117: StTdiAssociateAddress(
118: IN PIRP Irp
119: );
120:
121: NTSTATUS
122: StTdiListen(
123: IN PIRP Irp
124: );
125:
126: NTSTATUS
127: StTdiQueryInformation(
128: IN PDEVICE_CONTEXT DeviceContext,
129: IN PIRP Irp
130: );
131:
132: NTSTATUS
133: StTdiReceive(
134: IN PIRP Irp
135: );
136:
137: NTSTATUS
138: StTdiReceiveDatagram(
139: IN PIRP Irp
140: );
141:
142: NTSTATUS
143: StTdiSend(
144: IN PIRP Irp
145: );
146:
147: NTSTATUS
148: StTdiSendDatagram(
149: IN PIRP Irp
150: );
151:
152: NTSTATUS
153: StTdiSetEventHandler(
154: IN PIRP Irp
155: );
156:
157: NTSTATUS
158: StTdiSetInformation(
159: IN PIRP Irp
160: );
161:
162: VOID
163: StDeallocateResources(
164: IN PDEVICE_CONTEXT DeviceContext
165: );
166:
167: #ifdef ALLOC_PRAGMA
168: #pragma alloc_text(init,DriverEntry)
169: #endif
170:
171:
172:
173: NTSTATUS
174: DriverEntry(
175: IN PDRIVER_OBJECT DriverObject,
176: IN PUNICODE_STRING RegistryPath
177: )
178:
179: /*++
180:
181: Routine Description:
182:
183: This routine performs initialization of the sample
184: transport driver. It creates the device objects for the transport
185: provider and performs other driver initialization.
186:
187: Arguments:
188:
189: DriverObject - Pointer to driver object created by the system.
190:
191: RegistryPath - The name of ST's node in the registry.
192:
193: Return Value:
194:
195: The function value is the final status from the initialization operation.
196:
197: --*/
198:
199: {
200: ULONG i, j;
201: STRING nameString;
202: PDEVICE_CONTEXT DeviceContext;
203: PTP_REQUEST Request;
204: PTP_CONNECTION Connection;
205: PTP_ADDRESS_FILE AddressFile;
206: PTP_ADDRESS Address;
207: PTP_PACKET Packet;
208: PNDIS_PACKET NdisPacket;
209: PRECEIVE_PACKET_TAG ReceiveTag;
210: PBUFFER_TAG BufferTag;
211: NTSTATUS status;
212: UINT SuccessfulOpens;
213: UINT MaxUserData;
214:
215: PCONFIG_DATA StConfig = NULL;
216:
217:
218: ASSERT (sizeof (SHORT) == 2);
219:
220: //
221: // This allocates the CONFIG_DATA structure and returns
222: // it in StConfig.
223: //
224:
225: status = StConfigureTransport(RegistryPath, &StConfig);
226:
227: if (!NT_SUCCESS (status)) {
228: PANIC (" Failed to initialize transport, St initialization failed.\n");
229: return STATUS_INSUFFICIENT_RESOURCES;
230: }
231:
232: //
233: // make ourselves known to the NDIS wrapper.
234: //
235:
236: RtlInitString( &nameString, ST_DEVICE_NAME );
237:
238: status = StRegisterProtocol (&nameString);
239:
240: if (!NT_SUCCESS (status)) {
241:
242: StFreeConfigurationInfo(StConfig);
243: PANIC ("StInitialize: RegisterProtocol failed!\n");
244:
245: StWriteGeneralErrorLog(
246: (PVOID)DriverObject,
247: EVENT_TRANSPORT_REGISTER_FAILED,
248: 607,
249: status,
250: NULL,
251: 0,
252: NULL);
253:
254: return STATUS_INSUFFICIENT_RESOURCES;
255:
256: }
257:
258:
259: //
260: // Initialize the driver object with this driver's entry points.
261: //
262:
263: DriverObject->MajorFunction [IRP_MJ_CREATE] = StDispatchOpenClose;
264: DriverObject->MajorFunction [IRP_MJ_CLOSE] = StDispatchOpenClose;
265: DriverObject->MajorFunction [IRP_MJ_CLEANUP] = StDispatchOpenClose;
266: DriverObject->MajorFunction [IRP_MJ_INTERNAL_DEVICE_CONTROL] = StDispatchInternal;
267: DriverObject->MajorFunction [IRP_MJ_DEVICE_CONTROL] = StDispatch;
268:
269: DriverObject->DriverUnload = StUnload;
270:
271: //
272: // Initialize the global list of devices.
273: //
274:
275: InitializeListHead (&StDeviceList);
276:
277: SuccessfulOpens = 0;
278:
279: for (j=0;j<StConfig->NumAdapters;j++ ) {
280:
281:
282: //
283: // Loop through all the adapters that are in the configuration
284: // information structure. Allocate a device object for each
285: // one that we find.
286: //
287:
288: status = StCreateDeviceContext (DriverObject, &StConfig->Names[StConfig->DevicesOffset+j], &DeviceContext);
289:
290: if (!NT_SUCCESS (status)) {
291: continue;
292: }
293:
294: //
295: // Initialize our counter that records memory usage.
296: //
297:
298: DeviceContext->MemoryUsage = 0;
299: DeviceContext->MemoryLimit = StConfig->MaxMemoryUsage;
300:
301: //
302: // Now fire up NDIS so this adapter talks
303: //
304:
305: status = StInitializeNdis (DeviceContext,
306: StConfig,
307: j);
308:
309: if (!NT_SUCCESS (status)) {
310:
311: //
312: // Log an error.
313: //
314:
315: StWriteGeneralErrorLog(
316: DeviceContext,
317: EVENT_TRANSPORT_BINDING_FAILED,
318: 601,
319: status,
320: StConfig->Names[j].Buffer,
321: 0,
322: NULL);
323:
324: StDereferenceDeviceContext ("Initialize NDIS failed", DeviceContext);
325: continue;
326:
327: }
328:
329:
330: //
331: // Initialize our provider information structure; since it
332: // doesn't change, we just keep it around and copy it to
333: // whoever requests it.
334: //
335:
336:
337: MacReturnMaxDataSize(
338: &DeviceContext->MacInfo,
339: NULL,
340: 0,
341: DeviceContext->MaxSendPacketSize,
342: &MaxUserData);
343:
344: DeviceContext->Information.Version = 0x0100;
345: DeviceContext->Information.MaxSendSize = 0x1fffe; // 128k - 2
346: DeviceContext->Information.MaxConnectionUserData = 0;
347: DeviceContext->Information.MaxDatagramSize = MaxUserData - sizeof(ST_HEADER);
348: DeviceContext->Information.ServiceFlags = ST_SERVICE_FLAGS;
349: DeviceContext->Information.MinimumLookaheadData = 128;
350: DeviceContext->Information.MaximumLookaheadData =
351: DeviceContext->MaxReceivePacketSize - sizeof(ST_HEADER);
352: DeviceContext->Information.NumberOfResources = ST_TDI_RESOURCES;
353: KeQuerySystemTime (&DeviceContext->Information.StartTime);
354:
355:
356: //
357: // Allocate various structures we will need.
358: //
359:
360:
361: //
362: // The TP_PACKET structure has a CHAR[1] field at the end
363: // which we expand upon to include all the headers needed;
364: // the size of the MAC header depends on what the adapter
365: // told us about its max header size.
366: //
367:
368: DeviceContext->PacketHeaderLength =
369: DeviceContext->MacInfo.MaxHeaderLength +
370: sizeof (ST_HEADER);
371:
372: DeviceContext->PacketLength =
373: FIELD_OFFSET(TP_PACKET, Header[0]) +
374: DeviceContext->PacketHeaderLength;
375:
376:
377: //
378: // The BUFFER_TAG structure has a CHAR[1] field at the end
379: // which we expand upong to include all the frame data.
380: //
381:
382: DeviceContext->ReceiveBufferLength =
383: DeviceContext->MaxReceivePacketSize +
384: FIELD_OFFSET(BUFFER_TAG, Buffer[0]);
385:
386:
387: for (i=0; i<StConfig->InitRequests; i++) {
388:
389: StAllocateRequest (DeviceContext, &Request);
390:
391: if (Request == NULL) {
392: PANIC ("StInitialize: insufficient memory to allocate requests.\n");
393: status = STATUS_INSUFFICIENT_RESOURCES;
394: goto cleanup;
395: }
396:
397: InsertTailList (&DeviceContext->RequestPool, &Request->Linkage);
398: }
399:
400: DeviceContext->RequestInitAllocated = StConfig->InitRequests;
401: DeviceContext->RequestMaxAllocated = StConfig->MaxRequests;
402:
403:
404: for (i=0; i<StConfig->InitConnections; i++) {
405:
406: StAllocateConnection (DeviceContext, &Connection);
407:
408: if (Connection == NULL) {
409: PANIC ("StInitialize: insufficient memory to allocate connections.\n");
410: status = STATUS_INSUFFICIENT_RESOURCES;
411: goto cleanup;
412: }
413:
414: InsertTailList (&DeviceContext->ConnectionPool, &Connection->LinkList);
415: }
416:
417: DeviceContext->ConnectionInitAllocated = StConfig->InitConnections;
418: DeviceContext->ConnectionMaxAllocated = StConfig->MaxConnections;
419:
420:
421: for (i=0; i<StConfig->InitAddressFiles; i++) {
422:
423: StAllocateAddressFile (DeviceContext, &AddressFile);
424:
425: if (AddressFile == NULL) {
426: PANIC ("StInitialize: insufficient memory to allocate Address Files.\n");
427: status = STATUS_INSUFFICIENT_RESOURCES;
428: goto cleanup;
429: }
430:
431: InsertTailList (&DeviceContext->AddressFilePool, &AddressFile->Linkage);
432: }
433:
434: DeviceContext->AddressFileInitAllocated = StConfig->InitAddressFiles;
435: DeviceContext->AddressFileMaxAllocated = StConfig->MaxAddressFiles;
436:
437:
438: for (i=0; i<StConfig->InitAddresses; i++) {
439:
440: StAllocateAddress (DeviceContext, &Address);
441: if (Address == NULL) {
442: PANIC ("StInitialize: insufficient memory to allocate addresses.\n");
443: status = STATUS_INSUFFICIENT_RESOURCES;
444: goto cleanup;
445: }
446:
447: InsertTailList (&DeviceContext->AddressPool, &Address->Linkage);
448: }
449:
450: DeviceContext->AddressInitAllocated = StConfig->InitAddresses;
451: DeviceContext->AddressMaxAllocated = StConfig->MaxAddresses;
452:
453:
454: for (i=0; i<StConfig->InitPackets; i++) {
455:
456: StAllocateSendPacket (DeviceContext, &Packet);
457: if (Packet == NULL) {
458: PANIC ("StInitialize: insufficient memory to allocate packets.\n");
459: status = STATUS_INSUFFICIENT_RESOURCES;
460: goto cleanup;
461: }
462:
463: PushEntryList (&DeviceContext->PacketPool, (PSINGLE_LIST_ENTRY)&Packet->Linkage);
464: }
465:
466: DeviceContext->PacketInitAllocated = StConfig->InitPackets;
467:
468:
469: for (i=0; i<StConfig->InitReceivePackets; i++) {
470:
471: StAllocateReceivePacket (DeviceContext, &NdisPacket);
472:
473: if (NdisPacket == NULL) {
474: PANIC ("StInitialize: insufficient memory to allocate packet MDLs.\n");
475: status = STATUS_INSUFFICIENT_RESOURCES;
476: goto cleanup;
477: }
478:
479: ReceiveTag = (PRECEIVE_PACKET_TAG)NdisPacket->ProtocolReserved;
480: PushEntryList (&DeviceContext->ReceivePacketPool, (PSINGLE_LIST_ENTRY)&ReceiveTag->Linkage);
481:
482: }
483:
484: DeviceContext->ReceivePacketInitAllocated = StConfig->InitReceivePackets;
485:
486:
487: for (i=0; i<StConfig->InitReceiveBuffers; i++) {
488:
489: StAllocateReceiveBuffer (DeviceContext, &BufferTag);
490:
491: if (BufferTag == NULL) {
492: PANIC ("StInitialize: Unable to allocate receive packet.\n");
493: status = STATUS_INSUFFICIENT_RESOURCES;
494: goto cleanup;
495: }
496:
497: PushEntryList (&DeviceContext->ReceiveBufferPool, &BufferTag->Linkage);
498:
499: }
500:
501: DeviceContext->ReceiveBufferInitAllocated = StConfig->InitReceiveBuffers;
502:
503:
504: //
505: // Now link the device into the global list.
506: //
507:
508: InsertTailList (&StDeviceList, &DeviceContext->Linkage);
509:
510: DeviceContext->State = DEVICECONTEXT_STATE_OPEN;
511:
512: ++SuccessfulOpens;
513:
514: continue;
515:
516: cleanup:
517:
518: StWriteResourceErrorLog (DeviceContext, DeviceContext->MemoryUsage, 501);
519:
520: //
521: // Cleanup whatever device context we were initializing
522: // when we failed.
523: //
524:
525: StFreeResources (DeviceContext);
526: StCloseNdis (DeviceContext);
527: StDereferenceDeviceContext ("Load failed", DeviceContext);
528:
529: }
530:
531: StFreeConfigurationInfo(StConfig);
532:
533: return ((SuccessfulOpens > 0) ? STATUS_SUCCESS : STATUS_DEVICE_DOES_NOT_EXIST);
534:
535: }
536:
537: VOID
538: StUnload(
539: IN PDRIVER_OBJECT DriverObject
540: )
541:
542: /*++
543:
544: Routine Description:
545:
546: This routine unloads the sample transport driver.
547: It unbinds from any NDIS drivers that are open and frees all resources
548: associated with the transport. The I/O system will not call us until
549: nobody above has ST open.
550:
551: Arguments:
552:
553: DriverObject - Pointer to driver object created by the system.
554:
555: Return Value:
556:
557: None. When the function returns, the driver is unloaded.
558:
559: --*/
560:
561: {
562:
563: PDEVICE_CONTEXT DeviceContext;
564: PLIST_ENTRY p;
565:
566:
567: UNREFERENCED_PARAMETER (DriverObject);
568:
569: //
570: // Walk the list of device contexts.
571: //
572:
573: while (!IsListEmpty (&StDeviceList)) {
574:
575: p = RemoveHeadList (&StDeviceList);
576: DeviceContext = CONTAINING_RECORD (p, DEVICE_CONTEXT, Linkage);
577:
578: //
579: // Remove all the storage associated with the device.
580: //
581:
582: StFreeResources (DeviceContext);
583:
584: //
585: // Free the packet pools, etc. and close the
586: // adapter.
587: //
588:
589: StCloseNdis (DeviceContext);
590:
591: //
592: // And remove the creation reference from the device
593: // context.
594: //
595:
596: StDereferenceDeviceContext ("Unload", DeviceContext);
597:
598: }
599:
600:
601: //
602: // Finally, remove ourselves as an NDIS protocol.
603: //
604:
605: StDeregisterProtocol();
606:
607: return;
608:
609: }
610:
611:
612: VOID
613: StFreeResources (
614: IN PDEVICE_CONTEXT DeviceContext
615: )
616: /*++
617:
618: Routine Description:
619:
620: This routine is called by ST to clean up the data structures associated
621: with a given DeviceContext. When this routine exits, the DeviceContext
622: should be deleted as it no longer has any assocaited resources.
623:
624: Arguments:
625:
626: DeviceContext - Pointer to the DeviceContext we wish to clean up.
627:
628: Return Value:
629:
630: None.
631:
632: --*/
633: {
634: PLIST_ENTRY p;
635: PSINGLE_LIST_ENTRY s;
636: PTP_PACKET packet;
637: PTP_ADDRESS address;
638: PTP_CONNECTION connection;
639: PTP_REQUEST request;
640: PTP_ADDRESS_FILE addressFile;
641: PNDIS_PACKET ndisPacket;
642: PBUFFER_TAG BufferTag;
643:
644:
645: //
646: // Clean up packet pool.
647: //
648:
649: while ( DeviceContext->PacketPool.Next != NULL ) {
650: s = PopEntryList( &DeviceContext->PacketPool );
651: packet = CONTAINING_RECORD( s, TP_PACKET, Linkage );
652:
653: StDeallocateSendPacket (DeviceContext, packet);
654: }
655:
656: //
657: // Clean up address pool.
658: //
659:
660: while ( !IsListEmpty (&DeviceContext->AddressPool) ) {
661: p = RemoveHeadList (&DeviceContext->AddressPool);
662: address = CONTAINING_RECORD (p, TP_ADDRESS, Linkage);
663:
664: StDeallocateAddress (DeviceContext, address);
665: }
666:
667: //
668: // Clean up address file pool.
669: //
670:
671: while ( !IsListEmpty (&DeviceContext->AddressFilePool) ) {
672: p = RemoveHeadList (&DeviceContext->AddressFilePool);
673: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
674:
675: StDeallocateAddressFile (DeviceContext, addressFile);
676: }
677:
678: //
679: // Clean up connection pool.
680: //
681:
682: while ( !IsListEmpty (&DeviceContext->ConnectionPool) ) {
683: p = RemoveHeadList (&DeviceContext->ConnectionPool);
684: connection = CONTAINING_RECORD (p, TP_CONNECTION, LinkList);
685:
686: StDeallocateConnection (DeviceContext, connection);
687: }
688:
689: //
690: // Clean up request pool.
691: //
692:
693: while ( !IsListEmpty( &DeviceContext->RequestPool ) ) {
694: p = RemoveHeadList( &DeviceContext->RequestPool );
695: request = CONTAINING_RECORD (p, TP_REQUEST, Linkage );
696:
697: StDeallocateRequest (DeviceContext, request);
698: }
699:
700: //
701: // Clean up receive packet pool
702: //
703:
704: while ( DeviceContext->ReceivePacketPool.Next != NULL) {
705: s = PopEntryList (&DeviceContext->ReceivePacketPool);
706:
707: //
708: // HACK: This works because Linkage is the first field in
709: // ProtocolReserved for a receive packet.
710: //
711:
712: ndisPacket = CONTAINING_RECORD (s, NDIS_PACKET, ProtocolReserved[0]);
713:
714: StDeallocateReceivePacket (DeviceContext, ndisPacket);
715: }
716:
717:
718: //
719: // Clean up receive buffer pool.
720: //
721:
722: while ( DeviceContext->ReceiveBufferPool.Next != NULL ) {
723: s = PopEntryList( &DeviceContext->ReceiveBufferPool );
724: BufferTag = CONTAINING_RECORD (s, BUFFER_TAG, Linkage );
725:
726: StDeallocateReceiveBuffer (DeviceContext, BufferTag);
727: }
728:
729:
730: return;
731:
732: } /* StFreeResources */
733:
734:
735: NTSTATUS
736: StDispatch(
737: IN PDEVICE_OBJECT DeviceObject,
738: IN PIRP Irp
739: )
740:
741: /*++
742:
743: Routine Description:
744:
745: This routine is the main dispatch routine for the ST device driver.
746: It accepts an I/O Request Packet, performs the request, and then
747: returns with the appropriate status.
748:
749: Arguments:
750:
751: DeviceObject - Pointer to the device object for this driver.
752:
753: Irp - Pointer to the request packet representing the I/O request.
754:
755: Return Value:
756:
757: The function value is the status of the operation.
758:
759: --*/
760:
761: {
762: NTSTATUS Status;
763: PIO_STACK_LOCATION IrpSp;
764: PDEVICE_CONTEXT DeviceContext;
765:
766: //
767: // Check to see if ST has been initialized; if not, don't allow any use.
768: // Note that this only covers any user mode code use; kernel TDI clients
769: // will fail on their creation of an endpoint.
770: //
771:
772: DeviceContext = (PDEVICE_CONTEXT)DeviceObject;
773: if (DeviceContext->State != DEVICECONTEXT_STATE_OPEN) {
774: Irp->IoStatus.Status = STATUS_INVALID_DEVICE_STATE;
775: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
776: return STATUS_INVALID_DEVICE_STATE;
777: }
778:
779: //
780: // Make sure status information is consistent every time.
781: //
782:
783: IoMarkIrpPending (Irp);
784: Irp->IoStatus.Status = STATUS_PENDING;
785: Irp->IoStatus.Information = 0;
786:
787: //
788: // Get a pointer to the current stack location in the IRP. This is where
789: // the function codes and parameters are stored.
790: //
791:
792: IrpSp = IoGetCurrentIrpStackLocation (Irp);
793:
794: //
795: // Case on the function that is being performed by the requestor. If the
796: // operation is a valid one for this device, then make it look like it was
797: // successfully completed, where possible.
798: //
799:
800:
801: switch (IrpSp->MajorFunction) {
802:
803: case IRP_MJ_DEVICE_CONTROL:
804: Status = StDeviceControl (DeviceObject, Irp, IrpSp);
805: break;
806:
807: default:
808: Status = STATUS_INVALID_DEVICE_REQUEST;
809:
810: } /* major function switch */
811:
812: if (Status != STATUS_PENDING) {
813: IrpSp->Control &= ~SL_PENDING_RETURNED;
814: Irp->IoStatus.Status = Status;
815: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
816: }
817:
818: //
819: // Return the immediate status code to the caller.
820: //
821:
822: return Status;
823: } /* StDispatch */
824:
825:
826: NTSTATUS
827: StDispatchOpenClose(
828: IN PDEVICE_OBJECT DeviceObject,
829: IN PIRP Irp
830: )
831:
832: /*++
833:
834: Routine Description:
835:
836: This routine is the main dispatch routine for the ST device driver.
837: It accepts an I/O Request Packet, performs the request, and then
838: returns with the appropriate status.
839:
840: Arguments:
841:
842: DeviceObject - Pointer to the device object for this driver.
843:
844: Irp - Pointer to the request packet representing the I/O request.
845:
846: Return Value:
847:
848: The function value is the status of the operation.
849:
850: --*/
851:
852: {
853: KIRQL oldirql;
854: PDEVICE_CONTEXT DeviceContext;
855: NTSTATUS Status;
856: PIO_STACK_LOCATION IrpSp;
857: PFILE_FULL_EA_INFORMATION openType;
858: USHORT i;
859: BOOLEAN found;
860: PTP_ADDRESS_FILE AddressFile;
861: PTP_CONNECTION Connection;
862:
863: //
864: // Check to see if ST has been initialized; if not, don't allow any use.
865: // Note that this only covers any user mode code use; kernel TDI clients
866: // will fail on their creation of an endpoint.
867: //
868:
869: DeviceContext = (PDEVICE_CONTEXT)DeviceObject;
870: if (DeviceContext->State != DEVICECONTEXT_STATE_OPEN) {
871: Irp->IoStatus.Status = STATUS_INVALID_DEVICE_STATE;
872: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
873: return STATUS_INVALID_DEVICE_STATE;
874: }
875:
876: //
877: // Make sure status information is consistent every time.
878: //
879:
880: IoMarkIrpPending (Irp);
881: Irp->IoStatus.Status = STATUS_PENDING;
882: Irp->IoStatus.Information = 0;
883:
884: //
885: // Get a pointer to the current stack location in the IRP. This is where
886: // the function codes and parameters are stored.
887: //
888:
889: IrpSp = IoGetCurrentIrpStackLocation (Irp);
890:
891: //
892: // Case on the function that is being performed by the requestor. If the
893: // operation is a valid one for this device, then make it look like it was
894: // successfully completed, where possible.
895: //
896:
897:
898: switch (IrpSp->MajorFunction) {
899:
900: //
901: // The Create function opens a transport object (either address or
902: // connection). Access checking is performed on the specified
903: // address to ensure security of transport-layer addresses.
904: //
905:
906: case IRP_MJ_CREATE:
907:
908: openType =
909: (PFILE_FULL_EA_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
910:
911: if (openType != NULL) {
912:
913: found = TRUE;
914:
915: for (i=0;i<(USHORT)openType->EaNameLength;i++) {
916: if (openType->EaName[i] == TdiTransportAddress[i]) {
917: continue;
918: } else {
919: found = FALSE;
920: break;
921: }
922: }
923:
924: if (found) {
925: Status = StOpenAddress (DeviceObject, Irp, IrpSp);
926: break;
927: }
928:
929: //
930: // Connection?
931: //
932:
933: found = TRUE;
934:
935: for (i=0;i<(USHORT)openType->EaNameLength;i++) {
936: if (openType->EaName[i] == TdiConnectionContext[i]) {
937: continue;
938: } else {
939: found = FALSE;
940: break;
941: }
942: }
943:
944: if (found) {
945: Status = StOpenConnection (DeviceObject, Irp, IrpSp);
946: break;
947: }
948:
949: } else {
950:
951: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
952:
953: IrpSp->FileObject->FsContext = (PVOID)(DeviceContext->ControlChannelIdentifier);
954: ++DeviceContext->ControlChannelIdentifier;
955: if (DeviceContext->ControlChannelIdentifier == 0) {
956: DeviceContext->ControlChannelIdentifier = 1;
957: }
958:
959: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
960:
961: IrpSp->FileObject->FsContext2 = (PVOID)ST_FILE_TYPE_CONTROL;
962: Status = STATUS_SUCCESS;
963: }
964:
965: break;
966:
967: case IRP_MJ_CLOSE:
968:
969: //
970: // The Close function closes a transport endpoint, terminates
971: // all outstanding transport activity on the endpoint, and unbinds
972: // the endpoint from its transport address, if any. If this
973: // is the last transport endpoint bound to the address, then
974: // the address is removed from the provider.
975: //
976:
977: switch ((ULONG)IrpSp->FileObject->FsContext2) {
978: case TDI_TRANSPORT_ADDRESS_FILE:
979: AddressFile = (PTP_ADDRESS_FILE)IrpSp->FileObject->FsContext;
980:
981: //
982: // This creates a reference to AddressFile->Address
983: // which is removed by StCloseAddress.
984: //
985:
986: Status = StVerifyAddressObject(AddressFile);
987:
988: if (!NT_SUCCESS (Status)) {
989: Status = STATUS_INVALID_HANDLE;
990: } else {
991: Status = StCloseAddress (DeviceObject, Irp, IrpSp);
992: }
993:
994: break;
995:
996: case TDI_CONNECTION_FILE:
997:
998: //
999: // This is a connection
1000: //
1001:
1002: Connection = (PTP_CONNECTION)IrpSp->FileObject->FsContext;
1003: Status = StVerifyConnectionObject (Connection);
1004: if (NT_SUCCESS (Status)) {
1005:
1006: Status = StCloseConnection (DeviceObject, Irp, IrpSp);
1007: StDereferenceConnection ("Temporary Use",Connection);
1008:
1009: }
1010:
1011: break;
1012:
1013: case ST_FILE_TYPE_CONTROL:
1014:
1015: //
1016: // this always succeeds
1017: //
1018:
1019: Status = STATUS_SUCCESS;
1020: break;
1021:
1022: default:
1023: Status = STATUS_INVALID_HANDLE;
1024: }
1025:
1026: break;
1027:
1028: case IRP_MJ_CLEANUP:
1029:
1030: //
1031: // Handle the two stage IRP for a file close operation. When the first
1032: // stage hits, run down all activity on the object of interest. This
1033: // do everything to it but remove the creation hold. Then, when the
1034: // CLOSE irp hits, actually close the object.
1035: //
1036:
1037: switch ((ULONG)IrpSp->FileObject->FsContext2) {
1038: case TDI_TRANSPORT_ADDRESS_FILE:
1039: AddressFile = (PTP_ADDRESS_FILE)IrpSp->FileObject->FsContext;
1040: Status = StVerifyAddressObject(AddressFile);
1041: if (!NT_SUCCESS (Status)) {
1042:
1043: Status = STATUS_INVALID_HANDLE;
1044:
1045: } else {
1046:
1047: StStopAddressFile (AddressFile, AddressFile->Address);
1048: StDereferenceAddress ("IRP_MJ_CLEANUP", AddressFile->Address);
1049: Status = STATUS_SUCCESS;
1050: }
1051:
1052: break;
1053:
1054: case TDI_CONNECTION_FILE:
1055:
1056: Connection = (PTP_CONNECTION)IrpSp->FileObject->FsContext;
1057: Status = StVerifyConnectionObject (Connection);
1058: if (NT_SUCCESS (Status)) {
1059: StStopConnection (Connection, STATUS_LOCAL_DISCONNECT);
1060: Status = STATUS_SUCCESS;
1061: StDereferenceConnection ("Temporary Use",Connection);
1062: }
1063:
1064: break;
1065:
1066: case ST_FILE_TYPE_CONTROL:
1067:
1068: Status = STATUS_SUCCESS;
1069: break;
1070:
1071: default:
1072: Status = STATUS_INVALID_HANDLE;
1073: }
1074:
1075: break;
1076:
1077: default:
1078: Status = STATUS_INVALID_DEVICE_REQUEST;
1079:
1080: } /* major function switch */
1081:
1082: if (Status != STATUS_PENDING) {
1083: IrpSp->Control &= ~SL_PENDING_RETURNED;
1084: Irp->IoStatus.Status = Status;
1085: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
1086: }
1087:
1088:
1089: //
1090: // Return the immediate status code to the caller.
1091: //
1092:
1093: return Status;
1094: } /* StDispatchOpenClose */
1095:
1096:
1097: NTSTATUS
1098: StDeviceControl(
1099: IN PDEVICE_OBJECT DeviceObject,
1100: IN PIRP Irp,
1101: IN PIO_STACK_LOCATION IrpSp
1102: )
1103:
1104: /*++
1105:
1106: Routine Description:
1107:
1108: This routine dispatches TDI request types to different handlers based
1109: on the minor IOCTL function code in the IRP's current stack location.
1110: In addition to cracking the minor function code, this routine also
1111: reaches into the IRP and passes the packetized parameters stored there
1112: as parameters to the various TDI request handlers so that they are
1113: not IRP-dependent.
1114:
1115: Arguments:
1116:
1117: DeviceObject - Pointer to the device object for this driver.
1118:
1119: Irp - Pointer to the request packet representing the I/O request.
1120:
1121: IrpSp - Pointer to current IRP stack frame.
1122:
1123: Return Value:
1124:
1125: The function value is the status of the operation.
1126:
1127: --*/
1128:
1129: {
1130: NTSTATUS Status;
1131: PDEVICE_CONTEXT DeviceContext = (PDEVICE_CONTEXT)DeviceObject;
1132:
1133:
1134: //
1135: // Branch to the appropriate request handler. Preliminary checking of
1136: // the size of the request block is performed here so that it is known
1137: // in the handlers that the minimum input parameters are readable. It
1138: // is *not* determined here whether variable length input fields are
1139: // passed correctly; this is a check which must be made within each routine.
1140: //
1141:
1142: switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
1143:
1144: default:
1145:
1146: //
1147: // Convert the user call to the proper internal device call.
1148: //
1149:
1150: Status = TdiMapUserRequest (DeviceObject, Irp, IrpSp);
1151:
1152: if (Status == STATUS_SUCCESS) {
1153:
1154: //
1155: // If TdiMapUserRequest returns SUCCESS then the IRP
1156: // has been converted into an IRP_MJ_INTERNAL_DEVICE_CONTROL
1157: // IRP, so we dispatch it as usual. The IRP will
1158: // be completed by this call.
1159: //
1160: // StDispatchInternal expects to complete the IRP,
1161: // so we change Status to PENDING so we don't.
1162: //
1163:
1164: (VOID)StDispatchInternal (DeviceObject, Irp);
1165: Status = STATUS_PENDING;
1166:
1167: }
1168: }
1169:
1170: return Status;
1171: } /* StDeviceControl */
1172:
1173:
1174: NTSTATUS
1175: StDispatchInternal (
1176: IN PDEVICE_OBJECT DeviceObject,
1177: IN PIRP Irp
1178: )
1179:
1180: /*++
1181:
1182: Routine Description:
1183:
1184: This routine dispatches TDI request types to different handlers based
1185: on the minor IOCTL function code in the IRP's current stack location.
1186: In addition to cracking the minor function code, this routine also
1187: reaches into the IRP and passes the packetized parameters stored there
1188: as parameters to the various TDI request handlers so that they are
1189: not IRP-dependent.
1190:
1191: Arguments:
1192:
1193: DeviceObject - Pointer to the device object for this driver.
1194:
1195: Irp - Pointer to the request packet representing the I/O request.
1196:
1197: Return Value:
1198:
1199: The function value is the status of the operation.
1200:
1201: --*/
1202:
1203: {
1204: NTSTATUS Status;
1205: PDEVICE_CONTEXT DeviceContext;
1206: PIO_STACK_LOCATION IrpSp;
1207:
1208:
1209: //
1210: // Get a pointer to the current stack location in the IRP. This is where
1211: // the function codes and parameters are stored.
1212: //
1213:
1214: IrpSp = IoGetCurrentIrpStackLocation (Irp);
1215:
1216: DeviceContext = (PDEVICE_CONTEXT)DeviceObject;
1217:
1218:
1219: if (DeviceContext->State != DEVICECONTEXT_STATE_OPEN) {
1220: Irp->IoStatus.Status = STATUS_INVALID_DEVICE_STATE;
1221: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
1222: return STATUS_INVALID_DEVICE_STATE;
1223: }
1224:
1225:
1226: //
1227: // Make sure status information is consistent every time.
1228: //
1229:
1230: IoMarkIrpPending (Irp);
1231: Irp->IoStatus.Status = STATUS_PENDING;
1232: Irp->IoStatus.Information = 0;
1233:
1234:
1235: //
1236: // Branch to the appropriate request handler. Preliminary checking of
1237: // the size of the request block is performed here so that it is known
1238: // in the handlers that the minimum input parameters are readable. It
1239: // is *not* determined here whether variable length input fields are
1240: // passed correctly; this is a check which must be made within each routine.
1241: //
1242:
1243: switch (IrpSp->MinorFunction) {
1244:
1245: case TDI_ACCEPT:
1246: Status = StTdiAccept (Irp);
1247: break;
1248:
1249: case TDI_ACTION:
1250: Status = STATUS_SUCCESS;
1251: break;
1252:
1253: case TDI_ASSOCIATE_ADDRESS:
1254: Status = StTdiAssociateAddress (Irp);
1255: break;
1256:
1257: case TDI_DISASSOCIATE_ADDRESS:
1258: Status = StTdiDisassociateAddress (Irp);
1259: break;
1260:
1261: case TDI_CONNECT:
1262: Status = StTdiConnect (Irp);
1263: break;
1264:
1265: case TDI_DISCONNECT:
1266: Status = StTdiDisconnect (Irp);
1267: break;
1268:
1269: case TDI_LISTEN:
1270: Status = StTdiListen (Irp);
1271: break;
1272:
1273: case TDI_QUERY_INFORMATION:
1274: Status = StTdiQueryInformation (DeviceContext, Irp);
1275: break;
1276:
1277: case TDI_RECEIVE:
1278: Status = StTdiReceive (Irp);
1279: break;
1280:
1281: case TDI_RECEIVE_DATAGRAM:
1282: Status = StTdiReceiveDatagram (Irp);
1283: break;
1284:
1285: case TDI_SEND:
1286: Status = StTdiSend (Irp);
1287: break;
1288:
1289: case TDI_SEND_DATAGRAM:
1290: Status = StTdiSendDatagram (Irp);
1291: break;
1292:
1293: case TDI_SET_EVENT_HANDLER:
1294:
1295: //
1296: // Because this request will enable direct callouts from the
1297: // transport provider at DISPATCH_LEVEL to a client-specified
1298: // routine, this request is only valid in kernel mode, denying
1299: // access to this request in user mode.
1300: //
1301:
1302: Status = StTdiSetEventHandler (Irp);
1303: break;
1304:
1305: case TDI_SET_INFORMATION:
1306: Status = StTdiSetInformation (Irp);
1307: break;
1308:
1309:
1310: //
1311: // Something we don't know about was submitted.
1312: //
1313:
1314: default:
1315: Status = STATUS_INVALID_DEVICE_REQUEST;
1316: }
1317:
1318: if (Status != STATUS_PENDING) {
1319: IrpSp->Control &= ~SL_PENDING_RETURNED;
1320: Irp->IoStatus.Status = Status;
1321: IoCompleteRequest (Irp, IO_NETWORK_INCREMENT);
1322: }
1323:
1324:
1325: //
1326: // Return the immediate status code to the caller.
1327: //
1328:
1329: return Status;
1330:
1331: } /* StDispatchInternal */
1332:
1333:
1334: VOID
1335: StWriteResourceErrorLog(
1336: IN PDEVICE_CONTEXT DeviceContext,
1337: IN ULONG BytesNeeded,
1338: IN ULONG UniqueErrorValue
1339: )
1340:
1341: /*++
1342:
1343: Routine Description:
1344:
1345: This routine allocates and writes an error log entry indicating
1346: an out of resources condition.
1347:
1348: Arguments:
1349:
1350: DeviceContext - Pointer to the device context.
1351:
1352: BytesNeeded - If applicable, the number of bytes that could not
1353: be allocated.
1354:
1355: UniqueErrorValue - Used as the UniqueErrorValue in the error log
1356: packet.
1357:
1358: Return Value:
1359:
1360: None.
1361:
1362: --*/
1363:
1364: {
1365: PIO_ERROR_LOG_PACKET errorLogEntry;
1366: UCHAR EntrySize;
1367: PUCHAR StringLoc;
1368: ULONG TempUniqueError;
1369: static WCHAR UniqueErrorBuffer[4] = L"000";
1370: UINT i;
1371:
1372:
1373: EntrySize = sizeof(IO_ERROR_LOG_PACKET) +
1374: DeviceContext->DeviceNameLength +
1375: sizeof(UniqueErrorBuffer);
1376:
1377: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1378: (PDEVICE_OBJECT)DeviceContext,
1379: EntrySize
1380: );
1381:
1382: //
1383: // Convert the error value into a buffer.
1384: //
1385:
1386: TempUniqueError = UniqueErrorValue;
1387: for (i=1; i>=0; i--) {
1388: UniqueErrorBuffer[i] = (WCHAR)((TempUniqueError % 10) + L'0');
1389: TempUniqueError /= 10;
1390: }
1391:
1392: if (errorLogEntry != NULL) {
1393:
1394: errorLogEntry->MajorFunctionCode = (UCHAR)-1;
1395: errorLogEntry->RetryCount = (UCHAR)-1;
1396: errorLogEntry->DumpDataSize = sizeof(ULONG);
1397: errorLogEntry->NumberOfStrings = 2;
1398: errorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET);
1399: errorLogEntry->EventCategory = 0;
1400: errorLogEntry->ErrorCode = EVENT_TRANSPORT_RESOURCE_POOL;
1401: errorLogEntry->UniqueErrorValue = UniqueErrorValue;
1402: errorLogEntry->FinalStatus = STATUS_INSUFFICIENT_RESOURCES;
1403: errorLogEntry->SequenceNumber = (ULONG)-1;
1404: errorLogEntry->IoControlCode = 0;
1405: errorLogEntry->DumpData[0] = BytesNeeded;
1406:
1407: StringLoc = ((PUCHAR)errorLogEntry) + errorLogEntry->StringOffset;
1408: RtlCopyMemory (StringLoc, DeviceContext->DeviceName, DeviceContext->DeviceNameLength);
1409:
1410: StringLoc += DeviceContext->DeviceNameLength;
1411: RtlCopyMemory (StringLoc, UniqueErrorBuffer, sizeof(UniqueErrorBuffer));
1412:
1413: IoWriteErrorLogEntry(errorLogEntry);
1414:
1415: }
1416:
1417: } /* StWriteResourceErrorLog */
1418:
1419:
1420: VOID
1421: StWriteGeneralErrorLog(
1422: IN PDEVICE_CONTEXT DeviceContext,
1423: IN NTSTATUS ErrorCode,
1424: IN ULONG UniqueErrorValue,
1425: IN NTSTATUS FinalStatus,
1426: IN PWSTR SecondString,
1427: IN ULONG DumpDataCount,
1428: IN ULONG DumpData[]
1429: )
1430:
1431: /*++
1432:
1433: Routine Description:
1434:
1435: This routine allocates and writes an error log entry indicating
1436: a general problem as indicated by the parameters. It handles
1437: event codes REGISTER_FAILED, BINDING_FAILED, ADAPTER_NOT_FOUND,
1438: TRANSFER_DATA, TOO_MANY_LINKS, and BAD_PROTOCOL. All these
1439: events have messages with one or two strings in them.
1440:
1441: Arguments:
1442:
1443: DeviceContext - Pointer to the device context, or this may be
1444: a driver object instead.
1445:
1446: ErrorCode - The transport event code.
1447:
1448: UniqueErrorValue - Used as the UniqueErrorValue in the error log
1449: packet.
1450:
1451: FinalStatus - Used as the FinalStatus in the error log packet.
1452:
1453: SecondString - If not NULL, the string to use as the %3
1454: value in the error log packet.
1455:
1456: DumpDataCount - The number of ULONGs of dump data.
1457:
1458: DumpData - Dump data for the packet.
1459:
1460: Return Value:
1461:
1462: None.
1463:
1464: --*/
1465:
1466: {
1467: PIO_ERROR_LOG_PACKET errorLogEntry;
1468: UCHAR EntrySize;
1469: ULONG SecondStringSize;
1470: PUCHAR StringLoc;
1471: static WCHAR DriverName[3] = L"St";
1472:
1473: EntrySize = sizeof(IO_ERROR_LOG_PACKET) +
1474: (DumpDataCount * sizeof(ULONG));
1475:
1476: if (DeviceContext->Type == IO_TYPE_DEVICE) {
1477: EntrySize += (UCHAR)DeviceContext->DeviceNameLength;
1478: } else {
1479: EntrySize += sizeof(DriverName);
1480: }
1481:
1482: if (SecondString) {
1483: SecondStringSize = (wcslen(SecondString)*sizeof(WCHAR)) + sizeof(UNICODE_NULL);
1484: EntrySize += (UCHAR)SecondStringSize;
1485: }
1486:
1487: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1488: (PDEVICE_OBJECT)DeviceContext,
1489: EntrySize
1490: );
1491:
1492: if (errorLogEntry != NULL) {
1493:
1494: errorLogEntry->MajorFunctionCode = (UCHAR)-1;
1495: errorLogEntry->RetryCount = (UCHAR)-1;
1496: errorLogEntry->DumpDataSize = (USHORT)(DumpDataCount * sizeof(ULONG));
1497: errorLogEntry->NumberOfStrings = (SecondString == NULL) ? 1 : 2;
1498: errorLogEntry->StringOffset =
1499: sizeof(IO_ERROR_LOG_PACKET) + ((DumpDataCount-1) * sizeof(ULONG));
1500: errorLogEntry->EventCategory = 0;
1501: errorLogEntry->ErrorCode = ErrorCode;
1502: errorLogEntry->UniqueErrorValue = UniqueErrorValue;
1503: errorLogEntry->FinalStatus = FinalStatus;
1504: errorLogEntry->SequenceNumber = (ULONG)-1;
1505: errorLogEntry->IoControlCode = 0;
1506:
1507: if (DumpDataCount) {
1508: RtlCopyMemory(errorLogEntry->DumpData, DumpData, DumpDataCount * sizeof(ULONG));
1509: }
1510:
1511: StringLoc = ((PUCHAR)errorLogEntry) + errorLogEntry->StringOffset;
1512: if (DeviceContext->Type == IO_TYPE_DEVICE) {
1513: RtlCopyMemory (StringLoc, DeviceContext->DeviceName, DeviceContext->DeviceNameLength);
1514: StringLoc += DeviceContext->DeviceNameLength;
1515: } else {
1516: RtlCopyMemory (StringLoc, DriverName, sizeof(DriverName));
1517: StringLoc += sizeof(DriverName);
1518: }
1519: if (SecondString) {
1520: RtlCopyMemory (StringLoc, SecondString, SecondStringSize);
1521: }
1522:
1523: IoWriteErrorLogEntry(errorLogEntry);
1524:
1525: }
1526:
1527: } /* StWriteGeneralErrorLog */
1528:
1529:
1530: VOID
1531: StWriteOidErrorLog(
1532: IN PDEVICE_CONTEXT DeviceContext,
1533: IN NTSTATUS ErrorCode,
1534: IN NTSTATUS FinalStatus,
1535: IN PWSTR AdapterString,
1536: IN ULONG OidValue
1537: )
1538:
1539: /*++
1540:
1541: Routine Description:
1542:
1543: This routine allocates and writes an error log entry indicating
1544: a problem querying or setting an OID on an adapter. It handles
1545: event codes SET_OID_FAILED and QUERY_OID_FAILED.
1546:
1547: Arguments:
1548:
1549: DeviceContext - Pointer to the device context.
1550:
1551: ErrorCode - Used as the ErrorCode in the error log packet.
1552:
1553: FinalStatus - Used as the FinalStatus in the error log packet.
1554:
1555: AdapterString - The name of the adapter we were bound to.
1556:
1557: OidValue - The OID which could not be set or queried.
1558:
1559: Return Value:
1560:
1561: None.
1562:
1563: --*/
1564:
1565: {
1566: PIO_ERROR_LOG_PACKET errorLogEntry;
1567: UCHAR EntrySize;
1568: ULONG AdapterStringSize;
1569: PUCHAR StringLoc;
1570: static WCHAR OidBuffer[9] = L"00000000";
1571: UINT i;
1572: UINT CurrentDigit;
1573:
1574: AdapterStringSize = (wcslen(AdapterString)*sizeof(WCHAR)) + sizeof(UNICODE_NULL);
1575: EntrySize = sizeof(IO_ERROR_LOG_PACKET) -
1576: sizeof(ULONG) +
1577: DeviceContext->DeviceNameLength +
1578: AdapterStringSize +
1579: sizeof(OidBuffer);
1580:
1581: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1582: (PDEVICE_OBJECT)DeviceContext,
1583: EntrySize
1584: );
1585:
1586: //
1587: // Convert the OID into a buffer.
1588: //
1589:
1590: for (i=7; i>=0; i--) {
1591: CurrentDigit = OidValue & 0xf;
1592: OidValue >>= 4;
1593: if (CurrentDigit >= 0xa) {
1594: OidBuffer[i] = (WCHAR)(CurrentDigit - 0xa + L'A');
1595: } else {
1596: OidBuffer[i] = (WCHAR)(CurrentDigit + L'0');
1597: }
1598: }
1599:
1600: if (errorLogEntry != NULL) {
1601:
1602: errorLogEntry->MajorFunctionCode = (UCHAR)-1;
1603: errorLogEntry->RetryCount = (UCHAR)-1;
1604: errorLogEntry->DumpDataSize = 0;
1605: errorLogEntry->NumberOfStrings = 3;
1606: errorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET) - sizeof(ULONG);
1607: errorLogEntry->EventCategory = 0;
1608: errorLogEntry->ErrorCode = ErrorCode;
1609: errorLogEntry->UniqueErrorValue = 0;
1610: errorLogEntry->FinalStatus = FinalStatus;
1611: errorLogEntry->SequenceNumber = (ULONG)-1;
1612: errorLogEntry->IoControlCode = 0;
1613:
1614: StringLoc = ((PUCHAR)errorLogEntry) + errorLogEntry->StringOffset;
1615: RtlCopyMemory (StringLoc, DeviceContext->DeviceName, DeviceContext->DeviceNameLength);
1616: StringLoc += DeviceContext->DeviceNameLength;
1617:
1618: RtlCopyMemory (StringLoc, OidBuffer, sizeof(OidBuffer));
1619: StringLoc += sizeof(OidBuffer);
1620:
1621: RtlCopyMemory (StringLoc, AdapterString, AdapterStringSize);
1622:
1623: IoWriteErrorLogEntry(errorLogEntry);
1624:
1625: }
1626:
1627: } /* StWriteOidErrorLog */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.