procobj.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for procobj.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	KiAttachProcess (IN PKTHREAD Thread, IN PKPROCESS Process, IN PKLOCK_QUEUE_HANDLE ApcLock, IN PRKAPC_STATE SavedApcState)
VOID NTAPI	KeInitializeProcess (IN OUT PKPROCESS Process, IN KPRIORITY Priority, IN KAFFINITY Affinity, IN PULONG_PTR DirectoryTableBase, IN BOOLEAN Enable)
ULONG NTAPI	KeSetProcess (IN PKPROCESS Process, IN KPRIORITY Increment, IN BOOLEAN InWait)
VOID NTAPI	KeSetQuantumProcess (IN PKPROCESS Process, IN UCHAR Quantum)
KAFFINITY NTAPI	KeSetAffinityProcess (IN PKPROCESS Process, IN KAFFINITY Affinity)
BOOLEAN NTAPI	KeSetAutoAlignmentProcess (IN PKPROCESS Process, IN BOOLEAN Enable)
BOOLEAN NTAPI	KeSetDisableBoostProcess (IN PKPROCESS Process, IN BOOLEAN Disable)
KPRIORITY NTAPI	KeSetPriorityAndQuantumProcess (IN PKPROCESS Process, IN KPRIORITY Priority, IN UCHAR Quantum OPTIONAL)
VOID NTAPI	KeQueryValuesProcess (IN PKPROCESS Process, PPROCESS_VALUES Values)
VOID NTAPI	KeAttachProcess (IN PKPROCESS Process)
VOID NTAPI	KeDetachProcess (VOID)
BOOLEAN NTAPI	KeIsAttachedProcess (VOID)
VOID NTAPI	KeStackAttachProcess (IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
VOID NTAPI	KeUnstackDetachProcess (IN PRKAPC_STATE ApcState)
ULONG NTAPI	KeQueryRuntimeProcess (IN PKPROCESS Process, OUT PULONG UserTime)
BOOLEAN NTAPI	KeAddSystemServiceTable (IN PULONG_PTR Base, IN PULONG Count OPTIONAL, IN ULONG Limit, IN PUCHAR Number, IN ULONG Index)
BOOLEAN NTAPI	KeRemoveSystemServiceTable (IN ULONG Index)

Variables
LIST_ENTRY	KiProcessListHead
LIST_ENTRY	KiProcessInSwapListHead
LIST_ENTRY	KiProcessOutSwapListHead
LIST_ENTRY	KiStackInSwapListHead
KEVENT	KiSwapEvent
KSERVICE_TABLE_DESCRIPTOR	KeServiceDescriptorTable [SSDT_MAX_ENTRIES]
KSERVICE_TABLE_DESCRIPTOR	KeServiceDescriptorTableShadow [SSDT_MAX_ENTRIES]
PVOID	KeUserApcDispatcher
PVOID	KeUserCallbackDispatcher
PVOID	KeUserExceptionDispatcher
PVOID	KeRaiseUserExceptionDispatcher

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file procobj.c.

Function Documentation

KeAddSystemServiceTable()

BOOLEAN NTAPI KeAddSystemServiceTable	(	IN PULONG_PTR	Base,
		IN PULONG Count	OPTIONAL,
		IN ULONG	Limit,
		IN PUCHAR	Number,
		IN ULONG	Index
	)

Definition at line 908 of file procobj.c.

{
    PAGED_CODE();
 
    /* Check if descriptor table entry is free */
    if ((Index > SSDT_MAX_ENTRIES - 1) ||
        (KeServiceDescriptorTable[Index].Base) ||
        (KeServiceDescriptorTableShadow[Index].Base))
    {
        /* It's not, fail */
        return FALSE;
    }
 
    /* Initialize the shadow service descriptor table */
    KeServiceDescriptorTableShadow[Index].Base = Base;
    KeServiceDescriptorTableShadow[Index].Limit = Limit;
    KeServiceDescriptorTableShadow[Index].Number = Number;
    KeServiceDescriptorTableShadow[Index].Count = Count;
    return TRUE;
}

Referenced by DriverEntry().

KeAttachProcess()

VOID NTAPI KeAttachProcess

(

IN PKPROCESS

Process

)

Definition at line 582 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    PKTHREAD Thread = KeGetCurrentThread();
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check if we're already in that process */
    if (Thread->ApcState.Process == Process) return;
 
    /* Check if a DPC is executing or if we're already attached */
    if ((Thread->ApcStateIndex != OriginalApcEnvironment) ||
        (KeIsExecutingDpc()))
    {
        /* Invalid attempt */
        KeBugCheckEx(INVALID_PROCESS_ATTACH_ATTEMPT,
                     (ULONG_PTR)Process,
                     (ULONG_PTR)Thread->ApcState.Process,
                     Thread->ApcStateIndex,
                     KeIsExecutingDpc());
    }
    else
    {
        /* Acquire APC Lock */
        KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
        /* Acquire the dispatcher lock */
        KiAcquireDispatcherLockAtSynchLevel();
 
        /* Legit attach attempt: do it! */
        KiAttachProcess(Thread, Process, &ApcLock, &Thread->SavedApcState);
    }
}

