job.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for job.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	PspDeleteJob (PVOID ObjectBody)
VOID NTAPI	PspInitializeJobStructures (VOID)
NTSTATUS NTAPI	PspAssignProcessToJob (PEPROCESS Process, PEJOB Job)
NTSTATUS NTAPI	PspTerminateJobObject (PEJOB Job, KPROCESSOR_MODE AccessMode, NTSTATUS ExitStatus)
VOID NTAPI	PspRemoveProcessFromJob (IN PEPROCESS Process, IN PEJOB Job)
VOID NTAPI	PspExitProcessFromJob (IN PEJOB Job, IN PEPROCESS Process)
NTSTATUS NTAPI	NtAssignProcessToJobObject (HANDLE JobHandle, HANDLE ProcessHandle)
NTSTATUS NTAPI	NtCreateJobSet (IN ULONG NumJob, IN PJOB_SET_ARRAY UserJobSet, IN ULONG Flags)
NTSTATUS NTAPI	NtCreateJobObject (PHANDLE JobHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes)
NTSTATUS NTAPI	NtIsProcessInJob (IN HANDLE ProcessHandle, IN HANDLE JobHandle OPTIONAL)
NTSTATUS NTAPI	NtOpenJobObject (PHANDLE JobHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes)
NTSTATUS NTAPI	NtQueryInformationJobObject (HANDLE JobHandle, JOBOBJECTINFOCLASS JobInformationClass, PVOID JobInformation, ULONG JobInformationLength, PULONG ReturnLength)
NTSTATUS NTAPI	NtSetInformationJobObject (HANDLE JobHandle, JOBOBJECTINFOCLASS JobInformationClass, PVOID JobInformation, ULONG JobInformationLength)
NTSTATUS NTAPI	NtTerminateJobObject (HANDLE JobHandle, NTSTATUS ExitStatus)
PVOID NTAPI	PsGetJobLock (PEJOB Job)
ULONG NTAPI	PsGetJobSessionId (PEJOB Job)
ULONG NTAPI	PsGetJobUIRestrictionsClass (PEJOB Job)
VOID NTAPI	PsSetJobUIRestrictionsClass (PEJOB Job, ULONG UIRestrictionsClass)

Variables
POBJECT_TYPE	PsJobType = NULL
LIST_ENTRY	PsJobListHead
static FAST_MUTEX	PsJobListLock
BOOLEAN	PspUseJobSchedulingClasses
CHAR	PspJobSchedulingClasses [PSP_JOB_SCHEDULING_CLASSES]
GENERIC_MAPPING	PspJobMapping
ULONG	PspJobInfoLengths []
ULONG	PspJobInfoAlign []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file job.c.

Function Documentation

NtAssignProcessToJobObject()

NTSTATUS NTAPI NtAssignProcessToJobObject	(	HANDLE	JobHandle,
		HANDLE	ProcessHandle
	)

Definition at line 157 of file job.c.

