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