syscall/
data.rs

1use core::{
2    mem,
3    ops::{Deref, DerefMut},
4    slice,
5};
6
7use crate::flag::{EventFlags, MapFlags, PtraceFlags};
8
9#[derive(Copy, Clone, Debug, Default)]
10#[repr(C)]
11pub struct Event {
12    pub id: usize,
13    pub flags: EventFlags,
14    pub data: usize,
15}
16
17impl Deref for Event {
18    type Target = [u8];
19    fn deref(&self) -> &[u8] {
20        unsafe { slice::from_raw_parts(self as *const Event as *const u8, mem::size_of::<Event>()) }
21    }
22}
23
24impl DerefMut for Event {
25    fn deref_mut(&mut self) -> &mut [u8] {
26        unsafe { slice::from_raw_parts_mut(self as *mut Event as *mut u8, mem::size_of::<Event>()) }
27    }
28}
29
30#[derive(Copy, Clone, Debug, Default)]
31#[repr(C)]
32pub struct ITimerSpec {
33    pub it_interval: TimeSpec,
34    pub it_value: TimeSpec,
35}
36
37impl Deref for ITimerSpec {
38    type Target = [u8];
39    fn deref(&self) -> &[u8] {
40        unsafe {
41            slice::from_raw_parts(
42                self as *const ITimerSpec as *const u8,
43                mem::size_of::<ITimerSpec>(),
44            )
45        }
46    }
47}
48
49impl DerefMut for ITimerSpec {
50    fn deref_mut(&mut self) -> &mut [u8] {
51        unsafe {
52            slice::from_raw_parts_mut(
53                self as *mut ITimerSpec as *mut u8,
54                mem::size_of::<ITimerSpec>(),
55            )
56        }
57    }
58}
59
60#[derive(Copy, Clone, Debug, Default)]
61#[repr(C)]
62pub struct OldMap {
63    pub offset: usize,
64    pub size: usize,
65    pub flags: MapFlags,
66}
67
68impl Deref for OldMap {
69    type Target = [u8];
70    fn deref(&self) -> &[u8] {
71        unsafe {
72            slice::from_raw_parts(self as *const OldMap as *const u8, mem::size_of::<OldMap>())
73        }
74    }
75}
76
77impl DerefMut for OldMap {
78    fn deref_mut(&mut self) -> &mut [u8] {
79        unsafe {
80            slice::from_raw_parts_mut(self as *mut OldMap as *mut u8, mem::size_of::<OldMap>())
81        }
82    }
83}
84#[derive(Copy, Clone, Debug, Default)]
85#[repr(C)]
86pub struct Map {
87    /// The offset inside the file that is being mapped.
88    pub offset: usize,
89
90    /// The size of the memory map.
91    pub size: usize,
92
93    /// Contains both prot and map flags.
94    pub flags: MapFlags,
95
96    /// Functions as a hint to where in the virtual address space of the running process, to place
97    /// the memory map. If [`MapFlags::MAP_FIXED`] is set, then this address must be the address to
98    /// map to.
99    pub address: usize,
100}
101
102impl Deref for Map {
103    type Target = [u8];
104    fn deref(&self) -> &[u8] {
105        unsafe { slice::from_raw_parts(self as *const Map as *const u8, mem::size_of::<Map>()) }
106    }
107}
108
109impl DerefMut for Map {
110    fn deref_mut(&mut self) -> &mut [u8] {
111        unsafe { slice::from_raw_parts_mut(self as *mut Map as *mut u8, mem::size_of::<Map>()) }
112    }
113}
114
115#[derive(Copy, Clone, Debug, Default)]
116#[repr(C)]
117pub struct Packet {
118    pub id: u64,
119    pub pid: usize,
120    pub uid: u32,
121    pub gid: u32,
122    pub a: usize,
123    pub b: usize,
124    pub c: usize,
125    pub d: usize,
126}
127
128impl Deref for Packet {
129    type Target = [u8];
130    fn deref(&self) -> &[u8] {
131        unsafe {
132            slice::from_raw_parts(self as *const Packet as *const u8, mem::size_of::<Packet>())
133        }
134    }
135}
136
137impl DerefMut for Packet {
138    fn deref_mut(&mut self) -> &mut [u8] {
139        unsafe {
140            slice::from_raw_parts_mut(self as *mut Packet as *mut u8, mem::size_of::<Packet>())
141        }
142    }
143}
144
145#[derive(Copy, Clone, Debug, Default, PartialEq)]
146#[repr(C)]
147pub struct Stat {
148    pub st_dev: u64,
149    pub st_ino: u64,
150    pub st_mode: u16,
151    pub st_nlink: u32,
152    pub st_uid: u32,
153    pub st_gid: u32,
154    pub st_size: u64,
155    pub st_blksize: u32,
156    pub st_blocks: u64,
157    pub st_mtime: u64,
158    pub st_mtime_nsec: u32,
159    pub st_atime: u64,
160    pub st_atime_nsec: u32,
161    pub st_ctime: u64,
162    pub st_ctime_nsec: u32,
163}
164
165impl Deref for Stat {
166    type Target = [u8];
167    fn deref(&self) -> &[u8] {
168        unsafe { slice::from_raw_parts(self as *const Stat as *const u8, mem::size_of::<Stat>()) }
169    }
170}
171
172impl DerefMut for Stat {
173    fn deref_mut(&mut self) -> &mut [u8] {
174        unsafe { slice::from_raw_parts_mut(self as *mut Stat as *mut u8, mem::size_of::<Stat>()) }
175    }
176}
177
178#[derive(Copy, Clone, Debug, Default, PartialEq)]
179#[repr(C)]
180pub struct StatVfs {
181    pub f_bsize: u32,
182    pub f_blocks: u64,
183    pub f_bfree: u64,
184    pub f_bavail: u64,
185}
186
187impl Deref for StatVfs {
188    type Target = [u8];
189    fn deref(&self) -> &[u8] {
190        unsafe {
191            slice::from_raw_parts(
192                self as *const StatVfs as *const u8,
193                mem::size_of::<StatVfs>(),
194            )
195        }
196    }
197}
198
199impl DerefMut for StatVfs {
200    fn deref_mut(&mut self) -> &mut [u8] {
201        unsafe {
202            slice::from_raw_parts_mut(self as *mut StatVfs as *mut u8, mem::size_of::<StatVfs>())
203        }
204    }
205}
206
207#[derive(Copy, Clone, Debug, Default, PartialEq)]
208#[repr(C)]
209pub struct TimeSpec {
210    pub tv_sec: i64,
211    pub tv_nsec: i32,
212}
213
214impl Deref for TimeSpec {
215    type Target = [u8];
216    fn deref(&self) -> &[u8] {
217        unsafe {
218            slice::from_raw_parts(
219                self as *const TimeSpec as *const u8,
220                mem::size_of::<TimeSpec>(),
221            )
222        }
223    }
224}
225
226impl DerefMut for TimeSpec {
227    fn deref_mut(&mut self) -> &mut [u8] {
228        unsafe {
229            slice::from_raw_parts_mut(self as *mut TimeSpec as *mut u8, mem::size_of::<TimeSpec>())
230        }
231    }
232}
233
234#[derive(Clone, Copy, Debug, Default)]
235#[repr(C)]
236pub struct PtraceEvent {
237    pub cause: PtraceFlags,
238    pub a: usize,
239    pub b: usize,
240    pub c: usize,
241    pub d: usize,
242    pub e: usize,
243    pub f: usize,
244}
245
246impl Deref for PtraceEvent {
247    type Target = [u8];
248    fn deref(&self) -> &[u8] {
249        unsafe {
250            slice::from_raw_parts(
251                self as *const PtraceEvent as *const u8,
252                mem::size_of::<PtraceEvent>(),
253            )
254        }
255    }
256}
257
258impl DerefMut for PtraceEvent {
259    fn deref_mut(&mut self) -> &mut [u8] {
260        unsafe {
261            slice::from_raw_parts_mut(
262                self as *mut PtraceEvent as *mut u8,
263                mem::size_of::<PtraceEvent>(),
264            )
265        }
266    }
267}
268
269#[macro_export]
270macro_rules! ptrace_event {
271    ($cause:expr $(, $a:expr $(, $b:expr $(, $c:expr)?)?)?) => {
272        $crate::data::PtraceEvent {
273            cause: $cause,
274            $(a: $a,
275              $(b: $b,
276                $(c: $c,)?
277              )?
278            )?
279            ..Default::default()
280        }
281    }
282}
283
284bitflags::bitflags! {
285    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
286    pub struct GrantFlags: usize {
287        const GRANT_READ = 0x0000_0001;
288        const GRANT_WRITE = 0x0000_0002;
289        const GRANT_EXEC = 0x0000_0004;
290
291        const GRANT_SHARED = 0x0000_0008;
292        const GRANT_LAZY = 0x0000_0010;
293        const GRANT_SCHEME = 0x0000_0020;
294        const GRANT_PHYS = 0x0000_0040;
295        const GRANT_PINNED = 0x0000_0080;
296        const GRANT_PHYS_CONTIGUOUS = 0x0000_0100;
297    }
298}
299
300impl GrantFlags {
301    #[deprecated = "use the safe `from_bits_retain` method instead"]
302    pub unsafe fn from_bits_unchecked(bits: usize) -> Self {
303        Self::from_bits_retain(bits)
304    }
305}
306
307#[derive(Clone, Copy, Debug, Default)]
308#[repr(C)]
309pub struct GrantDesc {
310    pub base: usize,
311    pub size: usize,
312    pub flags: GrantFlags,
313    pub offset: u64,
314}
315
316impl Deref for GrantDesc {
317    type Target = [u8];
318    fn deref(&self) -> &[u8] {
319        unsafe {
320            slice::from_raw_parts(
321                self as *const GrantDesc as *const u8,
322                mem::size_of::<GrantDesc>(),
323            )
324        }
325    }
326}
327
328impl DerefMut for GrantDesc {
329    fn deref_mut(&mut self) -> &mut [u8] {
330        unsafe {
331            slice::from_raw_parts_mut(
332                self as *mut GrantDesc as *mut u8,
333                mem::size_of::<GrantDesc>(),
334            )
335        }
336    }
337}
338
339#[derive(Clone, Copy, Debug, Default)]
340#[repr(C)]
341pub struct SetSighandlerData {
342    pub user_handler: usize,
343    pub excp_handler: usize,
344    pub thread_control_addr: usize,
345    pub proc_control_addr: usize,
346}
347
348impl Deref for SetSighandlerData {
349    type Target = [u8];
350    fn deref(&self) -> &[u8] {
351        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
352    }
353}
354
355impl DerefMut for SetSighandlerData {
356    fn deref_mut(&mut self) -> &mut [u8] {
357        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut u8, mem::size_of::<Self>()) }
358    }
359}
360pub use crate::sigabi::*;
361
362#[derive(Copy, Clone, Debug, Default, PartialEq)]
363#[repr(C)]
364pub struct RtSigInfo {
365    pub arg: usize,
366    pub code: i32,
367    pub uid: u32,
368    pub pid: u32, // TODO: usize?
369}
370
371impl Deref for RtSigInfo {
372    type Target = [u8];
373    fn deref(&self) -> &[u8] {
374        unsafe {
375            slice::from_raw_parts(
376                self as *const RtSigInfo as *const u8,
377                mem::size_of::<RtSigInfo>(),
378            )
379        }
380    }
381}
382
383impl DerefMut for RtSigInfo {
384    fn deref_mut(&mut self) -> &mut [u8] {
385        unsafe {
386            slice::from_raw_parts_mut(self as *mut RtSigInfo as *mut u8, mem::size_of::<RtSigInfo>())
387        }
388    }
389}
syscall/data.rs

syscall/
data.rs