{
    PEPROCESS Process;
    KPROCESSOR_MODE PreviousMode;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    PreviousMode = ExGetPreviousMode();
 
    /* make sure we're having a handle with enough rights, especially the to
    terminate the process. otherwise one could abuse the job objects to
    terminate processes without having rights granted to do so! The reason
    I open the process handle before the job handle is that a simple test showed
    that it first complains about a invalid process handle! The other way around
    would be simpler though... */
    Status = ObReferenceObjectByHandle(
        ProcessHandle,
        PROCESS_TERMINATE,
        PsProcessType,
        PreviousMode,
        (PVOID*)&Process,
        NULL);
    if(NT_SUCCESS(Status))
    {
        if(Process->Job == NULL)
        {
            PEJOB Job;
 
            Status = ObReferenceObjectByHandle(
                JobHandle,
                JOB_OBJECT_ASSIGN_PROCESS,
                PsJobType,
                PreviousMode,
                (PVOID*)&Job,
                NULL);
            if(NT_SUCCESS(Status))
            {
                /* lock the process so we can safely assign the process. Note that in the
                meanwhile another thread could have assigned this process to a job! */
 
                if(ExAcquireRundownProtection(&Process->RundownProtect))
                {
                    if(Process->Job == NULL && PsGetProcessSessionId(Process) == Job->SessionId)
                    {
                        /* Just store the pointer to the job object in the process, we'll
                        assign it later. The reason we can't do this here is that locking
                        the job object might require it to wait, which is a bad thing
                        while holding the process lock! */
                        Process->Job = Job;
                        ObReferenceObject(Job);
                    }
                    else
                    {
                        /* process is already assigned to a job or session id differs! */
                        Status = STATUS_ACCESS_DENIED;
                    }
                    ExReleaseRundownProtection(&Process->RundownProtect);
 
                    if(NT_SUCCESS(Status))
                    {
                        /* let's actually assign the process to the job as we're not holding
                        the process lock anymore! */
                        Status = PspAssignProcessToJob(Process, Job);
                    }
                }
 
                ObDereferenceObject(Job);
            }
        }
        else
        {
            /* process is already assigned to a job or session id differs! */
            Status = STATUS_ACCESS_DENIED;
        }
 
        ObDereferenceObject(Process);
    }
 
    return Status;
}

Referenced by AssignProcessToJobObject(), and CreateProcessInternalW().

NtCreateJobObject()

NTSTATUS NTAPI NtCreateJobObject	(	PHANDLE	JobHandle,
		ACCESS_MASK	DesiredAccess,
		POBJECT_ATTRIBUTES	ObjectAttributes
	)

Definition at line 256 of file job.c.

{
    HANDLE hJob;
    PEJOB Job;
    KPROCESSOR_MODE PreviousMode;
    PEPROCESS CurrentProcess;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    PreviousMode = ExGetPreviousMode();
    CurrentProcess = PsGetCurrentProcess();
 
    /* check for valid buffers */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            ProbeForWriteHandle(JobHandle);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    Status = ObCreateObject(PreviousMode,
        PsJobType,
        ObjectAttributes,
        PreviousMode,
        NULL,
        sizeof(EJOB),
        0,
        0,
        (PVOID*)&Job);
 
    if(NT_SUCCESS(Status))
    {
        /* FIXME - Zero all fields as we don't yet implement all of them */
        RtlZeroMemory(Job, sizeof(EJOB));
 
        /* make sure that early destruction doesn't attempt to remove the object from
        the list before it even gets added! */
        Job->JobLinks.Flink = NULL;
 
        /* setup the job object - FIXME: More to do! */
        InitializeListHead(&Job->JobSetLinks);
        InitializeListHead(&Job->ProcessListHead);
 
        /* inherit the session id from the caller */
        Job->SessionId = PsGetProcessSessionId(CurrentProcess);
 
        KeInitializeGuardedMutex(&Job->MemoryLimitsLock);
 
        Status = ExInitializeResource(&Job->JobLock);
        if(!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to initialize job lock!!!\n");
            ObDereferenceObject(Job);
            return Status;
        }
        KeInitializeEvent(&Job->Event, NotificationEvent, FALSE);
 
        /* link the object into the global job list */
        ExAcquireFastMutex(&PsJobListLock);
        InsertTailList(&PsJobListHead, &Job->JobLinks);
        ExReleaseFastMutex(&PsJobListLock);
 
        Status = ObInsertObject(Job,
            NULL,
            DesiredAccess,
            0,
            NULL,
            &hJob);
        if(NT_SUCCESS(Status))
        {
            /* pass the handle back to the caller */
            _SEH2_TRY
            {
                /* NOTE: if the caller passed invalid buffers to receive the handle it's his
                own fault! the object will still be created and live... It's possible
                to find the handle using ObFindHandleForObject()! */
                *JobHandle = hJob;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                Status = _SEH2_GetExceptionCode();
            }
            _SEH2_END;
        }
    }
 
    return Status;
}

NtCreateJobSet()

