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 static F_WRLCK: libc::c_short = 1;
  42         pub static F_UNLCK: libc::c_short = 2;
  43         pub static F_SETLK: libc::c_int = 6;
  44         pub static 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 static F_UNLCK: libc::c_short = 2;
  61         pub static F_WRLCK: libc::c_short = 3;
  62         pub static F_SETLK: libc::c_int = 12;
  63         pub static 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 static F_UNLCK: libc::c_short = 2;
  82         pub static F_WRLCK: libc::c_short = 3;
  83         pub static F_SETLK: libc::c_int = 8;
  84         pub static F_SETLKW: libc::c_int = 9;
  85     }
  86
  87     #[cfg(target_os = "macos")]
  88     #[cfg(target_os = "ios")]
  89     mod os {
  90         use libc;
  91
  92         pub struct flock {
  93             pub l_start: libc::off_t,
  94             pub l_len: libc::off_t,
  95             pub l_pid: libc::pid_t,
  96             pub l_type: libc::c_short,
  97             pub l_whence: libc::c_short,
  98
  99             // not actually here, but brings in line with freebsd
 100             pub l_sysid: libc::c_int,
 101         }
 102
 103         pub static F_UNLCK: libc::c_short = 2;
 104         pub static F_WRLCK: libc::c_short = 3;
 105         pub static F_SETLK: libc::c_int = 8;
 106         pub static F_SETLKW: libc::c_int = 9;
 107     }
 108
 109     pub struct Lock {
 110         fd: libc::c_int,
 111     }
 112
 113     impl Lock {
 114         pub fn new(p: &Path) -> Lock {
 115             let fd = p.with_c_str(|s| unsafe {
 116                 libc::open(s, libc::O_RDWR | libc::O_CREAT, libc::S_IRWXU)
 117             });
 118             assert!(fd > 0);
 119             let flock = os::flock {
 120                 l_start: 0,
 121                 l_len: 0,
 122                 l_pid: 0,
 123                 l_whence: libc::SEEK_SET as libc::c_short,
 124                 l_type: os::F_WRLCK,
 125                 l_sysid: 0,
 126             };
 127             let ret = unsafe {
 128                 libc::fcntl(fd, os::F_SETLKW, &flock as *const os::flock)
 129             };
 130             if ret == -1 {
 131                 unsafe { libc::close(fd); }
 132                 fail!("could not lock `{}`", p.display())
 133             }
 134             Lock { fd: fd }
 135         }
 136     }
 137
 138     impl Drop for Lock {
 139         fn drop(&mut self) {
 140             let flock = os::flock {
 141                 l_start: 0,
 142                 l_len: 0,
 143                 l_pid: 0,
 144                 l_whence: libc::SEEK_SET as libc::c_short,
 145                 l_type: os::F_UNLCK,
 146                 l_sysid: 0,
 147             };
 148             unsafe {
 149                 libc::fcntl(self.fd, os::F_SETLK, &flock as *const os::flock);
 150                 libc::close(self.fd);
 151             }
 152         }
 153     }
 154 }
 155
 156 #[cfg(windows)]
 157 mod imp {
 158     use libc;
 159     use std::mem;
 160     use std::os;
 161     use std::ptr;
 162
 163     static LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002;
 164
 165     #[allow(non_snake_case)]
 166     extern "system" {
 167         fn LockFileEx(hFile: libc::HANDLE,
 168                       dwFlags: libc::DWORD,
 169                       dwReserved: libc::DWORD,
 170                       nNumberOfBytesToLockLow: libc::DWORD,
 171                       nNumberOfBytesToLockHigh: libc::DWORD,
 172                       lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
 173         fn UnlockFileEx(hFile: libc::HANDLE,
 174                         dwReserved: libc::DWORD,
 175                         nNumberOfBytesToLockLow: libc::DWORD,
 176                         nNumberOfBytesToLockHigh: libc::DWORD,
 177                         lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
 178     }
 179
 180     pub struct Lock {
 181         handle: libc::HANDLE,
 182     }
 183
 184     impl Lock {
 185         pub fn new(p: &Path) -> Lock {
 186             let mut p_16: Vec<u16> = p.as_str().unwrap().utf16_units().collect();
 187             p_16.push(0);
 188             let handle = unsafe {
 189                 libc::CreateFileW(p_16.as_ptr(),
 190                                   libc::FILE_GENERIC_READ |
 191                                     libc::FILE_GENERIC_WRITE,
 192                                   libc::FILE_SHARE_READ |
 193                                     libc::FILE_SHARE_DELETE |
 194                                     libc::FILE_SHARE_WRITE,
 195                                   ptr::null_mut(),
 196                                   libc::CREATE_ALWAYS,
 197                                   libc::FILE_ATTRIBUTE_NORMAL,
 198                                   ptr::null_mut())
 199             };
 200             if handle == libc::INVALID_HANDLE_VALUE {
 201                 fail!("create file error: {}", os::last_os_error());
 202             }
 203             let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
 204             let ret = unsafe {
 205                 LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
 206                            &mut overlapped)
 207             };
 208             if ret == 0 {
 209                 unsafe { libc::CloseHandle(handle); }
 210                 fail!("could not lock `{}`: {}", p.display(),
 211                       os::last_os_error())
 212             }
 213             Lock { handle: handle }
 214         }
 215     }
 216
 217     impl Drop for Lock {
 218         fn drop(&mut self) {
 219             let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() };
 220             unsafe {
 221                 UnlockFileEx(self.handle, 0, 100, 0, &mut overlapped);
 222                 libc::CloseHandle(self.handle);
 223             }
 224         }
 225     }
 226 }