* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ps/psmgr.c
* PURPOSE: Process management
- *
+ *
* PROGRAMMERS: David Welch (welch@mcmail.com)
*/
STANDARD_RIGHTS_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
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,
+ PROCESS_TERMINATE | PROCESS_SET_QUOTA | PROCESS_SET_INFORMATION |
+ PROCESS_SUSPEND_RESUME,
STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
PROCESS_ALL_ACCESS};
THREAD_ALERT | THREAD_SET_INFORMATION | THREAD_SET_CONTEXT,
STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
THREAD_ALL_ACCESS};
-
-BOOLEAN DoneInitYet = FALSE;
extern ULONG NtBuildNumber;
extern ULONG NtMajorVersion;
extern ULONG NtMinorVersion;
-
-VOID
-INIT_FUNCTION
-PsInitClientIDManagment(VOID);
-
+extern PVOID KeUserApcDispatcher;
+extern PVOID KeUserCallbackDispatcher;
+extern PVOID KeUserExceptionDispatcher;
+extern PVOID KeRaiseUserExceptionDispatcher;
+
+PVOID PspSystemDllBase = NULL;
+PVOID PspSystemDllSection = NULL;
+PVOID PspSystemDllEntryPoint = NULL;
+PHANDLE_TABLE PspCidTable = NULL;
VOID STDCALL PspKillMostProcesses();
+VOID INIT_FUNCTION NTAPI PsInitClientIDManagment(VOID);
+NTSTATUS STDCALL INIT_FUNCTION PspLookupKernelUserEntryPoints(VOID);
+
+#if defined (ALLOC_PRAGMA)
+#pragma alloc_text(INIT, PiInitProcessManager)
+#pragma alloc_text(INIT, PsInitClientIDManagment)
+#pragma alloc_text(INIT, PsInitThreadManagment)
+#pragma alloc_text(INIT, PsInitProcessManagment)
+#pragma alloc_text(INIT, PspLookupKernelUserEntryPoints)
+#pragma alloc_text(INIT, PsLocateSystemDll)
+#endif
+
/* FUNCTIONS ***************************************************************/
-VOID PiShutdownProcessManager(VOID)
+VOID
+NTAPI
+PiShutdownProcessManager(VOID)
{
DPRINT("PiShutdownProcessManager()\n");
-
+
PspKillMostProcesses();
}
-VOID INIT_FUNCTION
+VOID
+INIT_FUNCTION
+NTAPI
PiInitProcessManager(VOID)
{
PsInitJobManagment();
PsInitialiseW32Call();
}
-VOID
+VOID
INIT_FUNCTION
+NTAPI
+PsInitClientIDManagment(VOID)
+{
+ PspCidTable = ExCreateHandleTable(NULL);
+ ASSERT(PspCidTable);
+}
+
+VOID
+INIT_FUNCTION
+NTAPI
PsInitThreadManagment(VOID)
/*
* FUNCTION: Initialize thread managment
*/
{
+ UNICODE_STRING Name;
+ OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
PETHREAD FirstThread;
ULONG i;
InitializeListHead(&PriorityListHead[i]);
}
- PsThreadType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
-
- PsThreadType->Tag = TAG('T', 'H', 'R', 'T');
- PsThreadType->TotalObjects = 0;
- PsThreadType->TotalHandles = 0;
- PsThreadType->PeakObjects = 0;
- PsThreadType->PeakHandles = 0;
- PsThreadType->PagedPoolCharge = 0;
- PsThreadType->NonpagedPoolCharge = sizeof(ETHREAD);
- PsThreadType->Mapping = &PiThreadMapping;
- PsThreadType->Dump = NULL;
- PsThreadType->Open = NULL;
- PsThreadType->Close = NULL;
- PsThreadType->Delete = PspDeleteThread;
- PsThreadType->Parse = NULL;
- PsThreadType->Security = NULL;
- PsThreadType->QueryName = NULL;
- PsThreadType->OkayToClose = NULL;
- PsThreadType->Create = NULL;
- PsThreadType->DuplicationNotify = NULL;
-
- RtlInitUnicodeString(&PsThreadType->TypeName, L"Thread");
-
- ObpCreateTypeObject(PsThreadType);
-
- PsInitializeThread(NULL, &FirstThread, NULL, KernelMode, TRUE);
+ DPRINT("Creating Thread Object Type\n");
+
+ /* Initialize the Thread type */
+ RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
+ RtlInitUnicodeString(&Name, L"Thread");
+ ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
+ ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETHREAD);
+ ObjectTypeInitializer.GenericMapping = PiThreadMapping;
+ ObjectTypeInitializer.PoolType = NonPagedPool;
+ ObjectTypeInitializer.ValidAccessMask = THREAD_ALL_ACCESS;
+ ObjectTypeInitializer.DeleteProcedure = PspDeleteThread;
+ ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &PsThreadType);
+
+ PsInitializeIdleOrFirstThread(PsInitialSystemProcess, &FirstThread, NULL, KernelMode, TRUE);
FirstThread->Tcb.State = Running;
FirstThread->Tcb.FreezeCount = 0;
FirstThread->Tcb.UserAffinity = (1 << 0); /* Set the affinity of the first thread to the boot processor */
DPRINT("FirstThread %x\n",FirstThread);
- DoneInitYet = TRUE;
-
ExInitializeWorkItem(&PspReaperWorkItem, PspReapRoutine, NULL);
}
-VOID
+VOID
INIT_FUNCTION
+NTAPI
PsInitProcessManagment(VOID)
{
PKPROCESS KProcess;
NTSTATUS Status;
-
+ UNICODE_STRING Name;
+ OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
+
ShortPsLockDelay.QuadPart = -100LL;
PsLockTimeout.QuadPart = -10000000LL; /* one second */
/*
* Register the process object type
*/
-
- PsProcessType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
-
- PsProcessType->Tag = TAG('P', 'R', 'O', 'C');
- PsProcessType->TotalObjects = 0;
- PsProcessType->TotalHandles = 0;
- PsProcessType->PeakObjects = 0;
- PsProcessType->PeakHandles = 0;
- PsProcessType->PagedPoolCharge = 0;
- PsProcessType->NonpagedPoolCharge = sizeof(EPROCESS);
- PsProcessType->Mapping = &PiProcessMapping;
- PsProcessType->Dump = NULL;
- PsProcessType->Open = NULL;
- PsProcessType->Close = NULL;
- PsProcessType->Delete = PspDeleteProcess;
- PsProcessType->Parse = NULL;
- PsProcessType->Security = NULL;
- PsProcessType->QueryName = NULL;
- PsProcessType->OkayToClose = NULL;
- PsProcessType->Create = NULL;
- PsProcessType->DuplicationNotify = NULL;
-
- RtlInitUnicodeString(&PsProcessType->TypeName, L"Process");
-
- ObpCreateTypeObject(PsProcessType);
+
+ DPRINT("Creating Process Object Type\n");
+
+ /* Initialize the Process type */
+ RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
+ RtlInitUnicodeString(&Name, L"Process");
+ ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
+ ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EPROCESS);
+ ObjectTypeInitializer.GenericMapping = PiProcessMapping;
+ ObjectTypeInitializer.PoolType = NonPagedPool;
+ ObjectTypeInitializer.ValidAccessMask = PROCESS_ALL_ACCESS;
+ ObjectTypeInitializer.DeleteProcedure = PspDeleteProcess;
+ ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &PsProcessType);
InitializeListHead(&PsActiveProcessHead);
ExInitializeFastMutex(&PspActiveProcessMutex);
-
+
+ /*
+ * Initialize the default quota block.
+ */
+
+ RtlZeroMemory(&PspDefaultQuotaBlock, sizeof(PspDefaultQuotaBlock));
+ PspDefaultQuotaBlock.QuotaEntry[PagedPool].Limit = (SIZE_T)-1;
+ PspDefaultQuotaBlock.QuotaEntry[NonPagedPool].Limit = (SIZE_T)-1;
+ PspDefaultQuotaBlock.QuotaEntry[2].Limit = (SIZE_T)-1; /* Page file */
+
/*
* Initialize the idle process
*/
}
RtlZeroMemory(PsIdleProcess, sizeof(EPROCESS));
-
+
PsIdleProcess->Pcb.Affinity = 0xFFFFFFFF;
PsIdleProcess->Pcb.IopmOffset = 0xffff;
- PsIdleProcess->Pcb.LdtDescriptor[0] = 0;
- PsIdleProcess->Pcb.LdtDescriptor[1] = 0;
- PsIdleProcess->Pcb.BasePriority = PROCESS_PRIO_IDLE;
- PsIdleProcess->Pcb.ThreadQuantum = 6;
+ PsIdleProcess->Pcb.BasePriority = PROCESS_PRIORITY_IDLE;
+ PsIdleProcess->Pcb.QuantumReset = 6;
InitializeListHead(&PsIdleProcess->Pcb.ThreadListHead);
InitializeListHead(&PsIdleProcess->ThreadListHead);
- InitializeListHead(&PsIdleProcess->ProcessListEntry);
- KeInitializeDispatcherHeader(&PsIdleProcess->Pcb.DispatcherHeader,
+ InitializeListHead(&PsIdleProcess->ActiveProcessLinks);
+ KeInitializeDispatcherHeader(&PsIdleProcess->Pcb.Header,
ProcessObject,
- sizeof(EPROCESS),
+ sizeof(EPROCESS) / sizeof(LONG),
FALSE);
- PsIdleProcess->Pcb.DirectoryTableBase =
- (LARGE_INTEGER)(LONGLONG)(ULONG)MmGetPageDirectory();
+ PsIdleProcess->Pcb.DirectoryTableBase.QuadPart = (ULONG_PTR)MmGetPageDirectory();
strcpy(PsIdleProcess->ImageFileName, "Idle");
+ PspInheritQuota(PsIdleProcess, NULL);
/*
* Initialize the system process
KEBUGCHECK(0);
return;
}
-
+
/* System threads may run on any processor. */
- PsInitialSystemProcess->Pcb.Affinity = 0xFFFFFFFF;
+ RtlZeroMemory(PsInitialSystemProcess, sizeof(EPROCESS));
+#ifdef CONFIG_SMP
+ /* FIXME:
+ * Only the boot cpu is initialized. Threads of the
+ * system process should be able to run on all cpus.
+ */
+ PsInitialSystemProcess->Pcb.Affinity = 0xffffffff;
+#else
+ PsInitialSystemProcess->Pcb.Affinity = KeActiveProcessors;
+#endif
PsInitialSystemProcess->Pcb.IopmOffset = 0xffff;
- PsInitialSystemProcess->Pcb.LdtDescriptor[0] = 0;
- PsInitialSystemProcess->Pcb.LdtDescriptor[1] = 0;
- PsInitialSystemProcess->Pcb.BasePriority = PROCESS_PRIO_NORMAL;
- PsInitialSystemProcess->Pcb.ThreadQuantum = 6;
+ PsInitialSystemProcess->Pcb.BasePriority = PROCESS_PRIORITY_NORMAL;
+ PsInitialSystemProcess->Pcb.QuantumReset = 6;
InitializeListHead(&PsInitialSystemProcess->Pcb.ThreadListHead);
- KeInitializeDispatcherHeader(&PsInitialSystemProcess->Pcb.DispatcherHeader,
+ KeInitializeDispatcherHeader(&PsInitialSystemProcess->Pcb.Header,
ProcessObject,
- sizeof(EPROCESS),
+ sizeof(EPROCESS) / sizeof(LONG),
FALSE);
KProcess = &PsInitialSystemProcess->Pcb;
-
+ PspInheritQuota(PsInitialSystemProcess, NULL);
+
MmInitializeAddressSpace(PsInitialSystemProcess,
&PsInitialSystemProcess->AddressSpace);
-
+
KeInitializeEvent(&PsInitialSystemProcess->LockEvent, SynchronizationEvent, FALSE);
- PsInitialSystemProcess->LockCount = 0;
- PsInitialSystemProcess->LockOwner = NULL;
#if defined(__GNUC__)
- KProcess->DirectoryTableBase =
+ KProcess->DirectoryTableBase =
(LARGE_INTEGER)(LONGLONG)(ULONG)MmGetPageDirectory();
#else
{
#endif
strcpy(PsInitialSystemProcess->ImageFileName, "System");
-
+
PsInitialSystemProcess->Win32WindowStation = (HANDLE)0;
-
+
InsertHeadList(&PsActiveProcessHead,
- &PsInitialSystemProcess->ProcessListEntry);
+ &PsInitialSystemProcess->ActiveProcessLinks);
InitializeListHead(&PsInitialSystemProcess->ThreadListHead);
-
+
#ifndef SCHED_REWRITE
+ {
PTOKEN BootToken;
-
+
/* No parent, this is the Initial System Process. Assign Boot Token */
BootToken = SepCreateSystemProcessToken();
BootToken->TokenInUse = TRUE;
- PsInitialSystemProcess->Token = BootToken;
+ PsInitialSystemProcess->Token.Object = BootToken; /* FIXME */
ObReferenceObject(BootToken);
+ }
#endif
}
VOID
PspPostInitSystemProcess(VOID)
{
- NTSTATUS Status;
-
+ HANDLE_TABLE_ENTRY CidEntry;
+
/* this routine is called directly after the exectuive handle tables were
initialized. We'll set up the Client ID handle table and assign the system
process a PID */
PsInitClientIDManagment();
-
+
ObCreateHandleTable(NULL, FALSE, PsInitialSystemProcess);
ObpKernelHandleTable = PsInitialSystemProcess->ObjectTable;
-
- Status = PsCreateCidHandle(PsInitialSystemProcess,
- PsProcessType,
- &PsInitialSystemProcess->UniqueProcessId);
- if(!NT_SUCCESS(Status))
+
+ CidEntry.u1.Object = PsInitialSystemProcess;
+ CidEntry.u2.GrantedAccess = 0;
+ PsInitialSystemProcess->UniqueProcessId = ExCreateHandle(PspCidTable, &CidEntry);
+
+ if(!PsInitialSystemProcess->UniqueProcessId)
{
DPRINT1("Failed to create CID handle (unique process id) for the system process!\n");
KEBUGCHECK(0);
}
}
+
+NTSTATUS
+STDCALL
+INIT_FUNCTION
+PspLookupKernelUserEntryPoints(VOID)
+{
+ ANSI_STRING ProcedureName;
+ NTSTATUS Status;
+
+ /* Retrieve ntdll's startup address */
+ DPRINT("Getting Entrypoint: %p\n", PspSystemDllBase);
+ RtlInitAnsiString(&ProcedureName, "LdrInitializeThunk");
+ Status = LdrGetProcedureAddress((PVOID)PspSystemDllBase,
+ &ProcedureName,
+ 0,
+ &PspSystemDllEntryPoint);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1 ("LdrGetProcedureAddress failed (Status %x)\n", Status);
+ return (Status);
+ }
+
+ /* Get User APC Dispatcher */
+ DPRINT("Getting Entrypoint\n");
+ RtlInitAnsiString(&ProcedureName, "KiUserApcDispatcher");
+ Status = LdrGetProcedureAddress((PVOID)PspSystemDllBase,
+ &ProcedureName,
+ 0,
+ &KeUserApcDispatcher);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1 ("LdrGetProcedureAddress failed (Status %x)\n", Status);
+ return (Status);
+ }
+
+ /* Get Exception Dispatcher */
+ DPRINT("Getting Entrypoint\n");
+ RtlInitAnsiString(&ProcedureName, "KiUserExceptionDispatcher");
+ Status = LdrGetProcedureAddress((PVOID)PspSystemDllBase,
+ &ProcedureName,
+ 0,
+ &KeUserExceptionDispatcher);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1 ("LdrGetProcedureAddress failed (Status %x)\n", Status);
+ return (Status);
+ }
+
+ /* Get Callback Dispatcher */
+ DPRINT("Getting Entrypoint\n");
+ RtlInitAnsiString(&ProcedureName, "KiUserCallbackDispatcher");
+ Status = LdrGetProcedureAddress((PVOID)PspSystemDllBase,
+ &ProcedureName,
+ 0,
+ &KeUserCallbackDispatcher);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1 ("LdrGetProcedureAddress failed (Status %x)\n", Status);
+ return (Status);
+ }
+
+ /* Get Raise Exception Dispatcher */
+ DPRINT("Getting Entrypoint\n");
+ RtlInitAnsiString(&ProcedureName, "KiRaiseUserExceptionDispatcher");
+ Status = LdrGetProcedureAddress((PVOID)PspSystemDllBase,
+ &ProcedureName,
+ 0,
+ &KeRaiseUserExceptionDispatcher);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1 ("LdrGetProcedureAddress failed (Status %x)\n", Status);
+ return (Status);
+ }
+
+ /* Return success */
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+STDCALL
+PspMapSystemDll(PEPROCESS Process,
+ PVOID *DllBase)
+{
+ NTSTATUS Status;
+ SIZE_T ViewSize = 0;
+ PVOID ImageBase = 0;
+
+ /* Map the System DLL */
+ DPRINT("Mapping System DLL\n");
+ Status = MmMapViewOfSection(PspSystemDllSection,
+ Process,
+ (PVOID*)&ImageBase,
+ 0,
+ 0,
+ NULL,
+ &ViewSize,
+ 0,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1("Failed to map System DLL Into Process\n");
+ }
+
+ if (DllBase) *DllBase = ImageBase;
+
+ return Status;
+}
+
+NTSTATUS
+STDCALL
+INIT_FUNCTION
+PsLocateSystemDll(VOID)
+{
+ UNICODE_STRING DllPathname = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\ntdll.dll");
+ OBJECT_ATTRIBUTES FileObjectAttributes;
+ IO_STATUS_BLOCK Iosb;
+ HANDLE FileHandle;
+ HANDLE NTDllSectionHandle;
+ NTSTATUS Status;
+ CHAR BlockBuffer[1024];
+ PIMAGE_DOS_HEADER DosHeader;
+ PIMAGE_NT_HEADERS NTHeaders;
+
+ /* Locate and open NTDLL to determine ImageBase and LdrStartup */
+ InitializeObjectAttributes(&FileObjectAttributes,
+ &DllPathname,
+ 0,
+ NULL,
+ NULL);
+
+ DPRINT("Opening NTDLL\n");
+ Status = ZwOpenFile(&FileHandle,
+ FILE_READ_ACCESS,
+ &FileObjectAttributes,
+ &Iosb,
+ FILE_SHARE_READ,
+ FILE_SYNCHRONOUS_IO_NONALERT);
+
+ if (!NT_SUCCESS(Status)) {
+ DPRINT1("NTDLL open failed (Status %x)\n", Status);
+ return Status;
+ }
+
+ /* Load NTDLL is valid */
+ DPRINT("Reading NTDLL\n");
+ Status = ZwReadFile(FileHandle,
+ 0,
+ 0,
+ 0,
+ &Iosb,
+ BlockBuffer,
+ sizeof(BlockBuffer),
+ 0,
+ 0);
+ if (!NT_SUCCESS(Status) || Iosb.Information != sizeof(BlockBuffer)) {
+
+ DPRINT1("NTDLL header read failed (Status %x)\n", Status);
+ ZwClose(FileHandle);
+ return Status;
+ }
+
+ /* Check if it's valid */
+ DosHeader = (PIMAGE_DOS_HEADER)BlockBuffer;
+ NTHeaders = (PIMAGE_NT_HEADERS)(BlockBuffer + DosHeader->e_lfanew);
+
+ if ((DosHeader->e_magic != IMAGE_DOS_SIGNATURE) ||
+ (DosHeader->e_lfanew == 0L) ||
+ (*(PULONG) NTHeaders != IMAGE_NT_SIGNATURE)) {
+
+ DPRINT1("NTDLL format invalid\n");
+ ZwClose(FileHandle);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /* Create a section for NTDLL */
+ DPRINT("Creating section\n");
+ Status = ZwCreateSection(&NTDllSectionHandle,
+ SECTION_ALL_ACCESS,
+ NULL,
+ NULL,
+ PAGE_READONLY,
+ SEC_IMAGE | SEC_COMMIT,
+ FileHandle);
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1("NTDLL create section failed (Status %x)\n", Status);
+ ZwClose(FileHandle);
+ return(Status);
+ }
+ ZwClose(FileHandle);
+
+ /* Reference the Section */
+ DPRINT("ObReferenceObjectByHandle section: %d\n", NTDllSectionHandle);
+ Status = ObReferenceObjectByHandle(NTDllSectionHandle,
+ SECTION_ALL_ACCESS,
+ MmSectionObjectType,
+ KernelMode,
+ (PVOID*)&PspSystemDllSection,
+ NULL);
+ if (!NT_SUCCESS(Status)) {
+
+ DPRINT1("NTDLL section reference failed (Status %x)\n", Status);
+ return(Status);
+ }
+
+ /* Map it */
+ PspMapSystemDll(PsGetCurrentProcess(), &PspSystemDllBase);
+ DPRINT("LdrpSystemDllBase: %x\n", PspSystemDllBase);
+
+ /* Now get the Entrypoints */
+ PspLookupKernelUserEntryPoints();
+
+ return STATUS_SUCCESS;
+}
+
+
/**********************************************************************
* NAME EXPORTED
* PsGetVersion