Referenced by IntCheckImeShowStatus(), IntNotifyImeShowStatus(), IntSendMessageToUI(), MmCreatePeb(), MmCreateTeb(), MmDeleteTeb(), MmFreeMemoryArea(), MmFreePageTable(), MmInitializeProcessAddressSpace(), MmPageOutPhysicalAddress(), MmWorkingSetManager(), NtSetInformationProcess(), NtUserGetComboBoxInfo(), NtUserGetListBoxInfo(), NtUserGetThreadDesktop(), and VideoPortWin32kCallout().

KeDetachProcess()

VOID NTAPI KeDetachProcess

(

VOID

)

Definition at line 621 of file procobj.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    KLOCK_QUEUE_HANDLE ApcLock;
    PKPROCESS Process;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check if it's attached */
    if (Thread->ApcStateIndex == OriginalApcEnvironment) return;
 
    /* Acquire APC Lock */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Check for invalid attach attempts */
    if ((Thread->ApcState.KernelApcInProgress) ||
        !(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode])) ||
        !(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
    {
        /* Crash the system */
        KeBugCheck(INVALID_PROCESS_DETACH_ATTEMPT);
    }
 
    /* Get the process */
    Process = Thread->ApcState.Process;
 
    /* Acquire dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Decrease the stack count */
    ASSERT(Process->StackCount != 0);
    ASSERT(Process->State == ProcessInMemory);
    Process->StackCount--;
 
    /* Check if we can swap the process out */
    if (!Process->StackCount)
    {
        /* FIXME: Swap the process out */
    }
 
    /* Release dispatcher lock */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Restore the APC State */
    KiMoveApcState(&Thread->SavedApcState, &Thread->ApcState);
    Thread->SavedApcState.Process = NULL;
    Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
    Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
    Thread->ApcStateIndex = OriginalApcEnvironment;
 
    /* Release lock */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
 
    /* Swap Processes */
    KiSwapProcess(Thread->ApcState.Process, Process);
 
    /* Exit the dispatcher */
    KiExitDispatcher(ApcLock.OldIrql);
 
    /* Check if we have pending APCs */
    if (!(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode])))
    {
        /* What do you know, we do! Request them to be delivered */
        Thread->ApcState.KernelApcPending = TRUE;
        HalRequestSoftwareInterrupt(APC_LEVEL);
    }
}

Referenced by IntCheckImeShowStatus(), IntNotifyImeShowStatus(), IntSendMessageToUI(), MmCreatePeb(), MmCreateTeb(), MmDeleteTeb(), MmFreeMemoryArea(), MmFreePageTable(), MmInitializeProcessAddressSpace(), MmPageOutPhysicalAddress(), MmWorkingSetManager(), NtSetInformationProcess(), NtUserGetComboBoxInfo(), NtUserGetListBoxInfo(), NtUserGetThreadDesktop(), and VideoPortWin32kCallout().

KeInitializeProcess()

VOID NTAPI KeInitializeProcess	(	IN OUT PKPROCESS	Process,
		IN KPRIORITY	Priority,
		IN KAFFINITY	Affinity,
		IN PULONG_PTR	DirectoryTableBase,
		IN BOOLEAN	Enable
	)

Definition at line 115 of file procobj.c.

