ReactOS 0.4.15-dev-8422-g6219a1a
job.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/ps/job.c
5 * PURPOSE: Job Native Functions
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net) (stubs)
7 * Thomas Weidenmueller <w3seek@reactos.com>
8 * Pierre Schweitzer (pierre@reactos.org)
9 */
10
11/* INCLUDES *****************************************************************/
12
13#include <ntoskrnl.h>
14#define NDEBUG
15#include <debug.h>
16
17
18/* GLOBALS *******************************************************************/
19
21
24
26
28{
29 1 * 6,
30 2 * 6,
31 3 * 6,
32 4 * 6,
33 5 * 6,
34 6 * 6,
35 7 * 6,
36 8 * 6,
37 9 * 6,
38 10 * 6
39};
40
42{
44
47
49
50 STANDARD_RIGHTS_ALL | THREAD_ALL_ACCESS // bug fixed only in vista
51};
52
54{
55 0x0,
65 0x4
66};
67
69{
70 0x0,
71 sizeof(ULONG),
72 sizeof(ULONG),
73 sizeof(ULONG),
74 sizeof(ULONG),
75 sizeof(ULONG),
76 sizeof(ULONG),
77 sizeof(ULONG),
78 sizeof(ULONG),
79 sizeof(ULONG),
80 sizeof(ULONG)
81};
82
83/* FUNCTIONS *****************************************************************/
84
85VOID
87PspDeleteJob ( PVOID ObjectBody )
88{
89 PEJOB Job = (PEJOB)ObjectBody;
90
91 /* remove the reference to the completion port if associated */
92 if(Job->CompletionPort != NULL)
93 {
95 }
96
97 /* unlink the job object */
98 if(Job->JobLinks.Flink != NULL)
99 {
103 }
104
106}
107
108CODE_SEG("INIT")
109VOID
110NTAPI
112{
115}
116
118NTAPI
120 PEJOB Job)
121{
122 DPRINT("PspAssignProcessToJob() is unimplemented!\n");
124}
125
127NTAPI
131{
132 DPRINT("PspTerminateJobObject() is unimplemented!\n");
134}
135
136VOID
137NTAPI
139 IN PEJOB Job)
140{
141 /* FIXME */
142}
143
144VOID
145NTAPI
148{
149 /* FIXME */
150}
151
152/*
153 * @unimplemented
154 */
156NTAPI
158 HANDLE JobHandle,
160{
164
165 PAGED_CODE();
166
168
169 /* make sure we're having a handle with enough rights, especially the to
170 terminate the process. otherwise one could abuse the job objects to
171 terminate processes without having rights granted to do so! The reason
172 I open the process handle before the job handle is that a simple test showed
173 that it first complains about a invalid process handle! The other way around
174 would be simpler though... */
180 (PVOID*)&Process,
181 NULL);
182 if(NT_SUCCESS(Status))
183 {
184 if(Process->Job == NULL)
185 {
186 PEJOB Job;
187
189 JobHandle,
191 PsJobType,
193 (PVOID*)&Job,
194 NULL);
195 if(NT_SUCCESS(Status))
196 {
197 /* lock the process so we can safely assign the process. Note that in the
198 meanwhile another thread could have assigned this process to a job! */
199
200 if(ExAcquireRundownProtection(&Process->RundownProtect))
201 {
202 if(Process->Job == NULL && PsGetProcessSessionId(Process) == Job->SessionId)
203 {
204 /* Just store the pointer to the job object in the process, we'll
205 assign it later. The reason we can't do this here is that locking
206 the job object might require it to wait, which is a bad thing
207 while holding the process lock! */
208 Process->Job = Job;
210 }
211 else
212 {
213 /* process is already assigned to a job or session id differs! */
215 }
216 ExReleaseRundownProtection(&Process->RundownProtect);
217
218 if(NT_SUCCESS(Status))
219 {
220 /* let's actually assign the process to the job as we're not holding
221 the process lock anymore! */
223 }
224 }
225
227 }
228 }
229 else
230 {
231 /* process is already assigned to a job or session id differs! */
233 }
234
236 }
237
238 return Status;
239}
240
242NTAPI
244 IN PJOB_SET_ARRAY UserJobSet,
245 IN ULONG Flags)
246{
249}
250
251/*
252 * @unimplemented
253 */
255NTAPI
257 PHANDLE JobHandle,
260{
261 HANDLE hJob;
262 PEJOB Job;
264 PEPROCESS CurrentProcess;
266
267 PAGED_CODE();
268
270 CurrentProcess = PsGetCurrentProcess();
271
272 /* check for valid buffers */
274 {
276 {
277 ProbeForWriteHandle(JobHandle);
278 }
280 {
282 }
283 _SEH2_END;
284 }
285
287 PsJobType,
290 NULL,
291 sizeof(EJOB),
292 0,
293 0,
294 (PVOID*)&Job);
295
296 if(NT_SUCCESS(Status))
297 {
298 /* FIXME - Zero all fields as we don't yet implement all of them */
299 RtlZeroMemory(Job, sizeof(EJOB));
300
301 /* make sure that early destruction doesn't attempt to remove the object from
302 the list before it even gets added! */
303 Job->JobLinks.Flink = NULL;
304
305 /* setup the job object - FIXME: More to do! */
308
309 /* inherit the session id from the caller */
310 Job->SessionId = PsGetProcessSessionId(CurrentProcess);
311
313
315 if(!NT_SUCCESS(Status))
316 {
317 DPRINT1("Failed to initialize job lock!!!\n");
319 return Status;
320 }
322
323 /* link the object into the global job list */
327
329 NULL,
331 0,
332 NULL,
333 &hJob);
334 if(NT_SUCCESS(Status))
335 {
336 /* pass the handle back to the caller */
338 {
339 /* NOTE: if the caller passed invalid buffers to receive the handle it's his
340 own fault! the object will still be created and live... It's possible
341 to find the handle using ObFindHandleForObject()! */
342 *JobHandle = hJob;
343 }
345 {
347 }
348 _SEH2_END;
349 }
350 }
351
352 return Status;
353}
354
355
356/*
357 * @implemented
358 */
360NTAPI
363 IN HANDLE JobHandle OPTIONAL )
364{
368
370
371 PAGED_CODE();
372
378 (PVOID*)&Process,
379 NULL);
380 if(NT_SUCCESS(Status))
381 {
382 /* FIXME - make sure the job object doesn't get exchanged or deleted while trying to
383 reference it, e.g. by locking it somehow until it is referenced... */
384
385 PEJOB ProcessJob = Process->Job;
386
387 if(ProcessJob != NULL)
388 {
389 if(JobHandle == NULL)
390 {
391 /* the process is assigned to a job */
393 }
394 else /* JobHandle != NULL */
395 {
396 PEJOB JobObject;
397
398 /* get the job object and compare the object pointer with the one assigned to the process */
401 PsJobType,
403 (PVOID*)&JobObject,
404 NULL);
405 if(NT_SUCCESS(Status))
406 {
407 Status = ((ProcessJob == JobObject) ? STATUS_PROCESS_IN_JOB : STATUS_PROCESS_NOT_IN_JOB);
408 ObDereferenceObject(JobObject);
409 }
410 }
411 }
412 else
413 {
414 /* the process is not assigned to any job */
416 }
418 }
419
420 return Status;
421}
422
423
424/*
425 * @implemented
426 */
428NTAPI
430 PHANDLE JobHandle,
433{
435 HANDLE hJob;
437
438 PAGED_CODE();
439
441
442 /* check for valid buffers */
444 {
446 {
447 ProbeForWriteHandle(JobHandle);
448 }
450 {
452 }
453 _SEH2_END;
454 }
455
457 PsJobType,
459 NULL,
461 NULL,
462 &hJob);
463 if(NT_SUCCESS(Status))
464 {
466 {
467 *JobHandle = hJob;
468 }
470 {
472 }
473 _SEH2_END;
474 }
475
476 return Status;
477}
478
479
480/*
481 * @implemented
482 */
484NTAPI
486 HANDLE JobHandle,
487 JOBOBJECTINFOCLASS JobInformationClass,
488 PVOID JobInformation,
489 ULONG JobInformationLength,
491{
492 PEJOB Job;
494 BOOLEAN NoOutput;
495 PVOID GenericCopy;
496 PLIST_ENTRY NextEntry;
497 PKTHREAD CurrentThread;
501 ULONG RequiredLength, RequiredAlign, SizeToCopy, NeededSize;
502
503 PAGED_CODE();
504
505 CurrentThread = KeGetCurrentThread();
506
507 /* Validate class */
508 if (JobInformationClass > JobObjectJobSetInformation || JobInformationClass < JobObjectBasicAccountingInformation)
509 {
511 }
512
513 /* Get associated lengths & alignments */
514 RequiredLength = PspJobInfoLengths[JobInformationClass];
515 RequiredAlign = PspJobInfoAlign[JobInformationClass];
516 SizeToCopy = RequiredLength;
517 NeededSize = RequiredLength;
518
519 /* If length mismatch (needed versus provided) */
520 if (JobInformationLength != RequiredLength)
521 {
522 /* This can only be accepted if: JobObjectBasicProcessIdList or JobObjectSecurityLimitInformation
523 * Or if size is bigger than needed
524 */
525 if ((JobInformationClass != JobObjectBasicProcessIdList && JobInformationClass != JobObjectSecurityLimitInformation) ||
526 JobInformationLength < RequiredLength)
527 {
529 }
530
531 /* Set what we need to copy out */
532 SizeToCopy = JobInformationLength;
533 }
534
536 /* If not comming from umode, we need to probe buffers */
538 {
539 ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
540
542 {
543 /* Probe out buffer for write */
544 if (JobInformation != NULL)
545 {
546 ProbeForWrite(JobInformation, JobInformationLength, RequiredAlign);
547 }
548
549 /* But also return length if asked */
550 if (ReturnLength != NULL)
551 {
553 }
554 }
556 {
558 }
559 _SEH2_END;
560 }
561
562 /* If a job handle was provided, use it */
563 if (JobHandle != NULL)
564 {
567 PsJobType,
569 (PVOID*)&Job,
570 NULL);
571 if (!NT_SUCCESS(Status))
572 {
573 return Status;
574 }
575 }
576 /* Otherwise, get our current process' job, if any */
577 else
578 {
579 PEPROCESS CurrentProcess;
580
581 CurrentProcess = (PEPROCESS)CurrentThread->ApcState.Process;
582 Job = CurrentProcess->Job;
583 if (Job == NULL)
584 {
586 }
587
589 }
590
591 /* By default, assume we'll have to copy data */
592 NoOutput = FALSE;
593 /* Select class */
594 switch (JobInformationClass)
595 {
596 /* Basic counters */
599 /* Zero basics */
601
602 /* Lock */
603 KeEnterGuardedRegionThread(CurrentThread);
605
606 /* Initialize with job counters */
612 BasicAndIo.BasicInfo.TotalProcesses = Job->TotalProcesses;
613 BasicAndIo.BasicInfo.ActiveProcesses = Job->ActiveProcesses;
615
616 /* We also set IoInfo, even though we might not return it */
623
624 /* For every process, sum its counters */
625 for (NextEntry = Job->ProcessListHead.Flink;
626 NextEntry != &Job->ProcessListHead;
627 NextEntry = NextEntry->Flink)
628 {
630
631 Process = CONTAINING_RECORD(NextEntry, EPROCESS, JobLinks);
632 if (!BooleanFlagOn(Process->JobStatus, 2))
633 {
634 PROCESS_VALUES Values;
635
636 KeQueryValuesProcess(&Process->Pcb, &Values);
645 }
646 }
647
648 /* And done */
650 KeLeaveGuardedRegionThread(CurrentThread);
651
652 /* We'll copy back the buffer */
653 GenericCopy = &BasicAndIo;
655
656 break;
657
658 /* Limits information */
661 /* Lock */
662 KeEnterGuardedRegionThread(CurrentThread);
664
665 /* Copy basic information */
666 ExtendedLimit.BasicLimitInformation.LimitFlags = Job->LimitFlags;
672 ExtendedLimit.BasicLimitInformation.Affinity = Job->Affinity;
675
676 /* If asking for extending limits */
677 if (JobInformationClass == JobObjectExtendedLimitInformation)
678 {
679 /* Lock our memory lock */
681 /* Return limits */
682 ExtendedLimit.ProcessMemoryLimit = Job->ProcessMemoryLimit << PAGE_SHIFT;
683 ExtendedLimit.JobMemoryLimit = Job->JobMemoryLimit << PAGE_SHIFT;
685 ExtendedLimit.PeakJobMemoryUsed = Job->PeakJobMemoryUsed << PAGE_SHIFT;
687
688 /* And done */
690 KeLeaveGuardedRegionThread(CurrentThread);
691
692 /* We'll never return IoInfo, so zero it out to avoid
693 * kernel memory leak
694 */
695 RtlZeroMemory(&ExtendedLimit.IoInfo, sizeof(IO_COUNTERS));
696 }
697 else
698 {
699 /* And done */
701 KeLeaveGuardedRegionThread(CurrentThread);
702 }
703
704 /* We'll copy back the buffer */
705 GenericCopy = &ExtendedLimit;
707
708 break;
709
710 default:
711 DPRINT1("Class %d not implemented\n", JobInformationClass);
713 break;
714 }
715
716 /* Job is no longer required */
718
719 /* If we succeeed, copy back data */
720 if (NT_SUCCESS(Status))
721 {
723 {
724 /* If we have anything to copy, do it */
725 if (!NoOutput)
726 {
727 RtlCopyMemory(JobInformation, GenericCopy, SizeToCopy);
728 }
729
730 /* And return length if asked */
731 if (ReturnLength != NULL)
732 {
733 *ReturnLength = NeededSize;
734 }
735 }
737 {
739 }
740 _SEH2_END;
741 }
742
743 return Status;
744}
745
746
747/*
748 * @unimplemented
749 */
751NTAPI
753 HANDLE JobHandle,
754 JOBOBJECTINFOCLASS JobInformationClass,
755 PVOID JobInformation,
756 ULONG JobInformationLength)
757{
758 PEJOB Job;
760 PKTHREAD CurrentThread;
763 ULONG RequiredLength, RequiredAlign;
764
765 PAGED_CODE();
766
767 CurrentThread = KeGetCurrentThread();
768
769 /* Validate class */
770 if (JobInformationClass > JobObjectJobSetInformation || JobInformationClass < JobObjectBasicAccountingInformation)
771 {
773 }
774
775 /* Get associated lengths & alignments */
776 RequiredLength = PspJobInfoLengths[JobInformationClass];
777 RequiredAlign = PspJobInfoAlign[JobInformationClass];
778
780 /* If not comming from umode, we need to probe buffers */
782 {
783 ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
784
786 {
787 /* Probe out buffer for read */
788 if (JobInformationLength != 0)
789 {
790 ProbeForRead(JobInformation, JobInformationLength, RequiredAlign);
791 }
792 }
794 {
796 }
797 _SEH2_END;
798 }
799
800 /* Validate input size */
801 if (JobInformationLength != RequiredLength)
802 {
804 }
805
806 /* Open the given job */
808 if (JobInformationClass == JobObjectSecurityLimitInformation)
809 {
811 }
814 PsJobType,
816 (PVOID*)&Job,
817 NULL);
818 if (!NT_SUCCESS(Status))
819 {
820 return Status;
821 }
822
823 /* And set the information */
824 KeEnterGuardedRegionThread(CurrentThread);
825 switch (JobInformationClass)
826 {
828 DPRINT1("Class JobObjectExtendedLimitInformation not implemented\n");
830 break;
831
832 default:
833 DPRINT1("Class %d not implemented\n", JobInformationClass);
835 break;
836 }
837 KeLeaveGuardedRegionThread(CurrentThread);
838
840
841 return Status;
842}
843
844
845/*
846 * @unimplemented
847 */
849NTAPI
851 HANDLE JobHandle,
853{
855 PEJOB Job;
857
858 PAGED_CODE();
859
861
863 JobHandle,
865 PsJobType,
867 (PVOID*)&Job,
868 NULL);
869 if(NT_SUCCESS(Status))
870 {
872 Job,
874 ExitStatus);
876 }
877
878 return Status;
879}
880
881
882/*
883 * @implemented
884 */
885PVOID
886NTAPI
888{
889 ASSERT(Job);
890 return (PVOID)&Job->JobLock;
891}
892
893
894/*
895 * @implemented
896 */
897ULONG
898NTAPI
900{
901 ASSERT(Job);
902 return Job->SessionId;
903}
904
905
906/*
907 * @implemented
908 */
909ULONG
910NTAPI
912{
913 ASSERT(Job);
914 return Job->UIRestrictionsClass;
915}
916
917
918/*
919 * @unimplemented
920 */
921VOID
922NTAPI
924 ULONG UIRestrictionsClass)
925{
926 ASSERT(Job);
927 (void)InterlockedExchangeUL(&Job->UIRestrictionsClass, UIRestrictionsClass);
928 /* FIXME - walk through the job process list and update the restrictions? */
929}
930
931/* EOF */
#define PAGED_CODE()
#define CODE_SEG(...)
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define UNIMPLEMENTED
Definition: debug.h:118
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:43
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
#define ExReleaseRundownProtection
Definition: ex.h:136
#define ExGetPreviousMode
Definition: ex.h:140
#define InterlockedExchangeUL(Target, Value)
Definition: ex.h:1530
#define ExAcquireRundownProtection
Definition: ex.h:135
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Status
Definition: gdiplustypes.h:25
VOID FASTCALL KeReleaseGuardedMutexUnsafe(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:75
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
VOID FASTCALL KeAcquireGuardedMutexUnsafe(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:64
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
#define KeGetCurrentThread
Definition: hal.h:55
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define PROCESS_TERMINATE
Definition: pstypes.h:157
#define JOB_OBJECT_SET_SECURITY_ATTRIBUTES
Definition: pstypes.h:204
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:166
struct _JOBOBJECT_BASIC_PROCESS_ID_LIST JOBOBJECT_BASIC_PROCESS_ID_LIST
enum _JOBOBJECTINFOCLASS JOBOBJECTINFOCLASS
struct _EJOB * PEJOB
struct _JOBOBJECT_SECURITY_LIMIT_INFORMATION JOBOBJECT_SECURITY_LIMIT_INFORMATION
#define JOB_OBJECT_TERMINATE
Definition: pstypes.h:203
@ JobObjectBasicLimitInformation
Definition: pstypes.h:429
@ JobObjectBasicAndIoAccountingInformation
Definition: pstypes.h:435
@ JobObjectBasicAccountingInformation
Definition: pstypes.h:428
@ JobObjectSecurityLimitInformation
Definition: pstypes.h:432
@ JobObjectExtendedLimitInformation
Definition: pstypes.h:436
@ JobObjectBasicProcessIdList
Definition: pstypes.h:430
@ JobObjectJobSetInformation
Definition: pstypes.h:437
struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION JOBOBJECT_EXTENDED_LIMIT_INFORMATION
struct _JOBOBJECT_BASIC_ACCOUNTING_INFORMATION JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
#define JOB_OBJECT_ASSIGN_PROCESS
Definition: pstypes.h:200
#define JOB_OBJECT_SET_ATTRIBUTES
Definition: pstypes.h:201
#define JOB_OBJECT_QUERY
Definition: pstypes.h:202
struct _JOBOBJECT_ASSOCIATE_COMPLETION_PORT JOBOBJECT_ASSOCIATE_COMPLETION_PORT
#define KeEnterGuardedRegionThread(_Thread)
Definition: ke_x.h:27
#define KeLeaveGuardedRegionThread(_Thread)
Definition: ke_x.h:48
if(dx< 0)
Definition: linetemp.h:194
#define ASSERT(a)
Definition: mode.c:44
#define KernelMode
Definition: asm.h:34
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:867
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
#define SYNCHRONIZE
Definition: nt_native.h:61
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define STANDARD_RIGHTS_READ
Definition: nt_native.h:65
struct _EPROCESS * PEPROCESS
Definition: nt_native.h:30
#define STANDARD_RIGHTS_ALL
Definition: nt_native.h:69
#define STANDARD_RIGHTS_WRITE
Definition: nt_native.h:66
#define STANDARD_RIGHTS_EXECUTE
Definition: nt_native.h:67
@ NotificationEvent
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
VOID NTAPI KeQueryValuesProcess(IN PKPROCESS Process, PPROCESS_VALUES Values)
Definition: procobj.c:525
NTSTATUS NTAPI NtIsProcessInJob(IN HANDLE ProcessHandle, IN HANDLE JobHandle OPTIONAL)
Definition: job.c:361
VOID NTAPI PspRemoveProcessFromJob(IN PEPROCESS Process, IN PEJOB Job)
Definition: job.c:138
NTSTATUS NTAPI NtQueryInformationJobObject(HANDLE JobHandle, JOBOBJECTINFOCLASS JobInformationClass, PVOID JobInformation, ULONG JobInformationLength, PULONG ReturnLength)
Definition: job.c:485
ULONG NTAPI PsGetJobUIRestrictionsClass(PEJOB Job)
Definition: job.c:911
VOID NTAPI PspExitProcessFromJob(IN PEJOB Job, IN PEPROCESS Process)
Definition: job.c:146
VOID NTAPI PspInitializeJobStructures(VOID)
Definition: job.c:111
ULONG PspJobInfoAlign[]
Definition: job.c:68
NTSTATUS NTAPI NtTerminateJobObject(HANDLE JobHandle, NTSTATUS ExitStatus)
Definition: job.c:850
NTSTATUS NTAPI PspAssignProcessToJob(PEPROCESS Process, PEJOB Job)
Definition: job.c:119
PVOID NTAPI PsGetJobLock(PEJOB Job)
Definition: job.c:887
NTSTATUS NTAPI PspTerminateJobObject(PEJOB Job, KPROCESSOR_MODE AccessMode, NTSTATUS ExitStatus)
Definition: job.c:128
NTSTATUS NTAPI NtOpenJobObject(PHANDLE JobHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes)
Definition: job.c:429
BOOLEAN PspUseJobSchedulingClasses
Definition: job.c:25
ULONG NTAPI PsGetJobSessionId(PEJOB Job)
Definition: job.c:899
static FAST_MUTEX PsJobListLock
Definition: job.c:23
CHAR PspJobSchedulingClasses[PSP_JOB_SCHEDULING_CLASSES]
Definition: job.c:27
VOID NTAPI PspDeleteJob(PVOID ObjectBody)
Definition: job.c:87
NTSTATUS NTAPI NtSetInformationJobObject(HANDLE JobHandle, JOBOBJECTINFOCLASS JobInformationClass, PVOID JobInformation, ULONG JobInformationLength)
Definition: job.c:752
NTSTATUS NTAPI NtAssignProcessToJobObject(HANDLE JobHandle, HANDLE ProcessHandle)
Definition: job.c:157
LIST_ENTRY PsJobListHead
Definition: job.c:22
GENERIC_MAPPING PspJobMapping
Definition: job.c:41
NTSTATUS NTAPI NtCreateJobObject(PHANDLE JobHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes)
Definition: job.c:256
NTSTATUS NTAPI NtCreateJobSet(IN ULONG NumJob, IN PJOB_SET_ARRAY UserJobSet, IN ULONG Flags)
Definition: job.c:243
VOID NTAPI PsSetJobUIRestrictionsClass(PEJOB Job, ULONG UIRestrictionsClass)
Definition: job.c:923
ULONG PspJobInfoLengths[]
Definition: job.c:53
POBJECT_TYPE PsJobType
Definition: job.c:20
POBJECT_TYPE PsProcessType
Definition: process.c:20
ULONG NTAPI PsGetProcessSessionId(IN PEPROCESS Process)
Definition: process.c:1163
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_PROCESS_IN_JOB
Definition: ntstatus.h:108
#define STATUS_PROCESS_NOT_IN_JOB
Definition: ntstatus.h:107
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2935
NTSTATUS NTAPI ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN OUT PVOID ParseContext, OUT PHANDLE Handle)
Definition: obhandle.c:2532
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:1039
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
#define PSP_JOB_SCHEDULING_CLASSES
Definition: ps.h:71
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define ProbeForWriteHandle(Ptr)
Definition: probe.h:43
#define ProbeForWriteUlong(Ptr)
Definition: probe.h:36
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:73
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
JOBOBJECT_BASIC_ACCOUNTING_INFORMATION BasicInfo
Definition: pstypes.h:1596
LARGE_INTEGER ThisPeriodTotalUserTime
Definition: pstypes.h:1485
ULONGLONG OtherTransferCount
Definition: pstypes.h:1513
LARGE_INTEGER TotalKernelTime
Definition: pstypes.h:1484
ULONG LimitFlags
Definition: pstypes.h:1493
ULONG TotalProcesses
Definition: pstypes.h:1488
ULONG ActiveProcessLimit
Definition: pstypes.h:1496
LIST_ENTRY ProcessListHead
Definition: pstypes.h:1481
UCHAR PriorityClass
Definition: pstypes.h:1498
ULONG UIRestrictionsClass
Definition: pstypes.h:1499
ULONGLONG OtherOperationCount
Definition: pstypes.h:1510
LARGE_INTEGER PerJobUserTimeLimit
Definition: pstypes.h:1492
ULONG Affinity
Definition: pstypes.h:1497
PVOID CompletionPort
Definition: pstypes.h:1504
ULONG ActiveProcesses
Definition: pstypes.h:1489
KEVENT Event
Definition: pstypes.h:1479
ULONG PeakProcessMemoryUsed
Definition: pstypes.h:1517
ULONG ProcessMemoryLimit
Definition: pstypes.h:1515
ULONGLONG ReadTransferCount
Definition: pstypes.h:1511
ULONG SchedulingClass
Definition: pstypes.h:1507
ULONG TotalPageFaultCount
Definition: pstypes.h:1487
ULONG MinimumWorkingSetSize
Definition: pstypes.h:1494
LIST_ENTRY JobLinks
Definition: pstypes.h:1480
ULONG PeakJobMemoryUsed
Definition: pstypes.h:1518
ULONG TotalTerminatedProcesses
Definition: pstypes.h:1490
ULONG MaximumWorkingSetSize
Definition: pstypes.h:1495
LARGE_INTEGER TotalUserTime
Definition: pstypes.h:1483
ULONGLONG ReadOperationCount
Definition: pstypes.h:1508
LARGE_INTEGER ThisPeriodTotalKernelTime
Definition: pstypes.h:1486
ULONGLONG WriteOperationCount
Definition: pstypes.h:1509
EX_PUSH_LOCK MemoryLimitsLock
Definition: pstypes.h:1525
ULONG JobMemoryLimit
Definition: pstypes.h:1516
ULONGLONG WriteTransferCount
Definition: pstypes.h:1512
ERESOURCE JobLock
Definition: pstypes.h:1482
LIST_ENTRY JobSetLinks
Definition: pstypes.h:1527
LARGE_INTEGER PerProcessUserTimeLimit
Definition: pstypes.h:1491
ULONG SessionId
Definition: pstypes.h:1506
struct _EJOB * Job
Definition: pstypes.h:1303
ULONGLONG ReadOperationCount
Definition: pstypes.h:83
ULONGLONG WriteTransferCount
Definition: pstypes.h:87
ULONGLONG WriteOperationCount
Definition: pstypes.h:84
ULONGLONG ReadTransferCount
Definition: pstypes.h:86
ULONGLONG OtherOperationCount
Definition: pstypes.h:85
ULONGLONG OtherTransferCount
Definition: pstypes.h:88
LARGE_INTEGER PerProcessUserTimeLimit
Definition: pstypes.h:1551
JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation
Definition: pstypes.h:1602
KAPC_STATE ApcState
Definition: ketypes.h:1778
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LARGE_INTEGER TotalUserTime
Definition: ke.h:47
IO_COUNTERS IoInfo
Definition: ke.h:48
LARGE_INTEGER TotalKernelTime
Definition: ke.h:46
uint32_t * PULONG
Definition: typedefs.h:59
#define NTAPI
Definition: typedefs.h:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONGLONG QuadPart
Definition: typedefs.h:114
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:30
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define ExDeleteResource
Definition: exfuncs.h:345
#define ExInitializeResource
Definition: exfuncs.h:346
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
FAST_MUTEX
Definition: extypes.h:17
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
_In_ PEPROCESS _In_ KPROCESSOR_MODE AccessMode
Definition: mmfuncs.h:396
#define ObDereferenceObject
Definition: obfuncs.h:203
#define ObReferenceObject
Definition: obfuncs.h:204
#define PsGetCurrentProcess
Definition: psfuncs.h:17
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
char CHAR
Definition: xmlstorage.h:175