reactos/ntoskrnl/include/internal/ps.h

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2000 David Welch <welch@cwcom.net>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * FILE:            ntoskrnl/ke/kthread.c
  22  * PURPOSE:         Process manager definitions
  23  * PROGRAMMER:      David Welch (welch@cwcom.net)
  24  * UPDATE HISTORY:
  25  *                  Created 22/05/98
  26  */
  27
  28 #ifndef __INCLUDE_INTERNAL_PS_H
  29 #define __INCLUDE_INTERNAL_PS_H
  30
  31 #ifndef __ASM__
  32
  33 /* Forward declarations. */
  34 struct _KTHREAD;
  35 struct _KTRAPFRAME;
  36 struct _EJOB;
  37
  38 #endif /* __ASM__ */
  39
  40 #include <internal/arch/ps.h>
  41
  42 #ifndef __ASM__
  43
  44 #include <internal/mm.h>
  45 #include <napi/teb.h>
  46
  47 #ifndef KeGetCurrentProcessorNumber
  48 #define KeGetCurrentProcessorNumber() (KeGetCurrentKPCR()->ProcessorNumber)
  49 #endif
  50
  51 extern LCID PsDefaultThreadLocaleId;
  52 extern LCID PsDefaultSystemLocaleId;
  53
  54 #include <pshpack1.h>
  55
  56 typedef struct _KTHREAD
  57 {
  58    /* For waiting on thread exit */
  59    DISPATCHER_HEADER DispatcherHeader;    /* 00 */
  60
  61    /* List of mutants owned by the thread */
  62    LIST_ENTRY        MutantListHead;      /* 10 */
  63    PVOID             InitialStack;        /* 18 */
  64    ULONG_PTR         StackLimit;          /* 1C */
  65
  66    /* Pointer to the thread's environment block in user memory */
  67    PTEB              Teb;                 /* 20 */
  68
  69    /* Pointer to the thread's TLS array */
  70    PVOID             TlsArray;            /* 24 */
  71    PVOID             KernelStack;         /* 28 */
  72    UCHAR             DebugActive;         /* 2C */
  73
  74    /* Thread state (one of THREAD_STATE_xxx constants below) */
  75    UCHAR             State;               /* 2D */
  76    BOOLEAN           Alerted[2];          /* 2E */
  77    UCHAR             Iopl;                /* 30 */
  78    UCHAR             NpxState;            /* 31 */
  79    CHAR              Saturation;          /* 32 */
  80    CHAR              Priority;            /* 33 */
  81    KAPC_STATE        ApcState;            /* 34 */
  82    ULONG             ContextSwitches;     /* 4C */
  83    LONG              WaitStatus;          /* 50 */
  84    KIRQL             WaitIrql;            /* 54 */
  85    CHAR              WaitMode;            /* 55 */
  86    UCHAR             WaitNext;            /* 56 */
  87    UCHAR             WaitReason;          /* 57 */
  88    PKWAIT_BLOCK      WaitBlockList;       /* 58 */
  89    LIST_ENTRY        WaitListEntry;       /* 5C */
  90    ULONG             WaitTime;            /* 64 */
  91    CHAR              BasePriority;        /* 68 */
  92    UCHAR             DecrementCount;      /* 69 */
  93    UCHAR             PriorityDecrement;   /* 6A */
  94    CHAR              Quantum;             /* 6B */
  95    KWAIT_BLOCK       WaitBlock[4];        /* 6C */
  96    PVOID             LegoData;            /* CC */
  97    ULONG             KernelApcDisable;    /* D0 */
  98    KAFFINITY         UserAffinity;        /* D4 */
  99    UCHAR             SystemAffinityActive;/* D8 */
 100    UCHAR             PowerState;          /* D9 */
 101    UCHAR             NpxIrql;             /* DA */
 102    UCHAR             Pad[1];              /* DB */
 103    SSDT_ENTRY        *ServiceTable;       /* DC */
 104    PKQUEUE           Queue;               /* E0 */
 105    KSPIN_LOCK        ApcQueueLock;        /* E4 */
 106    KTIMER            Timer;               /* E8 */
 107    LIST_ENTRY        QueueListEntry;      /* 110 */
 108    KAFFINITY         Affinity;            /* 118 */
 109    UCHAR             Preempted;           /* 11C */
 110    UCHAR             ProcessReadyQueue;   /* 11D */
 111    UCHAR             KernelStackResident; /* 11E */
 112    UCHAR             NextProcessor;       /* 11F */
 113    PVOID             CallbackStack;       /* 120 */
 114    struct _W32THREAD *Win32Thread;        /* 124 */
 115    struct _KTRAP_FRAME *TrapFrame;        /* 128 */
 116    PKAPC_STATE       ApcStatePointer[2];  /* 12C */
 117    UCHAR             EnableStackSwap;     /* 134 */
 118    UCHAR             LargeStack;          /* 135 */
 119    UCHAR             ResourceIndex;       /* 136 */
 120    UCHAR             PreviousMode;        /* 137 */
 121    ULONG             KernelTime;          /* 138 */
 122    ULONG             UserTime;            /* 13C */
 123    KAPC_STATE        SavedApcState;       /* 140 */
 124    UCHAR             Alertable;           /* 158 */
 125    UCHAR             ApcStateIndex;       /* 159 */
 126    UCHAR             ApcQueueable;        /* 15A */
 127    UCHAR             AutoAlignment;       /* 15B */
 128    PVOID             StackBase;           /* 15C */
 129    KAPC              SuspendApc;          /* 160 */
 130    KSEMAPHORE        SuspendSemaphore;    /* 190 */
 131    LIST_ENTRY        ThreadListEntry;     /* 1A4 */
 132    CHAR              FreezeCount;         /* 1AC */
 133    UCHAR             SuspendCount;        /* 1AD */
 134    UCHAR             IdealProcessor;      /* 1AE */
 135    UCHAR             DisableBoost;        /* 1AF */
 136 } KTHREAD;
 137
 138 #include <poppack.h>
 139
 140 /* Top level irp definitions. */
 141 #define FSRTL_FSP_TOP_LEVEL_IRP                 (0x01)
 142 #define FSRTL_CACHE_TOP_LEVEL_IRP               (0x02)
 143 #define FSRTL_MOD_WRITE_TOP_LEVEL_IRP           (0x03)
 144 #define FSRTL_FAST_IO_TOP_LEVEL_IRP             (0x04)
 145 #define FSRTL_MAX_TOP_LEVEL_IRP_FLAG            (0x04)
 146
 147 #ifndef __USE_W32API
 148 typedef struct
 149 {
 150     PACCESS_TOKEN                   Token;
 151     BOOLEAN                         CopyOnOpen;
 152     BOOLEAN                         EffectiveOnly;
 153     SECURITY_IMPERSONATION_LEVEL    ImpersonationLevel;
 154 } PS_IMPERSONATION_INFORMATION, *PPS_IMPERSONATION_INFORMATION;
 155 #endif
 156
 157 #include <pshpack1.h>
 158
 159 typedef struct _ETHREAD
 160 {
 161   KTHREAD Tcb;
 162   union {
 163         LARGE_INTEGER CreateTime;
 164         UCHAR NestedFaultCount:2;
 165         UCHAR ApcNeeded:1;
 166   };
 167   LARGE_INTEGER ExitTime;
 168   LIST_ENTRY LpcReplyChain;
 169   NTSTATUS ExitStatus;
 170   PVOID OfsChain;
 171   LIST_ENTRY PostBlockList;
 172   LIST_ENTRY TerminationPortList;
 173   KSPIN_LOCK ActiveTimerListLock;
 174   LIST_ENTRY ActiveTimerListHead;
 175   CLIENT_ID Cid;
 176   KSEMAPHORE LpcReplySemaphore;
 177   PVOID LpcReplyMessage;
 178   ULONG LpcReplyMessageId;
 179   ULONG PerformanceCountLow;
 180   PPS_IMPERSONATION_INFORMATION ImpersonationInfo;
 181   LIST_ENTRY IrpList;
 182   PIRP TopLevelIrp;
 183   PDEVICE_OBJECT DeviceToVerify;
 184   ULONG ReadClusterSize;
 185   UCHAR ForwardClusterOnly;
 186   UCHAR DisablePageFaultClustering;
 187   UCHAR DeadThread;
 188   UCHAR HideFromDebugger;
 189   ULONG HasTerminated;
 190 #ifdef _ENABLE_THRDEVTPAIR
 191   PVOID EventPair;
 192 #endif /* _ENABLE_THRDEVTPAIR */
 193   ACCESS_MASK GrantedAccess;
 194   struct _EPROCESS *ThreadsProcess;
 195   PKSTART_ROUTINE StartAddress;
 196   LPTHREAD_START_ROUTINE Win32StartAddress;
 197   ULONG LpcReceivedMessageId;
 198   UCHAR LpcExitThreadCalled;
 199   UCHAR HardErrorsAreDisabled;
 200   UCHAR LpcReceivedMsgIdValid;
 201   UCHAR ActiveImpersonationInfo;
 202   ULONG PerformanceCountHigh;
 203   LIST_ENTRY ThreadListEntry;
 204 } ETHREAD;
 205
 206 #include <poppack.h>
 207
 208
 209 #ifndef __USE_W32API
 210
 211 typedef struct _ETHREAD *PETHREAD;
 212
 213 #endif /* __USE_W32API */
 214
 215
 216 typedef struct _KPROCESS
 217 {
 218   /* So it's possible to wait for the process to terminate */
 219   DISPATCHER_HEADER     DispatcherHeader;             /* 000 */
 220   /*
 221    * Presumably a list of profile objects associated with this process,
 222    * currently unused.
 223    */
 224   LIST_ENTRY            ProfileListHead;              /* 010 */
 225   /*
 226    * We use the first member of this array to hold the physical address of
 227    * the page directory for this process.
 228    */
 229   PHYSICAL_ADDRESS      DirectoryTableBase;           /* 018 */
 230   /*
 231    * Presumably a descriptor for the process's LDT, currently unused.
 232    */
 233   ULONG                 LdtDescriptor[2];             /* 020 */
 234   /*
 235    * Virtual Dos Machine flag.
 236    */
 237   ULONG                 NtVdmFlag;                    /* 028 */
 238   ULONG                 VdmUnused;                    /* 02C */
 239   /* Is the i/o permission map enabled for the process. */
 240   USHORT                IopmOffset;                   /* 030 */
 241   /*
 242    * Presumably I/O privilege level to be used for this process, currently
 243    * unused.
 244    */
 245   UCHAR                 Iopl;                         /* 032 */
 246   /* Set if this process is a virtual dos machine? */
 247   UCHAR                 VdmFlag;                      /* 033 */
 248   /* Bitmask of the processors being used by this process's threads? */
 249   ULONG                 ActiveProcessors;             /* 034 */
 250   /* Aggregate of the time this process's threads have spent in kernel mode? */
 251   ULONG                 KernelTime;                   /* 038 */
 252   /* Aggregate of the time this process's threads have spent in user mode? */
 253   ULONG                 UserTime;                     /* 03C */
 254   /* List of this process's threads that are ready for execution? */
 255   LIST_ENTRY            ReadyListHead;                /* 040 */
 256   /* List of this process's threads that have their stacks swapped out? */
 257   LIST_ENTRY            SwapListEntry;                /* 048 */
 258   /* List of this process's threads? */
 259   LIST_ENTRY            ThreadListHead;               /* 050 */
 260   /* Maybe a lock for this data structure, the type is assumed. */
 261   KSPIN_LOCK            ProcessLock;                  /* 058 */
 262   /* Default affinity mask for this process's threads? */
 263   ULONG                 Affinity;                     /* 05C */
 264   /* Count of the stacks allocated for this process's threads? */
 265   USHORT                StackCount;                   /* 060 */
 266   /* Base priority for this process's threads? */
 267   KPRIORITY             BasePriority;                 /* 062 */
 268   /* Default quantum for this process's threads */
 269   UCHAR                 ThreadQuantum;                /* 063 */
 270   /* Unknown. */
 271   UCHAR                 AutoAlignment;                /* 064 */
 272   /* Process execution state, currently either active or terminated. */
 273   UCHAR                 State;                        /* 065 */
 274   /* Seed for generating thread ids for this process's threads? */
 275   UCHAR                 ThreadSeed;                   /* 066 */
 276   /* Disable priority boosts? */
 277   UCHAR                 DisableBoost;                 /* 067 */
 278 } KPROCESS;
 279
 280 #ifndef __USE_W32API
 281
 282 typedef struct _KPROCESS *PKPROCESS;
 283
 284 typedef struct _HARDWARE_PTE_X86 {
 285     ULONG Valid             : 1;
 286     ULONG Write             : 1;
 287     ULONG Owner             : 1;
 288     ULONG WriteThrough      : 1;
 289     ULONG CacheDisable      : 1;
 290     ULONG Accessed          : 1;
 291     ULONG Dirty             : 1;
 292     ULONG LargePage         : 1;
 293     ULONG Global            : 1;
 294     ULONG CopyOnWrite       : 1;
 295     ULONG Prototype         : 1;
 296     ULONG reserved          : 1;
 297     ULONG PageFrameNumber   : 20;
 298 } HARDWARE_PTE_X86, *PHARDWARE_PTE_X86;
 299
 300 typedef struct _WOW64_PROCESS
 301 {
 302   PVOID Wow64;
 303 } WOW64_PROCESS, *PWOW64_PROCESS;
 304
 305 #endif /* __USE_W32API */
 306
 307 struct _EPROCESS
 308 {
 309   /* Microkernel specific process state. */
 310   KPROCESS              Pcb;                          /* 000 */
 311   /* Exit status of the process. */
 312   NTSTATUS              ExitStatus;                   /* 068 */
 313   /* Unknown. */
 314   KEVENT                LockEvent;                    /* 06C */
 315   /* Unknown. */
 316   ULONG                 LockCount;                    /* 07C */
 317
 318   /* Time of process creation. */
 319   LARGE_INTEGER         CreateTime;                   /* 080 */
 320
 321   /* Time of process exit. */
 322   LARGE_INTEGER         ExitTime;                     /* 088 */
 323   /* Unknown. */
 324   PKTHREAD              LockOwner;                    /* 090 */
 325   /* Process id. */
 326   HANDLE                UniqueProcessId;              /* 094 */
 327   /* Unknown. */
 328   LIST_ENTRY            ActiveProcessLinks;           /* 098 */
 329   /* Unknown. */
 330   ULONG                 QuotaPeakPoolUsage[2];        /* 0A0 */
 331   /* Unknown. */
 332   ULONG                 QuotaPoolUsage[2];            /* 0A8 */
 333   /* Unknown. */
 334   ULONG                 PagefileUsage;                /* 0B0 */
 335   /* Unknown. */
 336   ULONG                 CommitCharge;                 /* 0B4 */
 337   /* Unknown. */
 338   ULONG                 PeakPagefileUsage;            /* 0B8 */
 339   /* Unknown. */
 340   ULONG                 PeakVirtualSize;              /* 0BC */
 341   /* Unknown. */
 342   LARGE_INTEGER         VirtualSize;                  /* 0C0 */
 343
 344   MMSUPPORT             Vm;
 345   LIST_ENTRY            SessionProcessLinks;
 346   struct _EPORT         *DebugPort;
 347   struct _EPORT         *ExceptionPort;
 348   HANDLE_TABLE          HandleTable;
 349   PVOID                 Token;
 350   FAST_MUTEX            WorkingSetLock;
 351   ULONG                 WorkingSetPage;
 352   UCHAR                 ProcessOutswapEnabled;
 353   UCHAR                 ProcessOutswapped;
 354   UCHAR                 AddressSpaceInitialized;
 355   UCHAR                 AddressSpaceDeleted;
 356   FAST_MUTEX            AddressCreationLock;
 357   KSPIN_LOCK            HyperSpaceLock;
 358   PETHREAD              ForkInProgress;
 359   USHORT                VmOperation;
 360   UCHAR                 ForkWasSuccessful;
 361   UCHAR                 MmAgressiveWsTrimMask;
 362   PKEVENT               VmOperationEvent;
 363   PVOID                 PaeTop;
 364   ULONG                 LastFaultCount;
 365   ULONG                 ModifiedPageCount;
 366   PVOID                 VadRoot;
 367   PVOID                 VadHint;
 368   PVOID                 CloneRoot;
 369   ULONG                 NumberOfPrivatePages;
 370   ULONG                 NumberOfLockedPages;
 371   USHORT                NextPageColor;
 372   UCHAR                 ExitProcessCalled;
 373   UCHAR                 CreateProcessReported;
 374   HANDLE                SectionHandle;
 375   PPEB                  Peb;
 376   PVOID                 SectionBaseAddress;
 377   PEPROCESS_QUOTA_BLOCK QuotaBlock;
 378   NTSTATUS              LastThreadExitStatus;
 379   PPAGEFAULT_HISTORY    WorkingSetWatch;
 380   HANDLE                Win32WindowStation;
 381   HANDLE                InheritedFromUniqueProcessId;
 382   ULONG                 GrantedAccess;
 383   ULONG                 DefaultHardErrorProcessing;
 384   PVOID                 LdtInformation;
 385   PVOID                 VadFreeHint;
 386   PVOID                 VdmObjects;
 387   PVOID                 DeviceObjects;
 388   ULONG                 SessionId;
 389   LIST_ENTRY            PhysicalVadList;
 390   HARDWARE_PTE_X86      PageDirectoryPte;
 391   ULONGLONG             Filler;
 392   ULONG                 PaePageDirectoryPage;
 393   CHAR                  ImageFileName[16];
 394   ULONG                 VmTrimFaultValue;
 395   UCHAR                 SetTimerResolution;
 396   UCHAR                 PriorityClass;
 397   UCHAR                 SubSystemMinorVersion;
 398   UCHAR                 SubSystemMajorVersion;
 399   USHORT                SubSystemVersion;
 400   struct _W32PROCESS    *Win32Process;
 401   struct _EJOB          *Job;
 402   ULONG                 JobStatus;
 403   LIST_ENTRY            JobLinks;
 404   PVOID                 LockedPagesList;
 405   struct _EPORT         *SecurityPort;
 406   PWOW64_PROCESS        Wow64;
 407   LARGE_INTEGER         ReadOperationCount;
 408   LARGE_INTEGER         WriteOperationCount;
 409   LARGE_INTEGER         OtherOperationCount;
 410   LARGE_INTEGER         ReadTransferCount;
 411   LARGE_INTEGER         WriteTransferCount;
 412   LARGE_INTEGER         OtherTransferCount;
 413   ULONG                 CommitChargeLimit;
 414   ULONG                 CommitChargePeak;
 415   LIST_ENTRY            ThreadListHead;
 416   PRTL_BITMAP           VadPhysicalPagesBitMap;
 417   ULONG                 VadPhysicalPages;
 418   KSPIN_LOCK            AweLock;
 419
 420   /*
 421    * FIXME - ReactOS specified - remove the following fields ASAP!!!
 422    */
 423   MADDRESS_SPACE        AddressSpace;
 424   LIST_ENTRY            ProcessListEntry;
 425   FAST_MUTEX            TebLock;
 426   PVOID                 TebBlock;
 427   PVOID                 TebLastAllocated;
 428 };
 429
 430 #define PROCESS_STATE_TERMINATED (1)
 431 #define PROCESS_STATE_ACTIVE     (2)
 432
 433 VOID PiInitDefaultLocale(VOID);
 434 VOID PiInitProcessManager(VOID);
 435 VOID PiShutdownProcessManager(VOID);
 436 VOID PsInitThreadManagment(VOID);
 437 VOID PsInitProcessManagment(VOID);
 438 VOID PsInitIdleThread(VOID);
 439 VOID PsDispatchThreadNoLock(ULONG NewThreadStatus);
 440 VOID PiTerminateProcessThreads(PEPROCESS Process, NTSTATUS ExitStatus);
 441 VOID PsTerminateCurrentThread(NTSTATUS ExitStatus);
 442 VOID PsTerminateOtherThread(PETHREAD Thread, NTSTATUS ExitStatus);
 443 VOID PsReleaseThread(PETHREAD Thread);
 444 VOID PsBeginThread(PKSTART_ROUTINE StartRoutine, PVOID StartContext);
 445 VOID PsBeginThreadWithContextInternal(VOID);
 446 VOID PiKillMostProcesses(VOID);
 447 NTSTATUS STDCALL PiTerminateProcess(PEPROCESS Process, NTSTATUS ExitStatus);
 448 VOID PiInitApcManagement(VOID);
 449 VOID STDCALL PiDeleteThread(PVOID ObjectBody);
 450 VOID PsReapThreads(VOID);
 451 VOID PsInitializeThreadReaper(VOID);
 452 VOID PsQueueThreadReap(PETHREAD Thread);
 453 NTSTATUS
 454 PsInitializeThread(PEPROCESS Process,
 455                    PETHREAD* ThreadPtr,
 456                    PHANDLE ThreadHandle,
 457                    ACCESS_MASK DesiredAccess,
 458                    POBJECT_ATTRIBUTES ObjectAttributes,
 459                    BOOLEAN First);
 460
 461 PACCESS_TOKEN PsReferenceEffectiveToken(PETHREAD Thread,
 462                                         PTOKEN_TYPE TokenType,
 463                                         PUCHAR b,
 464                                         PSECURITY_IMPERSONATION_LEVEL Level);
 465
 466 NTSTATUS PsOpenTokenOfProcess(HANDLE ProcessHandle,
 467                               PACCESS_TOKEN* Token);
 468
 469 NTSTATUS PsSuspendThread(PETHREAD Thread, PULONG PreviousCount);
 470 NTSTATUS PsResumeThread(PETHREAD Thread, PULONG PreviousCount);
 471
 472 VOID STDCALL PsExitSpecialApc(PKAPC Apc,
 473                       PKNORMAL_ROUTINE *NormalRoutine,
 474                       PVOID *NormalContext,
 475                       PVOID *SystemArgument1,
 476                       PVOID *SystemArgument2);
 477
 478 #define THREAD_STATE_INITIALIZED  (0)
 479 #define THREAD_STATE_READY        (1)
 480 #define THREAD_STATE_RUNNING      (2)
 481 #define THREAD_STATE_SUSPENDED    (3)
 482 #define THREAD_STATE_FROZEN       (4)
 483 #define THREAD_STATE_TERMINATED_1 (5)
 484 #define THREAD_STATE_TERMINATED_2 (6)
 485 #define THREAD_STATE_BLOCKED      (7)
 486 #define THREAD_STATE_MAX          (8)
 487
 488
 489 /*
 490  * Internal thread priorities, added by Phillip Susi
 491  * TODO: rebalence these to make use of all priorities... the ones above 16
 492  * can not all be used right now
 493  */
 494 #define PROCESS_PRIO_IDLE                       3
 495 #define PROCESS_PRIO_NORMAL                     8
 496 #define PROCESS_PRIO_HIGH                       13
 497 #define PROCESS_PRIO_RT                         18
 498
 499
 500 VOID
 501 KeInitializeThread(PKPROCESS Process, PKTHREAD Thread, BOOLEAN First);
 502 NTSTATUS KeReleaseThread(PKTHREAD Thread);
 503
 504 VOID
 505 STDCALL
 506 KeStackAttachProcess (
 507     IN PKPROCESS Process,
 508     OUT PKAPC_STATE ApcState
 509     );
 510
 511 VOID
 512 STDCALL
 513 KeUnstackDetachProcess (
 514     IN PKAPC_STATE ApcState
 515     );
 516
 517 VOID STDCALL PiDeleteProcess(PVOID ObjectBody);
 518 VOID PsReapThreads(VOID);
 519 VOID PsInitializeThreadReaper(VOID);
 520 VOID PsQueueThreadReap(PETHREAD Thread);
 521 VOID PsUnfreezeOtherThread(PETHREAD Thread);
 522 VOID PsFreezeOtherThread(PETHREAD Thread);
 523 VOID PsFreezeProcessThreads(PEPROCESS Process);
 524 VOID PsUnfreezeProcessThreads(PEPROCESS Process);
 525 ULONG PsEnumThreadsByProcess(PEPROCESS Process);
 526 PEPROCESS PsGetNextProcess(PEPROCESS OldProcess);
 527 VOID
 528 PsBlockThread(PNTSTATUS Status, UCHAR Alertable, ULONG WaitMode,
 529               BOOLEAN DispatcherLock, KIRQL WaitIrql, UCHAR WaitReason);
 530 VOID
 531 PsUnblockThread(PETHREAD Thread, PNTSTATUS WaitStatus, KPRIORITY Increment);
 532 VOID
 533 PsApplicationProcessorInit(VOID);
 534 VOID
 535 PsPrepareForApplicationProcessorInit(ULONG Id);
 536 VOID STDCALL
 537 PsIdleThreadMain(PVOID Context);
 538
 539 VOID STDCALL
 540 PiSuspendThreadRundownRoutine(PKAPC Apc);
 541 VOID STDCALL
 542 PiSuspendThreadKernelRoutine(PKAPC Apc,
 543                              PKNORMAL_ROUTINE* NormalRoutine,
 544                              PVOID* NormalContext,
 545                              PVOID* SystemArgument1,
 546                              PVOID* SystemArguemnt2);
 547 VOID STDCALL
 548 PiSuspendThreadNormalRoutine(PVOID NormalContext,
 549                              PVOID SystemArgument1,
 550                              PVOID SystemArgument2);
 551 VOID STDCALL
 552 PsDispatchThread(ULONG NewThreadStatus);
 553 VOID
 554 PsInitialiseSuspendImplementation(VOID);
 555
 556 extern LONG PiNrThreadsAwaitingReaping;
 557
 558 NTSTATUS
 559 PsInitWin32Thread (PETHREAD Thread);
 560
 561 VOID
 562 PsTerminateWin32Process (PEPROCESS Process);
 563
 564 VOID
 565 PsTerminateWin32Thread (PETHREAD Thread);
 566
 567 VOID
 568 PsInitialiseW32Call(VOID);
 569
 570 VOID
 571 STDCALL
 572 PspRunCreateThreadNotifyRoutines(PETHREAD, BOOLEAN);
 573
 574 VOID
 575 STDCALL
 576 PspRunCreateProcessNotifyRoutines(PEPROCESS, BOOLEAN);
 577
 578 #include <pshpack1.h>
 579 typedef struct _PS_JOB_TOKEN_FILTER
 580 {
 581   UINT CapturedSidCount;
 582   PSID_AND_ATTRIBUTES CapturedSids;
 583   UINT CapturedSidsLength;
 584   UINT CapturedGroupCount;
 585   PSID_AND_ATTRIBUTES CapturedGroups;
 586   UINT CapturedGroupsLength;
 587   UINT CapturedPrivilegeCount;
 588   PLUID_AND_ATTRIBUTES CapturedPrivileges;
 589   UINT CapturedPrivilegesLength;
 590 } PS_JOB_TOKEN_FILTER, *PPS_JOB_TOKEN_FILTER;
 591 #include <poppack.h>
 592
 593 #include <pshpack1.h>
 594 typedef struct _EJOB
 595 {
 596   KEVENT Event;
 597   LIST_ENTRY JobLinks;
 598   LIST_ENTRY ProcessListHead;
 599   ERESOURCE JobLock;
 600   LARGE_INTEGER TotalUserTime;
 601   LARGE_INTEGER TotalKernelTime;
 602   LARGE_INTEGER ThisPeriodTotalUserTime;
 603   LARGE_INTEGER ThisPeriodTotalKernelTime;
 604   UINT TotalPageFaultCount;
 605   UINT TotalProcesses;
 606   UINT ActiveProcesses;
 607   UINT TotalTerminatedProcesses;
 608   LARGE_INTEGER PerProcessUserTimeLimit;
 609   LARGE_INTEGER PerJobUserTimeLimit;
 610   UINT LimitFlags;
 611   UINT MinimumWorkingSetSize;
 612   UINT MaximumWorkingSetSize;
 613   UINT ActiveProcessLimit;
 614   UINT Affinity;
 615   BYTE PriorityClass;
 616   UINT UIRestrictionsClass;
 617   UINT SecurityLimitFlags;
 618   PVOID Token;
 619   PPS_JOB_TOKEN_FILTER Filter;
 620   UINT EndOfJobTimeAction;
 621   PVOID CompletionPort;
 622   PVOID CompletionKey;
 623   UINT SessionId;
 624   UINT SchedulingClass;
 625   ULONGLONG ReadOperationCount;
 626   ULONGLONG WriteOperationCount;
 627   ULONGLONG OtherOperationCount;
 628   ULONGLONG ReadTransferCount;
 629   ULONGLONG WriteTransferCount;
 630   ULONGLONG OtherTransferCount;
 631   IO_COUNTERS IoInfo;
 632   UINT ProcessMemoryLimit;
 633   UINT JobMemoryLimit;
 634   UINT PeakProcessMemoryUsed;
 635   UINT PeakJobMemoryUsed;
 636   UINT CurrentJobMemoryUsed;
 637   FAST_MUTEX MemoryLimitsLock;
 638 } EJOB;
 639 #include <poppack.h>
 640
 641 VOID INIT_FUNCTION PsInitJobManagment(VOID);
 642
 643 /* CID */
 644
 645 typedef struct _CID_OBJECT
 646 {
 647   LONG ref;
 648   HANDLE Handle;
 649   LIST_ENTRY Entry;
 650   FAST_MUTEX Lock;
 651   union
 652   {
 653     struct _EPROCESS *Process;
 654     struct _ETHREAD *Thread;
 655     PVOID Object;
 656   } Obj;
 657 } CID_OBJECT, *PCID_OBJECT;
 658
 659 NTSTATUS PsCreateCidHandle(PVOID Object, POBJECT_TYPE ObjectType, PHANDLE Handle);
 660 NTSTATUS PsDeleteCidHandle(HANDLE CidHandle, POBJECT_TYPE ObjectType);
 661 PCID_OBJECT PsLockCidHandle(HANDLE CidHandle, POBJECT_TYPE ObjectType);
 662 VOID PsUnlockCidObject(PCID_OBJECT CidObject);
 663 NTSTATUS PsLockProcess(PEPROCESS Process, BOOL Timeout);
 664 VOID PsUnlockProcess(PEPROCESS Process);
 665
 666 #define ETHREAD_TO_KTHREAD(pEThread) (&(pEThread)->Tcb)
 667 #define KTHREAD_TO_ETHREAD(pKThread) (CONTAINING_RECORD((pKThread), ETHREAD, Tcb))
 668 #define EPROCESS_TO_KPROCESS(pEProcess) (&(pEProcess)->Pcb)
 669 #define KPROCESS_TO_EPROCESS(pKProcess) (CONTAINING_RECORD((pKProcess), EPROCESS, Pcb))
 670
 671 #endif /* ASSEMBLER */
 672
 673 #endif /* __INCLUDE_INTERNAL_PS_H */