{
#ifdef CONFIG_SMP
    ULONG i = 0;
    UCHAR IdealNode = 0;
    PKNODE Node;
#endif
 
    /* Initialize the Dispatcher Header */
    Process->Header.Type = ProcessObject;
    Process->Header.Size = sizeof(KPROCESS) / sizeof(ULONG);
    Process->Header.SignalState = 0;
    InitializeListHead(&(Process->Header.WaitListHead));
 
    /* Initialize Scheduler Data, Alignment Faults and Set the PDE */
    Process->Affinity = Affinity;
    Process->BasePriority = (CHAR)Priority;
    Process->QuantumReset = 6;
    Process->DirectoryTableBase[0] = DirectoryTableBase[0];
    Process->DirectoryTableBase[1] = DirectoryTableBase[1];
    Process->AutoAlignment = Enable;
#if defined(_M_IX86)
    Process->IopmOffset = KiComputeIopmOffset(IO_ACCESS_MAP_NONE);
#endif
 
    /* Initialize the lists */
    InitializeListHead(&Process->ThreadListHead);
    InitializeListHead(&Process->ProfileListHead);
    InitializeListHead(&Process->ReadyListHead);
 
    /* Initialize the current State */
    Process->State = ProcessInMemory;
 
    /* Check how many Nodes there are on the system */
#ifdef CONFIG_SMP
    if (KeNumberNodes > 1)
    {
        /* Set the new seed */
        KeProcessNodeSeed = (KeProcessNodeSeed + 1) / KeNumberNodes;
        IdealNode = KeProcessNodeSeed;
 
        /* Loop every node */
        do
        {
            /* Check if the affinity matches */
            if (KeNodeBlock[IdealNode]->ProcessorMask != Affinity) break;
 
            /* No match, try next Ideal Node and increase node loop index */
            IdealNode++;
            i++;
 
            /* Check if the Ideal Node is beyond the total number of nodes */
            if (IdealNode >= KeNumberNodes)
            {
                /* Normalize the Ideal Node */
                IdealNode -= KeNumberNodes;
            }
        } while (i < KeNumberNodes);
    }
 
    /* Set the ideal node and get the ideal node block */
    Process->IdealNode = IdealNode;
    Node = KeNodeBlock[IdealNode];
    ASSERT(Node->ProcessorMask & Affinity);
 
    /* Find the matching affinity set to calculate the thread seed */
    Affinity &= Node->ProcessorMask;
    Process->ThreadSeed = KeFindNextRightSetAffinity(Node->Seed,
                                                     (ULONG)Affinity);
    Node->Seed = Process->ThreadSeed;
#endif
}

KeIsAttachedProcess()

BOOLEAN NTAPI KeIsAttachedProcess

(

VOID

)

Definition at line 693 of file procobj.c.

{
    /* Return the APC State */
    return KeGetCurrentThread()->ApcStateIndex;
}

Referenced by IntEnlistPowerCallout(), MiAccessCheck(), MiCheckForUserStackOverflow(), MmWorkingSetManager(), ObpCloseHandle(), PspExitThread(), and RtlWalkFrameChain().

KeQueryRuntimeProcess()

ULONG NTAPI KeQueryRuntimeProcess	(	IN PKPROCESS	Process,
		OUT PULONG	UserTime
	)

Definition at line 860 of file procobj.c.

{
    ULONG TotalUser, TotalKernel;
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    PKTHREAD Thread;
 
    ASSERT_PROCESS(Process);
 
    /* Initialize user and kernel times */
    TotalUser = Process->UserTime;
    TotalKernel = Process->KernelTime;
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Loop all child threads and sum up their times */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Sum up times */
        TotalKernel += Thread->KernelTime;
        TotalUser += Thread->UserTime;
 
        /* Go to the next one */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release lock */
    KiReleaseProcessLock(&ProcessLock);
 
    /* Return the user time */
    *UserTime = TotalUser;
 
    /* Return the kernel time */
    return TotalKernel;
}

Referenced by NtQueryInformationProcess(), and QSI_DEF().

KeQueryValuesProcess()

VOID NTAPI KeQueryValuesProcess	(	IN PKPROCESS	Process,
		PPROCESS_VALUES	Values
	)

Definition at line 525 of file procobj.c.

{
    PEPROCESS EProcess;
    PLIST_ENTRY NextEntry;
    ULONG TotalKernel, TotalUser;
    KLOCK_QUEUE_HANDLE ProcessLock;
 
    ASSERT_PROCESS(Process);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Initialize user and kernel times */
    TotalKernel = Process->KernelTime;
    TotalUser = Process->UserTime;
 
    /* Copy the IO_COUNTERS from the process */
    EProcess = (PEPROCESS)Process;
    Values->IoInfo.ReadOperationCount = EProcess->ReadOperationCount.QuadPart;
    Values->IoInfo.WriteOperationCount = EProcess->WriteOperationCount.QuadPart;
    Values->IoInfo.OtherOperationCount = EProcess->OtherOperationCount.QuadPart;
    Values->IoInfo.ReadTransferCount = EProcess->ReadTransferCount.QuadPart;
    Values->IoInfo.WriteTransferCount = EProcess->WriteTransferCount.QuadPart;
    Values->IoInfo.OtherTransferCount = EProcess->OtherTransferCount.QuadPart;
 
    /* Loop all child threads and sum up their times */
    for (NextEntry = Process->ThreadListHead.Flink;
         NextEntry != &Process->ThreadListHead;
         NextEntry = NextEntry->Flink)
    {
        PKTHREAD Thread;
 
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Sum up times */
        TotalKernel += Thread->KernelTime;
        TotalUser += Thread->UserTime;
    }
 
    /* Release the process lock */
    KiReleaseProcessLock(&ProcessLock);
 
    /* Compute total times */
    Values->TotalKernelTime.QuadPart = TotalKernel * (LONGLONG)KeMaximumIncrement;
    Values->TotalUserTime.QuadPart = TotalUser * (LONGLONG)KeMaximumIncrement;
}

