[rustc.git] / src / librustdoc / flock.rs

// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Simple file-locking apis for each OS.
//!
//! This is not meant to be in the standard library, it does nothing with
//! green/native threading. This is just a bare-bones enough solution for
//! librustdoc, it is not production quality at all.

#![allow(non_camel_case_types)]

pub use self::imp::Lock;

#[cfg(unix)]
mod imp {
    use std::ffi::{CString, OsStr};
    use std::os::unix::prelude::*;
    use std::path::Path;
    use std::io;
    use libc;

    #[cfg(target_os = "linux")]
    mod os {
        use libc;

        pub struct flock {
            pub l_type: libc::c_short,
            pub l_whence: libc::c_short,
            pub l_start: libc::off_t,
            pub l_len: libc::off_t,
            pub l_pid: libc::pid_t,

            // not actually here, but brings in line with freebsd
            pub l_sysid: libc::c_int,
        }

        pub const F_WRLCK: libc::c_short = 1;
        pub const F_UNLCK: libc::c_short = 2;
        pub const F_SETLK: libc::c_int = 6;
        pub const F_SETLKW: libc::c_int = 7;
    }

    #[cfg(target_os = "freebsd")]
    mod os {
        use libc;

        pub struct flock {
            pub l_start: libc::off_t,
            pub l_len: libc::off_t,
            pub l_pid: libc::pid_t,
            pub l_type: libc::c_short,
            pub l_whence: libc::c_short,
            pub l_sysid: libc::c_int,
        }

        pub const F_UNLCK: libc::c_short = 2;
        pub const F_WRLCK: libc::c_short = 3;
        pub const F_SETLK: libc::c_int = 12;
        pub const F_SETLKW: libc::c_int = 13;
    }

    #[cfg(any(target_os = "dragonfly",
              target_os = "bitrig",
              target_os = "netbsd",
              target_os = "openbsd"))]
    mod os {
        use libc;

        pub struct flock {
            pub l_start: libc::off_t,
            pub l_len: libc::off_t,
            pub l_pid: libc::pid_t,
            pub l_type: libc::c_short,
            pub l_whence: libc::c_short,

            // not actually here, but brings in line with freebsd
            pub l_sysid: libc::c_int,
        }

        pub const F_UNLCK: libc::c_short = 2;
        pub const F_WRLCK: libc::c_short = 3;
        pub const F_SETLK: libc::c_int = 8;
        pub const F_SETLKW: libc::c_int = 9;
    }

    #[cfg(any(target_os = "macos", target_os = "ios"))]
    mod os {
        use libc;

        pub struct flock {
            pub l_start: libc::off_t,
            pub l_len: libc::off_t,
            pub l_pid: libc::pid_t,
            pub l_type: libc::c_short,
            pub l_whence: libc::c_short,

            // not actually here, but brings in line with freebsd
            pub l_sysid: libc::c_int,
        }

        pub const F_UNLCK: libc::c_short = 2;
        pub const F_WRLCK: libc::c_short = 3;
        pub const F_SETLK: libc::c_int = 8;
        pub const F_SETLKW: libc::c_int = 9;
    }

    #[cfg(target_os = "solaris")]
    mod os {
        use libc;

        pub struct flock {
            pub l_type: libc::c_short,
            pub l_whence: libc::c_short,
            pub l_start: libc::off_t,
            pub l_len: libc::off_t,
            pub l_sysid: libc::c_int,
            pub l_pid: libc::pid_t,
        }

        pub const F_WRLCK: libc::c_short = 2;
        pub const F_UNLCK: libc::c_short = 3;
        pub const F_SETLK: libc::c_int = 6;
        pub const F_SETLKW: libc::c_int = 7;
    }

    pub struct Lock {
        fd: libc::c_int,
    }

    impl Lock {
        pub fn new(p: &Path) -> Lock {
            let os: &OsStr = p.as_ref();
            let buf = CString::new(os.as_bytes()).unwrap();
            let fd = unsafe {
                libc::open(buf.as_ptr(), libc::O_RDWR | libc::O_CREAT,
                           libc::S_IRWXU as libc::c_int)
            };
            assert!(fd > 0, "failed to open lockfile: {}",
                    io::Error::last_os_error());
            let flock = os::flock {
                l_start: 0,
                l_len: 0,
                l_pid: 0,
                l_whence: libc::SEEK_SET as libc::c_short,
                l_type: os::F_WRLCK,
                l_sysid: 0,
            };
            let ret = unsafe {
                libc::fcntl(fd, os::F_SETLKW, &flock)
            };
            if ret == -1 {
                let err = io::Error::last_os_error();
                unsafe { libc::close(fd); }
                panic!("could not lock `{}`: {}", p.display(), err);
            }
            Lock { fd: fd }
        }
    }

    impl Drop for Lock {
        fn drop(&mut self) {
            let flock = os::flock {
                l_start: 0,
                l_len: 0,
                l_pid: 0,
                l_whence: libc::SEEK_SET as libc::c_short,
                l_type: os::F_UNLCK,
                l_sysid: 0,
            };
            unsafe {
                libc::fcntl(self.fd, os::F_SETLK, &flock);
                libc::close(self.fd);
            }
        }
    }
}

