How to obtain handles for all children process of current process in Windows?

For the purposes of performance monitoring on Windows OS, I need a program which can report both user and kernel times for an arbitrary process. On POSIX systems, standard time utility is perfectly OK as it reports wall clock time, user time and kernel time.

For Windows, there is no such utility by default. I looked around and found at least three alternatives. As I explain below, none of them actually suits my needs.

1. timeit from Windows SDK (cannot recall what exact version). It is no longer distributed, supported, or guaranteed to work on modern systems. I was not able to test it.
2. Cygwin's time. Almost identical to POSIX counterpart with similar output formatting.
3. timep.exe by Johnson (John) Hart, available in source code and binaries for his book "Windows System Programming, 4th Edition". This is a pretty simple utility that uses WinAPI's GetProcessTimes() to obtain the very same three values. I suspect that Cygwin's time is no different in that regard.

Now the problem: GetProcessTimes() only reports times for the PID directly spawned by timep, but not its children. This makes both time and timep useless for me.

My target EXE application is typically spawned through a BAT file which invokes one more BAT file; both BATs are meant to tune environment or alter command line arguments:

timep.exe
|    
+---wrapper.bat
              |
              +--- real-wrapper.bat
                                  |
                                  +--- application.exe

Times reported for wrapper.bat alone tell nothing about application.exe. Obviously, process creation models of POSIX (fork-exec) and Win32 (CreateProcess) are very different, which makes my goal that hard to achieve on Windows.

I want to try to write my own variant of time. It has to sum up times for given process and all his children, grandchildren etc., recursively. So far I can imagine the following approach:

1. CreateProcess() and get its PID (root PID) and handle; add this handle to a list
2. Enumerate all processes in system; for each process
   1. Compare its PID with root PID. If equal, get PID and handle for it, add it to the handle list.
   2. For every new PID, repeat process scan phase to collect more children handles
   3. Recurse down until no new process handles are added to the list
3. Wait for all collected handles from the list to terminate.
4. For each handle, call GetProcessTimes() and sum them up
5. Report results

This algorithm is bad because it is racy — children processes may be created late in the life of any process, or they can terminate before we get a chance to obtain their handle. In both cases, reported result times will be incorrect.

My question is: Is there a better solution?

EDIT: I was able to achieve my goal by using Job Objects. Below is a code snippet extracted from my application, relevant to obtaining kernel and user times from a process and all of its children. Hopefully it will save some time for someone.

I tested it with Windows 8.1 x64 and VS 2015, but it should be backwards-portable to at least Windows 7. Some fiddling might be required for 32-bit hosts (I am not sure) in regard to long long types - I am not familiar with CL.EXE's ways of dealing with them on such platforms.

#include <windows.h>
#include <string>
#include <cassert>
#include <iostream>
/* ... */

STARTUPINFO startUp;
PROCESS_INFORMATION procInfo;


/* Start program in paused state */
PROCESS_INFORMATION procInfo;
if (!CreateProcess(NULL, CmdParams, NULL, NULL, TRUE,
    CREATE_SUSPENDED | NORMAL_PRIORITY_CLASS, NULL, NULL, &startUp, &procInfo)) {
    DWORD err = GetLastError();
    // TODO format error message
    std::cerr << "Unable to start the process: " << err << std::endl;
    return 1;
}

HANDLE hProc = procInfo.hProcess;

/* Create job object and attach the process to it */
HANDLE hJob = CreateJobObject(NULL, NULL); // XXX no security attributes passed
assert(hJob != NULL);
int ret = AssignProcessToJobObject(hJob, hProc);
assert(ret);

/* Now run the process and allow it to spawn children */
ResumeThread(procInfo.hThread);

/* Block until the process terminates */
if (WaitForSingleObject(hProc, INFINITE) != WAIT_OBJECT_0) {
    DWORD err = GetLastError();
    // TODO format error message
    std::cerr << "Failed waiting for process termination: " << err << std::endl;
    return 1;
}

DWORD exitcode = 0;
ret = GetExitCodeProcess(hProc, &exitcode);
assert(ret);

/* Calculate wallclock time in nanoseconds.
   Ignore user and kernel times (third and fourth return parameters) */
FILETIME createTime, exitTime, unusedTime;
ret = GetProcessTimes(hProc, &createTime, &exitTime, &unusedTime, &unusedTime);
assert(ret);

LONGLONG createTimeNs = (LONGLONG)createTime.dwHighDateTime << 32 | createTime.dwLowDateTime;
LONGLONG exitTimeNs = (LONGLONG)exitTime.dwHighDateTime << 32 | exitTime.dwLowDateTime;
LONGLONG wallclockTimeNs = exitTimeNs - createTimeNs;

/* Get total user and kernel times for all processes of the job object */
JOBOBJECT_BASIC_ACCOUNTING_INFORMATION jobInfo;
ret = QueryInformationJobObject(hJob, JobObjectBasicAccountingInformation,
    &jobInfo, sizeof(jobInfo), NULL);
assert(ret);

if (jobInfo.ActiveProcesses != 0) {
    std::cerr << "Warning: there are still " 
        << jobInfo.ActiveProcesses 
        << " alive children processes" << std::endl;
    /* We may kill survived processes, if desired */
    TerminateJobObject(hJob, 127);
}

/* Get kernel and user times in nanoseconds */
LONGLONG kernelTimeNs = jobInfo.TotalKernelTime.QuadPart;
LONGLONG userTimeNs = jobInfo.TotalUserTime.QuadPart;

/* Clean up a bit */
CloseHandle(hProc);
CloseHandle(hJob);