Referenced by NtQueryInformationJobObject(), and NtQueryInformationProcess().

KeRemoveSystemServiceTable()

BOOLEAN NTAPI KeRemoveSystemServiceTable

(

IN ULONG

Index

)

Definition at line 938 of file procobj.c.

{
    PAGED_CODE();
 
    /* Make sure the Index is valid */
    if (Index > (SSDT_MAX_ENTRIES - 1)) return FALSE;
 
    /* Is there a Normal Descriptor Table? */
    if (!KeServiceDescriptorTable[Index].Base)
    {
        /* Not with the index, is there a shadow at least? */
        if (!KeServiceDescriptorTableShadow[Index].Base) return FALSE;
    }
 
    /* Now clear from the Shadow Table. */
    KeServiceDescriptorTableShadow[Index].Base = NULL;
    KeServiceDescriptorTableShadow[Index].Number = NULL;
    KeServiceDescriptorTableShadow[Index].Limit = 0;
    KeServiceDescriptorTableShadow[Index].Count = NULL;
 
    /* Check if we should clean from the Master one too */
    if (Index == 1)
    {
        KeServiceDescriptorTable[Index].Base = NULL;
        KeServiceDescriptorTable[Index].Number = NULL;
        KeServiceDescriptorTable[Index].Limit = 0;
        KeServiceDescriptorTable[Index].Count = NULL;
    }
 
    /* Return success */
    return TRUE;
}

KeSetAffinityProcess()

KAFFINITY NTAPI KeSetAffinityProcess	(	IN PKPROCESS	Process,
		IN KAFFINITY	Affinity
	)

Definition at line 265 of file procobj.c.

{
 
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    KAFFINITY OldAffinity;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    ASSERT((Affinity & KeActiveProcessors) != 0);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Acquire the dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Capture old affinity and update it */
    OldAffinity = Process->Affinity;
    Process->Affinity = Affinity;
 
    /* Loop all child threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Set affinity on it */
        KiSetAffinityThread(Thread, Affinity);
        NextEntry = NextEntry->Flink;
    }
 
    /* Release Dispatcher Database */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Release the process lock */
    KiReleaseProcessLockFromSynchLevel(&ProcessLock);
    KiExitDispatcher(ProcessLock.OldIrql);
 
    /* Return previous affinity */
    return OldAffinity;
}

Referenced by NtSetInformationProcess().

KeSetAutoAlignmentProcess()

BOOLEAN NTAPI KeSetAutoAlignmentProcess	(	IN PKPROCESS	Process,
		IN BOOLEAN	Enable
	)

Definition at line 313 of file procobj.c.

{
    /* Set or reset the bit depending on what the enable flag says */
    if (Enable)
    {
        return InterlockedBitTestAndSet(&Process->ProcessFlags,
                                        KPSF_AUTO_ALIGNMENT_BIT);
    }
    else
    {
        return InterlockedBitTestAndReset(&Process->ProcessFlags,
                                          KPSF_AUTO_ALIGNMENT_BIT);
    }
}

Referenced by NtSetInformationProcess().

KeSetDisableBoostProcess()

BOOLEAN NTAPI KeSetDisableBoostProcess	(	IN PKPROCESS	Process,
		IN BOOLEAN	Disable
	)

Definition at line 331 of file procobj.c.

{
    /* Set or reset the bit depending on what the disable flag says */
    if (Disable)
    {
        return InterlockedBitTestAndSet(&Process->ProcessFlags,
                                        KPSF_DISABLE_BOOST_BIT);
    }
    else
    {
        return InterlockedBitTestAndReset(&Process->ProcessFlags,
                                          KPSF_DISABLE_BOOST_BIT);
    }
}

Referenced by NtSetInformationProcess().

KeSetPriorityAndQuantumProcess()

KPRIORITY NTAPI KeSetPriorityAndQuantumProcess	(	IN PKPROCESS	Process,
		IN KPRIORITY	Priority,
		IN UCHAR Quantum	OPTIONAL
	)

