1061 lines
26 KiB
C
1061 lines
26 KiB
C
/*++
|
||
|
||
Copyright (c) 1989 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
psinit.c
|
||
|
||
Abstract:
|
||
|
||
Process Structure Initialization.
|
||
|
||
Author:
|
||
|
||
Mark Lucovsky (markl) 20-Apr-1989
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "psp.h"
|
||
|
||
#define ROUND_UP(VALUE,ROUND) ((ULONG)(((ULONG)VALUE + \
|
||
((ULONG)ROUND - 1L)) & (~((ULONG)ROUND - 1L))))
|
||
|
||
extern ULONG PsMinimumWorkingSet;
|
||
extern ULONG PsMaximumWorkingSet;
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma const_seg("PAGECONST")
|
||
#pragma data_seg("PAGEDATA")
|
||
#endif
|
||
#define NTDLL_PATH_NAME L"\\SystemRoot\\System32\\ntdll.dll"
|
||
const UNICODE_STRING PsNtDllPathName = {
|
||
sizeof(NTDLL_PATH_NAME) - sizeof(UNICODE_NULL),
|
||
sizeof(NTDLL_PATH_NAME),
|
||
NTDLL_PATH_NAME
|
||
};
|
||
|
||
ULONG PsPrioritySeperation; // nonpaged
|
||
BOOLEAN PspUseJobSchedulingClasses = FALSE;
|
||
PACCESS_TOKEN PspBootAccessToken = NULL;
|
||
HANDLE PspInitialSystemProcessHandle = NULL;
|
||
PHANDLE_TABLE PspCidTable; // nonpaged
|
||
SYSTEM_DLL PspSystemDll = {NULL};
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma const_seg("INITCONST")
|
||
#pragma data_seg("INITDATA")
|
||
#endif
|
||
ULONG PsRawPrioritySeparation = 0;
|
||
ULONG PsEmbeddedNTMask = 0;
|
||
|
||
|
||
|
||
NTSTATUS
|
||
MmCheckSystemImage(
|
||
IN HANDLE ImageFileHandle,
|
||
IN LOGICAL PurgeSection
|
||
);
|
||
|
||
NTSTATUS
|
||
LookupEntryPoint (
|
||
IN PVOID DllBase,
|
||
IN PSZ NameOfEntryPoint,
|
||
OUT PVOID *AddressOfEntryPoint
|
||
);
|
||
|
||
const GENERIC_MAPPING PspProcessMapping = {
|
||
STANDARD_RIGHTS_READ |
|
||
PROCESS_VM_READ | PROCESS_QUERY_INFORMATION,
|
||
STANDARD_RIGHTS_WRITE |
|
||
PROCESS_CREATE_PROCESS | PROCESS_CREATE_THREAD |
|
||
PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_DUP_HANDLE |
|
||
PROCESS_TERMINATE | PROCESS_SET_QUOTA |
|
||
PROCESS_SET_INFORMATION | PROCESS_SET_PORT,
|
||
STANDARD_RIGHTS_EXECUTE |
|
||
SYNCHRONIZE,
|
||
PROCESS_ALL_ACCESS
|
||
};
|
||
|
||
const GENERIC_MAPPING PspThreadMapping = {
|
||
STANDARD_RIGHTS_READ |
|
||
THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION,
|
||
STANDARD_RIGHTS_WRITE |
|
||
THREAD_TERMINATE | THREAD_SUSPEND_RESUME | THREAD_ALERT |
|
||
THREAD_SET_INFORMATION | THREAD_SET_CONTEXT,
|
||
STANDARD_RIGHTS_EXECUTE |
|
||
SYNCHRONIZE,
|
||
THREAD_ALL_ACCESS
|
||
};
|
||
|
||
const GENERIC_MAPPING PspJobMapping = {
|
||
STANDARD_RIGHTS_READ |
|
||
JOB_OBJECT_QUERY,
|
||
STANDARD_RIGHTS_WRITE |
|
||
JOB_OBJECT_ASSIGN_PROCESS | JOB_OBJECT_SET_ATTRIBUTES | JOB_OBJECT_TERMINATE,
|
||
STANDARD_RIGHTS_EXECUTE |
|
||
SYNCHRONIZE,
|
||
THREAD_ALL_ACCESS
|
||
};
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma data_seg()
|
||
#pragma const_seg("PAGECONST")
|
||
#endif
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(INIT,PsInitSystem)
|
||
#pragma alloc_text(INIT,PspInitPhase0)
|
||
#pragma alloc_text(INIT,PspInitPhase1)
|
||
#pragma alloc_text(INIT,PsLocateSystemDll)
|
||
#pragma alloc_text(INIT,PspInitializeSystemDll)
|
||
#pragma alloc_text(INIT,PspLookupSystemDllEntryPoint)
|
||
#pragma alloc_text(INIT,PspNameToOrdinal)
|
||
#pragma alloc_text(PAGE,PspMapSystemDll)
|
||
#pragma alloc_text(PAGE,PsChangeQuantumTable)
|
||
|
||
#endif
|
||
|
||
//
|
||
// Process Structure Global Data
|
||
//
|
||
|
||
POBJECT_TYPE PsThreadType;
|
||
POBJECT_TYPE PsProcessType;
|
||
PEPROCESS PsInitialSystemProcess;
|
||
PVOID PsSystemDllDllBase;
|
||
ULONG PspDefaultPagedLimit;
|
||
ULONG PspDefaultNonPagedLimit;
|
||
ULONG PspDefaultPagefileLimit;
|
||
SCHAR PspForegroundQuantum[3];
|
||
|
||
EPROCESS_QUOTA_BLOCK PspDefaultQuotaBlock;
|
||
BOOLEAN PspDoingGiveBacks;
|
||
POBJECT_TYPE PsJobType;
|
||
FAST_MUTEX PspJobListLock;
|
||
KSPIN_LOCK PspQuotaLock;
|
||
LIST_ENTRY PspJobList;
|
||
|
||
BOOLEAN PsReaperActive;
|
||
PETHREAD PsReaperList;
|
||
WORK_QUEUE_ITEM PsReaperWorkItem;
|
||
PVOID PsSystemDllBase;
|
||
#define PSP_1MB (1024*1024)
|
||
|
||
//
|
||
// List head and mutex that links all processes that have been initialized
|
||
//
|
||
|
||
FAST_MUTEX PspActiveProcessMutex;
|
||
LIST_ENTRY PsActiveProcessHead;
|
||
//extern PIMAGE_FILE_HEADER _header;
|
||
PEPROCESS PsIdleProcess;
|
||
PETHREAD PspShutdownThread;
|
||
|
||
BOOLEAN
|
||
PsInitSystem (
|
||
IN ULONG Phase,
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function performs process structure initialization.
|
||
It is called during phase 0 and phase 1 initialization. Its
|
||
function is to dispatch to the appropriate phase initialization
|
||
routine.
|
||
|
||
Arguments:
|
||
|
||
Phase - Supplies the initialization phase number.
|
||
|
||
LoaderBlock - Supplies a pointer to a loader parameter block.
|
||
|
||
Return Value:
|
||
|
||
TRUE - Initialization succeeded.
|
||
|
||
FALSE - Initialization failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
UNREFERENCED_PARAMETER (Phase);
|
||
|
||
switch ( InitializationPhase ) {
|
||
|
||
case 0 :
|
||
return PspInitPhase0(LoaderBlock);
|
||
case 1 :
|
||
return PspInitPhase1(LoaderBlock);
|
||
default:
|
||
KeBugCheckEx(UNEXPECTED_INITIALIZATION_CALL, 1, InitializationPhase, 0, 0);
|
||
}
|
||
// return 0; // Not reachable, quiet compiler
|
||
}
|
||
|
||
BOOLEAN
|
||
PspInitPhase0 (
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine performs phase 0 process structure initialization.
|
||
During this phase, the initial system process, phase 1 initialization
|
||
thread, and reaper threads are created. All object types and other
|
||
process structures are created and initialized.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
TRUE - Initialization was successful.
|
||
|
||
FALSE - Initialization Failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
UNICODE_STRING NameString;
|
||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||
OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
|
||
HANDLE ThreadHandle;
|
||
PETHREAD Thread;
|
||
MM_SYSTEMSIZE SystemSize;
|
||
ULONG i;
|
||
#if DBG
|
||
NTSTATUS Status;
|
||
#endif
|
||
|
||
SystemSize = MmQuerySystemSize();
|
||
PspDefaultPagefileLimit = (ULONG)-1;
|
||
|
||
#ifdef _WIN64
|
||
if ( sizeof(TEB) > 8192 || sizeof(PEB) > 4096 ) {
|
||
#else
|
||
if ( sizeof(TEB) > 4096 || sizeof(PEB) > 4096 ) {
|
||
#endif
|
||
KeBugCheckEx(PROCESS_INITIALIZATION_FAILED,99,sizeof(TEB),sizeof(PEB),99);
|
||
}
|
||
|
||
switch ( SystemSize ) {
|
||
|
||
case MmMediumSystem :
|
||
PsMinimumWorkingSet += 10;
|
||
PsMaximumWorkingSet += 100;
|
||
break;
|
||
|
||
case MmLargeSystem :
|
||
PsMinimumWorkingSet += 30;
|
||
PsMaximumWorkingSet += 300;
|
||
break;
|
||
|
||
case MmSmallSystem :
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//
|
||
// Initialize all the callback structures
|
||
//
|
||
|
||
for (i = 0; i < PSP_MAX_CREATE_THREAD_NOTIFY; i++) {
|
||
ExInitializeCallBack (&PspCreateThreadNotifyRoutine[i]);
|
||
}
|
||
|
||
for (i = 0; i < PSP_MAX_CREATE_PROCESS_NOTIFY; i++) {
|
||
ExInitializeCallBack (&PspCreateProcessNotifyRoutine[i]);
|
||
}
|
||
|
||
for (i = 0; i < PSP_MAX_LOAD_IMAGE_NOTIFY; i++) {
|
||
ExInitializeCallBack (&PspLoadImageNotifyRoutine[i]);
|
||
}
|
||
|
||
|
||
PsChangeQuantumTable(FALSE,PsRawPrioritySeparation);
|
||
|
||
//
|
||
// Quotas grow as needed automatically
|
||
//
|
||
|
||
// if ( !PspDefaultPagedLimit ) {
|
||
// PspDefaultPagedLimit = 0;
|
||
// }
|
||
// if ( !PspDefaultNonPagedLimit ) {
|
||
// PspDefaultNonPagedLimit = 0;
|
||
// }
|
||
|
||
if (PspDefaultNonPagedLimit == 0 && PspDefaultPagedLimit == 0) {
|
||
PspDoingGiveBacks = TRUE;
|
||
} else {
|
||
PspDoingGiveBacks = FALSE;
|
||
}
|
||
|
||
|
||
PspDefaultPagedLimit *= PSP_1MB;
|
||
PspDefaultNonPagedLimit *= PSP_1MB;
|
||
|
||
if (PspDefaultPagefileLimit != -1) {
|
||
PspDefaultPagefileLimit *= PSP_1MB;
|
||
}
|
||
|
||
|
||
//
|
||
// Initialize active process list head and mutex
|
||
//
|
||
|
||
InitializeListHead(&PsActiveProcessHead);
|
||
ExInitializeFastMutex(&PspActiveProcessMutex);
|
||
|
||
//
|
||
// Initialize the process security fields lock
|
||
//
|
||
|
||
|
||
PsIdleProcess = PsGetCurrentProcess();
|
||
|
||
PspInitializeProcessLock (PsIdleProcess);
|
||
ExInitializeRundownProtection (&PsIdleProcess->RundownProtect);
|
||
InitializeListHead (&PsIdleProcess->ThreadListHead);
|
||
|
||
|
||
PsIdleProcess->Pcb.KernelTime = 0;
|
||
PsIdleProcess->Pcb.KernelTime = 0;
|
||
|
||
//
|
||
// Initialize the shutdown thread pointer
|
||
//
|
||
PspShutdownThread = NULL;
|
||
|
||
//
|
||
// Initialize the common fields of the Object Type Prototype record
|
||
//
|
||
|
||
RtlZeroMemory( &ObjectTypeInitializer, sizeof( ObjectTypeInitializer ) );
|
||
ObjectTypeInitializer.Length = sizeof( ObjectTypeInitializer );
|
||
ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
|
||
ObjectTypeInitializer.SecurityRequired = TRUE;
|
||
ObjectTypeInitializer.PoolType = NonPagedPool;
|
||
ObjectTypeInitializer.InvalidAttributes = OBJ_PERMANENT |
|
||
OBJ_EXCLUSIVE |
|
||
OBJ_OPENIF;
|
||
|
||
|
||
//
|
||
// Create Object types for Thread and Process Objects.
|
||
//
|
||
|
||
RtlInitUnicodeString(&NameString, L"Process");
|
||
ObjectTypeInitializer.DefaultPagedPoolCharge = PSP_PROCESS_PAGED_CHARGE;
|
||
ObjectTypeInitializer.DefaultNonPagedPoolCharge = PSP_PROCESS_NONPAGED_CHARGE;
|
||
ObjectTypeInitializer.DeleteProcedure = PspProcessDelete;
|
||
ObjectTypeInitializer.ValidAccessMask = PROCESS_ALL_ACCESS;
|
||
ObjectTypeInitializer.GenericMapping = PspProcessMapping;
|
||
|
||
if ( !NT_SUCCESS(ObCreateObjectType(&NameString,
|
||
&ObjectTypeInitializer,
|
||
(PSECURITY_DESCRIPTOR) NULL,
|
||
&PsProcessType
|
||
)) ){
|
||
return FALSE;
|
||
}
|
||
|
||
RtlInitUnicodeString(&NameString, L"Thread");
|
||
ObjectTypeInitializer.DefaultPagedPoolCharge = PSP_THREAD_PAGED_CHARGE;
|
||
ObjectTypeInitializer.DefaultNonPagedPoolCharge = PSP_THREAD_NONPAGED_CHARGE;
|
||
ObjectTypeInitializer.DeleteProcedure = PspThreadDelete;
|
||
ObjectTypeInitializer.ValidAccessMask = THREAD_ALL_ACCESS;
|
||
ObjectTypeInitializer.GenericMapping = PspThreadMapping;
|
||
|
||
if ( !NT_SUCCESS(ObCreateObjectType(&NameString,
|
||
&ObjectTypeInitializer,
|
||
(PSECURITY_DESCRIPTOR) NULL,
|
||
&PsThreadType
|
||
)) ){
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
RtlInitUnicodeString(&NameString, L"Job");
|
||
ObjectTypeInitializer.DefaultPagedPoolCharge = 0;
|
||
ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EJOB);
|
||
ObjectTypeInitializer.DeleteProcedure = PspJobDelete;
|
||
ObjectTypeInitializer.CloseProcedure = PspJobClose;
|
||
ObjectTypeInitializer.ValidAccessMask = JOB_OBJECT_ALL_ACCESS;
|
||
ObjectTypeInitializer.GenericMapping = PspJobMapping;
|
||
ObjectTypeInitializer.InvalidAttributes = 0;
|
||
|
||
if ( !NT_SUCCESS(ObCreateObjectType(&NameString,
|
||
&ObjectTypeInitializer,
|
||
(PSECURITY_DESCRIPTOR) NULL,
|
||
&PsJobType
|
||
)) ){
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
//
|
||
// Initialize job list head and mutex
|
||
//
|
||
|
||
PspInitializeJobStructures();
|
||
|
||
InitializeListHead(&PspWorkingSetChangeHead.Links);
|
||
ExInitializeFastMutex(&PspWorkingSetChangeHead.Lock);
|
||
|
||
//
|
||
// Initialize CID handle table.
|
||
//
|
||
// N.B. The CID handle table is removed from the handle table list so
|
||
// it will not be enumerated for object handle queries.
|
||
//
|
||
|
||
PspCidTable = ExCreateHandleTable(NULL);
|
||
if (PspCidTable == NULL) {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Set PID and TID reuse to strict FIFO. This isn't absolutely needed but
|
||
// it makes tracking audits easier.
|
||
//
|
||
ExSetHandleTableStrictFIFO (PspCidTable);
|
||
|
||
ExRemoveHandleTable(PspCidTable);
|
||
|
||
#if defined(i386)
|
||
|
||
//
|
||
// Ldt Initialization
|
||
//
|
||
|
||
if ( !NT_SUCCESS(PspLdtInitialize()) ) {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Vdm support Initialization
|
||
//
|
||
|
||
if ( !NT_SUCCESS(PspVdmInitialize()) ) {
|
||
return FALSE;
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// Initialize Reaper Data Structures
|
||
//
|
||
|
||
PsReaperList = NULL;
|
||
PsReaperActive = FALSE;
|
||
|
||
ExInitializeWorkItem(&PsReaperWorkItem, PspReaper, NULL);
|
||
|
||
//
|
||
// Get a pointer to the system access token.
|
||
// This token is used by the boot process, so we can take the pointer
|
||
// from there.
|
||
//
|
||
|
||
PspBootAccessToken = ExFastRefGetObject (PsIdleProcess->Token);
|
||
|
||
InitializeObjectAttributes( &ObjectAttributes,
|
||
NULL,
|
||
0,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
if (!NT_SUCCESS (PspCreateProcess (&PspInitialSystemProcessHandle,
|
||
PROCESS_ALL_ACCESS,
|
||
&ObjectAttributes,
|
||
NULL,
|
||
0,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
0))) {
|
||
return FALSE;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(ObReferenceObjectByHandle(
|
||
PspInitialSystemProcessHandle,
|
||
0L,
|
||
PsProcessType,
|
||
KernelMode,
|
||
(PVOID *)&PsInitialSystemProcess,
|
||
NULL
|
||
)) ) {
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
strcpy((char *) &PsIdleProcess->ImageFileName[0],"Idle");
|
||
strcpy((char *) &PsInitialSystemProcess->ImageFileName[0],"System");
|
||
|
||
//
|
||
// The system process can allocate resources, and its name may be queried by
|
||
// NtQueryInfomationProcess and various audits. We must explicitly allocate memory
|
||
// for this field of the System EPROCESS, and initialize it appropriately. In this
|
||
// case, appropriate initialization means zeroing the memory.
|
||
//
|
||
|
||
PsInitialSystemProcess->SeAuditProcessCreationInfo.ImageFileName = ExAllocatePoolWithTag(
|
||
PagedPool,
|
||
sizeof(OBJECT_NAME_INFORMATION),
|
||
'aPeS'
|
||
);
|
||
|
||
if (PsInitialSystemProcess->SeAuditProcessCreationInfo.ImageFileName != NULL) {
|
||
RtlZeroMemory(
|
||
PsInitialSystemProcess->SeAuditProcessCreationInfo.ImageFileName,
|
||
sizeof(OBJECT_NAME_INFORMATION)
|
||
);
|
||
} else {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Phase 1 System initialization
|
||
//
|
||
|
||
if ( !NT_SUCCESS(PsCreateSystemThread(
|
||
&ThreadHandle,
|
||
THREAD_ALL_ACCESS,
|
||
&ObjectAttributes,
|
||
0L,
|
||
NULL,
|
||
Phase1Initialization,
|
||
(PVOID)LoaderBlock
|
||
)) ) {
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
if ( !NT_SUCCESS(ObReferenceObjectByHandle(
|
||
ThreadHandle,
|
||
0L,
|
||
PsThreadType,
|
||
KernelMode,
|
||
(PVOID *)&Thread,
|
||
NULL
|
||
)) ) {
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
ZwClose( ThreadHandle );
|
||
|
||
//
|
||
// On checked systems install an image callout routine
|
||
//
|
||
#if DBG
|
||
|
||
Status = PsSetLoadImageNotifyRoutine (PspImageNotifyTest);
|
||
if (!NT_SUCCESS (Status)) {
|
||
return FALSE;
|
||
}
|
||
|
||
#endif
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOLEAN
|
||
PspInitPhase1 (
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine performs phase 1 process structure initialization.
|
||
During this phase, the system DLL is located and relevant entry
|
||
points are extracted.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
TRUE - Initialization was successful.
|
||
|
||
FALSE - Initialization Failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
NTSTATUS st;
|
||
|
||
UNREFERENCED_PARAMETER (LoaderBlock);
|
||
|
||
PspInitializeJobStructuresPhase1();
|
||
|
||
st = PspInitializeSystemDll();
|
||
|
||
if ( !NT_SUCCESS(st) ) {
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
NTSTATUS
|
||
PsLocateSystemDll (
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function locates the system dll and creates a section for the
|
||
DLL and maps it into the system process.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
TRUE - Initialization was successful.
|
||
|
||
FALSE - Initialization Failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
HANDLE File;
|
||
HANDLE Section;
|
||
NTSTATUS st;
|
||
OBJECT_ATTRIBUTES ObjectAttributes;
|
||
IO_STATUS_BLOCK IoStatus;
|
||
|
||
//
|
||
// First see if we need to load this DLL at all.
|
||
//
|
||
if (ExVerifySuite (EmbeddedNT) && (PsEmbeddedNTMask&PS_EMBEDDED_NO_USERMODE)) {
|
||
return STATUS_SUCCESS;
|
||
}
|
||
//
|
||
// Initialize the system DLL
|
||
//
|
||
|
||
InitializeObjectAttributes(
|
||
&ObjectAttributes,
|
||
(PUNICODE_STRING)&PsNtDllPathName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
NULL,
|
||
NULL
|
||
);
|
||
|
||
st = ZwOpenFile(
|
||
&File,
|
||
SYNCHRONIZE | FILE_EXECUTE,
|
||
&ObjectAttributes,
|
||
&IoStatus,
|
||
FILE_SHARE_READ,
|
||
0
|
||
);
|
||
|
||
if (!NT_SUCCESS(st)) {
|
||
|
||
#if DBG
|
||
DbgPrint("PS: PsLocateSystemDll - NtOpenFile( NTDLL.DLL ) failed. Status == %lx\n",
|
||
st
|
||
);
|
||
#endif
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,2,0,0);
|
||
// return st;
|
||
}
|
||
|
||
st = MmCheckSystemImage(File, TRUE);
|
||
if ( st == STATUS_IMAGE_CHECKSUM_MISMATCH ||
|
||
st == STATUS_INVALID_IMAGE_PROTECT ) {
|
||
|
||
ULONG_PTR ErrorParameters;
|
||
ULONG ErrorResponse;
|
||
|
||
//
|
||
// Hard error time. A driver is corrupt.
|
||
//
|
||
|
||
ErrorParameters = (ULONG_PTR)&PsNtDllPathName;
|
||
|
||
NtRaiseHardError(
|
||
st,
|
||
1,
|
||
1,
|
||
&ErrorParameters,
|
||
OptionOk,
|
||
&ErrorResponse
|
||
);
|
||
return st;
|
||
}
|
||
|
||
st = ZwCreateSection(
|
||
&Section,
|
||
SECTION_ALL_ACCESS,
|
||
NULL,
|
||
0,
|
||
PAGE_EXECUTE,
|
||
SEC_IMAGE,
|
||
File
|
||
);
|
||
ZwClose( File );
|
||
|
||
if (!NT_SUCCESS(st)) {
|
||
#if DBG
|
||
DbgPrint("PS: PsLocateSystemDll: NtCreateSection Status == %lx\n",st);
|
||
#endif
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,3,0,0);
|
||
// return st;
|
||
}
|
||
|
||
//
|
||
// Now that we have the section, reference it, store its address in the
|
||
// PspSystemDll and then close handle to the section.
|
||
//
|
||
|
||
st = ObReferenceObjectByHandle(
|
||
Section,
|
||
SECTION_ALL_ACCESS,
|
||
MmSectionObjectType,
|
||
KernelMode,
|
||
&PspSystemDll.Section,
|
||
NULL
|
||
);
|
||
|
||
ZwClose(Section);
|
||
|
||
if ( !NT_SUCCESS(st) ) {
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,4,0,0);
|
||
// return st;
|
||
}
|
||
|
||
//
|
||
// Map the system dll into the user part of the address space
|
||
//
|
||
|
||
st = PspMapSystemDll(PsGetCurrentProcess(),&PspSystemDll.DllBase);
|
||
PsSystemDllDllBase = PspSystemDll.DllBase;
|
||
|
||
if ( !NT_SUCCESS(st) ) {
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,5,0,0);
|
||
// return st;
|
||
}
|
||
PsSystemDllBase = PspSystemDll.DllBase;
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
NTSTATUS
|
||
PspMapSystemDll (
|
||
IN PEPROCESS Process,
|
||
OUT PVOID *DllBase OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function maps the system DLL into the specified process.
|
||
|
||
Arguments:
|
||
|
||
Process - Supplies the address of the process to map the DLL into.
|
||
|
||
Return Value:
|
||
|
||
TBD
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS st;
|
||
PVOID ViewBase;
|
||
LARGE_INTEGER SectionOffset;
|
||
SIZE_T ViewSize;
|
||
|
||
PAGED_CODE();
|
||
|
||
ViewBase = NULL;
|
||
SectionOffset.LowPart = 0;
|
||
SectionOffset.HighPart = 0;
|
||
ViewSize = 0;
|
||
|
||
//
|
||
// Map the system dll into the user part of the address space
|
||
//
|
||
|
||
st = MmMapViewOfSection(
|
||
PspSystemDll.Section,
|
||
Process,
|
||
&ViewBase,
|
||
0L,
|
||
0L,
|
||
&SectionOffset,
|
||
&ViewSize,
|
||
ViewShare,
|
||
0L,
|
||
PAGE_READWRITE
|
||
);
|
||
|
||
if ( st != STATUS_SUCCESS ) {
|
||
#if DBG
|
||
DbgPrint("PS: Unable to map system dll at based address.\n");
|
||
#endif
|
||
st = STATUS_CONFLICTING_ADDRESSES;
|
||
}
|
||
|
||
if ( ARGUMENT_PRESENT(DllBase) ) {
|
||
*DllBase = ViewBase;
|
||
}
|
||
|
||
return st;
|
||
}
|
||
|
||
NTSTATUS
|
||
PspInitializeSystemDll (
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function initializes the system DLL and locates
|
||
various entrypoints within the DLL.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
TBD
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS st;
|
||
PSZ dll_entrypoint;
|
||
|
||
//
|
||
// If we skipped dll load becuase we are kernel only then exit now.
|
||
//
|
||
if (PsSystemDllDllBase == NULL) {
|
||
return STATUS_SUCCESS;
|
||
}
|
||
//
|
||
// Locate the important system dll entrypoints
|
||
//
|
||
|
||
dll_entrypoint = "LdrInitializeThunk";
|
||
|
||
st = PspLookupSystemDllEntryPoint(
|
||
dll_entrypoint,
|
||
(PVOID *)&PspSystemDll.LoaderInitRoutine
|
||
);
|
||
|
||
if ( !NT_SUCCESS(st) ) {
|
||
#if DBG
|
||
DbgPrint("PS: Unable to locate LdrInitializeThunk in system dll\n");
|
||
#endif
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,6,0,0);
|
||
// return st;
|
||
}
|
||
|
||
|
||
st = PspLookupKernelUserEntryPoints();
|
||
|
||
if ( !NT_SUCCESS(st) ) {
|
||
KeBugCheckEx(PROCESS1_INITIALIZATION_FAILED,st,8,0,0);
|
||
}
|
||
|
||
KdUpdateDataBlock();
|
||
|
||
return st;
|
||
}
|
||
|
||
NTSTATUS
|
||
PspLookupSystemDllEntryPoint (
|
||
IN PSZ NameOfEntryPoint,
|
||
OUT PVOID *AddressOfEntryPoint
|
||
)
|
||
|
||
{
|
||
return LookupEntryPoint (
|
||
PspSystemDll.DllBase,
|
||
NameOfEntryPoint,
|
||
AddressOfEntryPoint
|
||
);
|
||
}
|
||
|
||
const SCHAR PspFixedQuantums[6] = {
|
||
3*THREAD_QUANTUM,
|
||
3*THREAD_QUANTUM,
|
||
3*THREAD_QUANTUM,
|
||
6*THREAD_QUANTUM,
|
||
6*THREAD_QUANTUM,
|
||
6*THREAD_QUANTUM
|
||
};
|
||
|
||
const SCHAR PspVariableQuantums[6] = {
|
||
1*THREAD_QUANTUM,
|
||
2*THREAD_QUANTUM,
|
||
3*THREAD_QUANTUM,
|
||
2*THREAD_QUANTUM,
|
||
4*THREAD_QUANTUM,
|
||
6*THREAD_QUANTUM
|
||
};
|
||
|
||
//
|
||
// The table is ONLY used when fixed quantums are selected.
|
||
//
|
||
|
||
const SCHAR PspJobSchedulingClasses[PSP_NUMBER_OF_SCHEDULING_CLASSES] = {
|
||
1*THREAD_QUANTUM, // long fixed 0
|
||
2*THREAD_QUANTUM, // long fixed 1...
|
||
3*THREAD_QUANTUM,
|
||
4*THREAD_QUANTUM,
|
||
5*THREAD_QUANTUM,
|
||
6*THREAD_QUANTUM, // DEFAULT
|
||
7*THREAD_QUANTUM,
|
||
8*THREAD_QUANTUM,
|
||
9*THREAD_QUANTUM,
|
||
10*THREAD_QUANTUM // long fixed 9
|
||
};
|
||
|
||
VOID
|
||
PsChangeQuantumTable(
|
||
BOOLEAN ModifyActiveProcesses,
|
||
ULONG PrioritySeparation
|
||
)
|
||
{
|
||
|
||
PEPROCESS Process;
|
||
PETHREAD CurrentThread;
|
||
PLIST_ENTRY NextProcess;
|
||
ULONG QuantumIndex;
|
||
SCHAR const* QuantumTableBase;
|
||
PEJOB Job;
|
||
|
||
//
|
||
// extract priority seperation value
|
||
//
|
||
switch ( PrioritySeparation & PROCESS_PRIORITY_SEPARATION_MASK ) {
|
||
case 3:
|
||
PsPrioritySeperation = PROCESS_PRIORITY_SEPARATION_MAX;
|
||
break;
|
||
default:
|
||
PsPrioritySeperation = PrioritySeparation & PROCESS_PRIORITY_SEPARATION_MASK;
|
||
break;
|
||
}
|
||
|
||
//
|
||
// determine if we are using fixed or variable quantums
|
||
//
|
||
switch ( PrioritySeparation & PROCESS_QUANTUM_VARIABLE_MASK ) {
|
||
case PROCESS_QUANTUM_VARIABLE_VALUE:
|
||
QuantumTableBase = PspVariableQuantums;
|
||
break;
|
||
|
||
case PROCESS_QUANTUM_FIXED_VALUE:
|
||
QuantumTableBase = PspFixedQuantums;
|
||
break;
|
||
|
||
case PROCESS_QUANTUM_VARIABLE_DEF:
|
||
default:
|
||
if ( MmIsThisAnNtAsSystem() ) {
|
||
QuantumTableBase = PspFixedQuantums;
|
||
} else {
|
||
QuantumTableBase = PspVariableQuantums;
|
||
}
|
||
break;
|
||
}
|
||
|
||
//
|
||
// determine if we are using long or short
|
||
//
|
||
switch ( PrioritySeparation & PROCESS_QUANTUM_LONG_MASK ) {
|
||
case PROCESS_QUANTUM_LONG_VALUE:
|
||
QuantumTableBase = QuantumTableBase + 3;
|
||
break;
|
||
|
||
case PROCESS_QUANTUM_SHORT_VALUE:
|
||
break;
|
||
|
||
case PROCESS_QUANTUM_LONG_DEF:
|
||
default:
|
||
if ( MmIsThisAnNtAsSystem() ) {
|
||
QuantumTableBase = QuantumTableBase + 3;
|
||
}
|
||
break;
|
||
}
|
||
|
||
//
|
||
// Job Scheduling classes are ONLY meaningful if long fixed quantums
|
||
// are selected. In practice, this means stock NTS configurations
|
||
//
|
||
if ( QuantumTableBase == &PspFixedQuantums[3] ) {
|
||
PspUseJobSchedulingClasses = TRUE;
|
||
} else {
|
||
PspUseJobSchedulingClasses = FALSE;
|
||
}
|
||
|
||
RtlCopyMemory(PspForegroundQuantum,QuantumTableBase,sizeof(PspForegroundQuantum));
|
||
|
||
if (ModifyActiveProcesses) {
|
||
|
||
CurrentThread = PsGetCurrentThread ();
|
||
|
||
PspLockProcessList (CurrentThread);
|
||
|
||
NextProcess = PsActiveProcessHead.Flink;
|
||
|
||
while (NextProcess != &PsActiveProcessHead) {
|
||
Process = CONTAINING_RECORD(NextProcess,
|
||
EPROCESS,
|
||
ActiveProcessLinks);
|
||
|
||
if ( Process->Vm.Flags.MemoryPriority == MEMORY_PRIORITY_BACKGROUND ) {
|
||
QuantumIndex = 0;
|
||
} else {
|
||
QuantumIndex = PsPrioritySeperation;
|
||
}
|
||
|
||
if (Process->PriorityClass != PROCESS_PRIORITY_CLASS_IDLE) {
|
||
|
||
//
|
||
// If the process is contained within a JOB, AND we are
|
||
// running Fixed, Long Quantums, use the quantum associated
|
||
// with the Job's scheduling class
|
||
//
|
||
Job = Process->Job;
|
||
if (Job != NULL && PspUseJobSchedulingClasses ) {
|
||
Process->Pcb.ThreadQuantum = PspJobSchedulingClasses[Job->SchedulingClass];
|
||
} else {
|
||
Process->Pcb.ThreadQuantum = PspForegroundQuantum[QuantumIndex];
|
||
}
|
||
} else {
|
||
Process->Pcb.ThreadQuantum = THREAD_QUANTUM;
|
||
}
|
||
NextProcess = NextProcess->Flink;
|
||
}
|
||
PspUnlockProcessList (CurrentThread);
|
||
}
|
||
}
|