Function nc::rt_sigsuspend

source · 
pub unsafe fn rt_sigsuspend(set: &sigset_t) -> Result<(), Errno>
Expand description

Wait for a signal.

Always returns Errno, normally EINTR.

§Examples

let pid = unsafe { nc::fork() };
assert!(pid.is_ok());
let pid = pid.unwrap();
assert!(pid >= 0);

if pid == 0 {
    // child process.
    let mask = nc::sigset_t::default();
    let ret = unsafe { nc::rt_sigsuspend(&mask) };
    assert!(ret.is_ok());
} else {
    // parent process.
    let t = nc::timespec_t {
        tv_sec: 1,
        tv_nsec: 0,
    };
    let ret = unsafe { nc::nanosleep(&t, None) };
    assert!(ret.is_ok());

    let ret = unsafe { nc::kill(pid, nc::SIGTERM) };
    assert!(ret.is_ok());
}
Examples found in repository?
examples/resource_limit.rs (line 46)
37
38
39
40
41
42
43
44
45
46
47

fn main() {
    let pid = unsafe { nc::getpid() };
    println!("pid: {}", pid);

    get_file_limit();
    set_file_limit();
    get_file_limit();

    let mask = nc::sigset_t::default();
    let _ret = unsafe { nc::rt_sigsuspend(&mask) };
}
More examples
Hide additional examples
examples/prctl.rs (line 20)
13
14
15
16
17
18
19
20
21

fn main() {
    let process_name = "rust-001";
    let pid = unsafe { nc::getpid() };
    println!("pid: {}, process name: {}", pid, &process_name);
    set_process_name(process_name).unwrap();

    let mask = nc::sigset_t::default();
    let _ret = unsafe { nc::rt_sigsuspend(&mask) };
}
examples/alarm.rs (line 31)
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

fn main() {
    #[cfg(nc_has_sa_restorer)]
    let sa = nc::sigaction_t {
        sa_handler: handle_alarm as nc::sighandler_t,
        sa_flags: nc::SA_RESTORER | nc::SA_RESTART,
        sa_restorer: nc::restore::get_sa_restorer(),
        ..nc::sigaction_t::default()
    };
    #[cfg(not(nc_has_sa_restorer))]
    let sa = nc::sigaction_t {
        sa_handler: handle_alarm as nc::sighandler_t,
        sa_flags: nc::SA_RESTART,
        ..nc::sigaction_t::default()
    };
    let ret = unsafe { nc::rt_sigaction(nc::SIGALRM, Some(&sa), None) };
    assert!(ret.is_ok());

    let seconds = 1;
    let remaining = unsafe { nc::alarm(seconds) };
    let mask = nc::sigset_t::default();
    let ret = unsafe { nc::rt_sigsuspend(&mask) };
    assert!(ret.is_err());
    assert_eq!(ret, Err(nc::EINTR));
    assert_eq!(remaining.unwrap(), 0);
}
examples/timer.rs (line 48)
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

fn main() {
    fn handle_alarm(signum: i32) {
        assert_eq!(signum, nc::SIGALRM);
        let msg = "Hello alarm\n";
        let _ = unsafe { nc::write(2, msg.as_bytes()) };
    }

    #[cfg(nc_has_sa_restorer)]
    let sa = nc::sigaction_t {
        sa_handler: handle_alarm as nc::sighandler_t,
        sa_flags: nc::SA_RESTART | nc::SA_RESTORER,
        sa_restorer: nc::restore::get_sa_restorer(),
        ..nc::sigaction_t::default()
    };
    #[cfg(not(nc_has_sa_restorer))]
    let sa = nc::sigaction_t {
        sa_handler: handle_alarm as nc::sighandler_t,
        sa_flags: nc::SA_RESTART,
        ..nc::sigaction_t::default()
    };
    let ret = unsafe { nc::rt_sigaction(nc::SIGALRM, Some(&sa), None) };
    assert!(ret.is_ok());

    // Single shot timer, actived after 1 second.
    let itv = nc::itimerval_t {
        it_value: nc::timeval_t {
            tv_sec: 1,
            tv_usec: 0,
        },
        it_interval: nc::timeval_t {
            tv_sec: 0,
            tv_usec: 0,
        },
    };
    let ret = unsafe { nc::setitimer(nc::ITIMER_REAL, &itv, None) };
    assert!(ret.is_ok());

    let mut prev_itv = nc::itimerval_t::default();
    let ret = unsafe { nc::getitimer(nc::ITIMER_REAL, &mut prev_itv) };
    assert!(ret.is_ok());
    assert!(prev_itv.it_value.tv_sec <= itv.it_value.tv_sec);

    let mask = nc::sigset_t::default();
    let ret = unsafe { nc::rt_sigsuspend(&mask) };
    assert!(ret.is_err());

    let ret = unsafe { nc::getitimer(nc::ITIMER_REAL, &mut prev_itv) };
    assert!(ret.is_ok());
    assert_eq!(prev_itv.it_value.tv_sec, 0);
    assert_eq!(prev_itv.it_value.tv_usec, 0);
}