mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-01 23:12:02 +00:00
separate flock implementations into separate modules
This commit is contained in:
Andy Russell
parent
e7575f9670
commit
219d81f19b
@ -7,225 +7,20 @@
|
||||
#![allow(non_camel_case_types)]
|
||||
#![allow(nonstandard_style)]
|
||||
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io;
|
||||
use std::path::Path;
|
||||
|
||||
cfg_if! {
|
||||
// We use `flock` rather than `fcntl` on Linux, because WSL1 does not support
|
||||
// `fcntl`-style advisory locks properly (rust-lang/rust#72157).
|
||||
//
|
||||
// For other Unix targets we still use `fcntl` because it's more portable than
|
||||
// `flock`.
|
||||
if #[cfg(target_os = "linux")] {
|
||||
use std::os::unix::prelude::*;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
_file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path,
|
||||
wait: bool,
|
||||
create: bool,
|
||||
exclusive: bool)
|
||||
-> io::Result<Lock> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(create)
|
||||
.mode(libc::S_IRWXU as u32)
|
||||
.open(p)?;
|
||||
|
||||
let mut operation = if exclusive {
|
||||
libc::LOCK_EX
|
||||
} else {
|
||||
libc::LOCK_SH
|
||||
};
|
||||
if !wait {
|
||||
operation |= libc::LOCK_NB
|
||||
}
|
||||
|
||||
let ret = unsafe { libc::flock(file.as_raw_fd(), operation) };
|
||||
if ret == -1 {
|
||||
Err(io::Error::last_os_error())
|
||||
} else {
|
||||
Ok(Lock { _file: file })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
matches!(err.raw_os_error(), Some(libc::ENOTSUP) | Some(libc::ENOSYS))
|
||||
}
|
||||
}
|
||||
|
||||
// Note that we don't need a Drop impl to execute `flock(fd, LOCK_UN)`. Lock acquired by
|
||||
// `flock` is associated with the file descriptor and closing the file release it
|
||||
// automatically.
|
||||
mod linux;
|
||||
use linux as imp;
|
||||
} else if #[cfg(unix)] {
|
||||
use std::mem;
|
||||
use std::os::unix::prelude::*;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path,
|
||||
wait: bool,
|
||||
create: bool,
|
||||
exclusive: bool)
|
||||
-> io::Result<Lock> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(create)
|
||||
.mode(libc::S_IRWXU as u32)
|
||||
.open(p)?;
|
||||
|
||||
let lock_type = if exclusive {
|
||||
libc::F_WRLCK
|
||||
} else {
|
||||
libc::F_RDLCK
|
||||
};
|
||||
|
||||
let mut flock: libc::flock = unsafe { mem::zeroed() };
|
||||
flock.l_type = lock_type as libc::c_short;
|
||||
flock.l_whence = libc::SEEK_SET as libc::c_short;
|
||||
flock.l_start = 0;
|
||||
flock.l_len = 0;
|
||||
|
||||
let cmd = if wait { libc::F_SETLKW } else { libc::F_SETLK };
|
||||
let ret = unsafe {
|
||||
libc::fcntl(file.as_raw_fd(), cmd, &flock)
|
||||
};
|
||||
if ret == -1 {
|
||||
Err(io::Error::last_os_error())
|
||||
} else {
|
||||
Ok(Lock { file })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
matches!(err.raw_os_error(), Some(libc::ENOTSUP) | Some(libc::ENOSYS))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Lock {
|
||||
fn drop(&mut self) {
|
||||
let mut flock: libc::flock = unsafe { mem::zeroed() };
|
||||
flock.l_type = libc::F_UNLCK as libc::c_short;
|
||||
flock.l_whence = libc::SEEK_SET as libc::c_short;
|
||||
flock.l_start = 0;
|
||||
flock.l_len = 0;
|
||||
|
||||
unsafe {
|
||||
libc::fcntl(self.file.as_raw_fd(), libc::F_SETLK, &flock);
|
||||
}
|
||||
}
|
||||
}
|
||||
mod unix;
|
||||
use unix as imp;
|
||||
} else if #[cfg(windows)] {
|
||||
use std::mem;
|
||||
use std::os::windows::prelude::*;
|
||||
|
||||
use winapi::shared::winerror::ERROR_INVALID_FUNCTION;
|
||||
use winapi::um::minwinbase::{OVERLAPPED, LOCKFILE_FAIL_IMMEDIATELY, LOCKFILE_EXCLUSIVE_LOCK};
|
||||
use winapi::um::fileapi::LockFileEx;
|
||||
use winapi::um::winnt::{FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
_file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path,
|
||||
wait: bool,
|
||||
create: bool,
|
||||
exclusive: bool)
|
||||
-> io::Result<Lock> {
|
||||
assert!(p.parent().unwrap().exists(),
|
||||
"Parent directory of lock-file must exist: {}",
|
||||
p.display());
|
||||
|
||||
let share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE;
|
||||
|
||||
let mut open_options = OpenOptions::new();
|
||||
open_options.read(true)
|
||||
.share_mode(share_mode);
|
||||
|
||||
if create {
|
||||
open_options.create(true)
|
||||
.write(true);
|
||||
}
|
||||
|
||||
debug!("attempting to open lock file `{}`", p.display());
|
||||
let file = match open_options.open(p) {
|
||||
Ok(file) => {
|
||||
debug!("lock file opened successfully");
|
||||
file
|
||||
}
|
||||
Err(err) => {
|
||||
debug!("error opening lock file: {}", err);
|
||||
return Err(err)
|
||||
}
|
||||
};
|
||||
|
||||
let ret = unsafe {
|
||||
let mut overlapped: OVERLAPPED = mem::zeroed();
|
||||
|
||||
let mut dwFlags = 0;
|
||||
if !wait {
|
||||
dwFlags |= LOCKFILE_FAIL_IMMEDIATELY;
|
||||
}
|
||||
|
||||
if exclusive {
|
||||
dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
|
||||
}
|
||||
|
||||
debug!("attempting to acquire lock on lock file `{}`",
|
||||
p.display());
|
||||
LockFileEx(file.as_raw_handle(),
|
||||
dwFlags,
|
||||
0,
|
||||
0xFFFF_FFFF,
|
||||
0xFFFF_FFFF,
|
||||
&mut overlapped)
|
||||
};
|
||||
if ret == 0 {
|
||||
let err = io::Error::last_os_error();
|
||||
debug!("failed acquiring file lock: {}", err);
|
||||
Err(err)
|
||||
} else {
|
||||
debug!("successfully acquired lock");
|
||||
Ok(Lock { _file: file })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
err.raw_os_error() == Some(ERROR_INVALID_FUNCTION as i32)
|
||||
}
|
||||
}
|
||||
|
||||
// Note that we don't need a Drop impl on the Windows: The file is unlocked
|
||||
// automatically when it's closed.
|
||||
mod windows;
|
||||
use windows as imp;
|
||||
} else {
|
||||
#[derive(Debug)]
|
||||
pub struct Lock(());
|
||||
|
||||
impl Lock {
|
||||
pub fn new(_p: &Path, _wait: bool, _create: bool, _exclusive: bool)
|
||||
-> io::Result<Lock>
|
||||
{
|
||||
let msg = "file locks not supported on this platform";
|
||||
Err(io::Error::new(io::ErrorKind::Other, msg))
|
||||
}
|
||||
|
||||
pub fn error_unsupported(_err: &io::Error) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
mod unsupported;
|
||||
use unsupported as imp;
|
||||
}
|
||||
}
|
||||
|
||||
pub use imp::Lock;
|
||||
|
||||
40
compiler/rustc_data_structures/src/flock/linux.rs
Normal file
40
compiler/rustc_data_structures/src/flock/linux.rs
Normal file
@ -0,0 +1,40 @@
|
||||
//! We use `flock` rather than `fcntl` on Linux, because WSL1 does not support
|
||||
//! `fcntl`-style advisory locks properly (rust-lang/rust#72157). For other Unix
|
||||
//! targets we still use `fcntl` because it's more portable than `flock`.
|
||||
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io;
|
||||
use std::os::unix::prelude::*;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
_file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path, wait: bool, create: bool, exclusive: bool) -> io::Result<Lock> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(create)
|
||||
.mode(libc::S_IRWXU as u32)
|
||||
.open(p)?;
|
||||
|
||||
let mut operation = if exclusive { libc::LOCK_EX } else { libc::LOCK_SH };
|
||||
if !wait {
|
||||
operation |= libc::LOCK_NB
|
||||
}
|
||||
|
||||
let ret = unsafe { libc::flock(file.as_raw_fd(), operation) };
|
||||
if ret == -1 { Err(io::Error::last_os_error()) } else { Ok(Lock { _file: file }) }
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
matches!(err.raw_os_error(), Some(libc::ENOTSUP) | Some(libc::ENOSYS))
|
||||
}
|
||||
}
|
||||
|
||||
// Note that we don't need a Drop impl to execute `flock(fd, LOCK_UN)`. A lock acquired by
|
||||
// `flock` is associated with the file descriptor and closing the file releases it
|
||||
// automatically.
|
||||
51
compiler/rustc_data_structures/src/flock/unix.rs
Normal file
51
compiler/rustc_data_structures/src/flock/unix.rs
Normal file
@ -0,0 +1,51 @@
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io;
|
||||
use std::mem;
|
||||
use std::os::unix::prelude::*;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path, wait: bool, create: bool, exclusive: bool) -> io::Result<Lock> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.create(create)
|
||||
.mode(libc::S_IRWXU as u32)
|
||||
.open(p)?;
|
||||
|
||||
let lock_type = if exclusive { libc::F_WRLCK } else { libc::F_RDLCK };
|
||||
|
||||
let mut flock: libc::flock = unsafe { mem::zeroed() };
|
||||
flock.l_type = lock_type as libc::c_short;
|
||||
flock.l_whence = libc::SEEK_SET as libc::c_short;
|
||||
flock.l_start = 0;
|
||||
flock.l_len = 0;
|
||||
|
||||
let cmd = if wait { libc::F_SETLKW } else { libc::F_SETLK };
|
||||
let ret = unsafe { libc::fcntl(file.as_raw_fd(), cmd, &flock) };
|
||||
if ret == -1 { Err(io::Error::last_os_error()) } else { Ok(Lock { file }) }
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
matches!(err.raw_os_error(), Some(libc::ENOTSUP) | Some(libc::ENOSYS))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Lock {
|
||||
fn drop(&mut self) {
|
||||
let mut flock: libc::flock = unsafe { mem::zeroed() };
|
||||
flock.l_type = libc::F_UNLCK as libc::c_short;
|
||||
flock.l_whence = libc::SEEK_SET as libc::c_short;
|
||||
flock.l_start = 0;
|
||||
flock.l_len = 0;
|
||||
|
||||
unsafe {
|
||||
libc::fcntl(self.file.as_raw_fd(), libc::F_SETLK, &flock);
|
||||
}
|
||||
}
|
||||
}
|
||||
16
compiler/rustc_data_structures/src/flock/unsupported.rs
Normal file
16
compiler/rustc_data_structures/src/flock/unsupported.rs
Normal file
@ -0,0 +1,16 @@
|
||||
use std::io;
|
||||
use std::path::Path;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock(());
|
||||
|
||||
impl Lock {
|
||||
pub fn new(_p: &Path, _wait: bool, _create: bool, _exclusive: bool) -> io::Result<Lock> {
|
||||
let msg = "file locks not supported on this platform";
|
||||
Err(io::Error::new(io::ErrorKind::Other, msg))
|
||||
}
|
||||
|
||||
pub fn error_unsupported(_err: &io::Error) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
77
compiler/rustc_data_structures/src/flock/windows.rs
Normal file
77
compiler/rustc_data_structures/src/flock/windows.rs
Normal file
@ -0,0 +1,77 @@
|
||||
use std::fs::{File, OpenOptions};
|
||||
use std::io;
|
||||
use std::mem;
|
||||
use std::os::windows::prelude::*;
|
||||
use std::path::Path;
|
||||
|
||||
use winapi::shared::winerror::ERROR_INVALID_FUNCTION;
|
||||
use winapi::um::fileapi::LockFileEx;
|
||||
use winapi::um::minwinbase::{LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY, OVERLAPPED};
|
||||
use winapi::um::winnt::{FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Lock {
|
||||
_file: File,
|
||||
}
|
||||
|
||||
impl Lock {
|
||||
pub fn new(p: &Path, wait: bool, create: bool, exclusive: bool) -> io::Result<Lock> {
|
||||
assert!(
|
||||
p.parent().unwrap().exists(),
|
||||
"Parent directory of lock-file must exist: {}",
|
||||
p.display()
|
||||
);
|
||||
|
||||
let share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE;
|
||||
|
||||
let mut open_options = OpenOptions::new();
|
||||
open_options.read(true).share_mode(share_mode);
|
||||
|
||||
if create {
|
||||
open_options.create(true).write(true);
|
||||
}
|
||||
|
||||
debug!("attempting to open lock file `{}`", p.display());
|
||||
let file = match open_options.open(p) {
|
||||
Ok(file) => {
|
||||
debug!("lock file opened successfully");
|
||||
file
|
||||
}
|
||||
Err(err) => {
|
||||
debug!("error opening lock file: {}", err);
|
||||
return Err(err);
|
||||
}
|
||||
};
|
||||
|
||||
let ret = unsafe {
|
||||
let mut overlapped: OVERLAPPED = mem::zeroed();
|
||||
|
||||
let mut dwFlags = 0;
|
||||
if !wait {
|
||||
dwFlags |= LOCKFILE_FAIL_IMMEDIATELY;
|
||||
}
|
||||
|
||||
if exclusive {
|
||||
dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
|
||||
}
|
||||
|
||||
debug!("attempting to acquire lock on lock file `{}`", p.display());
|
||||
LockFileEx(file.as_raw_handle(), dwFlags, 0, 0xFFFF_FFFF, 0xFFFF_FFFF, &mut overlapped)
|
||||
};
|
||||
if ret == 0 {
|
||||
let err = io::Error::last_os_error();
|
||||
debug!("failed acquiring file lock: {}", err);
|
||||
Err(err)
|
||||
} else {
|
||||
debug!("successfully acquired lock");
|
||||
Ok(Lock { _file: file })
|
||||
}
|
||||
}
|
||||
|
||||
pub fn error_unsupported(err: &io::Error) -> bool {
|
||||
err.raw_os_error() == Some(ERROR_INVALID_FUNCTION as i32)
|
||||
}
|
||||
}
|
||||
|
||||
// Note that we don't need a Drop impl on Windows: The file is unlocked
|
||||
// automatically when it's closed.
|
||||
Loading…
Reference in New Issue
Block a user