Definition at line 349 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ProcessLock;
    KPRIORITY Delta;
    PLIST_ENTRY NextEntry, ListHead;
    KPRIORITY NewPriority, OldPriority;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check if the process already has this priority */
    if (Process->BasePriority == Priority) return Process->BasePriority;
 
    /* If the caller gave priority 0, normalize to 1 */
    if (!Priority) Priority = LOW_PRIORITY + 1;
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Acquire the dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Check if we are modifying the quantum too */
    if (Quantum) Process->QuantumReset = Quantum;
 
    /* Save the current base priority and update it */
    OldPriority = Process->BasePriority;
    Process->BasePriority = (SCHAR)Priority;
 
    /* Calculate the priority delta */
    Delta = Priority - OldPriority;
 
    /* Set the list head and list entry */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
 
    /* Check if this is a real-time priority */
    if (Priority >= LOW_REALTIME_PRIORITY)
    {
        /* Loop the thread list */
        while (NextEntry != ListHead)
        {
            /* Get the thread */
            Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
            /* Update the quantum if we had one */
            if (Quantum) Thread->QuantumReset = Quantum;
 
            /* Acquire the thread lock */
            KiAcquireThreadLock(Thread);
 
            /* Calculate the new priority */
            NewPriority = Thread->BasePriority + Delta;
            if (NewPriority < LOW_REALTIME_PRIORITY)
            {
                /* We're in real-time range, don't let it go below */
                NewPriority = LOW_REALTIME_PRIORITY;
            }
            else if (NewPriority > HIGH_PRIORITY)
            {
                /* We're going beyond the maximum priority, normalize */
                NewPriority = HIGH_PRIORITY;
            }
 
            /*
             * If priority saturation occured or the old priority was still in
             * the real-time range, don't do anything.
             */
            if (!(Thread->Saturation) || (OldPriority < LOW_REALTIME_PRIORITY))
            {
                /* Check if we had priority saturation */
                if (Thread->Saturation > 0)
                {
                    /* Boost priority to maximum */
                    NewPriority = HIGH_PRIORITY;
                }
                else if (Thread->Saturation < 0)
                {
                    /* If we had negative saturation, set minimum priority */
                    NewPriority = LOW_REALTIME_PRIORITY;
                }
 
                /* Update priority and quantum */
                Thread->BasePriority = (SCHAR)NewPriority;
                Thread->Quantum = Thread->QuantumReset;
 
                /* Disable decrements and update priority */
                Thread->PriorityDecrement = 0;
                KiSetPriorityThread(Thread, NewPriority);
            }
 
            /* Release the thread lock */
            KiReleaseThreadLock(Thread);
 
            /* Go to the next thread */
            NextEntry = NextEntry->Flink;
        }
    }
    else
    {
        /* Loop the thread list */
        while (NextEntry != ListHead)
        {
            /* Get the thread */
            Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
            /* Update the quantum if we had one */
            if (Quantum) Thread->QuantumReset = Quantum;
 
            /* Lock the thread */
            KiAcquireThreadLock(Thread);
 
            /* Calculate the new priority */
            NewPriority = Thread->BasePriority + Delta;
            if (NewPriority >= LOW_REALTIME_PRIORITY)
            {
                /* We're not real-time range, don't let it enter RT range */
                NewPriority = LOW_REALTIME_PRIORITY - 1;
            }
            else if (NewPriority <= LOW_PRIORITY)
            {
                /* We're going below the minimum priority, normalize */
                NewPriority = 1;
            }
 
            /*
             * If priority saturation occured or the old priority was still in
             * the real-time range, don't do anything.
             */
            if (!(Thread->Saturation) ||
                (OldPriority >= LOW_REALTIME_PRIORITY))
            {
                /* Check if we had priority saturation */
                if (Thread->Saturation > 0)
                {
                    /* Boost priority to maximum */
                    NewPriority = LOW_REALTIME_PRIORITY - 1;
                }
                else if (Thread->Saturation < 0)
                {
                    /* If we had negative saturation, set minimum priority */
                    NewPriority = 1;
                }
 
                /* Update priority and quantum */
                Thread->BasePriority = (SCHAR)NewPriority;
                Thread->Quantum = Thread->QuantumReset;
 
                /* Disable decrements and update priority */
                Thread->PriorityDecrement = 0;
                KiSetPriorityThread(Thread, NewPriority);
            }
 
            /* Release the thread lock */
            KiReleaseThreadLock(Thread);
 
            /* Go to the next thread */
            NextEntry = NextEntry->Flink;
        }
    }
 
    /* Release Dispatcher Database */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Release the process lock */
    KiReleaseProcessLockFromSynchLevel(&ProcessLock);
    KiExitDispatcher(ProcessLock.OldIrql);
 
    /* Return previous priority */
    return OldPriority;
}

