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_UNLCK: libc::c_short = 0x0200;
117 pub const F_WRLCK: libc::c_short = 0x0400;
118 pub const F_SETLK: libc::c_int = 0x0080;
119 pub const F_SETLKW: libc::c_int = 0x0100;
122 #[cfg(any(target_os = "macos", target_os = "ios"))]
128 pub l_start: libc::off_t,
129 pub l_len: libc::off_t,
130 pub l_pid: libc::pid_t,
131 pub l_type: libc::c_short,
132 pub l_whence: libc::c_short,
134 // not actually here, but brings in line with freebsd
135 pub l_sysid: libc::c_int,
138 pub const F_RDLCK: libc::c_short = 1;
139 pub const F_UNLCK: libc::c_short = 2;
140 pub const F_WRLCK: libc::c_short = 3;
141 pub const F_SETLK: libc::c_int = 8;
142 pub const F_SETLKW: libc::c_int = 9;
145 #[cfg(target_os = "solaris")]
151 pub l_type: libc::c_short,
152 pub l_whence: libc::c_short,
153 pub l_start: libc::off_t,
154 pub l_len: libc::off_t,
155 pub l_sysid: libc::c_int,
156 pub l_pid: libc::pid_t,
159 pub const F_RDLCK: libc::c_short = 1;
160 pub const F_WRLCK: libc::c_short = 2;
161 pub const F_UNLCK: libc::c_short = 3;
162 pub const F_SETLK: libc::c_int = 6;
163 pub const F_SETLKW: libc::c_int = 7;
176 -> io::Result<Lock> {
177 let os: &OsStr = p.as_ref();
178 let buf = CString::new(os.as_bytes()).unwrap();
179 let open_flags = if create {
180 libc::O_RDWR | libc::O_CREAT
186 libc::open(buf.as_ptr(), open_flags,
187 libc::S_IRWXU as libc::c_int)
191 return Err(io::Error::last_os_error());
194 let lock_type = if exclusive {
200 let flock = os::flock {
204 l_whence: libc::SEEK_SET as libc::c_short,
208 let cmd = if wait { os::F_SETLKW } else { os::F_SETLK };
210 libc::fcntl(fd, cmd, &flock)
213 let err = io::Error::last_os_error();
214 unsafe { libc::close(fd); }
224 let flock = os::flock {
228 l_whence: libc::SEEK_SET as libc::c_short,
233 libc::fcntl(self.fd, os::F_SETLK, &flock);
234 libc::close(self.fd);
245 use std::os::windows::prelude::*;
246 use std::os::windows::raw::HANDLE;
248 use std::fs::{File, OpenOptions};
249 use std::os::raw::{c_ulong, c_ulonglong, c_int};
251 type DWORD = c_ulong;
253 type ULONG_PTR = c_ulonglong;
255 type LPOVERLAPPED = *mut OVERLAPPED;
256 const LOCKFILE_EXCLUSIVE_LOCK: DWORD = 0x00000002;
257 const LOCKFILE_FAIL_IMMEDIATELY: DWORD = 0x00000001;
259 const FILE_SHARE_DELETE: DWORD = 0x4;
260 const FILE_SHARE_READ: DWORD = 0x1;
261 const FILE_SHARE_WRITE: DWORD = 0x2;
266 InternalHigh: ULONG_PTR,
273 fn LockFileEx(hFile: HANDLE,
276 nNumberOfBytesToLockLow: DWORD,
277 nNumberOfBytesToLockHigh: DWORD,
278 lpOverlapped: LPOVERLAPPED) -> BOOL;
291 -> io::Result<Lock> {
292 assert!(p.parent().unwrap().exists(),
293 "Parent directory of lock-file must exist: {}",
296 let share_mode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE;
298 let mut open_options = OpenOptions::new();
299 open_options.read(true)
300 .share_mode(share_mode);
303 open_options.create(true)
307 debug!("Attempting to open lock file `{}`", p.display());
308 let file = match open_options.open(p) {
310 debug!("Lock file opened successfully");
314 debug!("Error opening lock file: {}", err);
320 let mut overlapped: OVERLAPPED = mem::zeroed();
324 dwFlags |= LOCKFILE_FAIL_IMMEDIATELY;
328 dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
331 debug!("Attempting to acquire lock on lock file `{}`",
333 LockFileEx(file.as_raw_handle(),
341 let err = io::Error::last_os_error();
342 debug!("Failed acquiring file lock: {}", err);
345 debug!("Successfully acquired lock.");
346 Ok(Lock { _file: file })
351 // Note that we don't need a Drop impl on the Windows: The file is unlocked
352 // automatically when it's closed.
356 pub fn panicking_new(p: &Path,
361 Lock::new(p, wait, create, exclusive).unwrap_or_else(|err| {
362 panic!("could not lock `{}`: {}", p.display(), err);