#[cfg(windows)]
#[allow(bad_style)]
mod imp {
    use std::io;
    use std::mem;
    use std::os::windows::prelude::*;
    use std::os::windows::raw::HANDLE;
    use std::path::Path;
    use std::fs::{File, OpenOptions};

    type DWORD = u32;
    type LPOVERLAPPED = *mut OVERLAPPED;
    type BOOL = i32;
    const LOCKFILE_EXCLUSIVE_LOCK: DWORD = 0x00000002;

    #[repr(C)]
    struct OVERLAPPED {
        Internal: usize,
        InternalHigh: usize,
        Pointer: *mut u8,
        hEvent: *mut u8,
    }

    extern "system" {
        fn LockFileEx(hFile: HANDLE,
                      dwFlags: DWORD,
                      dwReserved: DWORD,
                      nNumberOfBytesToLockLow: DWORD,
                      nNumberOfBytesToLockHigh: DWORD,
                      lpOverlapped: LPOVERLAPPED) -> BOOL;
    }

    pub struct Lock {
        _file: File,
    }

    impl Lock {
        pub fn new(p: &Path) -> Lock {
            let f = OpenOptions::new().read(true).write(true).create(true)
                                      .open(p).unwrap();
            let ret = unsafe {
                let mut overlapped: OVERLAPPED = mem::zeroed();
                LockFileEx(f.as_raw_handle(), LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
                           &mut overlapped)
            };
            if ret == 0 {
                let err = io::Error::last_os_error();
                panic!("could not lock `{}`: {}", p.display(), err);
            }
            Lock { _file: f }
        }
    }
}
Commit	Line	Data
85aaf69f	1	// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
1a4d82fc JJ	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	#[cfg(unix)]
	22	mod imp {
c34b1796 AL	23	use std::ffi::{CString, OsStr};
	24	use std::os::unix::prelude::*;
	25	use std::path::Path;
	26	use std::io;
1a4d82fc JJ	27	use libc;
	28
	29	#[cfg(target_os = "linux")]
	30	mod os {
	31	use libc;
	32
	33	pub struct flock {
	34	pub l_type: libc::c_short,
	35	pub l_whence: libc::c_short,
	36	pub l_start: libc::off_t,
	37	pub l_len: libc::off_t,
	38	pub l_pid: libc::pid_t,
	39
	40	// not actually here, but brings in line with freebsd
	41	pub l_sysid: libc::c_int,
	42	}
	43
	44	pub const F_WRLCK: libc::c_short = 1;
	45	pub const F_UNLCK: libc::c_short = 2;
	46	pub const F_SETLK: libc::c_int = 6;
	47	pub const F_SETLKW: libc::c_int = 7;
	48	}
	49
	50	#[cfg(target_os = "freebsd")]
	51	mod os {
	52	use libc;
	53
	54	pub struct flock {
	55	pub l_start: libc::off_t,
	56	pub l_len: libc::off_t,
	57	pub l_pid: libc::pid_t,
	58	pub l_type: libc::c_short,
	59	pub l_whence: libc::c_short,
	60	pub l_sysid: libc::c_int,
	61	}
	62
	63	pub const F_UNLCK: libc::c_short = 2;
	64	pub const F_WRLCK: libc::c_short = 3;
	65	pub const F_SETLK: libc::c_int = 12;
	66	pub const F_SETLKW: libc::c_int = 13;
	67	}
	68
c34b1796 AL	69	#[cfg(any(target_os = "dragonfly",
c34b1796 AL	70	target_os = "bitrig",
c1a9b12d	71	target_os = "netbsd",
c34b1796	72	target_os = "openbsd"))]
1a4d82fc JJ	73	mod os {
	74	use libc;
	75
	76	pub struct flock {
	77	pub l_start: libc::off_t,
	78	pub l_len: libc::off_t,
	79	pub l_pid: libc::pid_t,
	80	pub l_type: libc::c_short,
	81	pub l_whence: libc::c_short,
	82
	83	// not actually here, but brings in line with freebsd
	84	pub l_sysid: libc::c_int,
	85	}
	86
	87	pub const F_UNLCK: libc::c_short = 2;
	88	pub const F_WRLCK: libc::c_short = 3;
	89	pub const F_SETLK: libc::c_int = 8;
	90	pub const F_SETLKW: libc::c_int = 9;
	91	}
	92
	93	#[cfg(any(target_os = "macos", target_os = "ios"))]
	94	mod os {
	95	use libc;
	96
	97	pub struct flock {
	98	pub l_start: libc::off_t,
	99	pub l_len: libc::off_t,
	100	pub l_pid: libc::pid_t,
	101	pub l_type: libc::c_short,
	102	pub l_whence: libc::c_short,
	103
	104	// not actually here, but brings in line with freebsd
	105	pub l_sysid: libc::c_int,
	106	}
	107
	108	pub const F_UNLCK: libc::c_short = 2;
	109	pub const F_WRLCK: libc::c_short = 3;
	110	pub const F_SETLK: libc::c_int = 8;
	111	pub const F_SETLKW: libc::c_int = 9;
	112	}