Referenced by NtSetInformationProcess(), and PsSetProcessPriorityByClass().

KeSetProcess()

ULONG NTAPI KeSetProcess	(	IN PKPROCESS	Process,
		IN KPRIORITY	Increment,
		IN BOOLEAN	InWait
	)

Definition at line 194 of file procobj.c.

{
    KIRQL OldIrql;
    ULONG OldState;
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock Dispatcher */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Get Old State */
    OldState = Process->Header.SignalState;
 
    /* Signal the Process */
    Process->Header.SignalState = TRUE;
 
    /* Check if was unsignaled and has waiters */
    if (!(OldState) &&
        !(IsListEmpty(&Process->Header.WaitListHead)))
    {
        /* Unwait the threads */
        KxUnwaitThread(&Process->Header, Increment);
    }
 
    /* Release Dispatcher Database */
    KiReleaseDispatcherLock(OldIrql);
 
    /* Return the previous State */
    return OldState;
}

KeSetQuantumProcess()

VOID NTAPI KeSetQuantumProcess	(	IN PKPROCESS	Process,
		IN UCHAR	Quantum
	)

Definition at line 229 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Set new quantum */
    Process->QuantumReset = Quantum;
 
    /* Loop all child threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Set quantum */
        Thread->QuantumReset = Quantum;
 
        /* Go to the next one */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release lock */
    KiReleaseProcessLock(&ProcessLock);
}

Referenced by PsChangeQuantumTable().

KeStackAttachProcess()

VOID NTAPI KeStackAttachProcess	(	IN PKPROCESS	Process,
		OUT PRKAPC_STATE	ApcState
	)

Definition at line 704 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    PKTHREAD Thread = KeGetCurrentThread();
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Crash system if DPC is being executed! */
    if (KeIsExecutingDpc())
    {
        /* Executing a DPC, crash! */
        KeBugCheckEx(INVALID_PROCESS_ATTACH_ATTEMPT,
                     (ULONG_PTR)Process,
                     (ULONG_PTR)Thread->ApcState.Process,
                     Thread->ApcStateIndex,
                     KeIsExecutingDpc());
    }
 
    /* Check if we are already in the target process */
    if (Thread->ApcState.Process == Process)
    {
        /* Set magic value so we don't crash later when detaching */
        ApcState->Process = (PKPROCESS)1;
        return;
    }
 
    /* Acquire APC Lock */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Acquire dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Check if the Current Thread is already attached */
    if (Thread->ApcStateIndex != OriginalApcEnvironment)
    {
        /* We're already attached, so save the APC State into what we got */
        KiAttachProcess(Thread, Process, &ApcLock, ApcState);
    }
    else
    {
        /* We're not attached, so save the APC State into SavedApcState */
        KiAttachProcess(Thread, Process, &ApcLock, &Thread->SavedApcState);
        ApcState->Process = NULL;
    }
}

Referenced by _IRQL_requires_max_(), DbgkpMarkProcessPeb(), DbgkpPostFakeProcessCreateMessages(), ExpDebuggerWorker(), IntAttachToCSRSS(), IntRemoveHook(), KdbCommand_Gdi_dumpht(), KdbCommand_Gdi_entry(), KdbCommand_Gdi_handle(), KdbpAttachToThread(), KdbpOverwriteInstruction(), MiDoMappedCopy(), MiDoPoolCopy(), MiLoadImageSection(), MiQueryMemoryBasicInformation(), MiUnmapViewOfSection(), MmCheckSystemImage(), MmMapViewOfArm3Section(), MmMapViewOfSection(), MmTrimUserMemory(), NtAllocateVirtualMemory(), NtFlushInstructionCache(), NtFreeVirtualMemory(), NtLockVirtualMemory(), NtProtectVirtualMemory(), NtSetInformationObject(), NtUnlockVirtualMemory(), NtUserSetWindowsHookEx(), NtUserWaitForInputIdle(), ObClearProcessHandleTable(), ObDuplicateObject(), ObpCloseHandle(), ObpCreateHandle(), ObpCreateUnnamedHandle(), ObSetHandleAttributes(), PspDeleteProcess(), PspSetQuotaLimits(), PspWriteTebImpersonationInfo(), and SepCleanupLUIDDeviceMapDirectory().

KeUnstackDetachProcess()

VOID NTAPI KeUnstackDetachProcess

(

IN PRKAPC_STATE

ApcState

)

