94 lines
3.1 KiB
Rust
94 lines
3.1 KiB
Rust
//! Bindings to acquire a global named lock.
|
|
//!
|
|
//! This is intended to be used to synchronize multiple compiler processes to
|
|
//! ensure that we can output complete errors without interleaving on Windows.
|
|
//! Note that this is currently only needed for allowing only one 32-bit MSVC
|
|
//! linker to execute at once on MSVC hosts, so this is only implemented for
|
|
//! `cfg(windows)`. Also note that this may not always be used on Windows,
|
|
//! only when targeting 32-bit MSVC.
|
|
//!
|
|
//! For more information about why this is necessary, see where this is called.
|
|
|
|
use std::any::Any;
|
|
|
|
#[cfg(windows)]
|
|
pub fn acquire_global_lock(name: &str) -> Box<dyn Any> {
|
|
use std::ffi::CString;
|
|
use std::io;
|
|
|
|
use winapi::shared::ntdef::HANDLE;
|
|
use winapi::um::handleapi::CloseHandle;
|
|
use winapi::um::synchapi::{CreateMutexA, ReleaseMutex, WaitForSingleObject};
|
|
use winapi::um::winbase::{INFINITE, WAIT_ABANDONED, WAIT_OBJECT_0};
|
|
|
|
struct Handle(HANDLE);
|
|
|
|
impl Drop for Handle {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
CloseHandle(self.0);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Guard(Handle);
|
|
|
|
impl Drop for Guard {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
ReleaseMutex((self.0).0);
|
|
}
|
|
}
|
|
}
|
|
|
|
let cname = CString::new(name).unwrap();
|
|
unsafe {
|
|
// Create a named mutex, with no security attributes and also not
|
|
// acquired when we create it.
|
|
//
|
|
// This will silently create one if it doesn't already exist, or it'll
|
|
// open up a handle to one if it already exists.
|
|
let mutex = CreateMutexA(std::ptr::null_mut(), 0, cname.as_ptr());
|
|
if mutex.is_null() {
|
|
panic!(
|
|
"failed to create global mutex named `{}`: {}",
|
|
name,
|
|
io::Error::last_os_error()
|
|
);
|
|
}
|
|
let mutex = Handle(mutex);
|
|
|
|
// Acquire the lock through `WaitForSingleObject`.
|
|
//
|
|
// A return value of `WAIT_OBJECT_0` means we successfully acquired it.
|
|
//
|
|
// A return value of `WAIT_ABANDONED` means that the previous holder of
|
|
// the thread exited without calling `ReleaseMutex`. This can happen,
|
|
// for example, when the compiler crashes or is interrupted via ctrl-c
|
|
// or the like. In this case, however, we are still transferred
|
|
// ownership of the lock so we continue.
|
|
//
|
|
// If an error happens.. well... that's surprising!
|
|
match WaitForSingleObject(mutex.0, INFINITE) {
|
|
WAIT_OBJECT_0 | WAIT_ABANDONED => {}
|
|
code => {
|
|
panic!(
|
|
"WaitForSingleObject failed on global mutex named \
|
|
`{}`: {} (ret={:x})",
|
|
name,
|
|
io::Error::last_os_error(),
|
|
code
|
|
);
|
|
}
|
|
}
|
|
|
|
// Return a guard which will call `ReleaseMutex` when dropped.
|
|
Box::new(Guard(mutex))
|
|
}
|
|
}
|
|
|
|
#[cfg(not(windows))]
|
|
pub fn acquire_global_lock(_name: &str) -> Box<dyn Any> {
|
|
Box::new(())
|
|
}
|