1 use core::ops::{Deref, DerefMut};
2 use core::{mem, slice};
3 
4 #[derive(Copy, Clone, Debug, Default)]
5 #[repr(C)]
6 pub struct Event {
7     pub id: usize,
8     pub flags: usize,
9     pub data: usize
10 }
11 
12 impl Deref for Event {
13     type Target = [u8];
deref(&self) -> &[u8]14     fn deref(&self) -> &[u8] {
15         unsafe {
16             slice::from_raw_parts(self as *const Event as *const u8, mem::size_of::<Event>()) as &[u8]
17         }
18     }
19 }
20 
21 impl DerefMut for Event {
deref_mut(&mut self) -> &mut [u8]22     fn deref_mut(&mut self) -> &mut [u8] {
23         unsafe {
24             slice::from_raw_parts_mut(self as *mut Event as *mut u8, mem::size_of::<Event>()) as &mut [u8]
25         }
26     }
27 }
28 
29 #[derive(Copy, Clone, Debug, Default)]
30 #[repr(C)]
31 pub struct ITimerSpec {
32     pub it_interval: TimeSpec,
33     pub it_value: TimeSpec,
34 }
35 
36 impl Deref for ITimerSpec {
37     type Target = [u8];
deref(&self) -> &[u8]38     fn deref(&self) -> &[u8] {
39         unsafe {
40             slice::from_raw_parts(self as *const ITimerSpec as *const u8,
41                                   mem::size_of::<ITimerSpec>()) as &[u8]
42         }
43     }
44 }
45 
46 impl DerefMut for ITimerSpec {
deref_mut(&mut self) -> &mut [u8]47     fn deref_mut(&mut self) -> &mut [u8] {
48         unsafe {
49             slice::from_raw_parts_mut(self as *mut ITimerSpec as *mut u8,
50                                       mem::size_of::<ITimerSpec>()) as &mut [u8]
51         }
52     }
53 }
54 
55 #[derive(Copy, Clone, Debug, Default)]
56 #[repr(C)]
57 pub struct Map {
58     pub offset: usize,
59     pub size: usize,
60     pub flags: usize,
61 }
62 
63 impl Deref for Map {
64     type Target = [u8];
deref(&self) -> &[u8]65     fn deref(&self) -> &[u8] {
66         unsafe {
67             slice::from_raw_parts(self as *const Map as *const u8, mem::size_of::<Map>()) as &[u8]
68         }
69     }
70 }
71 
72 impl DerefMut for Map {
deref_mut(&mut self) -> &mut [u8]73     fn deref_mut(&mut self) -> &mut [u8] {
74         unsafe {
75             slice::from_raw_parts_mut(self as *mut Map as *mut u8, mem::size_of::<Map>()) as &mut [u8]
76         }
77     }
78 }
79 
80 #[derive(Copy, Clone, Debug, Default)]
81 #[repr(C)]
82 pub struct Packet {
83     pub id: u64,
84     pub pid: usize,
85     pub uid: u32,
86     pub gid: u32,
87     pub a: usize,
88     pub b: usize,
89     pub c: usize,
90     pub d: usize
91 }
92 
93 impl Deref for Packet {
94     type Target = [u8];
deref(&self) -> &[u8]95     fn deref(&self) -> &[u8] {
96         unsafe {
97             slice::from_raw_parts(self as *const Packet as *const u8, mem::size_of::<Packet>()) as &[u8]
98         }
99     }
100 }
101 
102 impl DerefMut for Packet {
deref_mut(&mut self) -> &mut [u8]103     fn deref_mut(&mut self) -> &mut [u8] {
104         unsafe {
105             slice::from_raw_parts_mut(self as *mut Packet as *mut u8, mem::size_of::<Packet>()) as &mut [u8]
106         }
107     }
108 }
109 
110 #[derive(Copy, Clone, Debug)]
111 #[repr(C)]
112 pub struct SigAction {
113     pub sa_handler: extern "C" fn(usize),
114     pub sa_mask: [u64; 2],
115     pub sa_flags: usize,
116 }
117 
118 impl Default for SigAction {
default() -> Self119     fn default() -> Self {
120         Self {
121             sa_handler: unsafe { mem::transmute(0usize) },
122             sa_mask: [0; 2],
123             sa_flags: 0,
124         }
125     }
126 }
127 
128 #[derive(Copy, Clone, Debug, Default)]
129 #[repr(C)]
130 pub struct Stat {
131     pub st_dev: u64,
132     pub st_ino: u64,
133     pub st_mode: u16,
134     pub st_nlink: u32,
135     pub st_uid: u32,
136     pub st_gid: u32,
137     pub st_size: u64,
138     pub st_blksize: u32,
139     pub st_blocks: u64,
140     pub st_mtime: u64,
141     pub st_mtime_nsec: u32,
142     pub st_atime: u64,
143     pub st_atime_nsec: u32,
144     pub st_ctime: u64,
145     pub st_ctime_nsec: u32,
146 }
147 
148 impl Deref for Stat {
149     type Target = [u8];
deref(&self) -> &[u8]150     fn deref(&self) -> &[u8] {
151         unsafe {
152             slice::from_raw_parts(self as *const Stat as *const u8,
153                                   mem::size_of::<Stat>()) as &[u8]
154         }
155     }
156 }
157 
158 impl DerefMut for Stat {
deref_mut(&mut self) -> &mut [u8]159     fn deref_mut(&mut self) -> &mut [u8] {
160         unsafe {
161             slice::from_raw_parts_mut(self as *mut Stat as *mut u8,
162                                       mem::size_of::<Stat>()) as &mut [u8]
163         }
164     }
165 }
166 
167 #[derive(Copy, Clone, Debug, Default)]
168 #[repr(C)]
169 pub struct StatVfs {
170     pub f_bsize: u32,
171     pub f_blocks: u64,
172     pub f_bfree: u64,
173     pub f_bavail: u64,
174 }
175 
176 impl Deref for StatVfs {
177     type Target = [u8];
deref(&self) -> &[u8]178     fn deref(&self) -> &[u8] {
179         unsafe {
180             slice::from_raw_parts(self as *const StatVfs as *const u8,
181                                   mem::size_of::<StatVfs>()) as &[u8]
182         }
183     }
184 }
185 
186 impl DerefMut for StatVfs {
deref_mut(&mut self) -> &mut [u8]187     fn deref_mut(&mut self) -> &mut [u8] {
188         unsafe {
189             slice::from_raw_parts_mut(self as *mut StatVfs as *mut u8,
190                                       mem::size_of::<StatVfs>()) as &mut [u8]
191         }
192     }
193 }
194 
195 #[derive(Copy, Clone, Debug, Default, PartialEq)]
196 #[repr(C)]
197 pub struct TimeSpec {
198     pub tv_sec: i64,
199     pub tv_nsec: i32,
200 }
201 
202 impl Deref for TimeSpec {
203     type Target = [u8];
deref(&self) -> &[u8]204     fn deref(&self) -> &[u8] {
205         unsafe {
206             slice::from_raw_parts(self as *const TimeSpec as *const u8,
207                                   mem::size_of::<TimeSpec>()) as &[u8]
208         }
209     }
210 }
211 
212 impl DerefMut for TimeSpec {
deref_mut(&mut self) -> &mut [u8]213     fn deref_mut(&mut self) -> &mut [u8] {
214         unsafe {
215             slice::from_raw_parts_mut(self as *mut TimeSpec as *mut u8,
216                                       mem::size_of::<TimeSpec>()) as &mut [u8]
217         }
218     }
219 }
220 
221 #[derive(Copy, Clone, Debug, Default)]
222 #[repr(C)]
223 #[cfg(target_arch = "x86_64")]
224 pub struct IntRegisters {
225     pub r15: usize,
226     pub r14: usize,
227     pub r13: usize,
228     pub r12: usize,
229     pub rbp: usize,
230     pub rbx: usize,
231     pub r11: usize,
232     pub r10: usize,
233     pub r9: usize,
234     pub r8: usize,
235     pub rax: usize,
236     pub rcx: usize,
237     pub rdx: usize,
238     pub rsi: usize,
239     pub rdi: usize,
240     // pub orig_rax: usize,
241     pub rip: usize,
242     pub cs: usize,
243     pub eflags: usize,
244     pub rsp: usize,
245     pub ss: usize,
246     pub fs_base: usize,
247     pub gs_base: usize,
248     pub ds: usize,
249     pub es: usize,
250     pub fs: usize,
251     pub gs: usize
252 }
253 
254 impl Deref for IntRegisters {
255     type Target = [u8];
deref(&self) -> &[u8]256     fn deref(&self) -> &[u8] {
257         unsafe {
258             slice::from_raw_parts(self as *const IntRegisters as *const u8, mem::size_of::<IntRegisters>()) as &[u8]
259         }
260     }
261 }
262 
263 impl DerefMut for IntRegisters {
deref_mut(&mut self) -> &mut [u8]264     fn deref_mut(&mut self) -> &mut [u8] {
265         unsafe {
266             slice::from_raw_parts_mut(self as *mut IntRegisters as *mut u8, mem::size_of::<IntRegisters>()) as &mut [u8]
267         }
268     }
269 }
270 
271 #[derive(Clone, Copy)]
272 #[repr(C)]
273 #[cfg(target_arch = "x86_64")]
274 pub struct FloatRegisters {
275     pub cwd: u16,
276     pub swd: u16,
277     pub ftw: u16,
278     pub fop: u16,
279     pub rip: u64,
280     pub rdp: u64,
281     pub mxcsr: u32,
282     pub mxcr_mask: u32,
283     pub st_space: [u32; 32],
284     pub xmm_space: [u32; 64]
285 }
286 
287 impl Default for FloatRegisters {
default() -> Self288     fn default() -> Self {
289         // xmm_space is not Default until const generics
290         unsafe { mem::zeroed() }
291     }
292 }
293 
294 impl Deref for FloatRegisters {
295     type Target = [u8];
deref(&self) -> &[u8]296     fn deref(&self) -> &[u8] {
297         unsafe {
298             slice::from_raw_parts(self as *const FloatRegisters as *const u8, mem::size_of::<FloatRegisters>()) as &[u8]
299         }
300     }
301 }
302 
303 impl DerefMut for FloatRegisters {
deref_mut(&mut self) -> &mut [u8]304     fn deref_mut(&mut self) -> &mut [u8] {
305         unsafe {
306             slice::from_raw_parts_mut(self as *mut FloatRegisters as *mut u8, mem::size_of::<FloatRegisters>()) as &mut [u8]
307         }
308     }
309 }
310