Definition at line 756 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    PKTHREAD Thread = KeGetCurrentThread();
    PKPROCESS Process;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check for magic value meaning we were already in the same process */
    if (ApcState->Process == (PKPROCESS)1) return;
 
    /* Loop to make sure no APCs are pending  */
    for (;;)
    {
        /* Acquire APC Lock */
        KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
        /* Check if a kernel APC is pending */
        if (Thread->ApcState.KernelApcPending)
        {
            /* Check if kernel APC should be delivered */
            if (!(Thread->KernelApcDisable) && (ApcLock.OldIrql <= APC_LEVEL))
            {
                /* Release the APC lock so that the APC can be delivered */
                KiReleaseApcLock(&ApcLock);
                continue;
            }
        }
 
        /* Otherwise, break out */
        break;
    }
 
    /*
     * Check if the process isn't attacked, or has a Kernel APC in progress
     * or has pending APC of any kind.
     */
    if ((Thread->ApcStateIndex == OriginalApcEnvironment) ||
        (Thread->ApcState.KernelApcInProgress) ||
        (!IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode])) ||
        (!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
    {
        /* Bugcheck the system */
        KeBugCheck(INVALID_PROCESS_DETACH_ATTEMPT);
    }
 
    /* Get the process */
    Process = Thread->ApcState.Process;
 
    /* Acquire dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Decrease the stack count */
    ASSERT(Process->StackCount != 0);
    ASSERT(Process->State == ProcessInMemory);
    Process->StackCount--;
 
    /* Check if we can swap the process out */
    if (!Process->StackCount)
    {
        /* FIXME: Swap the process out */
    }
 
    /* Release dispatcher lock */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Check if there's an APC state to restore */
    if (ApcState->Process)
    {
        /* Restore the APC State */
        KiMoveApcState(ApcState, &Thread->ApcState);
    }
    else
    {
        /* The ApcState parameter is useless, so use the saved data and reset it */
        KiMoveApcState(&Thread->SavedApcState, &Thread->ApcState);
        Thread->SavedApcState.Process = NULL;
        Thread->ApcStateIndex = OriginalApcEnvironment;
        Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
        Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
    }
 
    /* Release lock */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
 
    /* Swap Processes */
    KiSwapProcess(Thread->ApcState.Process, Process);
 
    /* Exit the dispatcher */
    KiExitDispatcher(ApcLock.OldIrql);
 
    /* Check if we have pending APCs */
    if (!(IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode])))
    {
        /* What do you know, we do! Request them to be delivered */
        Thread->ApcState.KernelApcPending = TRUE;
        HalRequestSoftwareInterrupt(APC_LEVEL);
    }
}

Referenced by _IRQL_requires_max_(), DbgkpMarkProcessPeb(), DbgkpPostFakeProcessCreateMessages(), ExpDebuggerWorker(), IntDetachFromCSRSS(), IntRemoveHook(), KdbCommand_Gdi_dumpht(), KdbCommand_Gdi_entry(), KdbCommand_Gdi_handle(), KdbEnterDebuggerException(), KdbpAttachToThread(), KdbpOverwriteInstruction(), MiDoMappedCopy(), MiDoPoolCopy(), MiLoadImageSection(), MiQueryMemoryBasicInformation(), MiUnmapViewOfSection(), MmCheckSystemImage(), MmMapViewOfArm3Section(), MmMapViewOfSection(), MmTrimUserMemory(), NtAllocateVirtualMemory(), NtFlushInstructionCache(), NtFreeVirtualMemory(), NtLockVirtualMemory(), NtProtectVirtualMemory(), NtSetInformationObject(), NtUnlockVirtualMemory(), NtUserSetWindowsHookEx(), NtUserWaitForInputIdle(), ObClearProcessHandleTable(), ObDuplicateObject(), ObpCloseHandle(), ObpCreateHandle(), ObpCreateUnnamedHandle(), ObSetHandleAttributes(), PspDeleteProcess(), PspSetQuotaLimits(), PspWriteTebImpersonationInfo(), and SepCleanupLUIDDeviceMapDirectory().

KiAttachProcess()

VOID NTAPI KiAttachProcess	(	IN PKTHREAD	Thread,
		IN PKPROCESS	Process,
		IN PKLOCK_QUEUE_HANDLE	ApcLock,
		IN PRKAPC_STATE	SavedApcState
	)

Definition at line 35 of file procobj.c.

