BOOLEAN
PsIsSystemThread(
__in PETHREAD Thread
)
{
return (BOOLEAN)(IS_SYSTEM_THREAD(Thread));
}
NTSYSAPI
NTSTATUS
NTAPI
NtQueueApcThread(
IN HANDLE ThreadHandle,
IN PPS_APC_ROUTINE ApcRoutine,
IN PVOID ApcArgument1,
IN PVOID ApcArgument2,
IN PVOID ApcArgument3
)
/*++
Routine Description:
This function is used to queue a user-mode APC to the specified thread. The APC
will fire when the specified thread does an alertable wait
Arguments:
ThreadHandle - Supplies a handle to a thread object. The caller
must have THREAD_SET_CONTEXT access to the thread.
ApcRoutine - Supplies the address of the APC routine to execute when the
APC fires.
ApcArgument1 - Supplies the first PVOID passed to the APC
ApcArgument2 - Supplies the second PVOID passed to the APC
ApcArgument3 - Supplies the third PVOID passed to the APC
Return Value:
Returns an NT Status code indicating success or failure of the API
--*/
{
PETHREAD Thread;
NTSTATUS st;
KPROCESSOR_MODE Mode;
KIRQL Irql;
PKAPC Apc;
PAGED_CODE();
Mode = KeGetPreviousMode();
st = ObReferenceObjectByHandle(
ThreadHandle,
THREAD_SET_CONTEXT,
PsThreadType,
Mode,
(PVOID *)&Thread,
NULL
);
if ( NT_SUCCESS(st) ) {
st = STATUS_SUCCESS;
if ( IS_SYSTEM_THREAD(Thread) ) {
st = STATUS_INVALID_HANDLE;
}
else {
Apc = ExAllocatePoolWithQuotaTag(
(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE),
sizeof(*Apc),
'pasP'
);
if ( !Apc ) {
st = STATUS_NO_MEMORY;
}
else {
KeInitializeApc(
Apc,
&Thread->Tcb,
OriginalApcEnvironment,
PspQueueApcSpecialApc,
NULL,
(PKNORMAL_ROUTINE)ApcRoutine,
UserMode,
ApcArgument1
);
if ( !KeInsertQueueApc(Apc,ApcArgument2,ApcArgument3,0) ) {
ExFreePool(Apc);
st = STATUS_UNSUCCESSFUL;
}
}
}
ObDereferenceObject(Thread);
}
return st;
}
NTSTATUS
NtGetContextThread(
IN HANDLE ThreadHandle,
IN OUT PCONTEXT ThreadContext
)
/*++
Routine Description:
This function returns the usermode context of the specified thread. This
function will fail if the specified thread is a system thread. It will
return the wrong answer if the thread is a non-system thread that does
not execute in user-mode.
Arguments:
ThreadHandle - Supplies an open handle to the thread object from
which to retrieve context information. The handle
must allow THREAD_GET_CONTEXT access to the thread.
ThreadContext - Supplies the address of a buffer that will receive
the context of the specified thread.
Return Value:
None.
--*/
{
ULONG Alignment;
ULONG ContextFlags;
GETSETCONTEXT ContextFrame;
ULONG ContextLength;
KIRQL Irql;
KPROCESSOR_MODE Mode;
NTSTATUS Status;
PETHREAD Thread;
PAGED_CODE();
//
// Get previous mode and reference specified thread.
//
Mode = KeGetPreviousMode();
Status = ObReferenceObjectByHandle(ThreadHandle,
THREAD_GET_CONTEXT,
PsThreadType,
Mode,
(PVOID *)&Thread,
NULL);
//
// If the reference was successful, the check if the specified thread
// is a system thread.
//
if (NT_SUCCESS(Status)) {
//
// If the thread is not a system thread, then attempt to get the
// context of the thread.
//
if (IS_SYSTEM_THREAD(Thread) == FALSE) {
//
// Attempt to get the context of the specified thread.
//
try {
//
// Set the default alignment, capture the context flags,
// and set the default size of the context record.
//
Alignment = CONTEXT_ALIGN;
ContextFlags = ProbeAndReadUlong(&ThreadContext->ContextFlags);
ContextLength = sizeof(CONTEXT);
#if defined(_X86_)
//
// CONTEXT_EXTENDED_REGISTERS is SET, then we want sizeof(CONTEXT) set above
// otherwise (not set) we only want the old part of the context record.
//
if ((ContextFlags & CONTEXT_EXTENDED_REGISTERS) != CONTEXT_EXTENDED_REGISTERS) {
ContextLength = FIELD_OFFSET(CONTEXT, ExtendedRegisters);
}
#endif
#if defined(_MIPS_)
//
// The following code is included for backward compatibility
// with old code that does not understand extended context
// records on MIPS systems.
//
if ((ContextFlags & CONTEXT_EXTENDED_INTEGER) != CONTEXT_EXTENDED_INTEGER) {
Alignment = sizeof(ULONG);
ContextLength = FIELD_OFFSET(CONTEXT, ContextFlags) + 4;
}
#endif
if (Mode != KernelMode) {
ProbeForWrite(ThreadContext, ContextLength, Alignment);
}
} except(EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
}
//
// If an exception did not occur during the probe of the thread
// context, then get the context of the target thread.
//
if (NT_SUCCESS(Status)) {
KeInitializeEvent(&ContextFrame.OperationComplete,
NotificationEvent,
FALSE);
ContextFrame.Context.ContextFlags = ContextFlags;
ContextFrame.Mode = Mode;
if (Thread == PsGetCurrentThread()) {
ContextFrame.Apc.SystemArgument1 = NULL;
ContextFrame.Apc.SystemArgument2 = Thread;
KeRaiseIrql(APC_LEVEL, &Irql);
PspGetSetContextSpecialApc(&ContextFrame.Apc,
NULL,
NULL,
&ContextFrame.Apc.SystemArgument1,
&ContextFrame.Apc.SystemArgument2);
KeLowerIrql(Irql);
//
// Move context to specfied context record. If an exception
// occurs, then silently handle it and return success.
//
try {
RtlMoveMemory(ThreadContext,
&ContextFrame.Context,
ContextLength);
} except(EXCEPTION_EXECUTE_HANDLER) {
}
} else {
KeInitializeApc(&ContextFrame.Apc,
&Thread->Tcb,
OriginalApcEnvironment,
PspGetSetContextSpecialApc,
NULL,
NULL,
KernelMode,
NULL);
if (!KeInsertQueueApc(&ContextFrame.Apc, NULL, Thread, 2)) {
Status = STATUS_UNSUCCESSFUL;
} else {
KeWaitForSingleObject(&ContextFrame.OperationComplete,
Executive,
KernelMode,
FALSE,
NULL);
//
// Move context to specfied context record. If an
// exception occurs, then silently handle it and
// return success.
//
try {
RtlMoveMemory(ThreadContext,
&ContextFrame.Context,
ContextLength);
} except(EXCEPTION_EXECUTE_HANDLER) {
}
}
}
}
} else {
NTSTATUS UserCommitMemory(
PVOID pBase,
PVOID *ppCommit,
PULONG pCommitSize)
{
PDESKTOPVIEW pdv;
DWORD dwCommitOffset;
PWINDOWSTATION pwinsta;
PDESKTOP pdesk;
PBYTE pUserBase;
NTSTATUS Status;
/*
* If this is a system thread, we have no view of the desktop
* and must map it in. Fortunately, this does not happen often.
*/
if (IS_SYSTEM_THREAD(PsGetCurrentThread())) {
/*
* Find the desktop that owns the section.
*/
for (pwinsta = grpwinstaList; pwinsta; pwinsta = pwinsta->rpwinstaNext) {
for (pdesk = pwinsta->rpdeskList; pdesk; pdesk = pdesk->rpdeskNext) {
if (pdesk->pDeskInfo->pvDesktopBase == pBase)
goto FoundIt;
}
}
FoundIt:
if (pwinsta == NULL)
return STATUS_NO_MEMORY;
/*
* Map the section into the current process and commit the
* first page of the section.
*/
dwCommitOffset = (ULONG)((PBYTE)*ppCommit - (PBYTE)pBase);
Status = CommitReadOnlyMemory(pdesk->hsectionDesktop, PAGE_SIZE,
dwCommitOffset);
} else {
/*
* Find the current process' view of the desktop
*/
for (pdv = PpiCurrent()->pdvList; pdv != NULL; pdv = pdv->pdvNext) {
if (pdv->pdesk->pDeskInfo->pvDesktopBase == pBase)
break;
}
UserAssert(pdv);
/*
* Commit the memory
*/
pUserBase = (PVOID)((PBYTE)*ppCommit - pdv->ulClientDelta);
Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
&pUserBase,
0,
pCommitSize,
MEM_COMMIT,
PAGE_EXECUTE_READ
);
if (NT_SUCCESS(Status))
*ppCommit = (PVOID)((PBYTE)pUserBase + pdv->ulClientDelta);
}
return Status;
}
