for (i = 0; i < 4; i++)
{
/* Add it into the list */
- if (!InterlockedCompareExchangePointer(&KeyBody->KeyControlBlock->
+ if (!InterlockedCompareExchangePointer((PVOID*)&KeyBody->KeyControlBlock->
KeyBodyArray[i],
KeyBody,
NULL))
for (i = 0; i < 4; i++)
{
/* Add it into the list */
- if (InterlockedCompareExchangePointer(&KeyBody->KeyControlBlock->
+ if (InterlockedCompareExchangePointer((VOID*)&KeyBody->KeyControlBlock->
KeyBodyArray[i],
NULL,
KeyBody) == KeyBody)
/* Write the new level and attempt to change the table code */
TableBase = ((ULONG_PTR)Mid) | 1;
- Value = InterlockedExchangePointer(&HandleTable->TableCode, TableBase);
+ Value = InterlockedExchangePointer((PVOID*)&HandleTable->TableCode, (PVOID)TableBase);
}
else if (TableLevel == 1)
{
if (!Low) return FALSE;
/* Update the table */
- Value = InterlockedExchangePointer(&SecondLevel[i], Low);
+ Value = InterlockedExchangePointer((PVOID*)&SecondLevel[i], Low);
ASSERT(Value == NULL);
}
else
/* Write the new table and change the table code */
TableBase = ((ULONG_PTR)High) | 2;
- Value = InterlockedExchangePointer(&HandleTable->TableCode,
+ Value = InterlockedExchangePointer((PVOID*)&HandleTable->TableCode,
(PVOID)TableBase);
}
}
if (!Mid) return FALSE;
/* Update the table pointer */
- Value = InterlockedExchangePointer(&ThirdLevel[i], Mid);
+ Value = InterlockedExchangePointer((PVOID*)&ThirdLevel[i], Mid);
ASSERT(Value == NULL);
}
else
if (!Low) return FALSE;
/* Update the table pointer */
- Value = InterlockedExchangePointer(&ThirdLevel[i][j], Low);
+ Value = InterlockedExchangePointer((PVOID*)&ThirdLevel[i][j], Low);
ASSERT(Value == NULL);
}
}
/* It's not locked, remove the lock bit to lock it */
NewValue = OldValue & ~EXHANDLE_TABLE_ENTRY_LOCK_BIT;
if (InterlockedCompareExchangePointer(&HandleTableEntry->Object,
- NewValue,
- OldValue) == (PVOID)OldValue)
+ (PVOID)NewValue,
+ (PVOID)OldValue) == (PVOID)OldValue)
{
/* We locked it, get out */
return TRUE;
}
/* Clear the handle */
- Object = InterlockedExchangePointer(&HandleTableEntry->Object, NULL);
+ Object = InterlockedExchangePointer((PVOID*)&HandleTableEntry->Object, NULL);
/* Sanity checks */
ASSERT(Object != NULL);
ULONG ExpAnsiCodePageDataOffset, ExpOemCodePageDataOffset;
ULONG ExpUnicodeCaseTableDataOffset;
NLSTABLEINFO ExpNlsTableInfo;
-ULONG ExpNlsTableSize;
+SIZE_T ExpNlsTableSize;
PVOID ExpNlsSectionPointer;
/* CMOS Timer Sanity */
NTSTATUS Status;
HANDLE NlsSection;
PVOID SectionBase = NULL;
- ULONG ViewSize = 0;
+ SIZE_T ViewSize = 0;
LARGE_INTEGER SectionOffset = {{0}};
PLIST_ENTRY ListHead, NextEntry;
PMEMORY_ALLOCATION_DESCRIPTOR MdBlock;
OUT PCHAR *ProcessEnvironment)
{
NTSTATUS Status;
- ULONG Size;
+ SIZE_T Size;
PWSTR p;
UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
UNICODE_STRING SmssName, Environment, SystemDriveString, DebugString;
PLDR_DATA_TABLE_ENTRY NtosEntry;
PRTL_MESSAGE_RESOURCE_ENTRY MsgEntry;
ANSI_STRING CsdString;
- ULONG Remaining = 0;
+ SIZE_T Remaining = 0;
PCHAR RcEnd = NULL;
CHAR VersionBuffer [65];
PCHAR StringBuffer, EndBuffer, BeginBuffer, MpString = "";
PINIT_BUFFER InitBuffer;
ANSI_STRING TempString;
- ULONG LastTzBias, Size, Length, YearHack = 0, Disposition, MessageCode = 0;
+ ULONG LastTzBias, Size, YearHack = 0, Disposition, MessageCode = 0;
+ SIZE_T Length;
PRTL_USER_PROCESS_INFORMATION ProcessInfo;
KEY_VALUE_PARTIAL_INFORMATION KeyPartialInfo;
UNICODE_STRING KeyName, DebugString;
KeyValuePartialInformation,
&KeyPartialInfo,
sizeof(KeyPartialInfo),
- &Length);
+ &Size);
if (!NT_SUCCESS(Status)) AlternateShell = FALSE;
}
ZwClose(ProcessInfo->ProcessHandle);
/* Free the initial process environment */
- Size = 0;
+ Length = 0;
ZwFreeVirtualMemory(NtCurrentProcess(),
(PVOID*)&Environment,
- &Size,
+ &Length,
MEM_RELEASE);
/* Free the initial process parameters */
- Size = 0;
+ Length = 0;
ZwFreeVirtualMemory(NtCurrentProcess(),
(PVOID*)&ProcessParameters,
- &Size,
+ &Length,
MEM_RELEASE);
/* Increase init phase */
/* PRIVATE FUNCTIONS *********************************************************/
+#ifdef _WIN64
+#define InterlockedAndPointer(ptr,val) InterlockedAnd64((PLONGLONG)ptr,(LONGLONG)val)
+#else
+#define InterlockedAndPointer(ptr,val) InterlockedAnd((PLONG)ptr,(LONG)val)
+#endif
+
/*++
* @name ExpInitializePushLocks
*
ASSERT(NewValue.Waiting);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
}
/* Save the First Block */
- FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ FirstWaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
WaitBlock = FirstWaitBlock;
ASSERT(!NewValue.Waking);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) break;
ASSERT(PushLock->Waiting);
/* Remove waking bit from pushlock */
- InterlockedAnd((PLONG)PushLock, ~EX_PUSH_LOCK_WAKING);
+ InterlockedAndPointer(&PushLock->Value, ~EX_PUSH_LOCK_WAKING);
/* Leave the loop */
break;
}
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop the blocks */
ASSERT(!NewValue.Waking);
/* Update the value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
ASSERT(NewValue.Locked);
/* Set the new value */
- if (InterlockedCompareExchangePointer(PushLock,
+ if (InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr) != OldValue.Ptr)
{
WaitBlock->ShareCount = 0;
/* Set the current Wait Block pointer */
- WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)
- OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS);
+ WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)(
+ OldValue.Value &~ EX_PUSH_LOCK_PTR_BITS);
/* Point to ours */
NewValue.Value = (OldValue.Value & EX_PUSH_LOCK_MULTIPLE_SHARED) |
/* Write the new value */
TempValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value)
ASSERT(NewValue.Locked);
/* Set the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value)
if (OldValue.Waiting)
{
/* Set the current Wait Block pointer */
- WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)
- OldValue.Ptr &~ EX_PUSH_LOCK_PTR_BITS);
+ WaitBlock->Next = (PEX_PUSH_LOCK_WAIT_BLOCK)(
+ OldValue.Value &~ EX_PUSH_LOCK_PTR_BITS);
/* Nobody is the last waiter yet */
WaitBlock->Last = NULL;
#endif
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Ptr != OldValue.Ptr)
}
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
if (OldValue.MultipleShared)
{
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop until we find the last wait block */
ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared);
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
/* Write the new value */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value) continue;
}
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
if (OldValue.MultipleShared)
{
/* Get the wait block */
- WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)((ULONG_PTR)OldValue.Ptr &
+ WaitBlock = (PEX_PUSH_LOCK_WAIT_BLOCK)(OldValue.Value &
~EX_PUSH_LOCK_PTR_BITS);
/* Loop until we find the last wait block */
ASSERT(NewValue.Waking && !NewValue.Locked && !NewValue.MultipleShared);
/* Write the new value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value == OldValue.Value) return;
/* Write the new value */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
if (NewValue.Value != OldValue.Value) continue;
/* Write the New Value. Save our original value for waking */
WakeValue = NewValue;
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
ASSERT(NewValue.Waking && !NewValue.Waiting);
/* Write the New Value */
- NewValue.Ptr = InterlockedCompareExchangePointer(PushLock,
+ NewValue.Ptr = InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr);
NewValue.Waking = TRUE;
/* Write the New Value */
- if (InterlockedCompareExchangePointer(PushLock,
+ if (InterlockedCompareExchangePointer(&PushLock->Ptr,
NewValue.Ptr,
OldValue.Ptr) == OldValue.Ptr)
{
RtlZeroMemory(KdbTrapFrame, sizeof(KDB_KTRAP_FRAME));
StackPtr = (ULONG_PTR *) KernelStack;
+#if _M_X86_
KdbTrapFrame->Tf.Ebp = StackPtr[3];
KdbTrapFrame->Tf.Edi = StackPtr[4];
KdbTrapFrame->Tf.Esi = StackPtr[5];
KdbTrapFrame->Tf.SegDs = KGDT_R0_DATA;
KdbTrapFrame->Tf.SegEs = KGDT_R0_DATA;
KdbTrapFrame->Tf.SegGs = KGDT_R0_DATA;
+#endif
/* FIXME: what about the other registers??? */
}
}
/* Get the interrupt descriptor */
- if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
+ if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(ULONG_PTR)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
{
/*KdbpPrint("Couldn't access memory at 0x%p\n", (ULONG_PTR)Idtr.Base + (IntVect * 8));*/
return FALSE;
/* Get a pointer to the thread */
if (!NT_SUCCESS(PsLookupThreadByThreadId(ThreadId, &Thread)))
{
- KdbpPrint("Invalid thread id: 0x%08x\n", (ULONG)ThreadId);
+ KdbpPrint("Invalid thread id: 0x%08x\n", (ULONG_PTR)ThreadId);
return FALSE;
}
Process = Thread->ThreadsProcess;
/* Get a pointer to the process */
if (!NT_SUCCESS(PsLookupProcessByProcessId(ProcessId, &Process)))
{
- KdbpPrint("Invalid process id: 0x%08x\n", (ULONG)ProcessId);
+ KdbpPrint("Invalid process id: 0x%08x\n", (ULONG_PTR)ProcessId);
return FALSE;
}
Entry = Process->ThreadListHead.Flink;
if (Entry == &KdbCurrentProcess->ThreadListHead)
{
- KdbpPrint("No threads in process 0x%08x, cannot attach to process!\n", (ULONG)ProcessId);
+ KdbpPrint("No threads in process 0x%p, cannot attach to process!\n", ProcessId);
return FALSE;
}
SavedStackLimit = Thread->Tcb.StackLimit;
SavedKernelStack = Thread->Tcb.KernelStack;
Thread->Tcb.InitialStack = Thread->Tcb.StackBase = (char*)KdbStack + KDB_STACK_SIZE;
- Thread->Tcb.StackLimit = (ULONG)KdbStack;
+ Thread->Tcb.StackLimit = (ULONG_PTR)KdbStack;
Thread->Tcb.KernelStack = (char*)KdbStack + KDB_STACK_SIZE;
/*KdbpPrint("Switching to KDB stack 0x%08x-0x%08x\n", Thread->Tcb.StackLimit, Thread->Tcb.StackBase);*/
TrapFrame->Dr6 &= ~0x0000e00f;
/* Skip the current instruction */
- Context->Eip++;
+// Context->Eip++;
}
return ContinueType;
if (NT_SUCCESS(Status))
{
/* Set it */
- if (InterlockedCompareExchangePointer(&Process->
+ if (InterlockedCompareExchangePointer((PVOID*)&Process->
SeAuditProcessCreationInfo,
AuditName,
NULL))
NTAPI
LsaFreeReturnBuffer(PVOID Buffer)
{
- ULONG Size = 0;
+ SIZE_T Size = 0;
return ZwFreeVirtualMemory(NtCurrentProcess(),
&Buffer,
&Size,