1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

pub use self::os::{sem_t};
pub use self::os::{SEM_FAILED};

use {NTStr, int_t, uint_t, char_t};
use sys::types::{mode_t};
use time::{timespec};

#[cfg(target_os = "linux")]
#[path = "linux/mod.rs"]
mod os;

pub fn sem_close(sem: *mut sem_t) -> int_t {
    extern { fn sem_close(sem: *mut sem_t) -> int_t; }
    unsafe { sem_close(sem) }
}

pub fn sem_destroy(sem: *mut sem_t) -> int_t {
    extern { fn sem_destroy(sem: *mut sem_t) -> int_t; }
    unsafe { sem_destroy(sem) }
}

pub fn sem_getvalue(sem: *mut sem_t, sval: &mut int_t) -> int_t {
    extern { fn sem_getvalue(sem: *mut sem_t, sval: *mut int_t) -> int_t; }
    unsafe { sem_getvalue(sem, sval as *mut _) }
}

pub fn sem_init(sem: *mut sem_t, pshared: int_t, value: uint_t) -> int_t {
    extern { fn sem_init(sem: *mut sem_t, pshared: int_t, value: uint_t) -> int_t; }
    unsafe { sem_init(sem, pshared, value) }
}

pub fn sem_open<T: NTStr>(name: &T, oflag: int_t, mode: mode_t,
                            value: uint_t) -> *mut sem_t {
    extern { fn sem_open(name: *const char_t, oflag: int_t, ...) -> *mut sem_t; }
    unsafe { sem_open(name.as_ptr(), oflag, mode, value) }
}

pub fn sem_post(sem: *mut sem_t) -> int_t {
    extern { fn sem_post(sem: *mut sem_t) -> int_t; }
    unsafe { sem_post(sem) }
}

pub fn sem_timedwait(sem: *mut sem_t, abstime: &timespec) -> int_t {
    extern { fn sem_timedwait(sem: *mut sem_t, abstime: *const timespec) -> int_t; }
    unsafe { sem_timedwait(sem, abstime as *const _) }
}

pub fn sem_trywait(sem: *mut sem_t) -> int_t {
    extern { fn sem_trywait(sem: *mut sem_t) -> int_t; }
    unsafe { sem_trywait(sem) }
}

pub fn sem_unlink<T: NTStr>(name: &T) -> int_t {
    extern { fn sem_unlink(name: *const char_t) -> int_t; }
    unsafe { sem_unlink(name.as_ptr()) }
}

pub fn sem_wait(sem: *mut sem_t) -> int_t {
    extern { fn sem_wait(sem: *mut sem_t) -> int_t; }
    unsafe { sem_wait(sem) }
}