#![allow(nonstandard_style, dead_code)]
+use crate::Build;
use std::env;
use std::io;
use std::mem;
use std::ptr;
-use crate::Build;
-
-type HANDLE = *mut u8;
-type BOOL = i32;
-type DWORD = u32;
-type LPHANDLE = *mut HANDLE;
-type LPVOID = *mut u8;
-type JOBOBJECTINFOCLASS = i32;
-type SIZE_T = usize;
-type LARGE_INTEGER = i64;
-type UINT = u32;
-type ULONG_PTR = usize;
-type ULONGLONG = u64;
-
-const FALSE: BOOL = 0;
-const DUPLICATE_SAME_ACCESS: DWORD = 0x2;
-const PROCESS_DUP_HANDLE: DWORD = 0x40;
-const JobObjectExtendedLimitInformation: JOBOBJECTINFOCLASS = 9;
-const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: DWORD = 0x2000;
-const JOB_OBJECT_LIMIT_PRIORITY_CLASS: DWORD = 0x00000020;
-const SEM_FAILCRITICALERRORS: UINT = 0x0001;
-const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
-const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
-
-extern "system" {
- fn CreateJobObjectW(lpJobAttributes: *mut u8, lpName: *const u8) -> HANDLE;
- fn CloseHandle(hObject: HANDLE) -> BOOL;
- fn GetCurrentProcess() -> HANDLE;
- fn OpenProcess(dwDesiredAccess: DWORD,
- bInheritHandle: BOOL,
- dwProcessId: DWORD) -> HANDLE;
- fn DuplicateHandle(hSourceProcessHandle: HANDLE,
- hSourceHandle: HANDLE,
- hTargetProcessHandle: HANDLE,
- lpTargetHandle: LPHANDLE,
- dwDesiredAccess: DWORD,
- bInheritHandle: BOOL,
- dwOptions: DWORD) -> BOOL;
- fn AssignProcessToJobObject(hJob: HANDLE, hProcess: HANDLE) -> BOOL;
- fn SetInformationJobObject(hJob: HANDLE,
- JobObjectInformationClass: JOBOBJECTINFOCLASS,
- lpJobObjectInformation: LPVOID,
- cbJobObjectInformationLength: DWORD) -> BOOL;
- fn SetErrorMode(mode: UINT) -> UINT;
-}
-#[repr(C)]
-struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
- BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
- IoInfo: IO_COUNTERS,
- ProcessMemoryLimit: SIZE_T,
- JobMemoryLimit: SIZE_T,
- PeakProcessMemoryUsed: SIZE_T,
- PeakJobMemoryUsed: SIZE_T,
-}
-
-#[repr(C)]
-struct IO_COUNTERS {
- ReadOperationCount: ULONGLONG,
- WriteOperationCount: ULONGLONG,
- OtherOperationCount: ULONGLONG,
- ReadTransferCount: ULONGLONG,
- WriteTransferCount: ULONGLONG,
- OtherTransferCount: ULONGLONG,
-}
-
-#[repr(C)]
-struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
- PerProcessUserTimeLimit: LARGE_INTEGER,
- PerJobUserTimeLimit: LARGE_INTEGER,
- LimitFlags: DWORD,
- MinimumWorkingsetSize: SIZE_T,
- MaximumWorkingsetSize: SIZE_T,
- ActiveProcessLimit: DWORD,
- Affinity: ULONG_PTR,
- PriorityClass: DWORD,
- SchedulingClass: DWORD,
-}
+use winapi::shared::minwindef::{DWORD, FALSE, LPVOID};
+use winapi::um::errhandlingapi::SetErrorMode;
+use winapi::um::handleapi::{CloseHandle, DuplicateHandle};
+use winapi::um::jobapi2::{AssignProcessToJobObject, CreateJobObjectW, SetInformationJobObject};
+use winapi::um::processthreadsapi::{GetCurrentProcess, OpenProcess};
+use winapi::um::winbase::{BELOW_NORMAL_PRIORITY_CLASS, SEM_NOGPFAULTERRORBOX};
+use winapi::um::winnt::{
+ JobObjectExtendedLimitInformation, DUPLICATE_SAME_ACCESS, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
+ JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, JOB_OBJECT_LIMIT_PRIORITY_CLASS, PROCESS_DUP_HANDLE,
+};
pub unsafe fn setup(build: &mut Build) {
// Enable the Windows Error Reporting dialog which msys disables,
info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PRIORITY_CLASS;
info.BasicLimitInformation.PriorityClass = BELOW_NORMAL_PRIORITY_CLASS;
}
- let r = SetInformationJobObject(job,
- JobObjectExtendedLimitInformation,
- &mut info as *mut _ as LPVOID,
- mem::size_of_val(&info) as DWORD);
+ let r = SetInformationJobObject(
+ job,
+ JobObjectExtendedLimitInformation,
+ &mut info as *mut _ as LPVOID,
+ mem::size_of_val(&info) as DWORD,
+ );
assert!(r != 0, "{}", io::Error::last_os_error());
// Assign our process to this job object. Note that if this fails, one very
let r = AssignProcessToJobObject(job, GetCurrentProcess());
if r == 0 {
CloseHandle(job);
- return
+ return;
}
// If we've got a parent process (e.g., the python script that called us)
let parent = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid.parse().unwrap());
assert!(!parent.is_null(), "{}", io::Error::last_os_error());
let mut parent_handle = ptr::null_mut();
- let r = DuplicateHandle(GetCurrentProcess(), job,
- parent, &mut parent_handle,
- 0, FALSE, DUPLICATE_SAME_ACCESS);
+ let r = DuplicateHandle(
+ GetCurrentProcess(),
+ job,
+ parent,
+ &mut parent_handle,
+ 0,
+ FALSE,
+ DUPLICATE_SAME_ACCESS,
+ );
// If this failed, well at least we tried! An example of DuplicateHandle
// failing in the past has been when the wrong python2 package spawned this