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)]
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