libc 0.2.190

Raw FFI bindings to platform libraries like libc.
Documentation 
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226

//! Header source: `include/signal.h`
//!
//! * Headers: <https://git.musl-libc.org/cgit/musl/tree/include/signal.h> (official)
//! * Headers: <https://github.com/kraj/musl/blob/master/include/signal.h> (mirror)

use crate::prelude::*;

s_no_extra_traits! {
    // `mips*` targets swap the `s_errno` and `s_code` fields otherwise this
    // struct is target-agnostic (see
    // <https://www.openwall.com/lists/musl/2016/01/27/1/2>)
    pub struct siginfo_t {
        pub si_signo: c_int,

        #[cfg(any(
            target_arch = "mips",
            target_arch = "mips64",
            target_arch = "mips32r6",
            target_arch = "mips64r6"
        ))]
        pub si_code: c_int,

        pub si_errno: c_int,

        #[cfg(not(any(
            target_arch = "mips",
            target_arch = "mips64",
            target_arch = "mips32r6",
            target_arch = "mips64r6"
        )))]
        pub si_code: c_int,

        __si_fields: __c_anonymous_siginfo_t___si_fields,
    }

    union __c_anonymous_siginfo_t___si_fields {
        __pad: [c_char; 128 - 2 * size_of::<c_int>() - size_of::<c_long>()],
        __si_common: __c_anonymous___si_fields___si_common,
        __sigfault: __c_anonymous___si_fields___sigfault,
        __sigpoll: __c_anonymous___si_fields___sigpoll,
        __sigsys: __c_anonymous___si_fields___sigsys,
    }

    struct __c_anonymous___si_fields___si_common {
        __first: __c_anonymous___si_common___first,
        __second: __c_anonymous___si_common___second,
    }

    struct __c_anonymous___si_fields___sigfault {
        si_addr: *mut c_void,
        si_addr_lsb: c_short,
        __first: __c_anonymous___sigfault___first,
    }

    struct __c_anonymous___si_fields___sigpoll {
        si_band: c_long,
        si_fd: c_int,
    }

    struct __c_anonymous___si_fields___sigsys {
        si_call_addr: *mut c_void,
        si_syscall: c_int,
        si_arch: c_uint,
    }

    union __c_anonymous___si_common___first {
        __piduid: __c_anonymous___first___piduid,
        __timer: __c_anonymous___first___timer,
    }

    union __c_anonymous___si_common___second {
        si_value: crate::sigval,
        __sigchld: __c_anonymous___second___sigchld,
    }

    union __c_anonymous___sigfault___first {
        __addr_band: __c_anonymous___first___addr_band,
        si_pkey: c_uint,
    }

    struct __c_anonymous___first___piduid {
        si_pid: crate::pid_t,
        si_uid: crate::uid_t,
    }

    struct __c_anonymous___first___timer {
        si_timerid: c_int,
        si_overrun: c_int,
    }

    struct __c_anonymous___second___sigchld {
        si_status: c_int,
        si_utime: crate::clock_t,
        si_stime: crate::clock_t,
    }

    struct __c_anonymous___first___addr_band {
        si_lower: *mut c_void,
        si_upper: *mut c_void,
    }
}

impl siginfo_t {
    #[inline]
    pub const unsafe fn si_pid(&self) -> crate::pid_t {
        unsafe { self.__si_fields.__si_common.__first.__piduid.si_pid }
    }

    #[inline]
    pub const unsafe fn si_uid(&self) -> crate::uid_t {
        unsafe { self.__si_fields.__si_common.__first.__piduid.si_uid }
    }

    #[inline]
    pub const unsafe fn si_status(&self) -> c_int {
        unsafe { self.__si_fields.__si_common.__second.__sigchld.si_status }
    }

    #[inline]
    pub const unsafe fn si_utime(&self) -> crate::clock_t {
        unsafe { self.__si_fields.__si_common.__second.__sigchld.si_utime }
    }

    #[inline]
    pub const unsafe fn si_stime(&self) -> crate::clock_t {
        unsafe { self.__si_fields.__si_common.__second.__sigchld.si_stime }
    }

    #[inline]
    pub const unsafe fn si_value(&self) -> crate::sigval {
        unsafe { self.__si_fields.__si_common.__second.si_value }
    }

    #[inline]
    pub const unsafe fn si_addr(&self) -> *mut c_void {
        unsafe { self.__si_fields.__sigfault.si_addr }
    }

    #[inline]
    pub const unsafe fn si_addr_lsb(&self) -> c_short {
        unsafe { self.__si_fields.__sigfault.si_addr_lsb }
    }

    #[inline]
    pub const unsafe fn si_lower(&self) -> *mut c_void {
        unsafe { self.__si_fields.__sigfault.__first.__addr_band.si_lower }
    }

    #[inline]
    pub const unsafe fn si_upper(&self) -> *mut c_void {
        unsafe { self.__si_fields.__sigfault.__first.__addr_band.si_upper }
    }

    #[inline]
    pub const unsafe fn si_pkey(&self) -> c_uint {
        unsafe { self.__si_fields.__sigfault.__first.si_pkey }
    }

    #[inline]
    pub const unsafe fn si_band(&self) -> c_long {
        unsafe { self.__si_fields.__sigpoll.si_band }
    }

    #[inline]
    pub const unsafe fn si_fd(&self) -> c_int {
        unsafe { self.__si_fields.__sigpoll.si_fd }
    }

    #[inline]
    pub const unsafe fn si_timerid(&self) -> c_int {
        unsafe { self.__si_fields.__si_common.__first.__timer.si_timerid }
    }

    #[inline]
    pub const unsafe fn si_overrun(&self) -> c_int {
        unsafe { self.__si_fields.__si_common.__first.__timer.si_overrun }
    }

    #[inline]
    pub const unsafe fn si_ptr(&self) -> *mut c_void {
        unsafe { self.__si_fields.__si_common.__second.si_value.sival_ptr }
    }

    #[inline]
    pub unsafe fn si_int(&self) -> c_int {
        // DIFF(main): sigval is a union on `main`, struct on `libc-0.2`. The cast means
        // this can't be const at the MSRV.
        unsafe { self.__si_fields.__si_common.__second.si_value.sival_ptr as usize as c_int }
    }

    #[inline]
    pub const unsafe fn si_call_addr(&self) -> *mut c_void {
        unsafe { self.__si_fields.__sigsys.si_call_addr }
    }

    #[inline]
    pub const unsafe fn si_syscall(&self) -> c_int {
        unsafe { self.__si_fields.__sigsys.si_syscall }
    }

    #[inline]
    pub const unsafe fn si_arch(&self) -> c_uint {
        unsafe { self.__si_fields.__sigsys.si_arch }
    }
}

cfg_if! {
    if #[cfg(feature = "extra_traits")] {
        impl PartialEq for siginfo_t {
            fn eq(&self, other: &Self) -> bool {
                (self.si_signo, self.si_errno, self.si_code)
                    == (other.si_signo, other.si_errno, other.si_code)
            }
        }

        impl Eq for siginfo_t {}

        impl core::hash::Hash for siginfo_t {
            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
                self.si_signo.hash(state);
                self.si_errno.hash(state);
                self.si_code.hash(state);
            }
        }
    }
}