7453a54e SL	113
	114	#[cfg(target_os = "solaris")]
	115	mod os {
	116	use libc;
	117
	118	pub struct flock {
	119	pub l_type: libc::c_short,
	120	pub l_whence: libc::c_short,
	121	pub l_start: libc::off_t,
	122	pub l_len: libc::off_t,
	123	pub l_sysid: libc::c_int,
	124	pub l_pid: libc::pid_t,
	125	}
	126
	127	pub const F_WRLCK: libc::c_short = 2;
	128	pub const F_UNLCK: libc::c_short = 3;
	129	pub const F_SETLK: libc::c_int = 6;
	130	pub const F_SETLKW: libc::c_int = 7;
	131	}
1a4d82fc JJ	132
	133	pub struct Lock {
	134	fd: libc::c_int,
	135	}
	136
	137	impl Lock {
	138	pub fn new(p: &Path) -> Lock {
c34b1796 AL	139	let os: &OsStr = p.as_ref();
c34b1796 AL	140	let buf = CString::new(os.as_bytes()).unwrap();
1a4d82fc JJ	141	let fd = unsafe {
1a4d82fc JJ	142	libc::open(buf.as_ptr(), libc::O_RDWR \| libc::O_CREAT,
92a42be0	143	libc::S_IRWXU as libc::c_int)
1a4d82fc	144	};
c34b1796 AL	145	assert!(fd > 0, "failed to open lockfile: {}",
c34b1796 AL	146	io::Error::last_os_error());
1a4d82fc JJ	147	let flock = os::flock {
	148	l_start: 0,
	149	l_len: 0,
	150	l_pid: 0,
	151	l_whence: libc::SEEK_SET as libc::c_short,
	152	l_type: os::F_WRLCK,
	153	l_sysid: 0,
	154	};
	155	let ret = unsafe {
85aaf69f	156	libc::fcntl(fd, os::F_SETLKW, &flock)
1a4d82fc JJ	157	};
1a4d82fc JJ	158	if ret == -1 {
c34b1796	159	let err = io::Error::last_os_error();
1a4d82fc	160	unsafe { libc::close(fd); }
c34b1796	161	panic!("could not lock `{}`: {}", p.display(), err);
1a4d82fc JJ	162	}
	163	Lock { fd: fd }
	164	}
	165	}
	166
	167	impl Drop for Lock {
	168	fn drop(&mut self) {
	169	let flock = os::flock {
	170	l_start: 0,
	171	l_len: 0,
	172	l_pid: 0,
	173	l_whence: libc::SEEK_SET as libc::c_short,
	174	l_type: os::F_UNLCK,
	175	l_sysid: 0,
	176	};
	177	unsafe {
85aaf69f	178	libc::fcntl(self.fd, os::F_SETLK, &flock);
1a4d82fc JJ	179	libc::close(self.fd);
	180	}
	181	}
	182	}
	183	}
	184
	185	#[cfg(windows)]
