reactos/ntoskrnl/ps/process.c

   1 /*
   2  * COPYRIGHT:         See COPYING in the top level directory
   3  * PROJECT:           ReactOS kernel
   4  * FILE:              ntoskrnl/ps/process.c
   5  * PURPOSE:           Process managment
   6  * PROGRAMMER:        David Welch (welch@mcmail.com)
   7  * REVISION HISTORY:
   8  *              21/07/98: Created
   9  */
  10
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <ddk/ntddk.h>
  14 #include <internal/ob.h>
  15 #include <internal/mm.h>
  16 #include <internal/string.h>
  17
  18 #define NDEBUG
  19 #include <internal/debug.h>
  20
  21 /* GLOBALS ******************************************************************/
  22
  23 PEPROCESS SystemProcess = NULL;
  24 HANDLE SystemProcessHandle = NULL;
  25
  26 POBJECT_TYPE PsProcessType = NULL;
  27
  28 /* FUNCTIONS *****************************************************************/
  29
  30 VOID PsInitProcessManagment(VOID)
  31 {
  32    ANSI_STRING AnsiString;
  33    PKPROCESS KProcess;
  34
  35    /*
  36     * Register the process object type
  37     */
  38
  39    PsProcessType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
  40
  41    PsProcessType->TotalObjects = 0;
  42    PsProcessType->TotalHandles = 0;
  43    PsProcessType->MaxObjects = ULONG_MAX;
  44    PsProcessType->MaxHandles = ULONG_MAX;
  45    PsProcessType->PagedPoolCharge = 0;
  46    PsProcessType->NonpagedPoolCharge = sizeof(EPROCESS);
  47    PsProcessType->Dump = NULL;
  48    PsProcessType->Open = NULL;
  49    PsProcessType->Close = NULL;
  50    PsProcessType->Delete = NULL;
  51    PsProcessType->Parse = NULL;
  52    PsProcessType->Security = NULL;
  53    PsProcessType->QueryName = NULL;
  54    PsProcessType->OkayToClose = NULL;
  55
  56    RtlInitAnsiString(&AnsiString,"Process");
  57    RtlAnsiStringToUnicodeString(&PsProcessType->TypeName,&AnsiString,TRUE);
  58
  59    /*
  60     * Initialize the system process
  61     */
  62    SystemProcess = ObGenericCreateObject(NULL,PROCESS_ALL_ACCESS,NULL,
  63                                          PsProcessType);
  64    KProcess = &SystemProcess->Pcb;
  65
  66    InitializeListHead(&(KProcess->MemoryAreaList));
  67    ObInitializeHandleTable(NULL,FALSE,KProcess);
  68    KProcess->PageTableDirectory = get_page_directory();
  69
  70    SystemProcessHandle = ObInsertHandle(KProcess,SystemProcess,
  71                                         PROCESS_ALL_ACCESS,FALSE);
  72 }
  73
  74 PKPROCESS KeGetCurrentProcess(VOID)
  75 /*
  76  * FUNCTION: Returns a pointer to the current process
  77  */
  78 {
  79    return(&(PsGetCurrentProcess()->Pcb));
  80 }
  81
  82 struct _EPROCESS* PsGetCurrentProcess(VOID)
  83 /*
  84  * FUNCTION: Returns a pointer to the current process
  85  */
  86 {
  87    if (PsGetCurrentThread()==NULL
  88        || PsGetCurrentThread()->ThreadsProcess==NULL)
  89      {
  90         return(SystemProcess);
  91      }
  92    else
  93      {
  94         return(PsGetCurrentThread()->ThreadsProcess);
  95      }
  96 }
  97
  98 NTSTATUS STDCALL NtCreateProcess(
  99                            OUT PHANDLE ProcessHandle,
 100                            IN ACCESS_MASK DesiredAccess,
 101                            IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
 102                            IN HANDLE ParentProcessHandle,
 103                            IN BOOLEAN InheritObjectTable,
 104                            IN HANDLE SectionHandle OPTIONAL,
 105                            IN HANDLE DebugPort OPTIONAL,
 106                            IN HANDLE ExceptionPort OPTIONAL)
 107 {
 108    return(ZwCreateProcess(ProcessHandle,
 109                           DesiredAccess,
 110                           ObjectAttributes,
 111                           ParentProcessHandle,
 112                           InheritObjectTable,
 113                           SectionHandle,
 114                           DebugPort,
 115                           ExceptionPort));
 116 }
 117
 118 NTSTATUS STDCALL ZwCreateProcess(
 119                            OUT PHANDLE ProcessHandle,
 120                            IN ACCESS_MASK DesiredAccess,
 121                            IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
 122                            IN HANDLE ParentProcessHandle,
 123                            IN BOOLEAN InheritObjectTable,
 124                            IN HANDLE SectionHandle OPTIONAL,
 125                            IN HANDLE DebugPort OPTIONAL,
 126                            IN HANDLE ExceptionPort OPTIONAL)
 127 /*
 128  * FUNCTION: Creates a process.
 129  * ARGUMENTS:
 130  *        ProcessHandle (OUT) = Caller supplied storage for the resulting
 131  *                              handle
 132  *        DesiredAccess = Specifies the allowed or desired access to the
 133  *                        process can be a combination of
 134  *                        STANDARD_RIGHTS_REQUIRED| ..
 135  *        ObjectAttribute = Initialized attributes for the object, contains
 136  *                          the rootdirectory and the filename
 137  *        ParentProcess = Handle to the parent process.
 138  *        InheritObjectTable = Specifies to inherit the objects of the parent
 139  *                             process if true.
 140  *        SectionHandle = Handle to a section object to back the image file
 141  *        DebugPort = Handle to a DebugPort if NULL the system default debug
 142  *                    port will be used.
 143  *        ExceptionPort = Handle to a exception port.
 144  * REMARKS:
 145  *        This function maps to the win32 CreateProcess.
 146  * RETURNS: Status
 147  */
 148 {
 149    PEPROCESS Process;
 150    PEPROCESS ParentProcess;
 151    PULONG PageDirectory;
 152    PULONG CurrentPageDirectory;
 153    ULONG i;
 154    PKPROCESS KProcess;
 155    ULONG Base;
 156    ULONG Length;
 157    LARGE_INTEGER Offset;
 158    NTSTATUS Status;
 159
 160    DPRINT("ZwCreateProcess(ObjectAttributes %x)\n",ObjectAttributes);
 161
 162    Status = ObReferenceObjectByHandle(ParentProcessHandle,
 163                                       PROCESS_CREATE_PROCESS,
 164                                       PsProcessType,
 165                                       UserMode,
 166                                       &ParentProcessHandle,
 167                                       NULL);
 168
 169    if (Status != STATUS_SUCCESS)
 170      {
 171         DPRINT("ZwCreateProcess() = %x\n",Status);
 172         return(Status);
 173      }
 174
 175    Process = ObGenericCreateObject(ProcessHandle,
 176                                    DesiredAccess,
 177                                    ObjectAttributes,
 178                                    PsProcessType);
 179    KeInitializeDispatcherHeader(&Process->Pcb.DispatcherHeader,
 180                                 0,
 181                                 sizeof(EPROCESS),
 182                                 FALSE);
 183    KProcess = &(Process->Pcb);
 184
 185    InitializeListHead(&(KProcess->MemoryAreaList));
 186    ObInitializeHandleTable(KProcess,InheritObjectTable,KProcess);
 187
 188    PageDirectory = physical_to_linear((ULONG)get_free_page());
 189    KProcess->PageTableDirectory = PageDirectory;
 190
 191    CurrentPageDirectory = get_page_directory();
 192
 193    memset(PageDirectory,0,PAGESIZE);
 194    for (i=768;i<1024;i++)
 195      {
 196         PageDirectory[i]=CurrentPageDirectory[i];
 197      }
 198
 199    /*
 200     * FIXME: I don't what I'm supposed to know with a section handle
 201     */
 202    if (SectionHandle != NULL)
 203      {
 204         DbgPrint("ZwCreateProcess() non-NULL SectionHandle\n");
 205         return(STATUS_UNSUCCESSFUL);
 206      }
 207
 208    Process->Pcb.ProcessState = PROCESS_STATE_ACTIVE;
 209
 210    return(STATUS_SUCCESS);
 211 }
 212
 213
 214 NTSTATUS STDCALL NtOpenProcess (OUT PHANDLE ProcessHandle,
 215                                 IN ACCESS_MASK DesiredAccess,
 216                                 IN POBJECT_ATTRIBUTES ObjectAttributes,
 217                                 IN PCLIENT_ID ClientId)
 218 {
 219    return(ZwOpenProcess(ProcessHandle,
 220                         DesiredAccess,
 221                         ObjectAttributes,
 222                         ClientId));
 223 }
 224
 225 NTSTATUS STDCALL ZwOpenProcess (OUT PHANDLE ProcessHandle,
 226                                 IN ACCESS_MASK DesiredAccess,
 227                                 IN POBJECT_ATTRIBUTES ObjectAttributes,
 228                                 IN PCLIENT_ID ClientId)
 229 {
 230    UNIMPLEMENTED;
 231 }
 232
 233 NTSTATUS STDCALL NtQueryInformationProcess(IN HANDLE ProcessHandle,
 234                                            IN CINT ProcessInformationClass,
 235                                            OUT PVOID ProcessInformation,
 236                                            IN ULONG ProcessInformationLength,
 237                                            OUT PULONG ReturnLength)
 238 {
 239    return(ZwQueryInformationProcess(ProcessHandle,
 240                                     ProcessInformationClass,
 241                                     ProcessInformation,
 242                                     ProcessInformationLength,
 243                                     ReturnLength));
 244 }
 245
 246 NTSTATUS STDCALL ZwQueryInformationProcess(IN HANDLE ProcessHandle,
 247                                            IN CINT ProcessInformationClass,
 248                                            OUT PVOID ProcessInformation,
 249                                            IN ULONG ProcessInformationLength,
 250                                            OUT PULONG ReturnLength)
 251 {
 252    PEPROCESS Process;
 253    NTSTATUS Status;
 254
 255    Status = ObReferenceObjectByHandle(ProcessHandle,
 256                                       PROCESS_QUERY_INFORMATION,
 257                                       PsProcessType,
 258                                       UserMode,
 259                                       &ProcessHandle,
 260                                       NULL);
 261    if (Status != STATUS_SUCCESS)
 262      {
 263         return(Status);
 264      }
 265
 266    switch (ProcessInformationClass)
 267      {
 268       case ProcessBasicInformation:
 269       case ProcessQuotaLimits:
 270       case ProcessIoCounters:
 271       case ProcessVmCounters:
 272       case ProcessTimes:
 273       case ProcessBasePriority:
 274       case ProcessRaisePriority:
 275       case ProcessDebugPort:
 276       case ProcessExceptionPort:
 277       case ProcessAccessToken:
 278       case ProcessLdtInformation:
 279       case ProcessLdtSize:
 280       case ProcessDefaultHardErrorMode:
 281       case ProcessIoPortHandlers:
 282       case ProcessWorkingSetWatch:
 283       case ProcessUserModeIOPL:
 284       case ProcessEnableAlignmentFaultFixup:
 285       case ProcessPriorityClass:
 286       case ProcessWx86Information:
 287       case ProcessHandleCount:
 288       case ProcessAffinityMask:
 289       default:
 290         Status = STATUS_NOT_IMPLEMENTED;
 291      }
 292    return(Status);
 293 }
 294
 295 NTSTATUS STDCALL NtSetInformationProcess(IN HANDLE ProcessHandle,
 296                                          IN CINT ProcessInformationClass,
 297                                          IN PVOID ProcessInformation,
 298                                          IN ULONG ProcessInformationLength)
 299 {
 300    return(ZwSetInformationProcess(ProcessHandle,
 301                                   ProcessInformationClass,
 302                                   ProcessInformation,
 303                                   ProcessInformationLength));
 304 }
 305
 306 NTSTATUS STDCALL ZwSetInformationProcess(IN HANDLE ProcessHandle,
 307                                          IN CINT ProcessInformationClass,
 308                                          IN PVOID ProcessInformation,
 309                                          IN ULONG ProcessInformationLength)
 310 {
 311    UNIMPLEMENTED;
 312 }
 313