What's the correct way to use QueryInformationJobObject ?

[tunafish88]

I was playing with the ProcessJobTracker example class to add a method that can query the job object and I have two questions:

(a) I suppose the third parameter of QueryInformationJobObject should be a pointer that points to a block of of memory the size of JOBOBJECT_EXTENDED_LIMIT_INFORMATION. - Is my understanding correct ?

(2) I created a job object with

                 var extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION
                {
                    BasicLimitInformation = new JOBOBJECT_BASIC_LIMIT_INFORMATION
                    {
                        LimitFlags = 
                        (JOB_OBJECT_LIMIT.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE |
                        JOB_OBJECT_LIMIT.JOB_OBJECT_LIMIT_JOB_MEMORY|
                        JOB_OBJECT_LIMIT.JOB_OBJECT_LIMIT_PROCESS_MEMORY)
                    },
                    ProcessMemoryLimit = val,
                    JobMemoryLimit =val
                };

And here is the method I use to get the job memory limit. It seems to work fine mand give me the expected result, but I wanted to know if there is a better way to do this?

        public unsafe int GetMemoryCap()
        {

            var result = default(JOBOBJECT_EXTENDED_LIMIT_INFORMATION);
                int infoSize = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
                IntPtr infoPtr = Marshal.AllocHGlobal(infoSize);
                try
                {
                BOOL isCallSuccessful = QueryInformationJobObject(this.jobHandle, JOBOBJECTINFOCLASS.JobObjectExtendedLimitInformation, infoPtr.ToPointer(), (uint)infoSize, null);

                if (isCallSuccessful)
                {
                    result = Marshal.PtrToStructure<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>(infoPtr);
                }
                else
                {
                    throw new Exception("Trouble getting job object");
                }
            }
            finally
            {
                Marshal.FreeHGlobal(infoPtr);
            }

            return (int)result.JobMemoryLimit;
        }

[AArnott]

I was playing with the ProcessJobTracker example class

What example is this? Is it per chance this one?

(a) I suppose the third parameter of QueryInformationJobObject should be a pointer that points to a block of of memory the size of JOBOBJECT_EXTENDED_LIMIT_INFORMATION. - Is my understanding correct ?

Only if the second argument is JobObjectExtendedLimitInformation (which I see from the latter part of your question is in fact the case). In general, you should allocate enough memory to store the struct that will be initialized based on what you're asking for in the second argument.

It seems to work fine mand give me the expected result, but I wanted to know if there is a better way to do this?

Yes. You're doing manual memory management. Ugh. Much harder than necessary. But props to you for using try/finally to guard against memory leaks. But it isn't necessary with the easier way.

static unsafe int GetMemoryCap(HANDLE jobHandle)
{
    JOBOBJECT_EXTENDED_LIMIT_INFORMATION result = default;
    BOOL isCallSuccessful = QueryInformationJobObject(jobHandle, JOBOBJECTINFOCLASS.JobObjectExtendedLimitInformation, &result, (uint)sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION), null);
    if (!isCallSuccessful)
    {
        throw new Win32Exception();
    }

    return (int)result.JobMemoryLimit;
}

See how instead of allocating unmanaged memory and then copying data around, we just point directly at our local struct on the stack.
I also throw Win32Exception so that GetLastError() is automatically used to provide a meaningful exception that captures the underlying cause.

[tunafish88]

Yes, https://gist.github.com/AArnott/2609636d2f2369495abe76e8a01446a4 is the example I was using.
Also, thanks for the new snippet that avoids explicit memory management, it works perfectly.