xref: /reactos/ntoskrnl/ps/job.c (revision f4d29a74) 
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 
20 POBJECT_TYPE PsJobType = NULL;
21 
22 LIST_ENTRY PsJobListHead;
23 static FAST_MUTEX PsJobListLock;
24 
25 BOOLEAN PspUseJobSchedulingClasses;
26 
27 CHAR PspJobSchedulingClasses[PSP_JOB_SCHEDULING_CLASSES] =
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 
41 GENERIC_MAPPING PspJobMapping =
42 {
43     STANDARD_RIGHTS_READ | JOB_OBJECT_QUERY,
44 
45     STANDARD_RIGHTS_WRITE | JOB_OBJECT_ASSIGN_PROCESS |
46     JOB_OBJECT_SET_ATTRIBUTES | JOB_OBJECT_TERMINATE,
47 
48     STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
49 
50     STANDARD_RIGHTS_ALL | THREAD_ALL_ACCESS // bug fixed only in vista
51 };
52 
53 ULONG PspJobInfoLengths[] =
54 {
55     0x0,
56     sizeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION),
57     sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION),
58     sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST),
59     sizeof(JOBOBJECT_BASIC_UI_RESTRICTIONS),
60     sizeof(JOBOBJECT_SECURITY_LIMIT_INFORMATION),
61     sizeof(JOBOBJECT_END_OF_JOB_TIME_INFORMATION),
62     sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT),
63     sizeof(JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION),
64     sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION),
65     0x4
66 };
67 
68 ULONG PspJobInfoAlign[] =
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 
85 VOID
86 NTAPI
87 PspDeleteJob ( 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     {
94         ObDereferenceObject(Job->CompletionPort);
95     }
96 
97     /* unlink the job object */
98     if(Job->JobLinks.Flink != NULL)
99     {
100         ExAcquireFastMutex(&PsJobListLock);
101         RemoveEntryList(&Job->JobLinks);
102         ExReleaseFastMutex(&PsJobListLock);
103     }
104 
105     ExDeleteResource(&Job->JobLock);
106 }
107 
108 VOID
109 NTAPI
110 INIT_FUNCTION
111 PspInitializeJobStructures(VOID)
112 {
113     InitializeListHead(&PsJobListHead);
114     ExInitializeFastMutex(&PsJobListLock);
115 }
116 
117 NTSTATUS
118 NTAPI
119 PspAssignProcessToJob(PEPROCESS Process,
120     PEJOB Job)
121 {
122     DPRINT("PspAssignProcessToJob() is unimplemented!\n");
123     return STATUS_NOT_IMPLEMENTED;
124 }
125 
126 NTSTATUS
127 NTAPI
128 PspTerminateJobObject(PEJOB Job,
129     KPROCESSOR_MODE AccessMode,
130     NTSTATUS ExitStatus )
131 {
132     DPRINT("PspTerminateJobObject() is unimplemented!\n");
133     return STATUS_NOT_IMPLEMENTED;
134 }
135 
136 VOID
137 NTAPI
138 PspRemoveProcessFromJob(IN PEPROCESS Process,
139                         IN PEJOB Job)
140 {
141     /* FIXME */
142 }
143 
144 VOID
145 NTAPI
146 PspExitProcessFromJob(IN PEJOB Job,
147                       IN PEPROCESS Process)
148 {
149     /* FIXME */
150 }
151 
152 /*
153  * @unimplemented
154  */
155 NTSTATUS
156 NTAPI
157 NtAssignProcessToJobObject (
158     HANDLE JobHandle,
159     HANDLE ProcessHandle)
160 {
161     PEPROCESS Process;
162     KPROCESSOR_MODE PreviousMode;
163     NTSTATUS Status;
164 
165     PAGED_CODE();
166 
167     PreviousMode = ExGetPreviousMode();
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... */
175     Status = ObReferenceObjectByHandle(
176         ProcessHandle,
177         PROCESS_TERMINATE,
178         PsProcessType,
179         PreviousMode,
180         (PVOID*)&Process,
181         NULL);
182     if(NT_SUCCESS(Status))
183     {
184         if(Process->Job == NULL)
185         {
186             PEJOB Job;
187 
188             Status = ObReferenceObjectByHandle(
189                 JobHandle,
190                 JOB_OBJECT_ASSIGN_PROCESS,
191                 PsJobType,
192                 PreviousMode,
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;
209                         ObReferenceObject(Job);
210                     }
211                     else
212                     {
213                         /* process is already assigned to a job or session id differs! */
214                         Status = STATUS_ACCESS_DENIED;
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! */
222                         Status = PspAssignProcessToJob(Process, Job);
223                     }
224                 }
225 
226                 ObDereferenceObject(Job);
227             }
228         }
229         else
230         {
231             /* process is already assigned to a job or session id differs! */
232             Status = STATUS_ACCESS_DENIED;
233         }
234 
235         ObDereferenceObject(Process);
236     }
237 
238     return Status;
239 }
240 
241 NTSTATUS
242 NTAPI
243 NtCreateJobSet(IN ULONG NumJob,
244                IN PJOB_SET_ARRAY UserJobSet,
245                IN ULONG Flags)
246 {
247     UNIMPLEMENTED;
248     return STATUS_NOT_IMPLEMENTED;
249 }
250 
251 /*
252  * @unimplemented
253  */
254 NTSTATUS
255 NTAPI
256 NtCreateJobObject (
257     PHANDLE JobHandle,
258     ACCESS_MASK DesiredAccess,
259     POBJECT_ATTRIBUTES ObjectAttributes )
260 {
261     HANDLE hJob;
262     PEJOB Job;
263     KPROCESSOR_MODE PreviousMode;
264     PEPROCESS CurrentProcess;
265     NTSTATUS Status;
266 
267     PAGED_CODE();
268 
269     PreviousMode = ExGetPreviousMode();
270     CurrentProcess = PsGetCurrentProcess();
271 
272     /* check for valid buffers */
273     if (PreviousMode != KernelMode)
274     {
275         _SEH2_TRY
276         {
277             ProbeForWriteHandle(JobHandle);
278         }
279         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
280         {
281             _SEH2_YIELD(return _SEH2_GetExceptionCode());
282         }
283         _SEH2_END;
284     }
285 
286     Status = ObCreateObject(PreviousMode,
287         PsJobType,
288         ObjectAttributes,
289         PreviousMode,
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! */
306         InitializeListHead(&Job->JobSetLinks);
307         InitializeListHead(&Job->ProcessListHead);
308 
309         /* inherit the session id from the caller */
310         Job->SessionId = PsGetProcessSessionId(CurrentProcess);
311 
312         KeInitializeGuardedMutex(&Job->MemoryLimitsLock);
313 
314         Status = ExInitializeResource(&Job->JobLock);
315         if(!NT_SUCCESS(Status))
316         {
317             DPRINT1("Failed to initialize job lock!!!\n");
318             ObDereferenceObject(Job);
319             return Status;
320         }
321         KeInitializeEvent(&Job->Event, NotificationEvent, FALSE);
322 
323         /* link the object into the global job list */
324         ExAcquireFastMutex(&PsJobListLock);
325         InsertTailList(&PsJobListHead, &Job->JobLinks);
326         ExReleaseFastMutex(&PsJobListLock);
327 
328         Status = ObInsertObject(Job,
329             NULL,
330             DesiredAccess,
331             0,
332             NULL,
333             &hJob);
334         if(NT_SUCCESS(Status))
335         {
336             /* pass the handle back to the caller */
337             _SEH2_TRY
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             }
344             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
345             {
346                 Status = _SEH2_GetExceptionCode();
347             }
348             _SEH2_END;
349         }
350     }
351 
352     return Status;
353 }
354 
355 
356 /*
357  * @implemented
358  */
359 NTSTATUS
360 NTAPI
361 NtIsProcessInJob (
362     IN HANDLE ProcessHandle,
363     IN HANDLE JobHandle OPTIONAL )
364 {
365     KPROCESSOR_MODE PreviousMode;
366     PEPROCESS Process;
367     NTSTATUS Status;
368 
369     PreviousMode = ExGetPreviousMode();
370 
371     PAGED_CODE();
372 
373     Status = ObReferenceObjectByHandle(
374         ProcessHandle,
375         PROCESS_QUERY_INFORMATION,
376         PsProcessType,
377         PreviousMode,
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 */
392                 Status = STATUS_PROCESS_IN_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 */
399                 Status = ObReferenceObjectByHandle(JobHandle,
400                     JOB_OBJECT_QUERY,
401                     PsJobType,
402                     PreviousMode,
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 */
415             Status = STATUS_PROCESS_NOT_IN_JOB;
416         }
417         ObDereferenceObject(Process);
418     }
419 
420     return Status;
421 }
422 
423 
424 /*
425  * @implemented
426  */
427 NTSTATUS
428 NTAPI
429 NtOpenJobObject (
430     PHANDLE JobHandle,
431     ACCESS_MASK DesiredAccess,
432     POBJECT_ATTRIBUTES ObjectAttributes)
433 {
434     KPROCESSOR_MODE PreviousMode;
435     HANDLE hJob;
436     NTSTATUS Status;
437 
438     PAGED_CODE();
439 
440     PreviousMode = ExGetPreviousMode();
441 
442     /* check for valid buffers */
443     if (PreviousMode != KernelMode)
444     {
445         _SEH2_TRY
446         {
447             ProbeForWriteHandle(JobHandle);
448         }
449         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
450         {
451             _SEH2_YIELD(return _SEH2_GetExceptionCode());
452         }
453         _SEH2_END;
454     }
455 
456     Status = ObOpenObjectByName(ObjectAttributes,
457         PsJobType,
458         PreviousMode,
459         NULL,
460         DesiredAccess,
461         NULL,
462         &hJob);
463     if(NT_SUCCESS(Status))
464     {
465         _SEH2_TRY
466         {
467             *JobHandle = hJob;
468         }
469         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
470         {
471             Status = _SEH2_GetExceptionCode();
472         }
473         _SEH2_END;
474     }
475 
476     return Status;
477 }
478 
479 
480 /*
481  * @implemented
482  */
483 NTSTATUS
484 NTAPI
485 NtQueryInformationJobObject (
486     HANDLE JobHandle,
487     JOBOBJECTINFOCLASS JobInformationClass,
488     PVOID JobInformation,
489     ULONG JobInformationLength,
490     PULONG ReturnLength )
491 {
492     PEJOB Job;
493     NTSTATUS Status;
494     BOOLEAN NoOutput;
495     PVOID GenericCopy;
496     PLIST_ENTRY NextEntry;
497     PKTHREAD CurrentThread;
498     KPROCESSOR_MODE PreviousMode;
499     JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimit;
500     JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION BasicAndIo;
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     {
510         return STATUS_INVALID_INFO_CLASS;
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         {
528             return STATUS_INFO_LENGTH_MISMATCH;
529         }
530 
531         /* Set what we need to copy out */
532         SizeToCopy = JobInformationLength;
533     }
534 
535     PreviousMode = ExGetPreviousMode();
536     /* If not comming from umode, we need to probe buffers */
537     if (PreviousMode != KernelMode)
538     {
539         ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
540 
541         _SEH2_TRY
542         {
543             /* Probe out buffer for write */
544             if (JobInformation != NULL)
545             {
546                 ProbeForWrite(JobInformation, JobInformationLength, RequiredAlign);
547             }
548 
549             /* But also return lenght if asked */
550             if (ReturnLength != NULL)
551             {
552                 ProbeForWrite(JobInformation, sizeof(ULONG), sizeof(ULONG));
553             }
554         }
555         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
556         {
557             _SEH2_YIELD(return _SEH2_GetExceptionCode());
558         }
559         _SEH2_END;
560     }
561 
562     /* If a job handle was provided, use it */
563     if (JobHandle != NULL)
564     {
565         Status = ObReferenceObjectByHandle(JobHandle,
566                                            JOB_OBJECT_QUERY,
567                                            PsJobType,
568                                            PreviousMode,
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         {
585             return STATUS_ACCESS_DENIED;
586         }
587 
588         ObReferenceObject(Job);
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 */
597         case JobObjectBasicAccountingInformation:
598         case JobObjectBasicAndIoAccountingInformation:
599             /* Zero basics */
600             RtlZeroMemory(&BasicAndIo.BasicInfo, sizeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION));
601 
602             /* Lock */
603             KeEnterGuardedRegionThread(CurrentThread);
604             ExAcquireResourceSharedLite(&Job->JobLock, TRUE);
605 
606             /* Initialize with job counters */
607             BasicAndIo.BasicInfo.TotalUserTime.QuadPart = Job->TotalUserTime.QuadPart;
608             BasicAndIo.BasicInfo.TotalKernelTime.QuadPart = Job->TotalKernelTime.QuadPart;
609             BasicAndIo.BasicInfo.ThisPeriodTotalUserTime.QuadPart = Job->ThisPeriodTotalUserTime.QuadPart;
610             BasicAndIo.BasicInfo.ThisPeriodTotalKernelTime.QuadPart = Job->ThisPeriodTotalKernelTime.QuadPart;
611             BasicAndIo.BasicInfo.TotalPageFaultCount = Job->TotalPageFaultCount;
612             BasicAndIo.BasicInfo.TotalProcesses = Job->TotalProcesses;
613             BasicAndIo.BasicInfo.ActiveProcesses = Job->ActiveProcesses;
614             BasicAndIo.BasicInfo.TotalTerminatedProcesses = Job->TotalTerminatedProcesses;
615 
616             /* We also set IoInfo, even though we might not return it */
617             BasicAndIo.IoInfo.ReadOperationCount = Job->ReadOperationCount;
618             BasicAndIo.IoInfo.WriteOperationCount = Job->WriteOperationCount;
619             BasicAndIo.IoInfo.OtherOperationCount = Job->OtherOperationCount;
620             BasicAndIo.IoInfo.ReadTransferCount = Job->ReadTransferCount;
621             BasicAndIo.IoInfo.WriteTransferCount = Job->WriteTransferCount;
622             BasicAndIo.IoInfo.OtherTransferCount = Job->OtherTransferCount;
623 
624             /* For every process, sum its counters */
625             for (NextEntry = Job->ProcessListHead.Flink;
626                  NextEntry != &Job->ProcessListHead;
627                  NextEntry = NextEntry->Flink)
628             {
629                 PEPROCESS Process;
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);
637                     BasicAndIo.BasicInfo.TotalUserTime.QuadPart += Values.TotalUserTime.QuadPart;
638                     BasicAndIo.BasicInfo.TotalKernelTime.QuadPart += Values.TotalKernelTime.QuadPart;
639                     BasicAndIo.IoInfo.ReadOperationCount += Values.IoInfo.ReadOperationCount;
640                     BasicAndIo.IoInfo.WriteOperationCount += Values.IoInfo.WriteOperationCount;
641                     BasicAndIo.IoInfo.OtherOperationCount += Values.IoInfo.OtherOperationCount;
642                     BasicAndIo.IoInfo.ReadTransferCount += Values.IoInfo.ReadTransferCount;
643                     BasicAndIo.IoInfo.WriteTransferCount += Values.IoInfo.WriteTransferCount;
644                     BasicAndIo.IoInfo.OtherTransferCount += Values.IoInfo.OtherTransferCount;
645                 }
646             }
647 
648             /* And done */
649             ExReleaseResourceLite(&Job->JobLock);
650             KeLeaveGuardedRegionThread(CurrentThread);
651 
652             /* We'll copy back the buffer */
653             GenericCopy = &BasicAndIo;
654             Status = STATUS_SUCCESS;
655 
656             break;
657 
658         /* Limits information */
659         case JobObjectBasicLimitInformation:
660         case JobObjectExtendedLimitInformation:
661             /* Lock */
662             KeEnterGuardedRegionThread(CurrentThread);
663             ExAcquireResourceSharedLite(&Job->JobLock, TRUE);
664 
665             /* Copy basic information */
666             ExtendedLimit.BasicLimitInformation.LimitFlags = Job->LimitFlags;
667             ExtendedLimit.BasicLimitInformation.MinimumWorkingSetSize = Job->MinimumWorkingSetSize;
668             ExtendedLimit.BasicLimitInformation.MaximumWorkingSetSize = Job->MaximumWorkingSetSize;
669             ExtendedLimit.BasicLimitInformation.ActiveProcessLimit = Job->ActiveProcessLimit;
670             ExtendedLimit.BasicLimitInformation.PriorityClass = Job->PriorityClass;
671             ExtendedLimit.BasicLimitInformation.SchedulingClass = Job->SchedulingClass;
672             ExtendedLimit.BasicLimitInformation.Affinity = Job->Affinity;
673             ExtendedLimit.BasicLimitInformation.PerProcessUserTimeLimit.QuadPart = Job->PerProcessUserTimeLimit.QuadPart;
674             ExtendedLimit.BasicLimitInformation.PerJobUserTimeLimit.QuadPart = Job->PerJobUserTimeLimit.QuadPart;
675 
676             /* If asking for extending limits */
677             if (JobInformationClass == JobObjectExtendedLimitInformation)
678             {
679                 /* Lock our memory lock */
680                 KeAcquireGuardedMutexUnsafe(&Job->MemoryLimitsLock);
681                 /* Return limits */
682                 ExtendedLimit.ProcessMemoryLimit = Job->ProcessMemoryLimit << PAGE_SHIFT;
683                 ExtendedLimit.JobMemoryLimit = Job->JobMemoryLimit << PAGE_SHIFT;
684                 ExtendedLimit.PeakProcessMemoryUsed = Job->PeakProcessMemoryUsed << PAGE_SHIFT;
685                 ExtendedLimit.PeakJobMemoryUsed = Job->PeakJobMemoryUsed << PAGE_SHIFT;
686                 KeReleaseGuardedMutexUnsafe(&Job->MemoryLimitsLock);
687 
688                 /* And done */
689                 ExReleaseResourceLite(&Job->JobLock);
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 */
700                 ExReleaseResourceLite(&Job->JobLock);
701                 KeLeaveGuardedRegionThread(CurrentThread);
702             }
703 
704             /* We'll copy back the buffer */
705             GenericCopy = &ExtendedLimit;
706             Status = STATUS_SUCCESS;
707 
708             break;
709 
710         default:
711             DPRINT1("Class %d not implemented\n", JobInformationClass);
712             Status = STATUS_NOT_IMPLEMENTED;
713             break;
714     }
715 
716     /* Job is no longer required */
717     ObDereferenceObject(Job);
718 
719     /* If we succeeed, copy back data */
720     if (NT_SUCCESS(Status))
721     {
722         _SEH2_TRY
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         }
736         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
737         {
738             _SEH2_YIELD(return _SEH2_GetExceptionCode());
739         }
740         _SEH2_END;
741     }
742 
743     return Status;
744 }
745 
746 
747 /*
748  * @unimplemented
749  */
750 NTSTATUS
751 NTAPI
752 NtSetInformationJobObject (
753     HANDLE JobHandle,
754     JOBOBJECTINFOCLASS JobInformationClass,
755     PVOID JobInformation,
756     ULONG JobInformationLength)
757 {
758     PEJOB Job;
759     NTSTATUS Status;
760     PKTHREAD CurrentThread;
761     ACCESS_MASK DesiredAccess;
762     KPROCESSOR_MODE PreviousMode;
763     ULONG RequiredLength, RequiredAlign;
764 
765     PAGED_CODE();
766 
767     CurrentThread  = KeGetCurrentThread();
768 
769     /* Validate class */
770     if (JobInformationClass > JobObjectJobSetInformation || JobInformationClass < JobObjectBasicAccountingInformation)
771     {
772         return STATUS_INVALID_INFO_CLASS;
773     }
774 
775     /* Get associated lengths & alignments */
776     RequiredLength = PspJobInfoLengths[JobInformationClass];
777     RequiredAlign = PspJobInfoAlign[JobInformationClass];
778 
779     PreviousMode = ExGetPreviousMode();
780     /* If not comming from umode, we need to probe buffers */
781     if (PreviousMode != KernelMode)
782     {
783         ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
784 
785         _SEH2_TRY
786         {
787             /* Probe out buffer for read */
788             if (JobInformationLength != 0)
789             {
790                 ProbeForRead(JobInformation, JobInformationLength, RequiredAlign);
791             }
792         }
793         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
794         {
795             _SEH2_YIELD(return _SEH2_GetExceptionCode());
796         }
797         _SEH2_END;
798     }
799 
800     /* Validate input size */
801     if (JobInformationLength != RequiredLength)
802     {
803         return STATUS_INFO_LENGTH_MISMATCH;
804     }
805 
806     /* Open the given job */
807     DesiredAccess = JOB_OBJECT_SET_ATTRIBUTES;
808     if (JobInformationClass == JobObjectSecurityLimitInformation)
809     {
810         DesiredAccess |= JOB_OBJECT_SET_SECURITY_ATTRIBUTES;
811     }
812     Status = ObReferenceObjectByHandle(JobHandle,
813                                        DesiredAccess,
814                                        PsJobType,
815                                        PreviousMode,
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     {
827         case JobObjectExtendedLimitInformation:
828             DPRINT1("Class JobObjectExtendedLimitInformation not implemented\n");
829             Status = STATUS_SUCCESS;
830             break;
831 
832         default:
833             DPRINT1("Class %d not implemented\n", JobInformationClass);
834             Status = STATUS_NOT_IMPLEMENTED;
835             break;
836     }
837     KeLeaveGuardedRegionThread(CurrentThread);
838 
839     ObfDereferenceObject(Job);
840 
841     return Status;
842 }
843 
844 
845 /*
846  * @unimplemented
847  */
848 NTSTATUS
849 NTAPI
850 NtTerminateJobObject (
851     HANDLE JobHandle,
852     NTSTATUS ExitStatus )
853 {
854     KPROCESSOR_MODE PreviousMode;
855     PEJOB Job;
856     NTSTATUS Status;
857 
858     PAGED_CODE();
859 
860     PreviousMode = ExGetPreviousMode();
861 
862     Status = ObReferenceObjectByHandle(
863         JobHandle,
864         JOB_OBJECT_TERMINATE,
865         PsJobType,
866         PreviousMode,
867         (PVOID*)&Job,
868         NULL);
869     if(NT_SUCCESS(Status))
870     {
871         Status = PspTerminateJobObject(
872             Job,
873             PreviousMode,
874             ExitStatus);
875         ObDereferenceObject(Job);
876     }
877 
878     return Status;
879 }
880 
881 
882 /*
883  * @implemented
884  */
885 PVOID
886 NTAPI
887 PsGetJobLock ( PEJOB Job )
888 {
889     ASSERT(Job);
890     return (PVOID)&Job->JobLock;
891 }
892 
893 
894 /*
895  * @implemented
896  */
897 ULONG
898 NTAPI
899 PsGetJobSessionId ( PEJOB Job )
900 {
901     ASSERT(Job);
902     return Job->SessionId;
903 }
904 
905 
906 /*
907  * @implemented
908  */
909 ULONG
910 NTAPI
911 PsGetJobUIRestrictionsClass ( PEJOB Job )
912 {
913     ASSERT(Job);
914     return Job->UIRestrictionsClass;
915 }
916 
917 
918 /*
919  * @unimplemented
920  */
921 VOID
922 NTAPI
923 PsSetJobUIRestrictionsClass(PEJOB Job,
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 */
932