src/bootstrap/job.rs

   1 //! Job management on Windows for bootstrapping
   2 //!
   3 //! Most of the time when you're running a build system (e.g., make) you expect
   4 //! Ctrl-C or abnormal termination to actually terminate the entire tree of
   5 //! process in play, not just the one at the top. This currently works "by
   6 //! default" on Unix platforms because Ctrl-C actually sends a signal to the
   7 //! *process group* rather than the parent process, so everything will get torn
   8 //! down. On Windows, however, this does not happen and Ctrl-C just kills the
   9 //! parent process.
  10 //!
  11 //! To achieve the same semantics on Windows we use Job Objects to ensure that
  12 //! all processes die at the same time. Job objects have a mode of operation
  13 //! where when all handles to the object are closed it causes all child
  14 //! processes associated with the object to be terminated immediately.
  15 //! Conveniently whenever a process in the job object spawns a new process the
  16 //! child will be associated with the job object as well. This means if we add
  17 //! ourselves to the job object we create then everything will get torn down!
  18 //!
  19 //! Unfortunately most of the time the build system is actually called from a
  20 //! python wrapper (which manages things like building the build system) so this
  21 //! all doesn't quite cut it so far. To go the last mile we duplicate the job
  22 //! object handle into our parent process (a python process probably) and then
  23 //! close our own handle. This means that the only handle to the job object
  24 //! resides in the parent python process, so when python dies the whole build
  25 //! system dies (as one would probably expect!).
  26 //!
  27 //! Note that this module has a #[cfg(windows)] above it as none of this logic
  28 //! is required on Unix.
  29
  30 #![allow(nonstandard_style, dead_code)]
  31
  32 use std::env;
  33 use std::io;
  34 use std::mem;
  35 use std::ptr;
  36 use crate::Build;
  37
  38 type HANDLE = *mut u8;
  39 type BOOL = i32;
  40 type DWORD = u32;
  41 type LPHANDLE = *mut HANDLE;
  42 type LPVOID = *mut u8;
  43 type JOBOBJECTINFOCLASS = i32;
  44 type SIZE_T = usize;
  45 type LARGE_INTEGER = i64;
  46 type UINT = u32;
  47 type ULONG_PTR = usize;
  48 type ULONGLONG = u64;
  49
  50 const FALSE: BOOL = 0;
  51 const DUPLICATE_SAME_ACCESS: DWORD = 0x2;
  52 const PROCESS_DUP_HANDLE: DWORD = 0x40;
  53 const JobObjectExtendedLimitInformation: JOBOBJECTINFOCLASS = 9;
  54 const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: DWORD = 0x2000;
  55 const JOB_OBJECT_LIMIT_PRIORITY_CLASS: DWORD = 0x00000020;
  56 const SEM_FAILCRITICALERRORS: UINT = 0x0001;
  57 const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
  58 const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
  59
  60 extern "system" {
  61     fn CreateJobObjectW(lpJobAttributes: *mut u8, lpName: *const u8) -> HANDLE;
  62     fn CloseHandle(hObject: HANDLE) -> BOOL;
  63     fn GetCurrentProcess() -> HANDLE;
  64     fn OpenProcess(dwDesiredAccess: DWORD,
  65                    bInheritHandle: BOOL,
  66                    dwProcessId: DWORD) -> HANDLE;
  67     fn DuplicateHandle(hSourceProcessHandle: HANDLE,
  68                        hSourceHandle: HANDLE,
  69                        hTargetProcessHandle: HANDLE,
  70                        lpTargetHandle: LPHANDLE,
  71                        dwDesiredAccess: DWORD,
  72                        bInheritHandle: BOOL,
  73                        dwOptions: DWORD) -> BOOL;
  74     fn AssignProcessToJobObject(hJob: HANDLE, hProcess: HANDLE) -> BOOL;
  75     fn SetInformationJobObject(hJob: HANDLE,
  76                                JobObjectInformationClass: JOBOBJECTINFOCLASS,
  77                                lpJobObjectInformation: LPVOID,
  78                                cbJobObjectInformationLength: DWORD) -> BOOL;
  79     fn SetErrorMode(mode: UINT) -> UINT;
  80 }
  81
  82 #[repr(C)]
  83 struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
  84     BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
  85     IoInfo: IO_COUNTERS,
  86     ProcessMemoryLimit: SIZE_T,
  87     JobMemoryLimit: SIZE_T,
  88     PeakProcessMemoryUsed: SIZE_T,
  89     PeakJobMemoryUsed: SIZE_T,
  90 }
  91
  92 #[repr(C)]
  93 struct IO_COUNTERS {
  94     ReadOperationCount: ULONGLONG,
  95     WriteOperationCount: ULONGLONG,
  96     OtherOperationCount: ULONGLONG,
  97     ReadTransferCount: ULONGLONG,
  98     WriteTransferCount: ULONGLONG,
  99     OtherTransferCount: ULONGLONG,
 100 }
 101
 102 #[repr(C)]
 103 struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
 104     PerProcessUserTimeLimit: LARGE_INTEGER,
 105     PerJobUserTimeLimit: LARGE_INTEGER,
 106     LimitFlags: DWORD,
 107     MinimumWorkingsetSize: SIZE_T,
 108     MaximumWorkingsetSize: SIZE_T,
 109     ActiveProcessLimit: DWORD,
 110     Affinity: ULONG_PTR,
 111     PriorityClass: DWORD,
 112     SchedulingClass: DWORD,
 113 }
 114
 115 pub unsafe fn setup(build: &mut Build) {
 116     // Enable the Windows Error Reporting dialog which msys disables,
 117     // so we can JIT debug rustc
 118     let mode = SetErrorMode(0);
 119     SetErrorMode(mode & !SEM_NOGPFAULTERRORBOX);
 120
 121     // Create a new job object for us to use
 122     let job = CreateJobObjectW(ptr::null_mut(), ptr::null());
 123     assert!(!job.is_null(), "{}", io::Error::last_os_error());
 124
 125     // Indicate that when all handles to the job object are gone that all
 126     // process in the object should be killed. Note that this includes our
 127     // entire process tree by default because we've added ourselves and our
 128     // children will reside in the job by default.
 129     let mut info = mem::zeroed::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>();
 130     info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
 131     if build.config.low_priority {
 132         info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PRIORITY_CLASS;
 133         info.BasicLimitInformation.PriorityClass = BELOW_NORMAL_PRIORITY_CLASS;
 134     }
 135     let r = SetInformationJobObject(job,
 136                                     JobObjectExtendedLimitInformation,
 137                                     &mut info as *mut _ as LPVOID,
 138                                     mem::size_of_val(&info) as DWORD);
 139     assert!(r != 0, "{}", io::Error::last_os_error());
 140
 141     // Assign our process to this job object. Note that if this fails, one very
 142     // likely reason is that we are ourselves already in a job object! This can
 143     // happen on the build bots that we've got for Windows, or if just anyone
 144     // else is instrumenting the build. In this case we just bail out
 145     // immediately and assume that they take care of it.
 146     //
 147     // Also note that nested jobs (why this might fail) are supported in recent
 148     // versions of Windows, but the version of Windows that our bots are running
 149     // at least don't support nested job objects.
 150     let r = AssignProcessToJobObject(job, GetCurrentProcess());
 151     if r == 0 {
 152         CloseHandle(job);
 153         return
 154     }
 155
 156     // If we've got a parent process (e.g., the python script that called us)
 157     // then move ownership of this job object up to them. That way if the python
 158     // script is killed (e.g., via ctrl-c) then we'll all be torn down.
 159     //
 160     // If we don't have a parent (e.g., this was run directly) then we
 161     // intentionally leak the job object handle. When our process exits
 162     // (normally or abnormally) it will close the handle implicitly, causing all
 163     // processes in the job to be cleaned up.
 164     let pid = match env::var("BOOTSTRAP_PARENT_ID") {
 165         Ok(s) => s,
 166         Err(..) => return,
 167     };
 168
 169     let parent = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid.parse().unwrap());
 170     assert!(!parent.is_null(), "{}", io::Error::last_os_error());
 171     let mut parent_handle = ptr::null_mut();
 172     let r = DuplicateHandle(GetCurrentProcess(), job,
 173                             parent, &mut parent_handle,
 174                             0, FALSE, DUPLICATE_SAME_ACCESS);
 175
 176     // If this failed, well at least we tried! An example of DuplicateHandle
 177     // failing in the past has been when the wrong python2 package spawned this
 178     // build system (e.g., the `python2` package in MSYS instead of
 179     // `mingw-w64-x86_64-python2`. Not sure why it failed, but the "failure
 180     // mode" here is that we only clean everything up when the build system
 181     // dies, not when the python parent does, so not too bad.
 182     if r != 0 {
 183         CloseHandle(job);
 184     }
 185 }