[REACTX] Fix 64 bit issues
[reactos.git] / ntoskrnl / ps / job.c
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 */