able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/wdm/usb/hcd/uhcd/dbg.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

727 lines
14 KiB
C
Raw Blame History

/*++
Copyright (c) 1995,1996 Microsoft Corporation
:ts=4
Module Name:
dbg.c
Abstract:
Debug Code for UHCD.
Environment:
kernel mode only
Notes:
Revision History:
10-08-95 : created
--*/
#include "wdm.h"
#include "stdarg.h"
#include "stdio.h"
#include "usbdi.h"
#include "hcdi.h"
#include "uhcd.h"
// debug compile defines
// DEBUG# sets the level of spew 0 = none
// > 2 turns on debug heap code
// NTKERN_TRACE puts ' in the format buffer so that spew goes
// to ntkern buffer
#if DBG
// This turns the looping assert so that testers can't hit g
// past our assert before we can look at it.
// Win9x testers tend to do this but NT testers are conditioned not
// to so we only enable it for a DEBUG1 compile (win9x)
ULONG UHCD_Debug_Asserts =
#ifdef DEBUG1
1;
#else
0;
#endif
// this flag causes us to write a ' in the format string
// so that the string goes to the NTKERN buffer
// this trick causes problems with driver verifier on NT
// and the trace buffer isn't in NT anyway
ULONG UHCD_W98_Debug_Trace =
#ifdef NTKERN_TRACE
1;
#else
0;
#endif
// set the debug output spew level based on the DEBUG# define
// if compiled for W98 DEBUG1 is default
// if compiled for NT zero should be default
ULONG UHCD_Debug_Trace_Level =
#ifdef DEBUG3
#define DEBUG_HEAP
3;
#else
#ifdef DEBUG2
2;
#else
#ifdef DEBUG1
1;
#else
0;
#endif // DEBUG1
#endif // DEBUG2
#endif // DEBUG3
LONG UHCD_TotalAllocatedHeapSpace = 0;
ULONG
_cdecl
UHCD_KdPrintX(
ULONG l,
PCH Format,
...
)
{
va_list list;
int i;
int arg[5];
if (UHCD_Debug_Trace_Level >= l) {
if (l <= 1) {
// if flag is set override the '
// so that the level 1 strings are
// printed on the debugger terminal
if (UHCD_W98_Debug_Trace) {
DbgPrint("UHCD.SYS: ");
*Format = ' ';
} else {
DbgPrint("'UHCD.SYS: ");
}
} else {
DbgPrint("'UHCD.SYS: ");
}
va_start(list, Format);
for (i=0; i<4; i++)
arg[i] = va_arg(list, int);
DbgPrint(Format, arg[0], arg[1], arg[2], arg[3]);
}
return 0;
}
#if 0
ULONG
UHCD_DebugCommand(
IN ULONG Command,
IN ULONG Paramater1
)
/*++
Routine Description:
This routine performs a specific debug function.
Arguments:
Command - debug function
Return Value:
STATUS_SUCCESS if successful,
STATUS_UNSUCCESSFUL otherwise
--*/
{
USBD_STATUS status = USBD_STATUS_SUCCESS;
switch (Command) {
// case DBG_DUMP_FRAME_LIST:
break;
default:
status = USBD_STATUS_INVALID_PARAMETER;
}
return status;
}
#endif
VOID
UHCD_Debug_DumpTD(
IN struct _HW_TRANSFER_DESCRIPTOR *Transfer
)
/*++
Routine Description:
Dump a transfer descriptor to the debug terminal
Arguments:
Return Value:
--*/
{
if (UHCD_Debug_Trace_Level < 3)
return;
UHCD_KdPrint((2, "'TD DESCRIPTOR @va %0x\n", Transfer));
UHCD_KdPrint((2, "'TD ActualLength %0x\n", Transfer->ActualLength));
UHCD_KdPrint((2, "'TD Reserved_1 %0x\n", Transfer->Reserved_1));
UHCD_KdPrint((2, "'TD Active %0x\n", Transfer->Active));
UHCD_KdPrint((2, "'TD StatusField %0x\n", Transfer->StatusField));
UHCD_KdPrint((2, "'TD InterruptOnComplete %0x\n", Transfer->InterruptOnComplete));
UHCD_KdPrint((2, "'TD ShortPacketDetect %0x\n", Transfer->ShortPacketDetect));
UHCD_KdPrint((2, "'TD Isochronous %0x\n", Transfer->Isochronous));
UHCD_KdPrint((2, "'TD LowSpeedControl %0x\n", Transfer->LowSpeedControl));
UHCD_KdPrint((2, "'TD ErrorCounter %0x\n", Transfer->ErrorCounter));
UHCD_KdPrint((2, "'TD ReservedMBZ %0x\n", Transfer->ReservedMBZ));
UHCD_KdPrint((2, "'TD PID %0x\n", Transfer->PID));
UHCD_KdPrint((2, "'TD Address %0x\n", Transfer->Address));
UHCD_KdPrint((2, "'TD Endpoint %0x\n", Transfer->Endpoint));
UHCD_KdPrint((2, "'TD RetryToggle %0x\n", Transfer->RetryToggle));
UHCD_KdPrint((2, "'TD Reserved_2 %0x\n", Transfer->Reserved_2));
UHCD_KdPrint((2, "'TD MaxLength %0x\n", Transfer->MaxLength));
}
VOID
UHCD_Assert(
IN PVOID FailedAssertion,
IN PVOID FileName,
IN ULONG LineNumber,
IN PCHAR Message
)
/*++
Routine Description:
Debug Assert function.
Arguments:
DeviceObject - pointer to a device object
Irp - pointer to an I/O Request Packet
Return Value:
--*/
{
assert_loop:
// just call the NT assert function and stop
// in the debugger.
RtlAssert( FailedAssertion, FileName, LineNumber, Message );
// loop here to prevent users from going past
// are assert before we can look at it
// we only do thi sif the W98 DEBUG mode is set
TRAP();
if (UHCD_Debug_Asserts) {
goto assert_loop;
}
return;
}
VOID
UHCD_CheckSystemBuffer(
IN PUCHAR VirtualAddress,
IN ULONG Length
)
/*++
Routine Description:
Verify that this virtual address points to physically
contiguous memory.
Arguments:
VirtualAddress - virtual address of the system buffer
Length - length of buffer
Return Value:
--*/
{
UHCD_ASSERT(Length <= PAGE_SIZE);
UHCD_ASSERT( ADDRESS_AND_SIZE_TO_SPAN_PAGES( VirtualAddress, Length ) <= 1 );
}
//
// tag buffer we use to mark heap blocks we allocate
//
typedef struct _HEAP_TAG_BUFFER {
ULONG Sig;
ULONG Length;
} HEAP_TAG_BUFFER, *PHEAP_TAG_BUFFER;
PVOID
UHCD_Debug_GetHeap(
IN POOL_TYPE PoolType,
IN ULONG NumberOfBytes,
IN ULONG Signature,
IN PLONG TotalAllocatedHeapSpace
)
/*++
Routine Description:
Debug routine, used to debug heap problems. We are using this since
most NT debug functions are not supported by NTKERN.
Arguments:
PoolType - pool type passed to ExAllocatePool
NumberOfBytes - number of bytes for item
Signature - four byte signature supplied by caller
TotalAllocatedHeapSpace - pointer to variable where client stores
the total accumulated heap space allocated.
Return Value:
pointer to allocated memory
--*/
{
PUCHAR p;
#ifdef DEBUG_HEAP
ULONG *stk;
PHEAP_TAG_BUFFER tagBuffer;
// we call ExAllocatePoolWithTag but no tag will be added
// when running under NTKERN
#ifdef _M_IX86
_asm mov stk, ebp
#endif
p = (PUCHAR) ExAllocatePoolWithTag(PoolType,
NumberOfBytes + sizeof(HEAP_TAG_BUFFER),
Signature);
if (p) {
tagBuffer = (PHEAP_TAG_BUFFER) p;
tagBuffer->Sig = Signature;
tagBuffer->Length = NumberOfBytes;
p += sizeof(HEAP_TAG_BUFFER);
*TotalAllocatedHeapSpace += NumberOfBytes;
}
// LOGENTRY(LOG_MISC, (PUCHAR) &Signature, 0, 0, 0);
// LOGENTRY(LOG_MISC, 'GetH', p, NumberOfBytes, stk[1] & 0x00FFFFFF);
#else
p = (PUCHAR) ExAllocatePoolWithTag(PoolType,
NumberOfBytes,
Signature);
#endif /* DEBUG_HEAP */
return p;
}
VOID
UHCD_Debug_RetHeap(
IN PVOID P,
IN ULONG Signature,
IN PLONG TotalAllocatedHeapSpace
)
/*++
Routine Description:
Debug routine, used to debug heap problems. We are using this since
most NT debug functions are not supported by NTKERN.
Arguments:
P - pointer to free
Return Value:
none.
--*/
{
#ifdef DEBUG_HEAP
PHEAP_TAG_BUFFER tagBuffer;
ULONG *stk;
UHCD_ASSERT(P != 0);
#ifdef _M_IX86
_asm mov stk, ebp
#endif
tagBuffer = (PHEAP_TAG_BUFFER) ((PUCHAR)P - sizeof(HEAP_TAG_BUFFER));
*TotalAllocatedHeapSpace -= tagBuffer->Length;
// LOGENTRY(LOG_MISC, (PUCHAR) &Signature, 0, 0, 0);
// LOGENTRY(LOG_MISC, 'RetH', P, tagBuffer->Length, stk[1] & 0x00FFFFFF);
UHCD_ASSERT(*TotalAllocatedHeapSpace >= 0);
UHCD_ASSERT(tagBuffer->Sig == Signature);
// fill the buffer with bad data
RtlFillMemory(P, tagBuffer->Length, 0xff);
tagBuffer->Sig = UHCD_FREE_TAG;
// free the original block
ExFreePool(tagBuffer);
#else
ExFreePool(P);
#endif /* DEBUG_HEAP */
}
#if DBG
VOID
UHCD_PrintPowerMessage(
PUCHAR Label,
UCHAR MinorFunction
)
/*++
Routine Description:
Arguments:
Return Value:
NT status code
--*/
{
UHCD_KdPrint((2, "'(%s) ", Label));
switch (MinorFunction) {
case IRP_MN_WAIT_WAKE:
UHCD_KdPrint((2, "'IRP_MN_WAIT_WAKE\n"));
break;
case IRP_MN_SET_POWER:
UHCD_KdPrint((2, "'IRP_MN_SET_POWER\n"));
break;
case IRP_MN_QUERY_POWER:
UHCD_KdPrint((2, "'IRP_MN_QUERY_POWER\n"));
break;
}
}
VOID
UHCD_PrintPnPMessage(
PUCHAR Label,
UCHAR MinorFunction
)
/*++
Routine Description:
Arguments:
Return Value:
NT status code
--*/
{
UHCD_KdPrint((2, "'(%s) ", Label));
switch (MinorFunction) {
case IRP_MN_START_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_START_DEVICE\n"));
break;
case IRP_MN_STOP_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_STOP_DEVICE\n"));
break;
case IRP_MN_REMOVE_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_REMOVE_DEVICE\n"));
break;
case IRP_MN_QUERY_STOP_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_QUERY_STOP_DEVICE\n"));
break;
case IRP_MN_CANCEL_STOP_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_CANCEL_STOP_DEVICE\n"));
break;
case IRP_MN_QUERY_REMOVE_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_QUERY_REMOVE_DEVICE\n"));
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
UHCD_KdPrint((2, "'IRP_MN_CANCEL_REMOVE_DEVICE\n"));
break;
}
}
#endif
#endif /* DBG */
#ifdef DEBUG_LOG
KSPIN_LOCK LogSpinLock;
struct UHCD_LOG_ENTRY {
ULONG le_sig; // Identifying string
ULONG_PTR le_info1; // entry specific info
ULONG_PTR le_info2; // entry specific info
ULONG_PTR le_info3; // entry specific info
}; /* USBD_LOG_ENTRY */
struct UHCD_LOG_ENTRY *HcdLStart = 0; // No log yet
struct UHCD_LOG_ENTRY *HcdLPtr;
struct UHCD_LOG_ENTRY *HcdLEnd;
#ifdef PROFILE
ULONG LogMask = LOG_PROFILE;
#else
ULONG LogMask = 0xFFFFFFFF;
#endif
VOID
UHCD_Debug_LogEntry(
IN ULONG Mask,
IN ULONG Sig,
IN ULONG_PTR Info1,
IN ULONG_PTR Info2,
IN ULONG_PTR Info3
)
/*++
Routine Description:
Adds an Entry to UHCD log.
Arguments:
Return Value:
None.
--*/
{
KIRQL irql;
typedef union _SIG {
struct {
UCHAR Byte0;
UCHAR Byte1;
UCHAR Byte2;
UCHAR Byte3;
} b;
ULONG l;
} SIG, *PSIG;
SIG sig, rsig;
if (HcdLStart == 0) {
return;
}
if ((Mask & LogMask) == 0) {
return;
}
irql = KeGetCurrentIrql();
if (irql < DISPATCH_LEVEL) {
KeAcquireSpinLock(&LogSpinLock, &irql);
} else {
KeAcquireSpinLockAtDpcLevel(&LogSpinLock);
}
if (HcdLPtr > HcdLStart) {
HcdLPtr -= 1; // Decrement to next entry
} else {
HcdLPtr = HcdLEnd;
}
//RtlCopyMemory(HcdLPtr->le_name, Name, 4);
// LPtr->le_ret = (stk[1] & 0x00ffffff) | (CurVMID()<<24);
sig.l = Sig;
rsig.b.Byte0 = sig.b.Byte3;
rsig.b.Byte1 = sig.b.Byte2;
rsig.b.Byte2 = sig.b.Byte1;
rsig.b.Byte3 = sig.b.Byte0;
HcdLPtr->le_sig = rsig.l;
HcdLPtr->le_info1 = Info1;
HcdLPtr->le_info2 = Info2;
HcdLPtr->le_info3 = Info3;
UHCD_ASSERT(HcdLPtr >= HcdLStart);
if (irql < DISPATCH_LEVEL) {
KeReleaseSpinLock(&LogSpinLock, irql);
} else {
KeReleaseSpinLockFromDpcLevel(&LogSpinLock);
}
return;
}
VOID
UHCD_LogInit(
)
/*++
Routine Description:
Init the debug log - remember interesting information in a circular buffer
Arguments:
Return Value:
None.
--*/
{
#ifdef MAX_DEBUG
ULONG logSize = 4096*6;
#else
ULONG logSize = 4096*3;
#endif
KeInitializeSpinLock(&LogSpinLock);
HcdLStart = ExAllocatePoolWithTag(NonPagedPool,
logSize,
UHCD_TAG);
if (HcdLStart) {
HcdLPtr = HcdLStart;
// Point the end (and first entry) 1 entry from the end of the segment
HcdLEnd = HcdLStart + (logSize / sizeof(struct UHCD_LOG_ENTRY)) - 1;
} else {
TRAP();
}
return;
}
VOID
UHCD_LogFree(
)
/*++
Routine Description:
Arguments:
Return Value:
None.
--*/
{
if (HcdLStart) {
ExFreePool(HcdLStart);
}
return;
}
VOID
UHCD_LogTD(
IN ULONG s,
IN PULONG p
)
{
LOGENTRY(LOG_MISC, s, p, 0, 0);
LOGENTRY(LOG_MISC, s, *p, *(p+1), *(p+2));
LOGENTRY(LOG_MISC, s, *(p+3), *(p+4), *(p+5));
}
#ifdef DEBUG_LOG_IO
#undef WRITE_PORT_USHORT
#undef WRITE_PORT_ULONG
#undef WRITE_PORT_UCHAR
#undef READ_PORT_USHORT
#undef READ_PORT_ULONG
#undef READ_PORT_UCHAR
USHORT
UhcdLogIoUshort(PUSHORT Port, USHORT Val, BOOLEAN Write)
{
USHORT rval = 0;
if (Write) {
LOGENTRY(LOG_IO, 'WrUS', Port, (ULONG_PTR)Val & 0x0000ffff, 0);
WRITE_PORT_USHORT(Port, Val);
} else {
rval = READ_PORT_USHORT(Port);
LOGENTRY(LOG_IO, 'RdUS', Port, (ULONG_PTR)rval & 0x0000ffff, 0);
}
return rval;
}
ULONG
UhcdLogIoUlong(PULONG Port, ULONG Val, BOOLEAN Write)
{
ULONG rval = 0;
if (Write) {
LOGENTRY(LOG_IO, 'WrUL', Port, Val, 0);
WRITE_PORT_ULONG(Port, Val);
} else {
rval = READ_PORT_ULONG(Port);
LOGENTRY(LOG_IO, 'RdUL', Port, rval, 0);
}
return rval;
}
UCHAR
UhcdLogIoUchar(PUCHAR Port, UCHAR Val, BOOLEAN Write)
{
UCHAR rval = 0;
if (Write) {
LOGENTRY(LOG_IO, 'WrUC', Port, (ULONG_PTR)Val & 0x000000ff, 0);
WRITE_PORT_UCHAR(Port, Val);
} else {
rval = READ_PORT_UCHAR(Port);
LOGENTRY(LOG_IO, 'RdUC', Port, (ULONG_PTR)rval & 0x000000ff, 0);
}
return rval;
}
#endif // DEBUG_LOG_IO
#endif /* DEBUG_LOG */
Reference in a new issue View git blame Copy permalink