{
#if 0
    PLIST_ENTRY ListHead, NextEntry;
    PKTHREAD CurrentThread;
#endif
    ASSERT(Process != Thread->ApcState.Process);
 
    /* Increase Stack Count */
    ASSERT(Process->StackCount != MAXULONG_PTR);
    Process->StackCount++;
 
    /* Swap the APC Environment */
    KiMoveApcState(&Thread->ApcState, SavedApcState);
 
    /* Reinitialize Apc State */
    InitializeListHead(&Thread->ApcState.ApcListHead[KernelMode]);
    InitializeListHead(&Thread->ApcState.ApcListHead[UserMode]);
    Thread->ApcState.Process = Process;
    Thread->ApcState.KernelApcInProgress = FALSE;
    Thread->ApcState.KernelApcPending = FALSE;
    Thread->ApcState.UserApcPending = FALSE;
 
    /* Update Environment Pointers if needed*/
    if (SavedApcState == &Thread->SavedApcState)
    {
        Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->
                                                          SavedApcState;
        Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->ApcState;
        Thread->ApcStateIndex = AttachedApcEnvironment;
    }
 
    /* Check if the process is paged in */
    if (Process->State == ProcessInMemory)
    {
        /* Scan the ready list */
#if 0
        ListHead = &Process->ReadyListHead;
        NextEntry = ListHead->Flink;
        while (NextEntry != ListHead)
        {
            /* Get the thread */
            CurrentThread = CONTAINING_RECORD(NextEntry, KTHREAD, WaitListEntry);
 
            /* Remove it */
            RemoveEntryList(NextEntry);
            CurrentThread->ProcessReadyQueue = FALSE;
 
            /* Mark it ready */
            KiReadyThread(CurrentThread);
 
            /* Go to the next one */
            NextEntry = ListHead->Flink;
        }
#endif
 
        /* Release dispatcher lock */
        KiReleaseDispatcherLockFromSynchLevel();
 
        /* Release lock */
        KiReleaseApcLockFromSynchLevel(ApcLock);
 
        /* Swap Processes */
        KiSwapProcess(Process, SavedApcState->Process);
 
        /* Exit the dispatcher */
        KiExitDispatcher(ApcLock->OldIrql);
    }
    else
    {
        DPRINT1("Errr. ReactOS doesn't support paging out processes yet...\n");
        ASSERT(FALSE);
    }
}

Referenced by KeAttachProcess(), and KeStackAttachProcess().

Variable Documentation

KeRaiseUserExceptionDispatcher

PVOID KeRaiseUserExceptionDispatcher

Definition at line 29 of file procobj.c.

Referenced by KeRaiseUserException().

KeServiceDescriptorTable

KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[SSDT_MAX_ENTRIES]

Definition at line 23 of file procobj.c.

Referenced by ExpInitializeExecutive(), HalHandleNMI(), KeAddSystemServiceTable(), KeInitThread(), KeRemoveSystemServiceTable(), KiInitializeKernel(), KiInitSystem(), KiSystemCallHandler(), and PsConvertToGuiThread().

KeServiceDescriptorTableShadow

KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTableShadow[SSDT_MAX_ENTRIES]

Definition at line 24 of file procobj.c.

Referenced by ExpInitializeExecutive(), KeAddSystemServiceTable(), KeRemoveSystemServiceTable(), KiInitializeKernel(), KiInitSystem(), and PsConvertToGuiThread().

KeUserApcDispatcher

PVOID KeUserApcDispatcher

Definition at line 26 of file procobj.c.

Referenced by KiInitializeUserApc().

KeUserCallbackDispatcher

PVOID KeUserCallbackDispatcher

Definition at line 27 of file procobj.c.

Referenced by KdUpdateDataBlock(), and KiUserModeCallout().

KeUserExceptionDispatcher

PVOID KeUserExceptionDispatcher

Definition at line 28 of file procobj.c.

Referenced by KiDispatchException(), and KiDispatchExceptionToUser().

KiProcessInSwapListHead

LIST_ENTRY KiProcessInSwapListHead

Definition at line 19 of file procobj.c.

Referenced by KiInitializeKernel(), and KiInitSystem().

KiProcessListHead

LIST_ENTRY KiProcessListHead

Definition at line 18 of file procobj.c.

Referenced by KiInitializeKernel().

KiProcessOutSwapListHead

LIST_ENTRY KiProcessOutSwapListHead

Definition at line 19 of file procobj.c.

KiStackInSwapListHead

LIST_ENTRY KiStackInSwapListHead

Definition at line 20 of file procobj.c.

Referenced by KiInitializeKernel(), and KiInitSystem().

KiSwapEvent

KEVENT KiSwapEvent

Definition at line 21 of file procobj.c.

Referenced by KiInitializeKernel(), and KiInitSystem().