PLIST_ENTRY current_entry;
PCACHE_SEGMENT current;
- DPRINT("CcCopyRead(FileObject %x, FileOffset %x, "
- "Length %d, Wait %d, Buffer %x, IoStatus %x)\n",
- FileObject, (ULONG)FileOffset->QuadPart, Length, Wait,
+ DPRINT("CcCopyRead(FileObject 0x%p, FileOffset %I64x, "
+ "Length %d, Wait %d, Buffer 0x%p, IoStatus 0x%p)\n",
+ FileObject, FileOffset->QuadPart, Length, Wait,
Buffer, IoStatus);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
PVOID BaseAddress;
BOOLEAN Valid;
- DPRINT("CcCopyWrite(FileObject %x, FileOffset %x, "
- "Length %d, Wait %d, Buffer %x)\n",
- FileObject, (ULONG)FileOffset->QuadPart, Length, Wait, Buffer);
+ DPRINT("CcCopyWrite(FileObject 0x%p, FileOffset %I64x, "
+ "Length %d, Wait %d, Buffer 0x%p)\n",
+ FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
WriteOffset = (ULONG)FileOffset->QuadPart;
IO_STATUS_BLOCK Iosb;
KEVENT Event;
- DPRINT("CcZeroData(FileObject %x, StartOffset %I64x, EndOffset %I64x, "
+ DPRINT("CcZeroData(FileObject 0x%p, StartOffset %I64x, EndOffset %I64x, "
"Wait %d)\n", FileObject, StartOffset->QuadPart, EndOffset->QuadPart,
Wait);
LIST_ENTRY FreeListHead;
NTSTATUS Status;
- DPRINT("CcSetFileSizes(FileObject %x, FileSizes %x)\n",
+ DPRINT("CcSetFileSizes(FileObject 0x%p, FileSizes 0x%p)\n",
FileObject, FileSizes);
DPRINT("AllocationSize %d, FileSize %d, ValidDataLength %d\n",
(ULONG)FileSizes->AllocationSize.QuadPart,
Status = CcRosInternalFreeCacheSegment(current);
if (!NT_SUCCESS(Status))
{
- DPRINT1("CcRosInternalFreeCacheSegment failed, status = %x\n");
+ DPRINT1("CcRosInternalFreeCacheSegment failed, status = %x\n", Status);
KEBUGCHECK(0);
}
}
PINTERNAL_BCB iBcb;
ULONG ROffset;
- DPRINT("CcMapData(FileObject %x, FileOffset %d, Length %d, Wait %d,"
- " pBcb %x, pBuffer %x)\n", FileObject, (ULONG)FileOffset->QuadPart,
+ DPRINT("CcMapData(FileObject 0x%p, FileOffset %I64x, Length %d, Wait %d,"
+ " pBcb 0x%p, pBuffer 0x%p)\n", FileObject, FileOffset->QuadPart,
Length, Wait, pBcb, pBuffer);
ReadOffset = (ULONG)FileOffset->QuadPart;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(Bcb);
- DPRINT("AllocationSize %d, FileSize %d\n",
- (ULONG)Bcb->AllocationSize.QuadPart,
- (ULONG)Bcb->FileSize.QuadPart);
+ DPRINT("AllocationSize %I64x, FileSize %I64x\n",
+ Bcb->AllocationSize.QuadPart,
+ Bcb->FileSize.QuadPart);
if (ReadOffset % Bcb->CacheSegmentSize + Length > Bcb->CacheSegmentSize)
{
ASSERT(Bcb);
- DPRINT("CcReleaseCacheSegment(Bcb %x, CacheSeg %x, Valid %d)\n",
+ DPRINT("CcReleaseCacheSegment(Bcb 0x%p, CacheSeg 0x%p, Valid %d)\n",
Bcb, CacheSeg, Valid);
CacheSeg->Valid = Valid;
ASSERT(Bcb);
- DPRINT("CcRosLookupCacheSegment(Bcb %x, FileOffset %d)\n", Bcb, FileOffset);
+ DPRINT("CcRosLookupCacheSegment(Bcb -x%p, FileOffset %d)\n", Bcb, FileOffset);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
current_entry = Bcb->BcbSegmentListHead.Flink;
ASSERT(Bcb);
- DPRINT("CcRosMarkDirtyCacheSegment(Bcb %x, FileOffset %d)\n", Bcb, FileOffset);
+ DPRINT("CcRosMarkDirtyCacheSegment(Bcb 0x%p, FileOffset %d)\n", Bcb, FileOffset);
CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
if (CacheSeg == NULL)
ASSERT(Bcb);
- DPRINT("CcRosUnmapCacheSegment(Bcb %x, FileOffset %d, NowDirty %d)\n",
+ DPRINT("CcRosUnmapCacheSegment(Bcb 0x%p, FileOffset %d, NowDirty %d)\n",
Bcb, FileOffset, NowDirty);
CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
PFN_TYPE Page;
KIRQL oldIrql;
#endif
- DPRINT("Freeing cache segment %x\n", CacheSeg);
+ DPRINT("Freeing cache segment 0x%p\n", CacheSeg);
#ifdef CACHE_BITMAP
RegionSize = CacheSeg->Bcb->CacheSegmentSize / PAGE_SIZE;
ASSERT(Bcb);
- DPRINT("CcRosFreeCacheSegment(Bcb %x, CacheSeg %x)\n",
+ DPRINT("CcRosFreeCacheSegment(Bcb 0x%p, CacheSeg 0x%p)\n",
Bcb, CacheSeg);
ExAcquireFastMutex(&ViewLock);
NTSTATUS Status;
KIRQL oldIrql;
- DPRINT("CcFlushCache(SectionObjectPointers %x, FileOffset %x, Length %d, IoStatus %x)\n",
+ DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %d, IoStatus 0x%p)\n",
SectionObjectPointers, FileOffset, Length, IoStatus);
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
PBCB Bcb;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
- DPRINT("CcRosInitializeFileCache(FileObject %x, *Bcb %x, CacheSegmentSize %d)\n",
+ DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %d)\n",
FileObject, Bcb, CacheSegmentSize);
ExAcquireFastMutex(&ViewLock);
PAGED_CODE();
- DPRINT("CmpFindObject(ObjectAttributes %x, ReturnedObject %x, "
- "RemainingPath %x)\n",ObjectAttributes,ReturnedObject,RemainingPath);
+ DPRINT("CmpFindObject(ObjectAttributes 0x%p, ReturnedObject 0x%p, "
+ "RemainingPath 0x%p)\n",ObjectAttributes,ReturnedObject,RemainingPath);
DPRINT("ObjectAttributes->ObjectName %wZ\n",
ObjectAttributes->ObjectName);
PAGED_CODE();
- DPRINT("NtCreateKey (Name %wZ KeyHandle %x Root %x)\n",
+ DPRINT("NtCreateKey (Name %wZ KeyHandle 0x%p Root 0x%p)\n",
ObjectAttributes->ObjectName,
KeyHandle,
ObjectAttributes->RootDirectory);
}
}
- DPRINT("RemainingPath %S ParentObject %x\n", RemainingPath.Buffer, Object);
+ DPRINT("RemainingPath %S ParentObject 0x%p\n", RemainingPath.Buffer, Object);
Status = ObCreateObject(ExGetPreviousMode(),
CmiKeyType,
PAGED_CODE();
- DPRINT("NtDeleteKey(KeyHandle %x) called\n", KeyHandle);
+ DPRINT("NtDeleteKey(KeyHandle 0x%p) called\n", KeyHandle);
PreviousMode = ExGetPreviousMode();
PreviousMode = ExGetPreviousMode();
- DPRINT("KH %x I %d KIC %x KI %x L %d RL %x\n",
+ DPRINT("KH 0x%p I %d KIC %x KI 0x%p L %d RL 0x%p\n",
KeyHandle,
Index,
KeyInformationClass,
PAGED_CODE();
- DPRINT("KH %x I %d KVIC %x KVI %x L %d RL %x\n",
+ DPRINT("KH 0x%p I %d KVIC %x KVI 0x%p L %d RL 0x%p\n",
KeyHandle,
Index,
KeyValueInformationClass,
PAGED_CODE();
- DPRINT("NtOpenKey(KH %x DA %x OA %x OA->ON '%wZ'\n",
+ DPRINT("NtOpenKey(KH 0x%p DA %x OA 0x%p OA->ON '%wZ'\n",
KeyHandle,
DesiredAccess,
ObjectAttributes,
PAGED_CODE();
- DPRINT("NtQueryKey(KH %x KIC %x KI %x L %d RL %x)\n",
+ DPRINT("NtQueryKey(KH 0x%p KIC %x KI 0x%p L %d RL 0x%p)\n",
KeyHandle,
KeyInformationClass,
KeyInformation,
PAGED_CODE();
- DPRINT("NtQueryValueKey(KeyHandle %x ValueName %S Length %x)\n",
+ DPRINT("NtQueryValueKey(KeyHandle 0x%p ValueName %S Length %x)\n",
KeyHandle, ValueName->Buffer, Length);
/* Verify that the handle is valid and is a registry key */
PAGED_CODE();
- DPRINT("NtSetValueKey(KeyHandle %x ValueName '%wZ' Type %d)\n",
+ DPRINT("NtSetValueKey(KeyHandle 0x%p ValueName '%wZ' Type %d)\n",
KeyHandle, ValueName, Type);
DesiredAccess = KEY_SET_VALUE;
RtlZeroMemory (Hive,
sizeof(REGISTRY_HIVE));
- DPRINT("Hive %x\n", Hive);
+ DPRINT("Hive 0x%p\n", Hive);
Hive->HiveHeader = (PHIVE_HEADER)ExAllocatePool (NonPagedPool,
sizeof(HIVE_HEADER));
RtlZeroMemory (Hive,
sizeof(REGISTRY_HIVE));
- DPRINT ("Hive %x\n", Hive);
+ DPRINT ("Hive 0x%p\n", Hive);
Hive->HiveHeader = (PHIVE_HEADER)ExAllocatePool (NonPagedPool,
REG_BLOCK_SIZE);
RtlZeroMemory (Hive->HiveHeader,
REG_BLOCK_SIZE);
- DPRINT ("HiveHeader %x\n", Hive->HiveHeader);
+ DPRINT ("HiveHeader 0x%p\n", Hive->HiveHeader);
Hive->Flags = HIVE_NO_FILE;
RtlZeroMemory (Hive,
sizeof(REGISTRY_HIVE));
- DPRINT ("Hive %x\n", Hive);
+ DPRINT ("Hive 0x%p\n", Hive);
Hive->Flags = (Flags & REG_NO_LAZY_FLUSH) ? HIVE_NO_SYNCH : 0;
Hive->HiveHeader = (PHIVE_HEADER)ExAllocatePool(NonPagedPool,
ExReleaseResourceLite(&CmiRegistryLock);
KeLeaveCriticalRegion();
- DPRINT("DeferredContext %x\n", DeferredContext);
+ DPRINT("DeferredContext 0x%p\n", DeferredContext);
ExFreePool(DeferredContext);
DPRINT("CmiHiveSyncRoutine() done\n");
CmiHiveSyncRoutine,
WorkQueueItem);
- DPRINT("DeferredContext %x\n", WorkQueueItem);
+ DPRINT("DeferredContext 0x%p\n", WorkQueueItem);
ExQueueWorkItem(WorkQueueItem,
CriticalWorkQueue);
}
RtlpCreateUnicodeString(&FoundObject->Name,
KeyName.Buffer, NonPagedPool);
CmiAddKeyToList(ParsedKey, FoundObject);
- DPRINT("Created object 0x%x\n", FoundObject);
+ DPRINT("Created object 0x%p\n", FoundObject);
}
else
{
/* to allow a dichotomic search */
ParentKey->SubKeys[ParentKey->NumberOfSubKeys++] = NewKey;
- DPRINT("Reference parent key: 0x%x\n", ParentKey);
+ DPRINT("Reference parent key: 0x%p\n", ParentKey);
ObReferenceObjectByPointer(ParentKey,
STANDARD_RIGHTS_REQUIRED,
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCreateDebugObject(0x%x, 0x%x, 0x%x)\n", DebugHandle, DesiredAccess, ObjectAttributes);
+ DPRINT("NtCreateDebugObject(0x%p, 0x%x, 0x%p)\n", DebugHandle, DesiredAccess, ObjectAttributes);
/* Check Output Safety */
if(PreviousMode != KernelMode) {
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCreateEvent(0x%x, 0x%x, 0x%x)\n", EventHandle, DesiredAccess, ObjectAttributes);
+ DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n", EventHandle, DesiredAccess, ObjectAttributes);
/* Check Output Safety */
if(PreviousMode != KernelMode) {
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtOpenEvent(0x%x, 0x%x, 0x%x)\n", EventHandle, DesiredAccess, ObjectAttributes);
+ DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n", EventHandle, DesiredAccess, ObjectAttributes);
/* Check Output Safety */
if(PreviousMode != KernelMode) {
PEVENT_BASIC_INFORMATION BasicInfo = (PEVENT_BASIC_INFORMATION)EventInformation;
PAGED_CODE();
- DPRINT("NtQueryEvent(0x%x, 0x%x, 0x%x)\n", EventHandle, EventInformationClass);
+ DPRINT("NtQueryEvent(0x%p, 0x%x)\n", EventHandle, EventInformationClass);
/* Check buffers and class validity */
DefaultQueryInfoBufferCheck(EventInformationClass,
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCreateEventPair: %x\n", EventPairHandle);
+ DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle);
/* Check Output Safety */
if(PreviousMode == UserMode) {
NTSTATUS Status;
PAGED_CODE();
- DPRINT("NtSetHighEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
NTSTATUS Status;
PAGED_CODE();
- DPRINT("NtSetHighWaitLowEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
PreviousMode = ExGetPreviousMode();
- DPRINT1("NtSetHighEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT1("NtSetHighEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
NTSTATUS Status;
PAGED_CODE();
- DPRINT("NtSetHighWaitLowEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
NTSTATUS Status;
PAGED_CODE();
- DPRINT("NtSetHighWaitLowEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
NTSTATUS Status;
PAGED_CODE();
- DPRINT("NtSetHighWaitLowEventPair(EventPairHandle %x)\n", EventPairHandle);
+ DPRINT("NtSetHighWaitLowEventPair(EventPairHandle 0x%p)\n", EventPairHandle);
/* Open the Object */
Status = ObReferenceObjectByHandle(EventPairHandle,
PAGED_CODE();
- DPRINT("Entering handle table entry 0x%x lock...\n", Entry);
+ DPRINT("Entering handle table entry 0x%p lock...\n", Entry);
ASSERT(HandleTable);
ASSERT(Entry);
if(!Current)
{
- DPRINT("Attempted to lock empty handle table entry 0x%x or handle table shut down\n", Entry);
+ DPRINT("Attempted to lock empty handle table entry 0x%p or handle table shut down\n", Entry);
break;
}
(PVOID)New,
(PVOID)Current) == (PVOID)Current)
{
- DPRINT("SUCCESS handle table 0x%x entry 0x%x lock\n", HandleTable, Entry);
+ DPRINT("SUCCESS handle table 0x%p entry 0x%p lock\n", HandleTable, Entry);
/* we acquired the lock */
return TRUE;
}
else
{
freehandletable:
- DPRINT1("Failed to duplicate handle table 0x%x\n", SourceHandleTable);
+ DPRINT1("Failed to duplicate handle table 0x%p\n", SourceHandleTable);
ExReleaseHandleTableLock(SourceHandleTable);
ASSERT(Handle);
ASSERT(KeGetCurrentThread() != NULL);
- DPRINT("HT[0x%x]: HandleCount: %d\n", HandleTable, HandleTable->HandleCount);
+ DPRINT("HT[0x%p]: HandleCount: %d\n", HandleTable, HandleTable->HandleCount);
if(HandleTable->HandleCount < EX_MAX_HANDLES)
{
ASSERT(ELI_FROM_HANDLE(HandleTable->NextIndexNeedingPool) == 0);
- DPRINT("HandleTable->Table[%d] == 0x%x\n", tli, HandleTable->Table[tli]);
+ DPRINT("HandleTable->Table[%d] == 0x%p\n", tli, HandleTable->Table[tli]);
/* allocate a middle level entry list if required */
nmtbl = HandleTable->Table[tli];
ASSERT(nmtbl[mli] == NULL);
}
- DPRINT("HandleTable->Table[%d][%d] == 0x%x\n", tli, mli, nmtbl[mli]);
+ DPRINT("HandleTable->Table[%d][%d] == 0x%p\n", tli, mli, nmtbl[mli]);
if(HandleTable->QuotaProcess != NULL)
{
}
else
{
- DPRINT1("Can't allocate any more handles in handle table 0x%x!\n", HandleTable);
+ DPRINT1("Can't allocate any more handles in handle table 0x%p!\n", HandleTable);
}
return Entry;
ASSERT(Entry);
ASSERT(IS_VALID_EX_HANDLE(Handle));
- DPRINT("ExpFreeHandleTableEntry HT:0x%x Entry:0x%x\n", HandleTable, Entry);
+ DPRINT("ExpFreeHandleTableEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
/* automatically unlock the entry if currently locked. We however don't notify
anyone who waited on the handle because we're holding an exclusive lock after
mlp != NULL && mlp[mli] != NULL && mlp[mli][eli].u1.Object != NULL)
{
Entry = &mlp[mli][eli];
- DPRINT("handle lookup 0x%x -> entry 0x%x [HT:0x%x] ptr: 0x%x\n", Handle, Entry, HandleTable, mlp[mli][eli].u1.Object);
+ DPRINT("handle lookup 0x%x -> entry 0x%p [HT:0x%p] ptr: 0x%p\n", Handle, Entry, HandleTable, mlp[mli][eli].u1.Object);
}
}
else
PAGED_CODE();
- DPRINT("Entering handle table entry 0x%x lock...\n", Entry);
+ DPRINT("Entering handle table entry 0x%p lock...\n", Entry);
ASSERT(HandleTable);
ASSERT(Entry);
if(!Current || (HandleTable->Flags & EX_HANDLE_TABLE_CLOSING))
{
- DPRINT("Attempted to lock empty handle table entry 0x%x or handle table shut down\n", Entry);
+ DPRINT("Attempted to lock empty handle table entry 0x%p or handle table shut down\n", Entry);
break;
}
(PVOID)New,
(PVOID)Current) == (PVOID)Current)
{
- DPRINT("SUCCESS handle table 0x%x entry 0x%x lock\n", HandleTable, Entry);
+ DPRINT("SUCCESS handle table 0x%p entry 0x%p lock\n", HandleTable, Entry);
/* we acquired the lock */
return TRUE;
}
ASSERT(HandleTable);
ASSERT(Entry);
- DPRINT("ExUnlockHandleTableEntry HT:0x%x Entry:0x%x\n", HandleTable, Entry);
+ DPRINT("ExUnlockHandleTableEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
Current = (volatile ULONG_PTR)Entry->u1.Object;
/* This routine requires the entry to be locked */
ASSERT((ULONG_PTR)Entry->u1.Object & EX_HANDLE_ENTRY_LOCKED);
- DPRINT("DestroyHandleByEntry HT:0x%x Entry:0x%x\n", HandleTable, Entry);
+ DPRINT("DestroyHandleByEntry HT:0x%p Entry:0x%p\n", HandleTable, Entry);
KeEnterCriticalRegion();
ExAcquireHandleTableLockExclusive(HandleTable);
Handle);
if (HandleTableEntry != NULL && ExLockHandleTableEntry(HandleTable, HandleTableEntry))
{
- DPRINT("ExMapHandleToPointer HT:0x%x Entry:0x%x locked\n", HandleTable, HandleTableEntry);
+ DPRINT("ExMapHandleToPointer HT:0x%p Entry:0x%p locked\n", HandleTable, HandleTableEntry);
return HandleTableEntry;
}
ULONG Tag,
USHORT Depth)
{
- DPRINT("Initializing nonpaged lookaside list at 0x%X\n", Lookaside);
+ DPRINT("Initializing nonpaged lookaside list at 0x%p\n", Lookaside);
/* Initialize the Header */
ExInitializeSListHead(&Lookaside->L.ListHead);
ULONG Tag,
USHORT Depth)
{
- DPRINT("Initializing paged lookaside list at 0x%X\n", Lookaside);
+ DPRINT("Initializing paged lookaside list at 0x%p\n", Lookaside);
/* Initialize the Header */
ExInitializeSListHead(&Lookaside->L.ListHead);
ExpDeleteMutant(PVOID ObjectBody)
{
- DPRINT("ExpDeleteMutant(ObjectBody %x)\n", ObjectBody);
+ DPRINT("ExpDeleteMutant(ObjectBody 0x%p)\n", ObjectBody);
/* Make sure to release the Mutant */
KeReleaseMutant((PKMUTANT)ObjectBody,
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCreateMutant(0x%x, 0x%x, 0x%x)\n", MutantHandle, DesiredAccess, ObjectAttributes);
+ DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n", MutantHandle, DesiredAccess, ObjectAttributes);
/* Check Output Safety */
if(PreviousMode == UserMode) {
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtOpenMutant(0x%x, 0x%x, 0x%x)\n", MutantHandle, DesiredAccess, ObjectAttributes);
+ DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n", MutantHandle, DesiredAccess, ObjectAttributes);
/* Check Output Safety */
if(PreviousMode == UserMode) {
PreviousMode = ExGetPreviousMode();
- DPRINT("NtReleaseMutant(MutantHandle 0%x PreviousCount 0%x)\n",
+ DPRINT("NtReleaseMutant(MutantHandle 0x%p PreviousCount 0x%p)\n",
MutantHandle,
PreviousCount);
{
KIRQL oldIrql;
- DPRINT("ExAcquireResourceExclusiveLite(Resource %x, Wait %d)\n",
+ DPRINT("ExAcquireResourceExclusiveLite(Resource 0x%p, Wait %d)\n",
Resource, Wait);
ASSERT_IRQL_LESS(DISPATCH_LEVEL);
POWNER_ENTRY freeEntry;
ULONG i = 0;
- DPRINT("EiAddSharedOwner(Resource %x)\n", Resource);
+ DPRINT("EiAddSharedOwner(Resource 0x%p)\n", Resource);
if (Resource->ActiveCount == 0)
{
}
}
- DPRINT("Found free entry %x\n", freeEntry);
+ DPRINT("Found free entry 0x%p\n", freeEntry);
if (!freeEntry)
{
{
KIRQL oldIrql;
- DPRINT("ExAcquireResourceSharedLite(Resource %x, Wait %d)\n",
+ DPRINT("ExAcquireResourceSharedLite(Resource 0x%p, Wait %d)\n",
Resource, Wait);
ASSERT_IRQL_LESS(DISPATCH_LEVEL);
ULONG oldWaiters;
KIRQL oldIrql;
- DPRINT("ExConvertExclusiveToSharedLite(Resource %x)\n", Resource);
+ DPRINT("ExConvertExclusiveToSharedLite(Resource 0x%p)\n", Resource);
KeAcquireSpinLock(&Resource->SpinLock, &oldIrql);
{
KIRQL oldIrql;
- DPRINT("ExAcquireSharedStarveExclusive(Resource %x, Wait %d)\n",
+ DPRINT("ExAcquireSharedStarveExclusive(Resource 0x%p, Wait %d)\n",
Resource, Wait);
KeAcquireSpinLock(&Resource->SpinLock, &oldIrql);
PERESOURCE Resource
)
{
- DPRINT("ExDeleteResourceLite(Resource %x)\n", Resource);
+ DPRINT("ExDeleteResourceLite(Resource 0x%p)\n", Resource);
if (Resource->OwnerTable) ExFreePool(Resource->OwnerTable);
if (Resource->SharedWaiters) ExFreePool(Resource->SharedWaiters);
if (Resource->ExclusiveWaiters) ExFreePool(Resource->ExclusiveWaiters);
NTSTATUS STDCALL
ExInitializeResourceLite (PERESOURCE Resource)
{
- DPRINT("ExInitializeResourceLite(Resource %x)\n", Resource);
+ DPRINT("ExInitializeResourceLite(Resource 0x%p)\n", Resource);
memset(Resource,0,sizeof(ERESOURCE));
Resource->NumberOfSharedWaiters = 0;
Resource->NumberOfExclusiveWaiters = 0;
{
KIRQL oldIrql;
- DPRINT("ExReleaseResourceForThreadLite(Resource %x, ResourceThreadId %x)\n",
+ DPRINT("ExReleaseResourceForThreadLite(Resource 0x%p, ResourceThreadId 0x%p)\n",
Resource, ResourceThreadId);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
ASSERT (Timer->ApcAssociated);
Timer->ApcAssociated = FALSE;
- DPRINT("Timer, ThreadList: %x, %x\n", Timer, Thread);
+ DPRINT("Timer, ThreadList: 0x%p, 0x%p\n", Timer, Thread);
/* Unlock the list */
KeReleaseSpinLockFromDpcLevel(&Thread->ActiveTimerListLock);
KIRQL OldIrql;
PETIMER Timer = ObjectBody;
- DPRINT("ExpDeleteTimer(Timer: %x)\n", Timer);
+ DPRINT("ExpDeleteTimer(Timer: 0x%p)\n", Timer);
/* Lock the Wake List */
KeAcquireSpinLock(&ExpWakeListLock, &OldIrql);
PETIMER Timer;
KIRQL OldIrql;
- DPRINT("ExpTimerDpcRoutine(Dpc: %x)\n", Dpc);
+ DPRINT("ExpTimerDpcRoutine(Dpc: 0x%p)\n", Dpc);
/* Get the Timer Object */
Timer = (PETIMER)DeferredContext;
/* We need to find out which Timer we are */
Timer = CONTAINING_RECORD(Apc, ETIMER, TimerApc);
- DPRINT("ExpTimerApcKernelRoutine(Apc: %x. Timer: %x)\n", Apc, Timer);
+ DPRINT("ExpTimerApcKernelRoutine(Apc: 0x%p. Timer: 0x%p)\n", Apc, Timer);
/* Lock the Timer */
KeAcquireSpinLock(&Timer->Lock, &OldIrql);
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCancelTimer(0x%x, 0x%x)\n", TimerHandle, CurrentState);
+ DPRINT("NtCancelTimer(0x%p, 0x%x)\n", TimerHandle, CurrentState);
/* Check Parameter Validity */
if(CurrentState != NULL && PreviousMode != KernelMode) {
/* Check for success */
if(NT_SUCCESS(Status)) {
- DPRINT("Timer Referencced: %x\n", Timer);
+ DPRINT("Timer Referenced: 0x%p\n", Timer);
/* Lock the Timer */
KeAcquireSpinLock(&Timer->Lock, &OldIrql);
* Get the Thread.
*/
TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread, ETHREAD, Tcb);
- DPRINT("Removing from Thread: %x\n", TimerThread);
+ DPRINT("Removing from Thread: 0x%p\n", TimerThread);
/* Lock its active list */
KeAcquireSpinLockAtDpcLevel(&TimerThread->ActiveTimerListLock);
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtCreateTimer(Handle: %x, Type: %d)\n", TimerHandle, TimerType);
+ DPRINT("NtCreateTimer(Handle: 0x%p, Type: %d)\n", TimerHandle, TimerType);
/* Check Parameter Validity */
if (PreviousMode != KernelMode) {
if(NT_SUCCESS(Status)) {
/* Initialize the Kernel Timer */
- DPRINT("Initializing Timer: %x\n", Timer);
+ DPRINT("Initializing Timer: 0x%p\n", Timer);
KeInitializeTimerEx(&Timer->KeTimer, TimerType);
/* Initialize the Timer Lock */
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtOpenTimer(TimerHandle: %x)\n", TimerHandle);
+ DPRINT("NtOpenTimer(TimerHandle: 0x%p)\n", TimerHandle);
/* Check Parameter Validity */
if (PreviousMode != KernelMode) {
PTIMER_BASIC_INFORMATION BasicInfo = (PTIMER_BASIC_INFORMATION)TimerInformation;
PAGED_CODE();
- DPRINT("NtQueryTimer(TimerHandle: %x, Class: %d)\n", TimerHandle, TimerInformationClass);
+ DPRINT("NtQueryTimer(TimerHandle: 0x%p, Class: %d)\n", TimerHandle, TimerInformationClass);
/* Check Validity */
DefaultQueryInfoBufferCheck(TimerInformationClass,
_SEH_TRY {
/* FIXME: Interrupt correction based on Interrupt Time */
- DPRINT("Returning Information for Timer: %x. Time Remaining: %d\n", Timer, Timer->KeTimer.DueTime.QuadPart);
+ DPRINT("Returning Information for Timer: 0x%p. Time Remaining: %I64x\n", Timer, Timer->KeTimer.DueTime.QuadPart);
BasicInfo->TimeRemaining.QuadPart = Timer->KeTimer.DueTime.QuadPart;
BasicInfo->SignalState = KeReadStateTimer(&Timer->KeTimer);
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
- DPRINT("NtSetTimer(TimerHandle: %x, DueTime: %d, Apc: %x, Period: %d)\n", TimerHandle, DueTime->QuadPart, TimerApcRoutine, Period);
+ DPRINT("NtSetTimer(TimerHandle: 0x%p, DueTime: %I64x, Apc: 0x%p, Period: %d)\n", TimerHandle, DueTime->QuadPart, TimerApcRoutine, Period);
/* Check Parameter Validity */
if (PreviousMode != KernelMode) {
if (NT_SUCCESS(Status)) {
/* Lock the Timer */
- DPRINT("Timer Referencced: %x\n", Timer);
+ DPRINT("Timer Referencced: 0x%p\n", Timer);
KeAcquireSpinLock(&Timer->Lock, &OldIrql);
/* Cancel Running Timer */
* Get the Thread.
*/
TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread, ETHREAD, Tcb);
- DPRINT("Thread already running. Removing from Thread: %x\n", TimerThread);
+ DPRINT("Thread already running. Removing from Thread: 0x%p\n", TimerThread);
/* Lock its active list */
KeAcquireSpinLockAtDpcLevel(&TimerThread->ActiveTimerListLock);
if (TimerApcRoutine) {
/* Initialize the APC */
- DPRINT("Initializing APC: %x\n", Timer->TimerApc);
+ DPRINT("Initializing APC: 0x%p\n", Timer->TimerApc);
KeInitializeApc(&Timer->TimerApc,
&CurrentThread->Tcb,
CurrentApcEnvironment,
{
Granted = CONTAINING_RECORD(EnumEntry, FILE_LOCK_GRANTED , ListEntry);
- DPRINT1("%s, start: %i, len: %i, end: %i, key: %i, proc: 0x%X, fob: 0x%X\n",
+ DPRINT1("%s, start: %I64x, len: %I64x, end: %I64x, key: %i, proc: 0x%p, fob: 0x%p\n",
Granted->Lock.ExclusiveLock ? "EXCL" : "SHRD",
Granted->Lock.StartingByte.QuadPart,
Granted->Lock.Length.QuadPart,
Irp = CONTAINING_RECORD(EnumEntry, IRP , Tail.Overlay.ListEntry);
Stack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("%s, start: %i, len: %i, end: %i, key: %i, proc: 0x%X, fob: 0x%X\n",
+ DPRINT1("%s, start: %I64x, len: %I64x, end: %I64x, key: %i, proc: 0x%p, fob: 0x%p\n",
(Stack->Flags & SL_EXCLUSIVE_LOCK) ? "EXCL" : "SHRD",
Stack->Parameters.LockControl.ByteOffset.QuadPart,
Stack->Parameters.LockControl.Length->QuadPart,
PDEVICE_OBJECT AttachedDevice;
NTSTATUS Status = STATUS_SUCCESS;
- DPRINT("IoAttachDeviceByPointer(SourceDevice %x, TargetDevice %x)\n",
+ DPRINT("IoAttachDeviceByPointer(SourceDevice 0x%p, TargetDevice 0x%p)\n",
SourceDevice, TargetDevice);
/* Do the Attach */
&LocalAttach);
/* Return it */
- DPRINT("IoAttachDeviceToDeviceStack DONE: %x\n", LocalAttach);
+ DPRINT("IoAttachDeviceToDeviceStack DONE: 0x%p\n", LocalAttach);
return LocalAttach;
}
PDEVICE_OBJECT AttachedDevice;
PDEVOBJ_EXTENSION SourceDeviceExtension;
- DPRINT("IoAttachDeviceToDeviceStack(SourceDevice %x, TargetDevice %x)\n",
+ DPRINT("IoAttachDeviceToDeviceStack(SourceDevice 0x%p, TargetDevice 0x%p)\n",
SourceDevice, TargetDevice);
/* Get the Attached Device and source extension */
HANDLE TempHandle;
ASSERT_IRQL(PASSIVE_LEVEL);
- DPRINT("IoCreateDevice(DriverObject %x)\n",DriverObject);
+ DPRINT("IoCreateDevice(DriverObject 0x%p)\n", DriverObject);
/* Generate a name if we have to */
if (DeviceCharacteristics & FILE_AUTOGENERATED_DEVICE_NAME)
/* Clear the whole Object and extension so we don't null stuff manually */
RtlZeroMemory(CreatedDeviceObject, TotalSize);
- DPRINT("CreatedDeviceObject %x\n", CreatedDeviceObject);
+ DPRINT("CreatedDeviceObject 0x%p\n", CreatedDeviceObject);
/*
* Setup the Type and Size. Note that we don't use the aligned size,
AlignedDeviceExtensionSize);
/* Set the Type and Size. Question: why is Size 0 on Windows? */
- DPRINT("DeviceObjectExtension %x\n", DeviceObjectExtension);
+ DPRINT("DeviceObjectExtension 0x%p\n", DeviceObjectExtension);
DeviceObjectExtension->Type = IO_TYPE_DEVICE_OBJECT_EXTENSION;
DeviceObjectExtension->Size = 0;
STDCALL
IoDetachDevice(PDEVICE_OBJECT TargetDevice)
{
- DPRINT("IoDetachDevice(TargetDevice %x)\n", TargetDevice);
+ DPRINT("IoDetachDevice(TargetDevice 0x%p)\n", TargetDevice);
/* Remove the attachment */
TargetDevice->AttachedDevice->DeviceObjectExtension->AttachedTo = NULL;
IRP,
Tail.Overlay.DeviceQueueEntry);
DeviceObject->CurrentIrp = Irp;
- DPRINT("Next irp is %x\n", Irp);
+ DPRINT("Next irp is 0x%p\n", Irp);
DeviceObject->DriverObject->DriverStartIo(DeviceObject, Irp);
}
else
PKDEVICE_QUEUE_ENTRY entry;
PIRP Irp;
- DPRINT("IoStartNextPacket(DeviceObject %x, Cancelable %d)\n",
- DeviceObject,Cancelable);
+ DPRINT("IoStartNextPacket(DeviceObject 0x%p, Cancelable %d)\n",
+ DeviceObject, Cancelable);
entry = KeRemoveDeviceQueue(&DeviceObject->DeviceQueue);
BOOLEAN stat;
KIRQL oldirql;
- DPRINT("IoStartPacket(Irp %x)\n", Irp);
+ DPRINT("IoStartPacket(Irp 0x%p)\n", Irp);
ASSERT_IRQL(DISPATCH_LEVEL);
&DeviceObject);
if (!NT_SUCCESS(Status))
{
- DPRINT("Status %x\n",Status);
+ DPRINT("Status %x\n", Status);
return(Status);
}
KIRQL OldIrql;
PPRIVATE_DRIVER_EXTENSIONS DriverExtension, NextDriverExtension;
- DPRINT("IopDeleteDriver(ObjectBody %x)\n", ObjectBody);
+ DPRINT("IopDeleteDriver(ObjectBody 0x%p)\n", ObjectBody);
ExFreePool(Object->DriverExtension);
ExFreePool(Object->DriverName.Buffer);
UNICODE_STRING ServiceImagePath;
NTSTATUS Status;
- DPRINT("IopLoadServiceModule(%wZ, %x)\n", ServiceName, ModuleObject);
+ DPRINT("IopLoadServiceModule(%wZ, 0x%p)\n", ServiceName, ModuleObject);
/*
* Get information about the service.
{
PSERVICE_GROUP Group;
- DPRINT("IopGetGroupOrderList(%S, %x, %x, %x, %x, %x)\n",
+ DPRINT("IopGetGroupOrderList(%S, %x, 0x%p, %x, 0x%p, 0x%p)\n",
ValueName, ValueType, ValueData, ValueLength, Context, EntryContext);
if (ValueType == REG_BINARY &&
POBJECT_TYPE ParentObjectType;
NTSTATUS Status;
- DPRINT("IopCreateFile(ObjectBody %x, Parent %x, RemainingPath %S)\n",
+ DPRINT("IopCreateFile(ObjectBody 0x%p, Parent 0x%p, RemainingPath %S)\n",
ObjectBody,
Parent,
RemainingPath);
UserMode);
if (!NT_SUCCESS(Status))
{
- CPRINT("Failed to reference parent object %x\n", Parent);
+ CPRINT("Failed to reference parent object 0x%p\n", Parent);
return(Status);
}
{
/* Parent is a devce object */
DeviceObject = IoGetAttachedDevice((PDEVICE_OBJECT)Parent);
- DPRINT("DeviceObject %x\n", DeviceObject);
+ DPRINT("DeviceObject 0x%p\n", DeviceObject);
if (RemainingPath == NULL)
{
}
DeviceObject = ((PFILE_OBJECT)Parent)->DeviceObject;
- DPRINT("DeviceObject %x\n", DeviceObject);
+ DPRINT("DeviceObject 0x%p\n", DeviceObject);
FileObject->RelatedFileObject = (PFILE_OBJECT)Parent;
DPRINT("FileObject->FileName %wZ\n",
&FileObject->FileName);
FileObject->DeviceObject = DeviceObject;
- DPRINT("FileObject %x DeviceObject %x\n",
+ DPRINT("FileObject 0x%p DeviceObject 0x%p\n",
FileObject,
DeviceObject);
FileObject->Vpb = DeviceObject->Vpb;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- DPRINT("IopDeviceFsIoControl(DeviceHandle %x Event %x UserApcRoutine %x "
- "UserApcContext %x IoStatusBlock %x IoControlCode %x "
- "InputBuffer %x InputBufferLength %x OutputBuffer %x "
- "OutputBufferLength %x)\n",
+ DPRINT("IopDeviceFsIoControl(DeviceHandle 0x%p Event 0x%p UserApcRoutine 0x%p "
+ "UserApcContext 0x%p IoStatusBlock 0x%p IoControlCode %x "
+ "InputBuffer 0x%p InputBufferLength %x OutputBuffer 0x%p "
+ "OutputBufferLength 0x%p)\n",
DeviceHandle,Event,UserApcRoutine,UserApcContext,IoStatusBlock,
IoControlCode,InputBuffer,InputBufferLength,OutputBuffer,
OutputBufferLength);
PVOID SystemEaBuffer = NULL;
NTSTATUS Status = STATUS_SUCCESS;
- DPRINT("IoCreateFile(FileHandle %x, DesiredAccess %x, "
- "ObjectAttributes %x ObjectAttributes->ObjectName->Buffer %S)\n",
+ DPRINT("IoCreateFile(FileHandle 0x%p, DesiredAccess %x, "
+ "ObjectAttributes 0x%p ObjectAttributes->ObjectName->Buffer %S)\n",
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
KeInitializeEvent(&FileObject->Lock, SynchronizationEvent, TRUE);
KeInitializeEvent(&FileObject->Event, NotificationEvent, FALSE);
- DPRINT("FileObject %x\n", FileObject);
- DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
+ DPRINT("FileObject 0x%p\n", FileObject);
+ DPRINT("FileObject->DeviceObject 0x%p\n", FileObject->DeviceObject);
/*
* Create a new IRP to hand to
* the FS driver: this may fail
ASSERT_IRQL(PASSIVE_LEVEL);
- DPRINT("Finished IoCreateFile() (*FileHandle) %x\n", (*FileHandle));
+ DPRINT("Finished IoCreateFile() (*FileHandle) 0x%p\n", (*FileHandle));
return Status;
}
reason. These hacks need to be removed.
*/
- DPRINT("IoCreateStreamFileObject(FileObject %x, DeviceObject %x)\n",
+ DPRINT("IoCreateStreamFileObject(FileObject 0x%p, DeviceObject 0x%p)\n",
FileObject, DeviceObject);
PAGED_CODE();
/* Choose Device Object */
if (FileObject) DeviceObject = FileObject->DeviceObject;
- DPRINT("DeviceObject %x\n", DeviceObject);
+ DPRINT("DeviceObject 0x%p\n", DeviceObject);
/* HACK */
DeviceObject = IoGetAttachedDevice(DeviceObject);
KernelMode);
if (!NT_SUCCESS(Status)) return(Status);
- DPRINT("FileObject %x\n", FileObject);
+ DPRINT("FileObject 0x%p\n", FileObject);
/* Get the Device Object */
DeviceObject = IoGetRelatedDeviceObject(FileObject);
{
MAILSLOT_CREATE_PARAMETERS Buffer;
- DPRINT("NtCreateMailslotFile(FileHandle %x, DesiredAccess %x, "
- "ObjectAttributes %x ObjectAttributes->ObjectName->Buffer %S)\n",
+ DPRINT("NtCreateMailslotFile(FileHandle 0x%p, DesiredAccess %x, "
+ "ObjectAttributes 0x%p ObjectAttributes->ObjectName->Buffer %S)\n",
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
PAGED_CODE();
{
NAMED_PIPE_CREATE_PARAMETERS Buffer;
- DPRINT("NtCreateNamedPipeFile(FileHandle %x, DesiredAccess %x, "
- "ObjectAttributes %x ObjectAttributes->ObjectName->Buffer %S)\n",
+ DPRINT("NtCreateNamedPipeFile(FileHandle 0x%p, DesiredAccess %x, "
+ "ObjectAttributes 0x%p ObjectAttributes->ObjectName->Buffer %S)\n",
FileHandle,DesiredAccess,ObjectAttributes,
ObjectAttributes->ObjectName->Buffer);
PAGED_CODE();
ASSERT(IoStatusBlock != NULL);
ASSERT(FileInformation != NULL);
- DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
+ DPRINT("NtQueryInformationFile(Handle 0x%p StatBlk 0x%p FileInfo 0x%p Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
return STATUS_ACCESS_DENIED;
}
- DPRINT("FileObject %x\n", FileObject);
+ DPRINT("FileObject 0x%p\n", FileObject);
/* Check if this is a direct open or not */
if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
BOOLEAN LocalEvent = FALSE;
PKEVENT EventObject = NULL;
- DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
- "IoStatusBlock %x)\n", FileHandle, Buffer, Length, ByteOffset,
+ DPRINT("NtReadFile(FileHandle 0x%p Buffer 0x%p Length %x ByteOffset 0x%p, "
+ "IoStatusBlock 0x%p)\n", FileHandle, Buffer, Length, ByteOffset,
IoStatusBlock);
PAGED_CODE();
ASSERT(IoStatusBlock != NULL);
ASSERT(FileInformation != NULL);
- DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
+ DPRINT("NtSetInformationFile(Handle 0x%p StatBlk 0x%p FileInfo 0x%p Length %d "
"Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
return STATUS_ACCESS_DENIED;
}
- DPRINT("FileObject %x\n", FileObject);
+ DPRINT("FileObject 0x%p\n", FileObject);
/* FIXME: Later, we can implement a lot of stuff here and avoid a driver call */
/* Handle IO Completion Port quickly */
BOOLEAN LocalEvent = FALSE;
PKEVENT EventObject = NULL;
- DPRINT("NtWriteFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
- "IoStatusBlock %x)\n", FileHandle, Buffer, Length, ByteOffset,
+ DPRINT("NtWriteFile(FileHandle 0x%p Buffer 0x%p Length %x ByteOffset 0x%p, "
+ "IoStatusBlock 0x%p)\n", FileHandle, Buffer, Length, ByteOffset,
IoStatusBlock);
/* Validate User-Mode Buffers */
PIRP Irp;
NTSTATUS Status;
- DPRINT("IopMountFileSystem(DeviceObject %x, DeviceToMount %x)\n",
+ DPRINT("IopMountFileSystem(DeviceObject 0x%p, DeviceToMount 0x%p)\n",
DeviceObject,DeviceToMount);
ASSERT_IRQL(PASSIVE_LEVEL);
}
Irp->UserIosb = &IoStatusBlock;
- DPRINT("Irp->UserIosb %x\n", Irp->UserIosb);
+ DPRINT("Irp->UserIosb 0x%p\n", Irp->UserIosb);
Irp->UserEvent = &Event;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
PIRP Irp;
NTSTATUS Status;
- DPRINT("IopLoadFileSystem(DeviceObject %x)\n", DeviceObject);
+ DPRINT("IopLoadFileSystem(DeviceObject 0x%p)\n", DeviceObject);
ASSERT_IRQL(PASSIVE_LEVEL);
}
Irp->UserIosb = &IoStatusBlock;
- DPRINT("Irp->UserIosb %x\n", Irp->UserIosb);
+ DPRINT("Irp->UserIosb 0x%p\n", Irp->UserIosb);
Irp->UserEvent = &Event;
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
ASSERT_IRQL(PASSIVE_LEVEL);
- DPRINT("IoMountVolume(DeviceObject %x AllowRawMount %x)\n",
+ DPRINT("IoMountVolume(DeviceObject 0x%p AllowRawMount %x)\n",
DeviceObject, AllowRawMount);
switch (DeviceObject->DeviceType)
NTSTATUS Status;
PDEVICE_OBJECT DevObject;
- DPRINT("IoVerifyVolume(DeviceObject %x AllowRawMount %x)\n",
+ DPRINT("IoVerifyVolume(DeviceObject 0x%p AllowRawMount %x)\n",
DeviceObject, AllowRawMount);
Status = STATUS_SUCCESS;
{
PFILE_SYSTEM_OBJECT Fs;
- DPRINT("IoRegisterFileSystem(DeviceObject %x)\n",DeviceObject);
+ DPRINT("IoRegisterFileSystem(DeviceObject 0x%p)\n", DeviceObject);
Fs = ExAllocatePoolWithTag(NonPagedPool,
sizeof(FILE_SYSTEM_OBJECT),
PLIST_ENTRY current_entry;
PFILE_SYSTEM_OBJECT current;
- DPRINT("IoUnregisterFileSystem(DeviceObject %x)\n",DeviceObject);
+ DPRINT("IoUnregisterFileSystem(DeviceObject 0x%p)\n", DeviceObject);
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&FileSystemListLock, TRUE);
PKEVENT UserEvent;
BOOLEAN SyncIrp;
- if (Apc) DPRINT("IoSecondStageCompletition with APC: %x\n", Apc);
+ if (Apc) DPRINT("IoSecondStageCompletition with APC: 0x%p\n", Apc);
/* Get data from the APC */
FileObject = (PFILE_OBJECT)(*SystemArgument1);
Irp = CONTAINING_RECORD(Apc, IRP, Tail.Apc);
- DPRINT("IoSecondStageCompletition, %x\n", Irp);
+ DPRINT("IoSecondStageCompletition, 0x%p\n", Irp);
/* Save the User Event */
UserEvent = Irp->UserEvent;
PIO_STACK_LOCATION StackPtr;
LOCK_OPERATION AccessType;
- DPRINT("IoBuildAsynchronousFsdRequest(MajorFunction %x, DeviceObject %x, "
- "Buffer %x, Length %x, StartingOffset %x, "
- "IoStatusBlock %x\n",MajorFunction,DeviceObject,Buffer,Length,
+ DPRINT("IoBuildAsynchronousFsdRequest(MajorFunction %x, DeviceObject 0x%p, "
+ "Buffer 0x%p, Length %x, StartingOffset 0x%p, "
+ "IoStatusBlock 0x%p\n",MajorFunction,DeviceObject,Buffer,Length,
StartingOffset,IoStatusBlock);
/* Allocate IRP */
ULONG BufferLength;
LOCK_OPERATION AccessType;
- DPRINT("IoBuildDeviceIoRequest(IoControlCode %x, DeviceObject %x, "
- "InputBuffer %x, InputBufferLength %x, OutputBuffer %x, "
+ DPRINT("IoBuildDeviceIoRequest(IoControlCode %x, DeviceObject 0x%p, "
+ "InputBuffer 0x%p, InputBufferLength %x, OutputBuffer 0x%p, "
"OutputBufferLength %x, InternalDeviceIoControl %x "
- "Event %x, IoStatusBlock %x\n",IoControlCode,DeviceObject,
+ "Event 0x%p, IoStatusBlock 0x%p\n",IoControlCode,DeviceObject,
InputBuffer,InputBufferLength,OutputBuffer,OutputBufferLength,
InternalDeviceIoControl,Event,IoStatusBlock);
{
PIRP Irp;
- DPRINT("IoBuildSynchronousFsdRequest(MajorFunction %x, DeviceObject %x, "
- "Buffer %x, Length %x, StartingOffset %x, Event %x, "
- "IoStatusBlock %x\n",MajorFunction,DeviceObject,Buffer,Length,
+ DPRINT("IoBuildSynchronousFsdRequest(MajorFunction %x, DeviceObject 0x%p, "
+ "Buffer 0x%p, Length %x, StartingOffset 0x%p, Event 0x%p, "
+ "IoStatusBlock 0x%p\n",MajorFunction,DeviceObject,Buffer,Length,
StartingOffset,Event,IoStatusBlock);
/* Do the big work to set up the IRP */
KIRQL oldlvl;
PDRIVER_CANCEL CancelRoutine;
- DPRINT("IoCancelIrp(Irp %x)\n",Irp);
+ DPRINT("IoCancelIrp(Irp 0x%p)\n",Irp);
IoAcquireCancelSpinLock(&oldlvl);
PDRIVER_OBJECT DriverObject;
PIO_STACK_LOCATION Param;
- DPRINT("IofCallDriver(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);
+ DPRINT("IofCallDriver(DeviceObject 0x%p, Irp 0x%p)\n",DeviceObject,Irp);
/* Get the Driver Object */
DriverObject = DeviceObject->DriverObject;
/* Get the current one */
Param = IoGetCurrentIrpStackLocation(Irp);
- DPRINT("IrpSp 0x%X\n", Param);
+ DPRINT("IrpSp 0x0x%p\n", Param);
/* Get the Device Object */
Param->DeviceObject = DeviceObject;
NTSTATUS Status;
PMDL Mdl;
- DPRINT("IofCompleteRequest(Irp %x, PriorityBoost %d) Event %x THread %x\n",
+ DPRINT("IofCompleteRequest(Irp 0x%p, PriorityBoost %d) Event 0x%p THread 0x%p\n",
Irp,PriorityBoost, Irp->UserEvent, PsGetCurrentThread());
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
Mdl = Irp->MdlAddress;
while (Mdl)
{
- DPRINT("Unlocking MDL: %x\n", Mdl);
+ DPRINT("Unlocking MDL: 0x%p\n", Mdl);
MmUnlockPages(Mdl);
Mdl = Mdl->Next;
}
{
ASSERT(Irp != NULL);
- DPRINT("IoInitializeIrp(StackSize %x, Irp %x)\n",StackSize, Irp);
+ DPRINT("IoInitializeIrp(StackSize %x, Irp 0x%p)\n",StackSize, Irp);
/* Clear it */
RtlZeroMemory(Irp, PacketSize);
/* Initialize the Thread List */
InitializeListHead(&Irp->ThreadListEntry);
- DPRINT("Irp->Tail.Overlay.CurrentStackLocation %x\n", Irp->Tail.Overlay.CurrentStackLocation);
+ DPRINT("Irp->Tail.Overlay.CurrentStackLocation 0x%p\n", Irp->Tail.Overlay.CurrentStackLocation);
}
/*
PIO_STACK_LOCATION StackPtr;
PDEVICE_OBJECT DeviceObject;
- DPRINT("IoPageRead(FileObject %x, Mdl %x)\n",
+ DPRINT("IoPageRead(FileObject 0x%p, Mdl 0x%p)\n",
FileObject, Mdl);
/* Get the Device Object */
PIO_STACK_LOCATION StackPtr;
PDEVICE_OBJECT DeviceObject;
- DPRINT("IoSynchronousPageWrite(FileObject %x, Mdl %x)\n",
+ DPRINT("IoSynchronousPageWrite(FileObject 0x%p, Mdl 0x%p)\n",
FileObject, Mdl);
/* Get the Device Object */
ULONG Count;
ULONG Delta;
- DPRINT("VirtualAddress %x, SourceMdl->StartVa %x, SourceMdl->MappedSystemVa %x\n",
+ DPRINT("VirtualAddress 0x%p, SourceMdl->StartVa 0x%p, SourceMdl->MappedSystemVa 0x%p\n",
VirtualAddress, SourceMdl->StartVa, SourceMdl->MappedSystemVa);
TargetMdl->StartVa = (PVOID)PAGE_ROUND_DOWN(VirtualAddress);
PVOID Data = NULL;
PWSTR Ptr;
- DPRINT("IoGetDeviceProperty(%x %d)\n", DeviceObject, DeviceProperty);
+ DPRINT("IoGetDeviceProperty(0x%p %d)\n", DeviceObject, DeviceProperty);
if (DeviceNode == NULL)
return STATUS_INVALID_DEVICE_REQUEST;
KeyNameBuffer = ExAllocatePool(PagedPool,
(49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
- DPRINT("KeyNameBuffer: %x, value %S\n",
+ DPRINT("KeyNameBuffer: 0x%p, value %S\n",
KeyNameBuffer, RegistryPropertyName);
if (KeyNameBuffer == NULL)
NTSTATUS Status;
KIRQL OldIrql;
- DPRINT("ParentNode %x PhysicalDeviceObject %x\n",
+ DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p\n",
ParentNode, PhysicalDeviceObject);
Node = (PDEVICE_NODE)ExAllocatePool(NonPagedPool, sizeof(DEVICE_NODE));
{
NTSTATUS Status;
- DPRINT("Context %x\n", Context);
+ DPRINT("Context 0x%p\n", Context);
- DPRINT("IopTraverseDeviceTree(DeviceNode %x FirstDeviceNode %x Action %x Context %x)\n",
+ DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p FirstDeviceNode 0x%p Action %x Context 0x%p)\n",
Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
/* Start from the specified device node */
DEVICE_CAPABILITIES DeviceCapabilities;
DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
- DPRINT("PDO %x\n", DeviceNode->PhysicalDeviceObject);
+ DPRINT("PDO 0x%p\n", DeviceNode->PhysicalDeviceObject);
ParentDeviceNode = (PDEVICE_NODE)Context;
NTSTATUS Status;
ULONG i;
- DPRINT("DeviceNode %x\n", DeviceNode);
+ DPRINT("DeviceNode 0x%p\n", DeviceNode);
DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
return Status;
}
- DPRINT("Created PDO %x\n", Device->Pdo);
+ DPRINT("Created PDO 0x%p\n", Device->Pdo);
Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
DeviceExtension = (PPNPROOT_COMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
- DPRINT("DeviceObject %x DeviceExtension %x IsFDO %d\n",
+ DPRINT("DeviceObject 0x%p DeviceExtension 0x%p IsFDO %d\n",
DeviceObject,
DeviceExtension,
DeviceExtension->IsFDO);
PhysicalDeviceObject);
if (!PnpRootDeviceObject) {
- CPRINT("PnpRootDeviceObject 0x%X\n", PnpRootDeviceObject);
+ CPRINT("PnpRootDeviceObject 0x%p\n", PnpRootDeviceObject);
KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
}
if (!PhysicalDeviceObject) {
- CPRINT("PhysicalDeviceObject 0x%X\n", PhysicalDeviceObject);
+ CPRINT("PhysicalDeviceObject 0x%p\n", PhysicalDeviceObject);
KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
}
BOOLEAN
RawFsIsRawFileSystemDeviceObject(IN PDEVICE_OBJECT DeviceObject)
{
- DPRINT("RawFsIsRawFileSystemDeviceObject(DeviceObject %x)\n", DeviceObject);
+ DPRINT("RawFsIsRawFileSystemDeviceObject(DeviceObject 0x%p)\n", DeviceObject);
if (DeviceObject == DiskDeviceObject)
return TRUE;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
- DPRINT("RawFsReadDisk(pDeviceObject %x, Offset %I64x, Length %d, Buffer %x)\n",
+ DPRINT("RawFsReadDisk(pDeviceObject 0x%p, Offset %I64x, Length %d, Buffer 0x%p)\n",
pDeviceObject, ReadOffset->QuadPart, ReadLength, Buffer);
DPRINT ("Building synchronous FSD Request...\n");
return STATUS_UNSUCCESSFUL;
}
- DPRINT("Calling IO Driver... with irp %x\n", Irp);
+ DPRINT("Calling IO Driver... with irp 0x%p\n", Irp);
Status = IoCallDriver(pDeviceObject, Irp);
- DPRINT("Waiting for IO Operation for %x\n", Irp);
+ DPRINT("Waiting for IO Operation for 0x%p\n", Irp);
if (Status == STATUS_PENDING)
{
DPRINT("Operation pending\n");
KeWaitForSingleObject (&Event, Suspended, KernelMode, FALSE, NULL);
- DPRINT("Getting IO Status... for %x\n", Irp);
+ DPRINT("Getting IO Status... for 0x%p\n", Irp);
Status = IoStatus.Status;
}
if (!NT_SUCCESS(Status))
{
DPRINT("RawFsReadDisk() failed. Status %x\n", Status);
- DPRINT("(pDeviceObject %x, Offset %I64x, Size %d, Buffer %x\n",
+ DPRINT("(pDeviceObject 0x%p, Offset %I64x, Size %d, Buffer 0x%p\n",
pDeviceObject, ReadOffset->QuadPart, ReadLength, Buffer);
return Status;
}
- DPRINT("Block request succeeded for %x\n", Irp);
+ DPRINT("Block request succeeded for 0x%p\n", Irp);
return STATUS_SUCCESS;
}
KEVENT Event;
PIRP Irp;
- DPRINT("RawFsWriteDisk(pDeviceObject %x, Offset %I64x, Size %d, Buffer %x)\n",
+ DPRINT("RawFsWriteDisk(pDeviceObject 0x%p, Offset %I64x, Size %d, Buffer 0x%p)\n",
pDeviceObject, WriteOffset->QuadPart, WriteLength, Buffer);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
if (!NT_SUCCESS(Status))
{
DPRINT("RawFsWriteDisk() failed. Status %x\n", Status);
- DPRINT("(pDeviceObject %x, Offset %I64x, Size %d, Buffer %x\n",
+ DPRINT("(pDeviceObject 0x%p, Offset %I64x, Size %d, Buffer 0x%p\n",
pDeviceObject, WriteOffset->QuadPart, WriteLength, Buffer);
return Status;
}
IO_STATUS_BLOCK IoStatus;
NTSTATUS Status;
- DPRINT("RawFsBlockDeviceIoControl(DeviceObject %x, CtlCode %x, "
- "InputBuffer %x, InputBufferSize %x, OutputBuffer %x, "
- "POutputBufferSize %x (%x)\n", DeviceObject, CtlCode,
+ DPRINT("RawFsBlockDeviceIoControl(DeviceObject 0x%p, CtlCode %x, "
+ "InputBuffer 0x%p, InputBufferSize %x, OutputBuffer 0x%p, "
+ "POutputBufferSize 0x%p (%x)\n", DeviceObject, CtlCode,
InputBuffer, InputBufferSize, OutputBuffer, pOutputBufferSize,
pOutputBufferSize ? *pOutputBufferSize : 0);
return STATUS_INSUFFICIENT_RESOURCES;
}
- DPRINT("Calling IO Driver... with irp %x\n", Irp);
+ DPRINT("Calling IO Driver... with irp 0x%p\n", Irp);
Status = IoCallDriver(DeviceObject, Irp);
- DPRINT("Waiting for IO Operation for %x\n", Irp);
+ DPRINT("Waiting for IO Operation for 0x%p\n", Irp);
if (Status == STATUS_PENDING)
{
DPRINT("Operation pending\n");
KeWaitForSingleObject (&Event, Suspended, KernelMode, FALSE, NULL);
- DPRINT("Getting IO Status... for %x\n", Irp);
+ DPRINT("Getting IO Status... for 0x%p\n", Irp);
Status = IoStatus.Status;
}
if (OutputBufferSize)
PRAWFS_IRP_CONTEXT IrpContext;
UCHAR MajorFunction;
- DPRINT("RawFsAllocateIrpContext(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
+ DPRINT("RawFsAllocateIrpContext(DeviceObject 0x%p, Irp 0x%p)\n", DeviceObject, Irp);
ASSERT(DeviceObject);
ASSERT(Irp);
static VOID
RawFsFreeIrpContext(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsFreeIrpContext(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsFreeIrpContext(IrpContext 0x%p)\n", IrpContext);
ASSERT(IrpContext);
Count = InterlockedDecrement(&RawFsQueueCount);
- DPRINT("RawFsDoRequest(IrpContext %x), MajorFunction %x, %d\n",
+ DPRINT("RawFsDoRequest(IrpContext 0x%p), MajorFunction %x, %d\n",
IrpContext, ((PRAWFS_IRP_CONTEXT) IrpContext)->MajorFunction, Count);
RawFsDispatchRequest((PRAWFS_IRP_CONTEXT) IrpContext);
Count = InterlockedIncrement(&RawFsQueueCount);
- DPRINT("RawFsQueueRequest (IrpContext %x), %d\n", IrpContext, Count);
+ DPRINT("RawFsQueueRequest (IrpContext 0x%p), %d\n", IrpContext, Count);
IrpContext->Flags |= IRPCONTEXT_CANWAIT;
IoMarkIrpPending (IrpContext->Irp);
static NTSTATUS
RawFsClose(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsClose(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsClose(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
{
NTSTATUS Status;
- DPRINT("RawFsCreate(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsCreate(IrpContext 0x%p)\n", IrpContext);
ASSERT(IrpContext);
static NTSTATUS
RawFsRead(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsRead(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsRead(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsWrite(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsWrite(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsWrite(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS Status;
ULONG Size;
- DPRINT("RawFsMount(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsMount(IrpContext 0x%p)\n", IrpContext);
ASSERT(IrpContext);
{
NTSTATUS Status;
- DPRINT("RawFsFileSystemControl(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsFileSystemControl(IrpContext 0x%p)\n", IrpContext);
ASSERT(IrpContext);
static NTSTATUS
RawFsQueryInformation(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsQueryInformation(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsQueryInformation(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsSetInformation(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsSetInformation(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsSetInformation(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsDirectoryControl(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsDirectoryControl(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsDirectoryControl(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsQueryVolumeInformation(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsQueryVolumeInformation(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsQueryVolumeInformation(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsSetVolumeInformation(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsSetVolumeInformation(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsSetVolumeInformation(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsLockControl(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsLockControl(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsLockControl(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsCleanup(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsCleanup(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsCleanup(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS
RawFsFlush(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsFlush(IrpContext %x)\n", IrpContext);
+ DPRINT("RawFsFlush(IrpContext 0x%p)\n", IrpContext);
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS STDCALL
RawFsShutdown(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
- DPRINT("RawFsShutdown(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
+ DPRINT("RawFsShutdown(DeviceObject 0x%p, Irp 0x%p)\n", DeviceObject, Irp);
/*
* Note: Do NOT call UNIMPLEMENTED here!
static NTSTATUS
RawFsDispatchRequest(IN PRAWFS_IRP_CONTEXT IrpContext)
{
- DPRINT("RawFsDispatchRequest(IrpContext %x), MajorFunction %x\n",
+ DPRINT("RawFsDispatchRequest(IrpContext 0x%p), MajorFunction %x\n",
IrpContext, IrpContext->MajorFunction);
ASSERT(IrpContext);
PRAWFS_IRP_CONTEXT IrpContext;
NTSTATUS Status;
- DPRINT("RawFsBuildRequest(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
+ DPRINT("RawFsBuildRequest(DeviceObject 0x%p, Irp 0x%p)\n", DeviceObject, Irp);
ASSERT(DeviceObject);
ASSERT(Irp);
return(Status);
}
- DPRINT("FileObject %x\n", FileObject);
+ DPRINT("FileObject 0x%p\n", FileObject);
DeviceObject = FileObject->DeviceObject;
Timer = CONTAINING_RECORD(TimerEntry, IO_TIMER, IoTimerList);
if (Timer->TimerEnabled) {
- DPRINT("Dispatching a Timer Routine: %x for Device Object: %x \n",
+ DPRINT("Dispatching a Timer Routine: 0x%p for Device Object: 0x%p \n",
Timer->TimerRoutine,
Timer->DeviceObject);
Timer->TimerRoutine(Timer->DeviceObject, Timer->Context);
* RETURNS: Status
*/
{
- DPRINT("IoInitializeTimer() called for Device Object: %x with Routine: %x \n", DeviceObject, TimerRoutine);
+ DPRINT("IoInitializeTimer() called for Device Object: 0x%p with Routine: 0x%p \n", DeviceObject, TimerRoutine);
/* Allocate Timer */
if (!DeviceObject->Timer) {
{
KIRQL OldIrql;
- DPRINT("IoStartTimer for Device Object: %x\n", DeviceObject);
+ DPRINT("IoStartTimer for Device Object: 0x%p\n", DeviceObject);
/* Lock Timers */
KeAcquireSpinLock(&IopTimerLock, &OldIrql);
/* Unlock Timers */
KeReleaseSpinLock(&IopTimerLock, OldIrql);
- DPRINT("IoStartTimer Completed for Device Object: %x New Count: %x \n", DeviceObject, IopTimerCount);
+ DPRINT("IoStartTimer Completed for Device Object: 0x%p New Count: %x \n", DeviceObject, IopTimerCount);
}
/*
{
KIRQL OldIrql;
- DPRINT("IoStopTimer for Device Object: %x\n", DeviceObject);
+ DPRINT("IoStopTimer for Device Object: 0x%p\n", DeviceObject);
/* Lock Timers */
KeAcquireSpinLock(&IopTimerLock, &OldIrql);
/* Unlock Timers */
KeReleaseSpinLock(&IopTimerLock, OldIrql);
- DPRINT("IoStopTimer Completed for Device Object: %x New Count: %x \n", DeviceObject, IopTimerCount);
+ DPRINT("IoStopTimer Completed for Device Object: 0x%p New Count: %x \n", DeviceObject, IopTimerCount);
}
if (!NT_SUCCESS(KdbpSafeReadMemory(Mem, (PVOID)Eip, sizeof (Mem))))
{
- KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Eip);
+ KdbpPrint("Couldn't access memory at 0x%p\n", Eip);
return FALSE;
}
/* Read memory */
if (!NT_SUCCESS(KdbpSafeReadMemory(Mem, (PVOID)Eip, sizeof (Mem))))
{
- /*KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Eip);*/
+ /*KdbpPrint("Couldn't access memory at 0x%p\n", Eip);*/
return FALSE;
}
/* Get the interrupt descriptor */
if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
{
- /*KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Idtr.Base + (IntVect * 8));*/
+ /*KdbpPrint("Couldn't access memory at 0x%p\n", (ULONG_PTR)Idtr.Base + (IntVect * 8));*/
return FALSE;
}
{
if ((Address % Size) != 0)
{
- KdbpPrint("Address (0x%x) must be aligned to a multiple of the size (%d)\n", Address, Size);
+ KdbpPrint("Address (0x%p) must be aligned to a multiple of the size (%d)\n", Address, Size);
return STATUS_UNSUCCESSFUL;
}
if (AccessType == KdbAccessExec && Size != 1)
0xCC, &BreakPoint->Data.SavedInstruction);
if (!NT_SUCCESS(Status))
{
- KdbpPrint("Couldn't access memory at 0x%x\n", BreakPoint->Address);
+ KdbpPrint("Couldn't access memory at 0x%p\n", BreakPoint->Address);
return FALSE;
}
KdbSwBreakPoints[KdbSwBreakPointCount++] = BreakPoint;
if (ExpNr == 14)
{
/* FIXME: Add noexec memory stuff */
- ULONG Cr2, Err;
+ ULONG_PTR Cr2;
+ ULONG Err;
asm volatile("movl %%cr2, %0" : "=r"(Cr2));
Err = TrapFrame->ErrorCode;
- DbgPrint("Memory at 0x%x could not be %s: ", Cr2, (Err & (1 << 1)) ? "written" : "read");
+ DbgPrint("Memory at 0x%p could not be %s: ", Cr2, (Err & (1 << 1)) ? "written" : "read");
if ((Err & (1 << 0)) == 0)
DbgPrint("Page not present.\n");
else
break;
if (!NT_SUCCESS(KdbpSafeReadMemory(&Address, (PVOID)(Frame + sizeof(ULONG_PTR)), sizeof (ULONG_PTR))))
{
- KdbpPrint("Couldn't access memory at 0x%x!\n", Frame + sizeof(ULONG_PTR));
+ KdbpPrint("Couldn't access memory at 0x%p!\n", Frame + sizeof(ULONG_PTR));
break;
}
if (!KdbSymPrintAddress((PVOID)Address))
break;
if (!NT_SUCCESS(KdbpSafeReadMemory(&Frame, (PVOID)Frame, sizeof (ULONG_PTR))))
{
- KdbpPrint("Couldn't access memory at 0x%x!\n", Frame);
+ KdbpPrint("Couldn't access memory at 0x%p!\n", Frame);
break;
}
}
if (!KdbpSymFindModuleByAddress((PVOID)Address, &Info))
{
- KdbpPrint("No module containing address 0x%x found!\n", Address);
+ KdbpPrint("No module containing address 0x%p found!\n", Address);
return TRUE;
}
DisplayOnlyOneModule = TRUE;
if (Value != ExceptionContinueExecution ||
0 != (ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE))
{
- DPRINT("ExceptionRecord->ExceptionAddress = 0x%x\n", ExceptionRecord->ExceptionAddress);
+ DPRINT("ExceptionRecord->ExceptionAddress = 0x%p\n", ExceptionRecord->ExceptionAddress);
/* Enter KDB if available */
Action = KdpEnterDebuggerException(ExceptionRecord,
projects / reactos.git / commitdiff