1 // Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Simple file-locking apis for each OS.
13 //! This is not meant to be in the standard library, it does nothing with
14 //! green/native threading. This is just a bare-bones enough solution for
15 //! librustdoc, it is not production quality at all.
17 #![allow(non_camel_case_types)]
20 pub use self::imp::Lock;
24 use std::ffi::{CString, OsStr};
25 use std::os::unix::prelude::*;
30 #[cfg(any(target_os = "linux", target_os = "android"))]
36 pub l_type: libc::c_short,
37 pub l_whence: libc::c_short,
38 pub l_start: libc::off_t,
39 pub l_len: libc::off_t,
40 pub l_pid: libc::pid_t,
42 // not actually here, but brings in line with freebsd
43 pub l_sysid: libc::c_int,
46 pub const F_RDLCK: libc::c_short = 0;
47 pub const F_WRLCK: libc::c_short = 1;
48 pub const F_UNLCK: libc::c_short = 2;
49 pub const F_SETLK: libc::c_int = 6;
50 pub const F_SETLKW: libc::c_int = 7;
53 #[cfg(target_os = "freebsd")]
59 pub l_start: libc::off_t,
60 pub l_len: libc::off_t,
61 pub l_pid: libc::pid_t,
62 pub l_type: libc::c_short,
63 pub l_whence: libc::c_short,
64 pub l_sysid: libc::c_int,
67 pub const F_RDLCK: libc::c_short = 1;
68 pub const F_UNLCK: libc::c_short = 2;
69 pub const F_WRLCK: libc::c_short = 3;
70 pub const F_SETLK: libc::c_int = 12;
71 pub const F_SETLKW: libc::c_int = 13;
74 #[cfg(any(target_os = "dragonfly",
77 target_os = "openbsd"))]
83 pub l_start: libc::off_t,
84 pub l_len: libc::off_t,
85 pub l_pid: libc::pid_t,
86 pub l_type: libc::c_short,
87 pub l_whence: libc::c_short,
89 // not actually here, but brings in line with freebsd
90 pub l_sysid: libc::c_int,
93 pub const F_RDLCK: libc::c_short = 1;
94 pub const F_UNLCK: libc::c_short = 2;
95 pub const F_WRLCK: libc::c_short = 3;
96 pub const F_SETLK: libc::c_int = 8;
97 pub const F_SETLKW: libc::c_int = 9;
100 #[cfg(target_os = "haiku")]
106 pub l_type: libc::c_short,
107 pub l_whence: libc::c_short,
108 pub l_start: libc::off_t,
109 pub l_len: libc::off_t,
110 pub l_pid: libc::pid_t,
112 // not actually here, but brings in line with freebsd
113 pub l_sysid: libc::c_int,
116 pub const F_RDLCK: libc::c_short = 0x0040;
117 pub const F_UNLCK: libc::c_short = 0x0200;
118 pub const F_WRLCK: libc::c_short = 0x0400;
119 pub const F_SETLK: libc::c_int = 0x0080;
120 pub const F_SETLKW: libc::c_int = 0x0100;
123 #[cfg(any(target_os = "macos", target_os = "ios"))]
129 pub l_start: libc::off_t,
130 pub l_len: libc::off_t,
131 pub l_pid: libc::pid_t,
132 pub l_type: libc::c_short,
133 pub l_whence: libc::c_short,
135 // not actually here, but brings in line with freebsd
136 pub l_sysid: libc::c_int,
139 pub const F_RDLCK: libc::c_short = 1;
140 pub const F_UNLCK: libc::c_short = 2;
141 pub const F_WRLCK: libc::c_short = 3;
142 pub const F_SETLK: libc::c_int = 8;
143 pub const F_SETLKW: libc::c_int = 9;
146 #[cfg(target_os = "solaris")]
152 pub l_type: libc::c_short,
153 pub l_whence: libc::c_short,
154 pub l_start: libc::off_t,
155 pub l_len: libc::off_t,
156 pub l_sysid: libc::c_int,
157 pub l_pid: libc::pid_t,
160 pub const F_RDLCK: libc::c_short = 1;
161 pub const F_WRLCK: libc::c_short = 2;
162 pub const F_UNLCK: libc::c_short = 3;
163 pub const F_SETLK: libc::c_int = 6;
164 pub const F_SETLKW: libc::c_int = 7;
177 -> io::Result<Lock> {
178 let os: &OsStr = p.as_ref();
179 let buf = CString::new(os.as_bytes()).unwrap();
180 let open_flags = if create {
181 libc::O_RDWR | libc::O_CREAT
187 libc::open(buf.as_ptr(), open_flags,
188 libc::S_IRWXU as libc::c_int)
192 return Err(io::Error::last_os_error());
195 let lock_type = if exclusive {
201 let flock = os::flock {
205 l_whence: libc::SEEK_SET as libc::c_short,
209 let cmd = if wait { os::F_SETLKW } else { os::F_SETLK };
211 libc::fcntl(fd, cmd, &flock)
214 let err = io::Error::last_os_error();
215 unsafe { libc::close(fd); }
225 let flock = os::flock {
229 l_whence: libc::SEEK_SET as libc::c_short,
234 libc::fcntl(self.fd, os::F_SETLK, &flock);
235 libc::close(self.fd);
246 use std::os::windows::prelude::*;
247 use std::os::windows::raw::HANDLE;
249 use std::fs::{File, OpenOptions};
250 use std::os::raw::{c_ulong, c_int};
252 type DWORD = c_ulong;
254 type ULONG_PTR = usize;
256 type LPOVERLAPPED = *mut OVERLAPPED;
257 const LOCKFILE_EXCLUSIVE_LOCK: DWORD = 0x0000_0002;
258 const LOCKFILE_FAIL_IMMEDIATELY: DWORD = 0x0000_0001;
260 const FILE_SHARE_DELETE: DWORD = 0x4;
261 const FILE_SHARE_READ: DWORD = 0x1;
262 const FILE_SHARE_WRITE: DWORD = 0x2;
267 InternalHigh: ULONG_PTR,
274 fn LockFileEx(hFile: HANDLE,
277 nNumberOfBytesToLockLow: DWORD,
278 nNumberOfBytesToLockHigh: DWORD,
279 lpOverlapped: LPOVERLAPPED) -> BOOL;
292 -> io::Result<Lock> {
293 assert!(p.parent().unwrap().exists(),
294 "Parent directory of lock-file must exist: {}",
297 let share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE;
299 let mut open_options = OpenOptions::new();
300 open_options.read(true)
301 .share_mode(share_mode);
304 open_options.create(true)
308 debug!("Attempting to open lock file `{}`", p.display());
309 let file = match open_options.open(p) {
311 debug!("Lock file opened successfully");
315 debug!("Error opening lock file: {}", err);
321 let mut overlapped: OVERLAPPED = mem::zeroed();
325 dwFlags |= LOCKFILE_FAIL_IMMEDIATELY;
329 dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
332 debug!("Attempting to acquire lock on lock file `{}`",
334 LockFileEx(file.as_raw_handle(),
342 let err = io::Error::last_os_error();
343 debug!("Failed acquiring file lock: {}", err);
346 debug!("Successfully acquired lock.");
347 Ok(Lock { _file: file })
352 // Note that we don't need a Drop impl on the Windows: The file is unlocked
353 // automatically when it's closed.
357 pub fn panicking_new(p: &Path,
362 Lock::new(p, wait, create, exclusive).unwrap_or_else(|err| {
363 panic!("could not lock `{}`: {}", p.display(), err);