NTSTATUS NTAPI NtCreateJobSet	(	IN ULONG	NumJob,
		IN PJOB_SET_ARRAY	UserJobSet,
		IN ULONG	Flags
	)

Definition at line 243 of file job.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CreateJobSet().

NtIsProcessInJob()

NTSTATUS NTAPI NtIsProcessInJob	(	IN HANDLE	ProcessHandle,
		IN HANDLE JobHandle	OPTIONAL
	)

Definition at line 361 of file job.c.

{
    KPROCESSOR_MODE PreviousMode;
    PEPROCESS Process;
    NTSTATUS Status;
 
    PreviousMode = ExGetPreviousMode();
 
    PAGED_CODE();
 
    Status = ObReferenceObjectByHandle(
        ProcessHandle,
        PROCESS_QUERY_INFORMATION,
        PsProcessType,
        PreviousMode,
        (PVOID*)&Process,
        NULL);
    if(NT_SUCCESS(Status))
    {
        /* FIXME - make sure the job object doesn't get exchanged or deleted while trying to
        reference it, e.g. by locking it somehow until it is referenced... */
 
        PEJOB ProcessJob = Process->Job;
 
        if(ProcessJob != NULL)
        {
            if(JobHandle == NULL)
            {
                /* the process is assigned to a job */
                Status = STATUS_PROCESS_IN_JOB;
            }
            else /* JobHandle != NULL */
            {
                PEJOB JobObject;
 
                /* get the job object and compare the object pointer with the one assigned to the process */
                Status = ObReferenceObjectByHandle(JobHandle,
                    JOB_OBJECT_QUERY,
                    PsJobType,
                    PreviousMode,
                    (PVOID*)&JobObject,
                    NULL);
                if(NT_SUCCESS(Status))
                {
                    Status = ((ProcessJob == JobObject) ? STATUS_PROCESS_IN_JOB : STATUS_PROCESS_NOT_IN_JOB);
                    ObDereferenceObject(JobObject);
                }
            }
        }
        else
        {
            /* the process is not assigned to any job */
            Status = STATUS_PROCESS_NOT_IN_JOB;
        }
        ObDereferenceObject(Process);
    }
 
    return Status;
}

Referenced by CreateProcessInternalW(), and IsProcessInJob().

NtOpenJobObject()

NTSTATUS NTAPI NtOpenJobObject	(	PHANDLE	JobHandle,
		ACCESS_MASK	DesiredAccess,
		POBJECT_ATTRIBUTES	ObjectAttributes
	)

Definition at line 429 of file job.c.

