]> git.lizzy.rs Git - rust.git/blob - src/librustdoc/flock.rs
return &mut T from the arenas, not &T
[rust.git] / src / librustdoc / flock.rs
1 // Copyright 2014 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.
4 //
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.
10
11 //! Simple file-locking apis for each OS.
12 //!
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.
16
17 #![allow(non_camel_case_types)]
18
19 pub use self::imp::Lock;
20
21
22 #[cfg(unix)]
23 mod imp {
24     use libc;
25
26     #[cfg(target_os = "linux")]
27     mod os {
28         use libc;
29
30         pub struct flock {
31             pub l_type: libc::c_short,
32             pub l_whence: libc::c_short,
33             pub l_start: libc::off_t,
34             pub l_len: libc::off_t,
35             pub l_pid: libc::pid_t,
36
37             // not actually here, but brings in line with freebsd
38             pub l_sysid: libc::c_int,
39         }
40
41         pub const F_WRLCK: libc::c_short = 1;
42         pub const F_UNLCK: libc::c_short = 2;
43         pub const F_SETLK: libc::c_int = 6;
44         pub const F_SETLKW: libc::c_int = 7;
45     }
46
47     #[cfg(target_os = "freebsd")]
48     mod os {
49         use libc;
50
51         pub struct flock {
52             pub l_start: libc::off_t,
53             pub l_len: libc::off_t,
54             pub l_pid: libc::pid_t,
55             pub l_type: libc::c_short,
56             pub l_whence: libc::c_short,
57             pub l_sysid: libc::c_int,
58         }
59
60         pub const F_UNLCK: libc::c_short = 2;
61         pub const F_WRLCK: libc::c_short = 3;
62         pub const F_SETLK: libc::c_int = 12;
63         pub const F_SETLKW: libc::c_int = 13;
64     }
65
66     #[cfg(target_os = "dragonfly")]
67     mod os {
68         use libc;
69
70         pub struct flock {
71             pub l_start: libc::off_t,
72             pub l_len: libc::off_t,
73             pub l_pid: libc::pid_t,
74             pub l_type: libc::c_short,
75             pub l_whence: libc::c_short,
76
77             // not actually here, but brings in line with freebsd
78             pub l_sysid: libc::c_int,
79         }
80
81         pub const F_UNLCK: libc::c_short = 2;
82         pub const F_WRLCK: libc::c_short = 3;
83         pub const F_SETLK: libc::c_int = 8;
84         pub const F_SETLKW: libc::c_int = 9;
85     }
86
87     #[cfg(any(target_os = "macos", target_os = "ios"))]
88     mod os {
89         use libc;
90
91         pub struct flock {
92             pub l_start: libc::off_t,
93             pub l_len: libc::off_t,
94             pub l_pid: libc::pid_t,
95             pub l_type: libc::c_short,
96             pub l_whence: libc::c_short,
97
98             // not actually here, but brings in line with freebsd
99             pub l_sysid: libc::c_int,
100         }
101
102         pub const F_UNLCK: libc::c_short = 2;
103         pub const F_WRLCK: libc::c_short = 3;
104         pub const F_SETLK: libc::c_int = 8;
105         pub const F_SETLKW: libc::c_int = 9;
106     }
107
108     pub struct Lock {
109         fd: libc::c_int,
110     }
111
112     impl Lock {
113         pub fn new(p: &Path) -> Lock {
114             let fd = p.with_c_str(|s| unsafe {
115                 libc::open(s, libc::O_RDWR | libc::O_CREAT, libc::S_IRWXU)
116             });
117             assert!(fd > 0);
118             let flock = os::flock {
119                 l_start: 0,
120                 l_len: 0,
121                 l_pid: 0,
122                 l_whence: libc::SEEK_SET as libc::c_short,
123                 l_type: os::F_WRLCK,
124                 l_sysid: 0,
125             };
126             let ret = unsafe {
127                 libc::fcntl(fd, os::F_SETLKW, &flock as *const os::flock)
128             };
129             if ret == -1 {
130                 unsafe { libc::close(fd); }
131                 fail!("could not lock `{}`", p.display())
132             }
133             Lock { fd: fd }
134         }
135     }
136
137     impl Drop for Lock {
138         fn drop(&mut self) {
139             let flock = os::flock {
140                 l_start: 0,
141                 l_len: 0,
142                 l_pid: 0,
143                 l_whence: libc::SEEK_SET as libc::c_short,
144                 l_type: os::F_UNLCK,
145                 l_sysid: 0,
146             };
147             unsafe {
148                 libc::fcntl(self.fd, os::F_SETLK, &flock as *const os::flock);
149                 libc::close(self.fd);
150             }
151         }
152     }
153 }
154
155 #[cfg(windows)]
156 mod imp {
157     use libc;
158     use std::mem;
159     use std::os;
160     use std::ptr;
161
162     static LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002;
163
164     #[allow(non_snake_case)]
165     extern "system" {
166         fn LockFileEx(hFile: libc::HANDLE,
167                       dwFlags: libc::DWORD,
168                       dwReserved: libc::DWORD,
169                       nNumberOfBytesToLockLow: libc::DWORD,
170                       nNumberOfBytesToLockHigh: libc::DWORD,
171                       lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
172         fn UnlockFileEx(hFile: libc::HANDLE,
173                         dwReserved: libc::DWORD,
174                         nNumberOfBytesToLockLow: libc::DWORD,
175                         nNumberOfBytesToLockHigh: libc::DWORD,
176                         lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
177     }
178
179     pub struct Lock {
180         handle: libc::HANDLE,
181     }
182
183     impl Lock {
184         pub fn new(p: &Path) -> Lock {
185             let mut p_16: Vec<u16> = p.as_str().unwrap().utf16_units().collect();
186             p_16.push(0);
187             let handle = unsafe {
188                 libc::CreateFileW(p_16.as_ptr(),
189                                   libc::FILE_GENERIC_READ |
190                                     libc::FILE_GENERIC_WRITE,
191                                   libc::FILE_SHARE_READ |
192                                     libc::FILE_SHARE_DELETE |
193                                     libc::FILE_SHARE_WRITE,
194                                   ptr::null_mut(),
195                                   libc::CREATE_ALWAYS,
196                                   libc::FILE_ATTRIBUTE_NORMAL,
197                                   ptr::null_mut())
198             };
199             if handle == libc::INVALID_HANDLE_VALUE {
200                 fail!("create file error: {}", os::last_os_error());
201             }
202             let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
203             let ret = unsafe {
204                 LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
205                            &mut overlapped)
206             };
207             if ret == 0 {
208                 unsafe { libc::CloseHandle(handle); }
209                 fail!("could not lock `{}`: {}", p.display(),
210                       os::last_os_error())
211             }
212             Lock { handle: handle }
213         }
214     }
215
216     impl Drop for Lock {
217         fn drop(&mut self) {
218             let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
219             unsafe {
220                 UnlockFileEx(self.handle, 0, 100, 0, &mut overlapped);
221                 libc::CloseHandle(self.handle);
222             }
223         }
224     }
225 }