92a42be0	186	#[allow(bad_style)]
1a4d82fc	187	mod imp {
c34b1796	188	use std::io;
1a4d82fc	189	use std::mem;
c34b1796	190	use std::os::windows::prelude::*;
92a42be0	191	use std::os::windows::raw::HANDLE;
c34b1796	192	use std::path::Path;
92a42be0 SL	193	use std::fs::{File, OpenOptions};
	194
	195	type DWORD = u32;
	196	type LPOVERLAPPED = *mut OVERLAPPED;
	197	type BOOL = i32;
	198	const LOCKFILE_EXCLUSIVE_LOCK: DWORD = 0x00000002;
	199
	200	#[repr(C)]
	201	struct OVERLAPPED {
	202	Internal: usize,
	203	InternalHigh: usize,
	204	Pointer: *mut u8,
	205	hEvent: *mut u8,
	206	}
1a4d82fc	207
1a4d82fc	208	extern "system" {
92a42be0 SL	209	fn LockFileEx(hFile: HANDLE,
	210	dwFlags: DWORD,
	211	dwReserved: DWORD,
	212	nNumberOfBytesToLockLow: DWORD,
	213	nNumberOfBytesToLockHigh: DWORD,
	214	lpOverlapped: LPOVERLAPPED) -> BOOL;
1a4d82fc JJ	215	}
	216
	217	pub struct Lock {
92a42be0	218	_file: File,
1a4d82fc JJ	219	}
	220
	221	impl Lock {
	222	pub fn new(p: &Path) -> Lock {
92a42be0 SL	223	let f = OpenOptions::new().read(true).write(true).create(true)
92a42be0 SL	224	.open(p).unwrap();
1a4d82fc	225	let ret = unsafe {
92a42be0 SL	226	let mut overlapped: OVERLAPPED = mem::zeroed();
92a42be0 SL	227	LockFileEx(f.as_raw_handle(), LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0,
1a4d82fc JJ	228	&mut overlapped)
	229	};
	230	if ret == 0 {
c34b1796	231	let err = io::Error::last_os_error();
c34b1796	232	panic!("could not lock `{}`: {}", p.display(), err);
1a4d82fc	233	}
92a42be0	234	Lock { _file: f }
1a4d82fc JJ	235	}
	236	}
	237	}