{
    KPROCESSOR_MODE PreviousMode;
    HANDLE hJob;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    PreviousMode = ExGetPreviousMode();
 
    /* check for valid buffers */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            ProbeForWriteHandle(JobHandle);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    Status = ObOpenObjectByName(ObjectAttributes,
        PsJobType,
        PreviousMode,
        NULL,
        DesiredAccess,
        NULL,
        &hJob);
    if(NT_SUCCESS(Status))
    {
        _SEH2_TRY
        {
            *JobHandle = hJob;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    return Status;
}

NtQueryInformationJobObject()

NTSTATUS NTAPI NtQueryInformationJobObject	(	HANDLE	JobHandle,
		JOBOBJECTINFOCLASS	JobInformationClass,
		PVOID	JobInformation,
		ULONG	JobInformationLength,
		PULONG	ReturnLength
	)

Definition at line 485 of file job.c.

{
    PEJOB Job;
    NTSTATUS Status;
    BOOLEAN NoOutput;
    PVOID GenericCopy;
    PLIST_ENTRY NextEntry;
    PKTHREAD CurrentThread;
    KPROCESSOR_MODE PreviousMode;
    JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimit;
    JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION BasicAndIo;
    ULONG RequiredLength, RequiredAlign, SizeToCopy, NeededSize;
 
    PAGED_CODE();
 
    CurrentThread  = KeGetCurrentThread();
 
    /* Validate class */
    if (JobInformationClass > JobObjectJobSetInformation || JobInformationClass < JobObjectBasicAccountingInformation)
    {
        return STATUS_INVALID_INFO_CLASS;
    }
 
    /* Get associated lengths & alignments */
    RequiredLength = PspJobInfoLengths[JobInformationClass];
    RequiredAlign = PspJobInfoAlign[JobInformationClass];
    SizeToCopy = RequiredLength;
    NeededSize = RequiredLength;
 
    /* If length mismatch (needed versus provided) */
    if (JobInformationLength != RequiredLength)
    {
        /* This can only be accepted if: JobObjectBasicProcessIdList or JobObjectSecurityLimitInformation
         * Or if size is bigger than needed
         */
        if ((JobInformationClass != JobObjectBasicProcessIdList && JobInformationClass != JobObjectSecurityLimitInformation) ||
            JobInformationLength < RequiredLength)
        {
            return STATUS_INFO_LENGTH_MISMATCH;
        }
 
        /* Set what we need to copy out */
        SizeToCopy = JobInformationLength;
    }
 
    PreviousMode = ExGetPreviousMode();
    /* If not comming from umode, we need to probe buffers */
    if (PreviousMode != KernelMode)
    {
        ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
 
        _SEH2_TRY
        {
            /* Probe out buffer for write */
            if (JobInformation != NULL)
            {
                ProbeForWrite(JobInformation, JobInformationLength, RequiredAlign);
            }
 
            /* But also return length if asked */
            if (ReturnLength != NULL)
            {
                ProbeForWriteUlong(ReturnLength);
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* If a job handle was provided, use it */
    if (JobHandle != NULL)
    {
        Status = ObReferenceObjectByHandle(JobHandle,
                                           JOB_OBJECT_QUERY,
                                           PsJobType,
                                           PreviousMode,
                                           (PVOID*)&Job,
                                           NULL);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
    /* Otherwise, get our current process' job, if any */
    else
    {
        PEPROCESS CurrentProcess;
 
        CurrentProcess = (PEPROCESS)CurrentThread->ApcState.Process;
        Job = CurrentProcess->Job;
        if (Job == NULL)
        {
            return STATUS_ACCESS_DENIED;
        }
 
        ObReferenceObject(Job);
    }
 
    /* By default, assume we'll have to copy data */
    NoOutput = FALSE;
    /* Select class */
    switch (JobInformationClass)
    {
        /* Basic counters */
        case JobObjectBasicAccountingInformation:
        case JobObjectBasicAndIoAccountingInformation:
            /* Zero basics */
            RtlZeroMemory(&BasicAndIo.BasicInfo, sizeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION));
 
            /* Lock */
            KeEnterGuardedRegionThread(CurrentThread);
            ExAcquireResourceSharedLite(&Job->JobLock, TRUE);
 
            /* Initialize with job counters */
            BasicAndIo.BasicInfo.TotalUserTime.QuadPart = Job->TotalUserTime.QuadPart;
            BasicAndIo.BasicInfo.TotalKernelTime.QuadPart = Job->TotalKernelTime.QuadPart;
            BasicAndIo.BasicInfo.ThisPeriodTotalUserTime.QuadPart = Job->ThisPeriodTotalUserTime.QuadPart;
            BasicAndIo.BasicInfo.ThisPeriodTotalKernelTime.QuadPart = Job->ThisPeriodTotalKernelTime.QuadPart;
            BasicAndIo.BasicInfo.TotalPageFaultCount = Job->TotalPageFaultCount;
            BasicAndIo.BasicInfo.TotalProcesses = Job->TotalProcesses;
            BasicAndIo.BasicInfo.ActiveProcesses = Job->ActiveProcesses;
            BasicAndIo.BasicInfo.TotalTerminatedProcesses = Job->TotalTerminatedProcesses;
 
            /* We also set IoInfo, even though we might not return it */
            BasicAndIo.IoInfo.ReadOperationCount = Job->ReadOperationCount;
            BasicAndIo.IoInfo.WriteOperationCount = Job->WriteOperationCount;
            BasicAndIo.IoInfo.OtherOperationCount = Job->OtherOperationCount;
            BasicAndIo.IoInfo.ReadTransferCount = Job->ReadTransferCount;
            BasicAndIo.IoInfo.WriteTransferCount = Job->WriteTransferCount;
            BasicAndIo.IoInfo.OtherTransferCount = Job->OtherTransferCount;
 
            /* For every process, sum its counters */
            for (NextEntry = Job->ProcessListHead.Flink;
                 NextEntry != &Job->ProcessListHead;
                 NextEntry = NextEntry->Flink)
            {
                PEPROCESS Process;
 
                Process = CONTAINING_RECORD(NextEntry, EPROCESS, JobLinks);
                if (!BooleanFlagOn(Process->JobStatus, 2))
                {
                    PROCESS_VALUES Values;
 
                    KeQueryValuesProcess(&Process->Pcb, &Values);
                    BasicAndIo.BasicInfo.TotalUserTime.QuadPart += Values.TotalUserTime.QuadPart;
                    BasicAndIo.BasicInfo.TotalKernelTime.QuadPart += Values.TotalKernelTime.QuadPart;
                    BasicAndIo.IoInfo.ReadOperationCount += Values.IoInfo.ReadOperationCount;
                    BasicAndIo.IoInfo.WriteOperationCount += Values.IoInfo.WriteOperationCount;
                    BasicAndIo.IoInfo.OtherOperationCount += Values.IoInfo.OtherOperationCount;
                    BasicAndIo.IoInfo.ReadTransferCount += Values.IoInfo.ReadTransferCount;
                    BasicAndIo.IoInfo.WriteTransferCount += Values.IoInfo.WriteTransferCount;
                    BasicAndIo.IoInfo.OtherTransferCount += Values.IoInfo.OtherTransferCount;
                }
            }
 
            /* And done */
            ExReleaseResourceLite(&Job->JobLock);
            KeLeaveGuardedRegionThread(CurrentThread);
 
            /* We'll copy back the buffer */
            GenericCopy = &BasicAndIo;
            Status = STATUS_SUCCESS;
 
            break;
 
        /* Limits information */
        case JobObjectBasicLimitInformation:
        case JobObjectExtendedLimitInformation:
            /* Lock */
            KeEnterGuardedRegionThread(CurrentThread);
            ExAcquireResourceSharedLite(&Job->JobLock, TRUE);
 
            /* Copy basic information */
            ExtendedLimit.BasicLimitInformation.LimitFlags = Job->LimitFlags;
            ExtendedLimit.BasicLimitInformation.MinimumWorkingSetSize = Job->MinimumWorkingSetSize;
            ExtendedLimit.BasicLimitInformation.MaximumWorkingSetSize = Job->MaximumWorkingSetSize;
            ExtendedLimit.BasicLimitInformation.ActiveProcessLimit = Job->ActiveProcessLimit;
            ExtendedLimit.BasicLimitInformation.PriorityClass = Job->PriorityClass;
            ExtendedLimit.BasicLimitInformation.SchedulingClass = Job->SchedulingClass;
            ExtendedLimit.BasicLimitInformation.Affinity = Job->Affinity;
            ExtendedLimit.BasicLimitInformation.PerProcessUserTimeLimit.QuadPart = Job->PerProcessUserTimeLimit.QuadPart;
            ExtendedLimit.BasicLimitInformation.PerJobUserTimeLimit.QuadPart = Job->PerJobUserTimeLimit.QuadPart;
 
            /* If asking for extending limits */
            if (JobInformationClass == JobObjectExtendedLimitInformation)
            {
                /* Lock our memory lock */
                KeAcquireGuardedMutexUnsafe(&Job->MemoryLimitsLock);
                /* Return limits */
                ExtendedLimit.ProcessMemoryLimit = Job->ProcessMemoryLimit << PAGE_SHIFT;
                ExtendedLimit.JobMemoryLimit = Job->JobMemoryLimit << PAGE_SHIFT;
                ExtendedLimit.PeakProcessMemoryUsed = Job->PeakProcessMemoryUsed << PAGE_SHIFT;
                ExtendedLimit.PeakJobMemoryUsed = Job->PeakJobMemoryUsed << PAGE_SHIFT;
                KeReleaseGuardedMutexUnsafe(&Job->MemoryLimitsLock);
 
                /* And done */
                ExReleaseResourceLite(&Job->JobLock);
                KeLeaveGuardedRegionThread(CurrentThread);
 
                /* We'll never return IoInfo, so zero it out to avoid
                 * kernel memory leak
                 */
                RtlZeroMemory(&ExtendedLimit.IoInfo, sizeof(IO_COUNTERS));
            }
            else
            {
                /* And done */
                ExReleaseResourceLite(&Job->JobLock);
                KeLeaveGuardedRegionThread(CurrentThread);
            }
 
            /* We'll copy back the buffer */
            GenericCopy = &ExtendedLimit;
            Status = STATUS_SUCCESS;
 
            break;
 
        default:
            DPRINT1("Class %d not implemented\n", JobInformationClass);
            Status = STATUS_NOT_IMPLEMENTED;
            break;
    }
 
    /* Job is no longer required */
    ObDereferenceObject(Job);
 
    /* If we succeeed, copy back data */
    if (NT_SUCCESS(Status))
    {
        _SEH2_TRY
        {
            /* If we have anything to copy, do it */
            if (!NoOutput)
            {
                RtlCopyMemory(JobInformation, GenericCopy, SizeToCopy);
            }
 
            /* And return length if asked */
            if (ReturnLength != NULL)
            {
                *ReturnLength = NeededSize;
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    return Status;
}

Referenced by QueryInformationJobObject().

NtSetInformationJobObject()

NTSTATUS NTAPI NtSetInformationJobObject	(	HANDLE	JobHandle,
		JOBOBJECTINFOCLASS	JobInformationClass,
		PVOID	JobInformation,
		ULONG	JobInformationLength
	)

Definition at line 752 of file job.c.

{
    PEJOB Job;
    NTSTATUS Status;
    PKTHREAD CurrentThread;
    ACCESS_MASK DesiredAccess;
    KPROCESSOR_MODE PreviousMode;
    ULONG RequiredLength, RequiredAlign;
 
    PAGED_CODE();
 
    CurrentThread  = KeGetCurrentThread();
 
    /* Validate class */
    if (JobInformationClass > JobObjectJobSetInformation || JobInformationClass < JobObjectBasicAccountingInformation)
    {
        return STATUS_INVALID_INFO_CLASS;
    }
 
    /* Get associated lengths & alignments */
    RequiredLength = PspJobInfoLengths[JobInformationClass];
    RequiredAlign = PspJobInfoAlign[JobInformationClass];
 
    PreviousMode = ExGetPreviousMode();
    /* If not comming from umode, we need to probe buffers */
    if (PreviousMode != KernelMode)
    {
        ASSERT(((RequiredAlign) == 1) || ((RequiredAlign) == 2) || ((RequiredAlign) == 4) || ((RequiredAlign) == 8) || ((RequiredAlign) == 16));
 
        _SEH2_TRY
        {
            /* Probe out buffer for read */
            if (JobInformationLength != 0)
            {
                ProbeForRead(JobInformation, JobInformationLength, RequiredAlign);
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* Validate input size */
    if (JobInformationLength != RequiredLength)
    {
        return STATUS_INFO_LENGTH_MISMATCH;
    }
 
    /* Open the given job */
    DesiredAccess = JOB_OBJECT_SET_ATTRIBUTES;
    if (JobInformationClass == JobObjectSecurityLimitInformation)
    {
        DesiredAccess |= JOB_OBJECT_SET_SECURITY_ATTRIBUTES;
    }
    Status = ObReferenceObjectByHandle(JobHandle,
                                       DesiredAccess,
                                       PsJobType,
                                       PreviousMode,
                                       (PVOID*)&Job,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* And set the information */
    KeEnterGuardedRegionThread(CurrentThread);
    switch (JobInformationClass)
    {
        case JobObjectExtendedLimitInformation:
            DPRINT1("Class JobObjectExtendedLimitInformation not implemented\n");
            Status = STATUS_SUCCESS;
            break;
 
        default:
            DPRINT1("Class %d not implemented\n", JobInformationClass);
            Status = STATUS_NOT_IMPLEMENTED;
            break;
    }
    KeLeaveGuardedRegionThread(CurrentThread);
 
    ObDereferenceObject(Job);
 
    return Status;
}

Referenced by SetInformationJobObject().

NtTerminateJobObject()

NTSTATUS NTAPI NtTerminateJobObject	(	HANDLE	JobHandle,
		NTSTATUS	ExitStatus
	)

Definition at line 850 of file job.c.

{
    KPROCESSOR_MODE PreviousMode;
    PEJOB Job;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    PreviousMode = ExGetPreviousMode();
 
    Status = ObReferenceObjectByHandle(
        JobHandle,
        JOB_OBJECT_TERMINATE,
        PsJobType,
        PreviousMode,
        (PVOID*)&Job,
        NULL);
    if(NT_SUCCESS(Status))
    {
        Status = PspTerminateJobObject(
            Job,
            PreviousMode,
            ExitStatus);
        ObDereferenceObject(Job);
    }
 
    return Status;
}

Referenced by TerminateJobObject().

PsGetJobLock()

PVOID NTAPI PsGetJobLock

(

PEJOB

Job

)

Definition at line 887 of file job.c.

{
    ASSERT(Job);
    return (PVOID)&Job->JobLock;
}

PsGetJobSessionId()

ULONG NTAPI PsGetJobSessionId

(

PEJOB

Job

)

Definition at line 899 of file job.c.

{
    ASSERT(Job);
    return Job->SessionId;
}

PsGetJobUIRestrictionsClass()

ULONG NTAPI PsGetJobUIRestrictionsClass

(

PEJOB

Job

)

Definition at line 911 of file job.c.

{
    ASSERT(Job);
    return Job->UIRestrictionsClass;
}

PspAssignProcessToJob()

NTSTATUS NTAPI PspAssignProcessToJob	(	PEPROCESS	Process,
		PEJOB	Job
	)

Definition at line 119 of file job.c.

{
    DPRINT("PspAssignProcessToJob() is unimplemented!\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by NtAssignProcessToJobObject().

PspDeleteJob()

VOID NTAPI PspDeleteJob

(

PVOID

ObjectBody

)

Definition at line 87 of file job.c.

{
    PEJOB Job = (PEJOB)ObjectBody;
 
    /* remove the reference to the completion port if associated */
    if(Job->CompletionPort != NULL)
    {
        ObDereferenceObject(Job->CompletionPort);
    }
 
    /* unlink the job object */
    if(Job->JobLinks.Flink != NULL)
    {
        ExAcquireFastMutex(&PsJobListLock);
        RemoveEntryList(&Job->JobLinks);
        ExReleaseFastMutex(&PsJobListLock);
    }
 
    ExDeleteResource(&Job->JobLock);
}

PspExitProcessFromJob()

VOID NTAPI PspExitProcessFromJob	(	IN PEJOB	Job,
		IN PEPROCESS	Process
	)

Definition at line 146 of file job.c.

{
    /* FIXME */
}

Referenced by PspExitThread().

PspInitializeJobStructures()

VOID NTAPI PspInitializeJobStructures

(

VOID

)

Definition at line 111 of file job.c.

{
    InitializeListHead(&PsJobListHead);
    ExInitializeFastMutex(&PsJobListLock);
}

Referenced by PspInitPhase0().

PspRemoveProcessFromJob()

VOID NTAPI PspRemoveProcessFromJob	(	IN PEPROCESS	Process,
		IN PEJOB	Job
	)

Definition at line 138 of file job.c.

{
    /* FIXME */
}

Referenced by PspDeleteProcess().

PspTerminateJobObject()

NTSTATUS NTAPI PspTerminateJobObject	(	PEJOB	Job,
		KPROCESSOR_MODE	AccessMode,
		NTSTATUS	ExitStatus
	)

Definition at line 128 of file job.c.

{
    DPRINT("PspTerminateJobObject() is unimplemented!\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by NtTerminateJobObject().

PsSetJobUIRestrictionsClass()

VOID NTAPI PsSetJobUIRestrictionsClass	(	PEJOB	Job,
		ULONG	UIRestrictionsClass
	)

Definition at line 923 of file job.c.

{
    ASSERT(Job);
    (void)InterlockedExchangeUL(&Job->UIRestrictionsClass, UIRestrictionsClass);
    /* FIXME - walk through the job process list and update the restrictions? */
}

Variable Documentation

PsJobListHead

LIST_ENTRY PsJobListHead

Definition at line 22 of file job.c.

Referenced by NtCreateJobObject(), and PspInitializeJobStructures().

PsJobListLock

FAST_MUTEX PsJobListLock

static

Definition at line 23 of file job.c.

Referenced by NtCreateJobObject(), PspDeleteJob(), and PspInitializeJobStructures().

PsJobType

POBJECT_TYPE PsJobType = NULL

Definition at line 20 of file job.c.

Referenced by NtAssignProcessToJobObject(), NtCreateJobObject(), NtIsProcessInJob(), NtOpenJobObject(), NtQueryInformationJobObject(), NtSetInformationJobObject(), NtTerminateJobObject(), PspInitPhase0(), and TestObjectTypes().

PspJobInfoAlign

ULONG PspJobInfoAlign[]

Initial value:

=
{
    0x0,
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG),
    sizeof(ULONG)
}

Definition at line 68 of file job.c.

Referenced by NtQueryInformationJobObject(), and NtSetInformationJobObject().

PspJobInfoLengths

ULONG PspJobInfoLengths[]

Initial value:

=
{
    0x0,
    sizeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION),
    sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION),
    sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST),
    sizeof(JOBOBJECT_BASIC_UI_RESTRICTIONS),
    sizeof(JOBOBJECT_SECURITY_LIMIT_INFORMATION),
    sizeof(JOBOBJECT_END_OF_JOB_TIME_INFORMATION),
    sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT),
    sizeof(JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION),
    sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION),
    0x4
}

Definition at line 53 of file job.c.

Referenced by NtQueryInformationJobObject(), and NtSetInformationJobObject().

PspJobMapping

GENERIC_MAPPING PspJobMapping

Initial value:

=
{
    STANDARD_RIGHTS_READ | JOB_OBJECT_QUERY,
 
    STANDARD_RIGHTS_WRITE | JOB_OBJECT_ASSIGN_PROCESS |
    JOB_OBJECT_SET_ATTRIBUTES | JOB_OBJECT_TERMINATE,
 
    STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
 
    STANDARD_RIGHTS_ALL | THREAD_ALL_ACCESS 
}

Definition at line 41 of file job.c.

Referenced by PspInitPhase0().

PspJobSchedulingClasses

CHAR PspJobSchedulingClasses[PSP_JOB_SCHEDULING_CLASSES]

Initial value:

=
{
    1 * 6,
    2 * 6,
    3 * 6,
    4 * 6,
    5 * 6,
    6 * 6,
    7 * 6,
    8 * 6,
    9 * 6,
    10 * 6
}

Definition at line 27 of file job.c.

Referenced by PsChangeQuantumTable(), and PspComputeQuantumAndPriority().

PspUseJobSchedulingClasses

BOOLEAN PspUseJobSchedulingClasses

Definition at line 25 of file job.c.

Referenced by PsChangeQuantumTable(), and PspComputeQuantumAndPriority().