/*++ Copyright (C) Microsoft Corporation, 1992 - 1999 Module Name: classkd.c Abstract: Debugger Extension Api for interpretting scsiport structures Author: Peter Wieland (peterwie) 16-Oct-1995 johnstra ervinp Environment: User Mode. Revision History: --*/ #include "pch.h" #include "classpnp.h" // #defines ALLOCATE_SRB_FROM_POOL as needed #include "classp.h" // Classpnp's private definitions #include "cdrom.h" #include "classkd.h" // routines that are useful for all class drivers typedef struct _REMOVE_TRACKING_BLOCK REMOVE_TRACKING_BLOCK, *PREMOVE_TRACKING_BLOCK; struct _REMOVE_TRACKING_BLOCK { PREMOVE_TRACKING_BLOCK NextBlock; PVOID Tag; LARGE_INTEGER TimeLocked; PCSTR File; ULONG Line; }; FLAG_NAME FdoFlags[] = { FLAG_NAME(DEV_WRITE_CACHE), // 0x00000001 FLAG_NAME(DEV_USE_SCSI1), // 0x00000002 FLAG_NAME(DEV_SAFE_START_UNIT), // 0x00000004 FLAG_NAME(DEV_NO_12BYTE_CDB), // 0x00000008 {0,0} }; DECLARE_API(classext) /*++ Routine Description: Dumps the device extension for a given device object, or dumps the given device extension Arguments: args - string containing the address of the device object or device extension Return Value: none --*/ { ULONG64 devObjAddr = 0; ULONG detail = 0; GetAddressAndDetailLevel64(args, &devObjAddr, &detail); /* * Read the device object and extension into the debugger's address space. */ if (devObjAddr == 0){ xdprintf(0, "\n usage: !classext \n\n"); } else { CSHORT objType = GetUSHORTField(devObjAddr, "nt!_DEVICE_OBJECT", "Type"); if (objType == IO_TYPE_DEVICE){ ULONG64 devExtAddr; devExtAddr = GetULONGField(devObjAddr, "nt!_DEVICE_OBJECT", "DeviceExtension"); if (devExtAddr != BAD_VALUE){ ULONG64 commonExtAddr = devExtAddr; ULONG64 tmpDevObjAddr; BOOLEAN isFdo; /* * To sanity-check our device context, check that the 'DeviceObject' field matches our device object. */ tmpDevObjAddr = GetULONGField(devExtAddr, "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "DeviceObject"); isFdo = GetUCHARField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "IsFdo"); if ((tmpDevObjAddr == devObjAddr) && isFdo && (isFdo != BAD_VALUE)){ ULONG64 fdoDataAddr; fdoDataAddr = GetULONGField(devExtAddr, "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "PrivateFdoData"); if (fdoDataAddr != BAD_VALUE){ ClassDumpFdoExtensionInternal(fdoDataAddr, detail, 0); ClassDumpFdoExtensionExternal(devExtAddr, detail, 0); // this hasn't worked in some time // ClassDumpCommonExtension(devObjAddr, detail, 0); } } else { dprintf("%08p is not a storage class FDO (for PDO information, use !classext on the parent FDO) \n", devObjAddr); dprintf(g_genericErrorHelpStr); } } } else { dprintf("Error: 0x%08p is not a device object\n", devObjAddr); dprintf(g_genericErrorHelpStr); } } return S_OK; } VOID ClassDumpCommonExtension( IN ULONG64 Address, IN ULONG Detail, IN ULONG Depth ) { ULONG result; ULONG offset; ULONG tmp; BOOLEAN IsFdo; BOOLEAN IsInitialized; ULONG IsRemoved; ULONG64 DeviceObject; ULONG64 LowerDeviceObject; UCHAR CurrentState; UCHAR PreviousState; ULONG64 DriverData; ULONG PagingPathCount; ULONG DumpPathCount; ULONG HibernationPathCount; FIELD_INFO deviceFields[] = { {"IsFdo", NULL, 0, COPY, 0, (PVOID) &IsFdo}, {"IsInitialized", NULL, 0, COPY, 0, (PVOID) &IsInitialized}, {"IsRemoved", NULL, 0, COPY, 0, (PVOID) &IsRemoved}, {"DeviceObject", NULL, 0, COPY, 0, (PVOID) &DeviceObject}, {"LowerDeviceObject", NULL, 0, COPY, 0, (PVOID) &LowerDeviceObject}, {"CurrentState", NULL, 0, COPY, 0, (PVOID) &CurrentState}, {"PreviousState", NULL, 0, COPY, 0, (PVOID) &PreviousState}, {"DriverData", NULL, 0, COPY, 0, (PVOID) &DriverData}, {"PagingPathCount", NULL, 0, COPY, 0, (PVOID) &PagingPathCount}, {"DumpPathCount", NULL, 0, COPY, 0, (PVOID) &DumpPathCount}, {"HibernationPathCount", NULL, 0, COPY, 0, (PVOID) &HibernationPathCount}, }; SYM_DUMP_PARAM DevSym = { sizeof (SYM_DUMP_PARAM), "classpnp!_COMMON_DEVICE_EXTENSION", DBG_DUMP_NO_PRINT, Address, NULL, NULL, NULL, sizeof (deviceFields) / sizeof (FIELD_INFO), &deviceFields[0] }; result = Ioctl(IG_DUMP_SYMBOL_INFO, &DevSym, DevSym.size); if (result) { SCSIKD_PRINT_ERROR(result); return; } xdprintfEx(Depth, ("Classpnp %s device extension at address %p\n", (!IsFdo ? "physical" : "functional"), Address)); xdprintfEx(Depth, ("Common Extension:\n")); Depth += 1; tmp = Depth; if(IsInitialized) { xdprintfEx(tmp, ("Initialized " )); tmp = 0; } switch(IsRemoved) { case REMOVE_PENDING: { xdprintfEx(tmp, ("RemovePending")); tmp = 0; break; } case REMOVE_COMPLETE: { xdprintfEx(tmp, ("RemoveComplete")); tmp = 0; break; } } if(tmp == 0) { dprintf("\n"); } tmp = 0; // // Calculate the runtime address of the first field to follow the common // device extension. To do this, we query the type info for the offset // of the last field, then increment it by the appropriate amount. // result = GetFieldOffset("classpnp!_COMMON_DEVICE_EXTENSION", "Reserved4", &offset); if (result) { SCSIKD_PRINT_ERROR(result); return; } offset += IsPtr64() ? sizeof(ULONG64) : sizeof(ULONG32); xdprintfEx(Depth, ("DO 0x%p LowerObject 0x%p Other Extension 0x%p\n", DeviceObject, LowerDeviceObject, Address + offset )); xdprintfEx(Depth, ("Current PnP state 0x%x Previous state 0x%x\n", CurrentState, PreviousState)); xdprintfEx(Depth, ("DriverData 0x%p UsePathCounts (P%d, C%d, H%d)\n", DriverData, PagingPathCount, DumpPathCount, HibernationPathCount )); if(!IsFdo) { xdprintfEx(Depth - 1, ("PhysicalExtension:\n")); ClassDumpPdo(Address, Detail, Depth); } else { xdprintfEx(Depth - 1, ("FunctionalExtension:\n")); ClassDumpFdo(Address, Detail, Depth); } ClassDumpLocks(Address, Depth - 1); return; } VOID ClassDumpFdoExtensionExternal( IN ULONG64 FdoExtAddr, IN ULONG Detail, IN ULONG Depth ) { ULONG64 commonExtAddr = FdoExtAddr; ULONG64 mediaChangeInfoAddr; ULONG64 childPdoExtAddr; ULONG isRemoved; UCHAR isInitialized; ULONG removeLock; UCHAR currentState, previousState; ULONG64 lowerDevObjAddr; xdprintf(Depth, "\n"); xdprintf(Depth, "Classpnp _EXTERNAL_ data:\n\n"); /* * Print the media change information (which only exists for removable media like cdrom) */ mediaChangeInfoAddr = GetULONGField(FdoExtAddr, "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "MediaChangeDetectionInfo"); if (mediaChangeInfoAddr != BAD_VALUE){ if (mediaChangeInfoAddr){ ULONG64 mediaChangeIrpAddr = GetULONGField(mediaChangeInfoAddr, "classpnp!_MEDIA_CHANGE_DETECTION_INFO", "MediaChangeIrp"); UCHAR gesnSupported = GetUCHARField(mediaChangeInfoAddr, "classpnp!_MEDIA_CHANGE_DETECTION_INFO", "Gesn.Supported"); xdprintf(Depth+1, ""), dprintf("MEDIA_CHANGE_DETECTION_INFO @ %08p:\n", mediaChangeInfoAddr); if (gesnSupported){ xdprintf(Depth+2, "GESN is supported\n"); } else { xdprintf(Depth+2, "GESN is NOT supported\n"); } xdprintf(Depth+2, ""), dprintf("MediaChangeIrp = %08p\n", mediaChangeIrpAddr); xdprintf(Depth+2, ""), dprintf("(for more info, use 'dt classpnp!_MEDIA_CHANGE_DETECTION_INFO %08p')\n", mediaChangeInfoAddr); dprintf("\n"); } else { xdprintf(Depth+1, "MediaChangeDetectionInfo is NULL\n"); } } /* * Print the media type and geometry information */ { ULONG64 geometryInfoAddr = GetFieldAddr(FdoExtAddr, "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "DiskGeometry"); if (geometryInfoAddr != BAD_VALUE){ ULONG64 numCylinders = GetULONGField(geometryInfoAddr, "classpnp!_DISK_GEOMETRY", "Cylinders"); ULONG mediaType = (ULONG)GetULONGField(geometryInfoAddr, "classpnp!_DISK_GEOMETRY", "MediaType"); ULONG64 tracksPerCylinder = GetULONGField(geometryInfoAddr, "classpnp!_DISK_GEOMETRY", "TracksPerCylinder"); ULONG64 sectorsPerTrack = GetULONGField(geometryInfoAddr, "classpnp!_DISK_GEOMETRY", "SectorsPerTrack"); ULONG64 bytesPerSector = GetULONGField(geometryInfoAddr, "classpnp!_DISK_GEOMETRY", "BytesPerSector"); if ((numCylinders != BAD_VALUE) && (mediaType != BAD_VALUE) && (tracksPerCylinder != BAD_VALUE) && (sectorsPerTrack != BAD_VALUE) && (bytesPerSector != BAD_VALUE)){ ULONG64 totalVolume = numCylinders*tracksPerCylinder*sectorsPerTrack*bytesPerSector; xdprintf(Depth+1, ""), dprintf("Media type: %s(%xh)\n", DbgGetMediaTypeStr(mediaType), mediaType); xdprintf(Depth+1, ""), dprintf("Geometry: %d(%xh)cyl x %d(%xh)tracks x %d(%xh)sectors x %d(%xh)bytes\n", (ULONG)numCylinders, (ULONG)numCylinders, (ULONG)tracksPerCylinder, (ULONG)tracksPerCylinder, (ULONG)sectorsPerTrack, (ULONG)sectorsPerTrack, (ULONG)bytesPerSector, (ULONG)bytesPerSector); xdprintf(Depth+1+4, ""), dprintf("= %x'%xh", (ULONG)(totalVolume>>32), (ULONG)totalVolume); if (totalVolume > (ULONG64)(1 << 30)){ dprintf(" = ~%d GB\n", (ULONG)(totalVolume >> 30)); } else { dprintf(" = ~%d MB\n", (ULONG)(totalVolume >> 20)); } } } } /* * Print 'IsInitialized' state. */ isInitialized = GetUCHARField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "IsInitialized"); xdprintf(Depth+1, "IsInitialized = %d\n", isInitialized); /* * Print the 'IsRemoved' state. */ isRemoved = (ULONG)GetULONGField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "IsRemoved"); removeLock = (ULONG)GetULONGField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "RemoveLock"); xdprintf(Depth+1, "Remove lock count = %d\n", removeLock); switch (isRemoved){ #undef MAKE_CASE #define MAKE_CASE(remCase) case remCase: xdprintf(Depth+1, "IsRemoved = " #remCase "(%d)\n", isRemoved); break; MAKE_CASE(NO_REMOVE) MAKE_CASE(REMOVE_PENDING) MAKE_CASE(REMOVE_COMPLETE) } /* * Print the PnP state. */ currentState = GetUCHARField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "CurrentState"); previousState = GetUCHARField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "PreviousState"); xdprintf(Depth+1, "PnP state: CurrentState:"); switch (currentState){ #undef MAKE_CASE #define MAKE_CASE(pnpCase) case pnpCase: xdprintf(0, #pnpCase "(%xh)", pnpCase); break; MAKE_CASE(IRP_MN_START_DEVICE) MAKE_CASE(IRP_MN_STOP_DEVICE) MAKE_CASE(IRP_MN_REMOVE_DEVICE) MAKE_CASE(IRP_MN_QUERY_STOP_DEVICE) MAKE_CASE(IRP_MN_QUERY_REMOVE_DEVICE) MAKE_CASE(IRP_MN_CANCEL_STOP_DEVICE) MAKE_CASE(IRP_MN_CANCEL_REMOVE_DEVICE) default: xdprintf(0, "???(%xh)", currentState); break; } xdprintf(0, " PreviousState:"); switch (previousState){ #undef MAKE_CASE #define MAKE_CASE(pnpCase) case pnpCase: xdprintf(0, #pnpCase "(%xh)", pnpCase); break; MAKE_CASE(IRP_MN_START_DEVICE) MAKE_CASE(IRP_MN_STOP_DEVICE) MAKE_CASE(IRP_MN_REMOVE_DEVICE) MAKE_CASE(IRP_MN_QUERY_STOP_DEVICE) MAKE_CASE(IRP_MN_QUERY_REMOVE_DEVICE) MAKE_CASE(IRP_MN_CANCEL_STOP_DEVICE) MAKE_CASE(IRP_MN_CANCEL_REMOVE_DEVICE) case 0x0FF: xdprintf(0, "(None)"); break; default: xdprintf(0, "???(%xh)", previousState); break; } xdprintf(0, "\n"); /* * Print target device */ lowerDevObjAddr = GetULONGField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "LowerDeviceObject"); xdprintf(Depth+1, ""), dprintf("Target device=%08p\n", lowerDevObjAddr); /* * Dump child PDO list */ xdprintf(Depth+1, "Child PDOs:\n"); childPdoExtAddr = GetULONGField(commonExtAddr, "classpnp!_COMMON_DEVICE_EXTENSION", "ChildList"); while (childPdoExtAddr && (childPdoExtAddr != BAD_VALUE)){ ULONG64 pdoAddr = GetULONGField(childPdoExtAddr, "classpnp!_PHYSICAL_DEVICE_EXTENSION", "DeviceObject"); UCHAR isEnumerated = GetUCHARField(childPdoExtAddr, "classpnp!_PHYSICAL_DEVICE_EXTENSION", "IsEnumerated"); UCHAR isMissing = GetUCHARField(childPdoExtAddr, "classpnp!_PHYSICAL_DEVICE_EXTENSION", "IsMissing"); xdprintf(Depth+2, ""), dprintf("PDO=%08p IsEnumerated=%d IsMissing=%d\n", pdoAddr, isEnumerated, isMissing); childPdoExtAddr = GetULONGField(childPdoExtAddr, "classpnp!_PHYSICAL_DEVICE_EXTENSION", "CommonExtension.ChildList"); } dprintf("\n"); dprintf("\n"); xdprintf(Depth+2, ""), dprintf("(for more info use 'dt classpnp!_FUNCTIONAL_DEVICE_EXTENSION %08p')\n", FdoExtAddr); xdprintf(0, "\n"); } VOID ClassDumpFdoExtensionInternal( IN ULONG64 FdoDataAddr, IN ULONG Detail, IN ULONG Depth ) { ULONG64 keTickCountAddr; ULONG keTickCount; ULONG len; dprintf("\n"); xdprintf(Depth, ""), dprintf("Classpnp _INTERNAL_ data (%08p):\n", FdoDataAddr); /* * Dump TRANSFER_PACKET lists */ ClassDumpTransferPacketLists(FdoDataAddr, Detail, Depth+1); /* * Dump private error logs */ ClassDumpPrivateErrorLogs(FdoDataAddr, Detail, Depth+1); /* * Show time at trap (for comparison with error log timestamps) */ keTickCountAddr = GetExpression("nt!KeTickCount"); if (ReadMemory(keTickCountAddr, &keTickCount, sizeof(ULONG), &len)){ dprintf("\n"); xdprintf(Depth, ""), dprintf("KeTickCount trap time: %08xh = %d.%d\n", keTickCount, (ULONG)(keTickCount/1000), (ULONG)(keTickCount%1000)); } dprintf("\n"); xdprintf(Depth+2, ""), dprintf("(for more info use 'dt classpnp!_CLASS_PRIVATE_FDO_DATA %08p')\n", FdoDataAddr); } VOID ClassDumpTransferPacketLists(ULONG64 FdoDataAddr, ULONG Detail, ULONG Depth) { ULONG64 allxferPktsListAddr; /* * Print transfer packet lists */ allxferPktsListAddr = GetFieldAddr(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "AllTransferPacketsList"); if (allxferPktsListAddr != BAD_VALUE){ ULONG64 listEntryAddr; ULONG numTotalXferPkts = (ULONG)GetULONGField(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "NumTotalTransferPackets"); ULONG numFreeXferPkts = (ULONG)GetULONGField(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "NumFreeTransferPackets"); ULONG numPackets; char *extraSpaces = IsPtr64() ? " " : ""; /* * Walk AllTransferPacketsList and print only the outstanding packets with full SRB info. */ xdprintf(Depth, "\n"); xdprintf(Depth, "Outstanding transfer packets: (out of %d total)\n", numTotalXferPkts); xdprintf(Depth, "\n"); xdprintf(Depth+1, " packet %s irp %s srb %s sense %s status \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); xdprintf(Depth+1, "--------%s --------%s --------%s --------%s -------- \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); numPackets = 0; listEntryAddr = GetULONGField(allxferPktsListAddr, "nt!_LIST_ENTRY", "Flink"); while ((listEntryAddr != allxferPktsListAddr) && (listEntryAddr != BAD_VALUE)){ ULONG64 pktAddr; pktAddr = GetContainingRecord(listEntryAddr, "classpnp!_TRANSFER_PACKET", "AllPktsListEntry"); if (pktAddr == BAD_VALUE){ break; } else { ClassDumpTransferPacket(pktAddr, TRUE, FALSE, TRUE, Depth+1); numPackets++; listEntryAddr = GetULONGField(listEntryAddr, "nt!_LIST_ENTRY", "Flink"); } } if (numPackets != numTotalXferPkts){ xdprintf(Depth, "*** Warning: NumTotalTransferPackets(%d) doesn't match length of queue(%d) ***\n", numTotalXferPkts, numPackets); } if (Detail > 0){ ULONG64 slistEntryAddr; /* * Print all transfer packets */ xdprintf(Depth, "\n"); xdprintf(Depth, "All transfer packets: (%d total, %d free)\n", numTotalXferPkts, numFreeXferPkts); xdprintf(Depth, "\n"); xdprintf(Depth+1, " packet %s irp %s srb %s sense %s status \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); xdprintf(Depth+1, "--------%s --------%s --------%s --------%s -------- \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); numPackets = 0; listEntryAddr = GetULONGField(allxferPktsListAddr, "nt!_LIST_ENTRY", "Flink"); while ((listEntryAddr != allxferPktsListAddr) && (listEntryAddr != BAD_VALUE)){ ULONG64 pktAddr; pktAddr = GetContainingRecord(listEntryAddr, "classpnp!_TRANSFER_PACKET", "AllPktsListEntry"); if (pktAddr == BAD_VALUE){ break; } else { ClassDumpTransferPacket(pktAddr, TRUE, TRUE, FALSE, Depth+1); listEntryAddr = GetULONGField(listEntryAddr, "nt!_LIST_ENTRY", "Flink"); } } /* * Print free packets sList */ xdprintf(Depth, "\n"); xdprintf(Depth, "Free transfer packets in fast SLIST: (%d free)\n", numFreeXferPkts); if (IsPtr64()){ xdprintf(Depth, "(Cannot display fast SLIST on 64-bit system)\n"); } else { xdprintf(Depth+1, " packet %s irp %s srb %s sense %s status \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); xdprintf(Depth+1, "--------%s --------%s --------%s --------%s -------- \n", extraSpaces, extraSpaces, extraSpaces, extraSpaces); numPackets = 0; slistEntryAddr = GetULONGField(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "FreeTransferPacketsList.Next.Next"); while (slistEntryAddr && (slistEntryAddr != BAD_VALUE)){ ULONG64 pktAddr; pktAddr = GetContainingRecord(slistEntryAddr, "classpnp!_TRANSFER_PACKET", "SlistEntry"); if (pktAddr == BAD_VALUE){ break; } else { ClassDumpTransferPacket(pktAddr, TRUE, TRUE, FALSE, Depth+1); numPackets++; slistEntryAddr = GetULONGField(pktAddr, "classpnp!_TRANSFER_PACKET", "SlistEntry.Next"); } } if (numPackets != numFreeXferPkts){ xdprintf(Depth, "*** Warning: NumFreeTransferPackets(%d) doesn't match length of queue(%d) ***\n", numFreeXferPkts, numPackets); } } } } } /* * ClassDumpTransferPacket * * Dump TRANSFER_PACKET contents under the following heading: * * " packet irp srb sense status " * " -------- -------- -------- -------- -------- " * */ VOID ClassDumpTransferPacket( ULONG64 PktAddr, BOOLEAN DumpPendingPkts, BOOLEAN DumpFreePkts, BOOLEAN DumpFullInfo, ULONG Depth) { ULONG64 irpAddr = GetULONGField(PktAddr, "classpnp!_TRANSFER_PACKET", "Irp"); ULONG64 srbAddr = GetFieldAddr(PktAddr, "classpnp!_TRANSFER_PACKET", "Srb"); ULONG64 senseAddr = GetFieldAddr(PktAddr, "classpnp!_TRANSFER_PACKET", "SrbErrorSenseData"); if ((irpAddr == BAD_VALUE) || (srbAddr == BAD_VALUE) || (senseAddr == BAD_VALUE)){ dprintf("\n ClassDumpTransferPacket: error retrieving contents of packet %08p.\n", PktAddr); } else { UCHAR currentStackLoc = GetUCHARField(irpAddr, "nt!_IRP", "CurrentLocation"); UCHAR stackCount = GetUCHARField(irpAddr, "nt!_IRP", "StackCount"); BOOLEAN isPending; isPending = (currentStackLoc != stackCount+1); if ((isPending && DumpPendingPkts) || (!isPending && DumpFreePkts)){ /* * Print the transfer packet description line */ xdprintf(Depth, ""); dprintf("%08p", PktAddr); dprintf(" %08p", irpAddr); dprintf(" %08p", srbAddr); dprintf(" %08p", senseAddr); if (isPending){ xdprintf(0, " pending*"); } else { xdprintf(0, " (free)"); } xdprintf(0, "\n"); if (DumpFullInfo){ ULONG64 bufLen = GetULONGField(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "DataTransferLength"); ULONG64 cdbAddr = GetFieldAddr(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "Cdb"); ULONG64 origIrpAddr = GetULONGField(PktAddr, "classpnp!_TRANSFER_PACKET", "OriginalIrp"); ULONG64 mdlAddr = GetULONGField(origIrpAddr, "nt!_IRP", "MdlAddress"); UCHAR scsiOp = GetUCHARField(cdbAddr, "classpnp!_CDB", "CDB6GENERIC.OperationCode"); UCHAR srbStat = GetUCHARField(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "SrbStatus"); ULONG64 bufAddr; /* * The the buffer address from the MDL if possible; * else from the SRB (which may not be valid). */ bufAddr = GetULONGField(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "DataBuffer"); if (mdlAddr && (mdlAddr != BAD_VALUE)){ ULONG mdlFlags = (ULONG)GetULONGField(mdlAddr, "nt!_MDL", "MdlFlags"); if ((mdlFlags != BAD_VALUE) && (mdlFlags & MDL_PAGES_LOCKED)){ bufAddr = GetULONGField(mdlAddr, "nt!_MDL", "MappedSystemVa"); } } else { /* * There's no MDL, so bufAddr should be the actual kernel-space pointer. * Sanity-check it. */ if (!IsPtr64() && !(bufAddr & 0x80000000)){ bufAddr = BAD_VALUE; } } /* * Print the SRB description line */ xdprintf(Depth+1, "("); dprintf("%s ", DbgGetScsiOpStr(scsiOp)); dprintf("status=%s ", DbgGetSrbStatusStr(srbStat)); if (mdlAddr && (mdlAddr != BAD_VALUE)){ if (bufAddr == BAD_VALUE){ dprintf("mdl=%08p ", mdlAddr); } else { dprintf("mdl+%08p ", bufAddr); } } else if (bufAddr == BAD_VALUE){ dprintf("buf=??? "); } else { dprintf("buf=%08p ", bufAddr); } dprintf("len=%08lx", bufLen); dprintf(")\n"); /* * Print a line with original irp if appropriate */ if (cdbAddr != BAD_VALUE){ UCHAR scsiOp = GetUCHARField(cdbAddr, "classpnp!_CDB", "CDB6GENERIC.OperationCode"); if ((scsiOp == SCSIOP_READ) || (scsiOp == SCSIOP_WRITE)){ xdprintf(Depth+1, ""), dprintf("(OriginalIrp=%08p)\n", origIrpAddr); } } } } } } VOID ClassDumpPrivateErrorLogs(ULONG64 FdoDataAddr, ULONG Detail, ULONG Depth) { ULONG64 errLogsAddr; errLogsAddr = GetFieldAddr(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "ErrorLogs"); if (errLogsAddr != BAD_VALUE){ ULONG errLogSize = GetTypeSize("classpnp!_CLASS_ERROR_LOG_DATA"); if (errLogSize != BAD_VALUE){ ULONG nextErrLogIndex, firstErrLogIndex, lastErrLogIndex; /* * Find what should be the index of the last error log (if there were any error logs) * See if it is valid by checking for a non-zero timestamp. */ nextErrLogIndex = (ULONG)GetULONGField(FdoDataAddr, "classpnp!_CLASS_PRIVATE_FDO_DATA", "ErrorLogNextIndex"); if (nextErrLogIndex != BAD_VALUE){ ULONG64 tickCount; lastErrLogIndex = (nextErrLogIndex+NUM_ERROR_LOG_ENTRIES-1) % NUM_ERROR_LOG_ENTRIES; tickCount = GetULONGField(errLogsAddr+lastErrLogIndex*errLogSize, "classpnp!_CLASS_ERROR_LOG_DATA", "TickCount"); if (tickCount == BAD_VALUE){ } else if (tickCount == 0){ /* * The "latest" error log is not initialized, so there are no error logs */ dprintf("\n"), xdprintf(Depth, "No Error Logs:\n"); } else { /* * Search forward through the circular list for the first valid error log. */ for (firstErrLogIndex = (lastErrLogIndex+1)%NUM_ERROR_LOG_ENTRIES; firstErrLogIndex != lastErrLogIndex; firstErrLogIndex = (firstErrLogIndex+1)%NUM_ERROR_LOG_ENTRIES){ ULONG64 thisErrLogAddr = errLogsAddr+firstErrLogIndex*errLogSize; tickCount = GetULONGField(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "TickCount"); if (tickCount == BAD_VALUE){ /* * something's screwed up; abort */ break; } else if (tickCount != 0){ /* * found the earliest of the recorded error logs, break */ break; } } if (tickCount != BAD_VALUE){ /* * Now that we've found the valid range of error logs, print them out. */ ULONG numErrLogs = (lastErrLogIndex >= firstErrLogIndex) ? lastErrLogIndex-firstErrLogIndex+1 : lastErrLogIndex+NUM_ERROR_LOG_ENTRIES-firstErrLogIndex+1; dprintf("\n\n"), xdprintf(Depth, "ERROR LOGS (%d):\n", numErrLogs); xdprintf(Depth, "---------------------------------------------------\n"); do { ULONG64 thisErrLogAddr = errLogsAddr+firstErrLogIndex*errLogSize; ULONG64 tickCount = GetFieldAddr(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "TickCount"); ULONG64 senseDataAddr = GetFieldAddr(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "SenseData"); ULONG64 srbAddr = GetFieldAddr(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "Srb"); ULONG64 cdbAddr; // GetFieldOffset of an embedded struct gets the wrong address for some reason, // so do this manually. #if 0 cdbAddr = GetFieldAddr(thisErrLogAddr, "classpnp!_SCSI_REQUEST_BLOCK", "Cdb"); #else cdbAddr = (srbAddr == BAD_VALUE) ? BAD_VALUE : IsPtr64() ? srbAddr + 0x48 : srbAddr + 0x30; #endif if ((thisErrLogAddr != BAD_VALUE) && (srbAddr != BAD_VALUE) && (senseDataAddr != BAD_VALUE) && (cdbAddr != BAD_VALUE)){ UCHAR scsiOp = GetUCHARField(cdbAddr, "classpnp!_CDB", "CDB6GENERIC.OperationCode"); UCHAR srbStat = GetUCHARField(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "SrbStatus"); UCHAR scsiStat = GetUCHARField(srbAddr, "classpnp!_SCSI_REQUEST_BLOCK", "ScsiStatus"); UCHAR isPaging = GetUCHARField(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "ErrorPaging"); UCHAR isRetried = GetUCHARField(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "ErrorRetried"); UCHAR isUnhandled = GetUCHARField(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "ErrorUnhandled"); tickCount = GetULONGField(thisErrLogAddr, "classpnp!_CLASS_ERROR_LOG_DATA", "TickCount"); if ((scsiOp != BAD_VALUE) && (tickCount != BAD_VALUE)){ xdprintf(Depth+1, ""); dprintf(": ", (ULONG)(tickCount/1000), (ULONG)(tickCount%1000)); dprintf("%s(%xh)\n", DbgGetScsiOpStr(scsiOp), (ULONG)scsiOp); xdprintf(Depth+2, ""); dprintf("srbStat=%s(%xh) scsiStat=%xh \n", DbgGetSrbStatusStr(srbStat), (ULONG)srbStat, (ULONG)scsiStat ); xdprintf(Depth+2, ""); dprintf("SenseData = %s/%s/%s \n", DbgGetSenseCodeStr(srbStat, senseDataAddr), DbgGetAdditionalSenseCodeStr(srbStat, senseDataAddr), DbgGetAdditionalSenseCodeQualifierStr(srbStat, senseDataAddr)); xdprintf(Depth+2, ""); if (isPaging) dprintf("Paging; "); else dprintf("(not paging); "); if (isRetried) dprintf("Retried; "); else dprintf("(not retried); "); if (isUnhandled) dprintf("Unhandled; "); dprintf("\n"); xdprintf(Depth+2, ""); dprintf("(for more info, use 'dt classpnp!_CLASS_ERROR_LOG_DATA %08p'\n\n", thisErrLogAddr); firstErrLogIndex = (firstErrLogIndex+1)%NUM_ERROR_LOG_ENTRIES; } else { break; } } else { break; } } while (firstErrLogIndex != (lastErrLogIndex+1)%NUM_ERROR_LOG_ENTRIES); xdprintf(Depth, "---------------------------------------------------\n"); } } } } } } VOID ClassDumpMediaChangeInfo( ULONG64 Address, ULONG Detail, ULONG Depth ) { PUCHAR states[] = {"Unknown", "Present", "Not Present"}; ULONG result; ULONG64 MediaChangeDetectionInfo; ULONG offset; LONG MediaChangeDetectionDisableCount; ULONG MediaChangeDetectionState; BOOLEAN MediaChangeIrpLost; LONG MediaChangeIrpTimeInUse; ULONG64 MediaChangeIrp; ULONG64 SenseBuffer; result = GetFieldData(Address, "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "MediaChangeDetectionInfo", sizeof(ULONG64), &MediaChangeDetectionInfo); if (result) { SCSIKD_PRINT_ERROR(result); return; } xdprintfEx(Depth, ("MediaChangeNotification:\n")); Depth++; if (MediaChangeDetectionInfo == 0) { xdprintfEx(Depth, ("MCN is not enabled for this device\n")); return; } InitTypeRead(MediaChangeDetectionInfo, classpnp!_MEDIA_CHANGE_DETECTION_INFO); MediaChangeDetectionDisableCount = (LONG) ReadField(MediaChangeDetectionDisableCount); MediaChangeDetectionState = (ULONG) ReadField(MediaChangeDetectionState); MediaChangeIrpLost = (BOOLEAN) ReadField(MediaChangeIrpLost); MediaChangeIrpTimeInUse = (LONG) ReadField(MediaChangeIrpTimeInUse); MediaChangeIrp = ReadField(MediaChangeIrp); SenseBuffer = ReadField(SenseBuffer); result = GetFieldOffset("classpnp!_MEDIA_CHANGE_DETECTION_INFO", "MediaChangeSrb", &offset); if (result) { SCSIKD_PRINT_ERROR(result); return; } xdprintfEx(Depth, ("MCN is ")); // indent if (MediaChangeDetectionDisableCount == 0) { dprintf("Enabled "); } else { dprintf("Disabled "); } dprintf("Current State %s", states[MediaChangeDetectionState] ); if (MediaChangeIrpLost != 0) { dprintf(" *** MCN Irp Lost for %x ticks *** ", MediaChangeIrpTimeInUse); } dprintf("\n"); // end indent xdprintfEx(Depth, ("Irp %p Srb %p SenseBuffer %p\n", MediaChangeIrp, MediaChangeDetectionInfo + offset, SenseBuffer )); return; } VOID ClassDumpFdo( ULONG64 Address, ULONG Detail, ULONG Depth ) { ULONG result; ULONG offset; ULONG tmp; ULONG64 LowerPdo; ULONG64 DeviceDescriptor; ULONG64 AdapterDescriptor; ULONG DevicePowerState; ULONG ErrorCount; BOOLEAN DMActive; ULONG DMByteSkew; ULONG DMSkew; ULONG64 SenseData; ULONG TimeOutValue; ULONG DeviceNumber; ULONG FSrbFlags; USHORT DeviceFlags; ULONG64 DiskGeometryCylinders; ULONG DiskGeometryMediaType; ULONG DiskGeometryTracksPerCylinder; ULONG DiskGeometrySectorsPerTrack; ULONG DiskGeometryBytesPerSector; LONG LockCount; LONG ProtectedLockCount; LONG InternalLockCount; ULONG MediaChangeCount; ULONG64 ChildLockOwner; ULONG ChildLockAcquisitionCount; FIELD_INFO deviceFields[] = { {"LowerPdo", NULL, 0, COPY, 0, (PVOID) &LowerPdo}, {"DeviceDescriptor", NULL, 0, COPY, 0, (PVOID) &DeviceDescriptor}, {"AdapterDescriptor", NULL, 0, COPY, 0, (PVOID) &AdapterDescriptor}, {"DevicePowerState", NULL, 0, COPY, 0, (PVOID) &DevicePowerState}, {"ErrorCount", NULL, 0, COPY, 0, (PVOID) &ErrorCount}, {"DMActive", NULL, 0, COPY, 0, (PVOID) &DMActive}, {"DMByteSkew", NULL, 0, COPY, 0, (PVOID) &DMByteSkew}, {"DMSkew", NULL, 0, COPY, 0, (PVOID) &DMSkew}, {"SenseData", NULL, 0, COPY, 0, (PVOID) &SenseData}, {"TimeOutValue", NULL, 0, COPY, 0, (PVOID) &TimeOutValue}, {"DeviceNumber", NULL, 0, COPY, 0, (PVOID) &DeviceNumber}, {"SrbFlags", NULL, 0, COPY, 0, (PVOID) &FSrbFlags}, {"DeviceFlags", NULL, 0, COPY, 0, (PVOID) &DeviceFlags}, {"DiskGeometry.Cylinders", NULL, 0, COPY, 0, (PVOID) &DiskGeometryCylinders}, {"DiskGeometry.MediaType", NULL, 0, COPY, 0, (PVOID) &DiskGeometryMediaType}, {"DiskGeometry.TracksPerCylinder", NULL, 0, COPY, 0, (PVOID) &DiskGeometryTracksPerCylinder}, {"DiskGeometry.SectorsPerTrack", NULL, 0, COPY, 0, (PVOID) &DiskGeometrySectorsPerTrack}, {"DiskGeometry.BytesPerSector", NULL, 0, COPY, 0, (PVOID) &DiskGeometryBytesPerSector}, {"LockCount", NULL, 0, COPY, 0, (PVOID) &LockCount}, {"ProtectedLockCount", NULL, 0, COPY, 0, (PVOID) &ProtectedLockCount}, {"InternalLockCount", NULL, 0, COPY, 0, (PVOID) &InternalLockCount}, {"MediaChangeCount", NULL, 0, COPY, 0, (PVOID) &MediaChangeCount}, {"ChildLockOwner", NULL, 0, COPY, 0, (PVOID) &ChildLockOwner}, {"ChildLockAcquisitionCount", NULL, 0, COPY, 0, (PVOID) &ChildLockAcquisitionCount}, }; SYM_DUMP_PARAM DevSym = { sizeof (SYM_DUMP_PARAM), "classpnp!_FUNCTIONAL_DEVICE_EXTENSION", DBG_DUMP_NO_PRINT, Address, NULL, NULL, NULL, sizeof (deviceFields) / sizeof (FIELD_INFO), &deviceFields[0] }; result = Ioctl(IG_DUMP_SYMBOL_INFO, &DevSym, DevSym.size); if (result) { SCSIKD_PRINT_ERROR(result); return; } tmp = Depth; xdprintfEx(Depth, ("LowerPdo 0x%p DeviceDesc 0x%p AdapterDesc 0x%p\n", LowerPdo, DeviceDescriptor, AdapterDescriptor)); xdprintfEx(Depth, ("DevicePowerState %d ErrorCount %#x\n", DevicePowerState, ErrorCount )); if(DMActive) { xdprintfEx(Depth, ("DMByteSkew 0x%08lx DmSkew 0x%08lx\n", DMByteSkew, DMSkew)); } else { xdprintfEx(Depth, ("DM Not Found\n")); } xdprintfEx(Depth, ("Sense Data 0x%p Timeout %d DeviceNumber %d\n", SenseData, TimeOutValue, DeviceNumber)); DumpFlags(Depth, "Srb Flags", FSrbFlags, SrbFlags); DumpFlags(Depth, "Device Flags", DeviceFlags, FdoFlags); xdprintfEx(Depth, ("DiskGeometry:\n")); { Depth++; xdprintfEx(Depth, ("Cylinders %#I64x MediaType %#x\n", DiskGeometryCylinders, DiskGeometryMediaType )); xdprintfEx(Depth, ("Tracks %#x Sectors %#x Bytes %#x\n", DiskGeometryTracksPerCylinder, DiskGeometrySectorsPerTrack, DiskGeometryBytesPerSector)); Depth--; } xdprintfEx(Depth, ("Lock Counts: Normal %#x Protected %#x Internal %#x\n", LockCount, ProtectedLockCount, InternalLockCount)); ClassDumpMediaChangeInfo(Address, Detail, Depth); xdprintfEx(Depth, ("Media Change Count %#x\n", MediaChangeCount)); result = GetFieldOffset("classpnp!_FUNCTIONAL_DEVICE_EXTENSION", "ChildLock", &offset); if (result) { SCSIKD_PRINT_ERROR(result); return; } xdprintfEx(Depth, ("ChildLock: Event %08p, Owner %08p, Count %#x\n", Address + offset, ChildLockOwner, ChildLockAcquisitionCount )); ClassDumpChildren(Address, Detail, Depth); return; } VOID ClassDumpChildren( IN ULONG64 Fdo, IN ULONG Detail, IN ULONG Depth ) { ULONG i; ULONG64 ChildList; ULONG result; xdprintfEx(Depth, ("Children: \n")); Depth++; result = GetFieldData(Fdo, "classpnp!_COMMON_DEVICE_EXTENSION", "ChildList", sizeof(ULONG64), &ChildList); if (result) { SCSIKD_PRINT_ERROR(result); return; } if (ChildList == 0) { xdprintfEx(Depth, ("No Children\n")); } while((ChildList != 0) && (!CheckControlC())) { ULONG64 DeviceObject; xdprintfEx(Depth, ("Child 0x%p ", ChildList)); /* result = GetFieldData(ChildList, "classpnp!_PHYSICAL_DEVICE_EXTENSION", "DeviceObject", sizeof(ULONG64), &DeviceObject); if (result) { SCSIKD_PRINT_ERROR(result); break; } */ if(Detail > 1) { dprintf("\n"); ClassDumpCommonExtension(ChildList, Detail, Depth + 1); } else { dprintf("DevObj 0x%p\n", ChildList); } // // Get the next child. // result = GetFieldData(ChildList, "classpnp!_COMMON_DEVICE_EXTENSION", "ChildList", sizeof(ULONG64), &ChildList); if (result) { SCSIKD_PRINT_ERROR(result); break; } } return; } VOID ClassDumpPdo( ULONG64 Address, ULONG Detail, ULONG Depth ) { ULONG tmp; BOOLEAN IsMissing; BOOLEAN IsEnumerated; tmp = Depth; InitTypeRead(Address, classpnp!_PHYSICAL_DEVICE_EXTENSION); IsMissing = (BOOLEAN)ReadField(IsMissing); IsEnumerated = (BOOLEAN)ReadField(IsEnumerated); if(IsMissing) { xdprintfEx(tmp, ("Missing " )); tmp = 0; } if(IsEnumerated) { xdprintfEx(tmp, ("Enumerated")); tmp = 0; } if(tmp == 0) { dprintf("\n"); } tmp = 0; return; } BOOLEAN ClassIsCheckedVersion( ULONG64 RemoveTrackingSpinlock ) { if ((PVOID)RemoveTrackingSpinlock == (PVOID)-1) { // // negative one is an invalid value for a spinlock, // therefore this is a FRE build // return FALSE; } else { return TRUE; } } VOID ClassDumpLocks( ULONG64 CommonExtension, ULONG Depth ) /*++ Routine Description: dumps the remove locks for a given device object Arguments: CommonExtension - a pointer to the local copy of the device object common extension Return Value: None --*/ { ULONG result; ULONG64 lockEntryAddress; ULONG64 RemoveLock; ULONG64 RemoveTrackingSpinlock; ULONG64 RemoveTrackingList; InitTypeRead(CommonExtension, classpnp!_COMMON_DEVICE_EXTENSION); RemoveLock = ReadField(RemoveLock); RemoveTrackingSpinlock = ReadField(RemoveTrackingSpinlock); xdprintfEx(Depth, ("RemoveLock count is %d", RemoveLock)); // // seeing if RemoveTrackingSpinLock is -1 is our check for the // FRE version, which does not contain useful data. // if(!ClassIsCheckedVersion(RemoveTrackingSpinlock)) { dprintf(" (not tracked on free build)\n"); return; } RemoveTrackingList = ReadField(RemoveTrackingList); lockEntryAddress = RemoveTrackingList; dprintf(":\n"); Depth++; if(RemoveTrackingSpinlock != 0) { xdprintfEx(Depth, ("RemoveTrackingList at %p is in intermediate state\n", RemoveTrackingList)); return; } while((lockEntryAddress != 0L) && !CheckControlC()) { UCHAR buffer[512]; ULONG64 Tag; ULONG64 File; ULONG64 Line; ULONG64 NextBlock; InitTypeRead(lockEntryAddress, classpnp!_REMOVE_TRACKING_BLOCK); Tag = ReadField(Tag); File = ReadField(File); Line = ReadField(Line); NextBlock = ReadField(NextBlock); result = sizeof(buffer)-sizeof(UCHAR); if(!GetAnsiString(File, buffer, &result)) { xdprintfEx(Depth, ("Tag 0x%p File 0x%p Line %d\n", Tag, File, Line)); } else { PUCHAR name; name = &buffer[result]; while((result > 0) && (*(name - 1) != '\\') && (*(name - 1) != '/') && (!CheckControlC())) { name--; result--; } xdprintfEx(Depth, ("Tag 0x%p File %8s Line %d\n", Tag, name, Line)); } lockEntryAddress = NextBlock; } return; }