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, PartialEq)]
116#[repr(C)]
117pub struct Stat {
118    pub st_dev: u64,
119    pub st_ino: u64,
120    pub st_mode: u16,
121    pub st_nlink: u32,
122    pub st_uid: u32,
123    pub st_gid: u32,
124    pub st_size: u64,
125    pub st_blksize: u32,
126    pub st_blocks: u64,
127    pub st_mtime: u64,
128    pub st_mtime_nsec: u32,
129    pub st_atime: u64,
130    pub st_atime_nsec: u32,
131    pub st_ctime: u64,
132    pub st_ctime_nsec: u32,
133}
134
135impl Deref for Stat {
136    type Target = [u8];
137    fn deref(&self) -> &[u8] {
138        unsafe { slice::from_raw_parts(self as *const Stat as *const u8, mem::size_of::<Stat>()) }
139    }
140}
141
142impl DerefMut for Stat {
143    fn deref_mut(&mut self) -> &mut [u8] {
144        unsafe { slice::from_raw_parts_mut(self as *mut Stat as *mut u8, mem::size_of::<Stat>()) }
145    }
146}
147
148#[derive(Copy, Clone, Debug, Default, PartialEq)]
149#[repr(C)]
150pub struct StatVfs {
151    pub f_bsize: u32,
152    pub f_blocks: u64,
153    pub f_bfree: u64,
154    pub f_bavail: u64,
155}
156
157impl Deref for StatVfs {
158    type Target = [u8];
159    fn deref(&self) -> &[u8] {
160        unsafe {
161            slice::from_raw_parts(
162                self as *const StatVfs as *const u8,
163                mem::size_of::<StatVfs>(),
164            )
165        }
166    }
167}
168
169impl DerefMut for StatVfs {
170    fn deref_mut(&mut self) -> &mut [u8] {
171        unsafe {
172            slice::from_raw_parts_mut(self as *mut StatVfs as *mut u8, mem::size_of::<StatVfs>())
173        }
174    }
175}
176
177#[derive(Copy, Clone, Debug, Default, PartialEq)]
178#[repr(C)]
179pub struct TimeSpec {
180    pub tv_sec: i64,
181    pub tv_nsec: i32,
182}
183
184impl Deref for TimeSpec {
185    type Target = [u8];
186    fn deref(&self) -> &[u8] {
187        unsafe {
188            slice::from_raw_parts(
189                self as *const TimeSpec as *const u8,
190                mem::size_of::<TimeSpec>(),
191            )
192        }
193    }
194}
195
196impl DerefMut for TimeSpec {
197    fn deref_mut(&mut self) -> &mut [u8] {
198        unsafe {
199            slice::from_raw_parts_mut(self as *mut TimeSpec as *mut u8, mem::size_of::<TimeSpec>())
200        }
201    }
202}
203
204#[derive(Clone, Copy, Debug, Default)]
205#[repr(C)]
206pub struct PtraceEvent {
207    pub cause: PtraceFlags,
208    pub a: usize,
209    pub b: usize,
210    pub c: usize,
211    pub d: usize,
212    pub e: usize,
213    pub f: usize,
214}
215
216impl Deref for PtraceEvent {
217    type Target = [u8];
218    fn deref(&self) -> &[u8] {
219        unsafe {
220            slice::from_raw_parts(
221                self as *const PtraceEvent as *const u8,
222                mem::size_of::<PtraceEvent>(),
223            )
224        }
225    }
226}
227
228impl DerefMut for PtraceEvent {
229    fn deref_mut(&mut self) -> &mut [u8] {
230        unsafe {
231            slice::from_raw_parts_mut(
232                self as *mut PtraceEvent as *mut u8,
233                mem::size_of::<PtraceEvent>(),
234            )
235        }
236    }
237}
238
239#[macro_export]
240macro_rules! ptrace_event {
241    ($cause:expr $(, $a:expr $(, $b:expr $(, $c:expr)?)?)?) => {
242        $crate::data::PtraceEvent {
243            cause: $cause,
244            $(a: $a,
245              $(b: $b,
246                $(c: $c,)?
247              )?
248            )?
249            ..Default::default()
250        }
251    }
252}
253
254bitflags::bitflags! {
255    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
256    pub struct GrantFlags: usize {
257        const GRANT_READ = 0x0000_0001;
258        const GRANT_WRITE = 0x0000_0002;
259        const GRANT_EXEC = 0x0000_0004;
260
261        const GRANT_SHARED = 0x0000_0008;
262        const GRANT_LAZY = 0x0000_0010;
263        const GRANT_SCHEME = 0x0000_0020;
264        const GRANT_PHYS = 0x0000_0040;
265        const GRANT_PINNED = 0x0000_0080;
266        const GRANT_PHYS_CONTIGUOUS = 0x0000_0100;
267    }
268}
269
270impl GrantFlags {
271    #[deprecated = "use the safe `from_bits_retain` method instead"]
272    pub unsafe fn from_bits_unchecked(bits: usize) -> Self {
273        Self::from_bits_retain(bits)
274    }
275}
276
277#[derive(Clone, Copy, Debug, Default)]
278#[repr(C)]
279pub struct GrantDesc {
280    pub base: usize,
281    pub size: usize,
282    pub flags: GrantFlags,
283    pub offset: u64,
284}
285
286impl Deref for GrantDesc {
287    type Target = [u8];
288    fn deref(&self) -> &[u8] {
289        unsafe {
290            slice::from_raw_parts(
291                self as *const GrantDesc as *const u8,
292                mem::size_of::<GrantDesc>(),
293            )
294        }
295    }
296}
297
298impl DerefMut for GrantDesc {
299    fn deref_mut(&mut self) -> &mut [u8] {
300        unsafe {
301            slice::from_raw_parts_mut(
302                self as *mut GrantDesc as *mut u8,
303                mem::size_of::<GrantDesc>(),
304            )
305        }
306    }
307}
308
309#[derive(Clone, Copy, Debug, Default)]
310#[repr(C)]
311pub struct SetSighandlerData {
312    pub user_handler: usize,
313    pub excp_handler: usize,
314    pub thread_control_addr: usize,
315    pub proc_control_addr: usize,
316}
317
318impl Deref for SetSighandlerData {
319    type Target = [u8];
320    fn deref(&self) -> &[u8] {
321        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
322    }
323}
324
325impl DerefMut for SetSighandlerData {
326    fn deref_mut(&mut self) -> &mut [u8] {
327        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut u8, mem::size_of::<Self>()) }
328    }
329}
330pub use crate::sigabi::*;
331
332/// UNSTABLE
333#[derive(Copy, Clone, Debug, Default, PartialEq)]
334#[repr(C)]
335pub struct ProcSchemeAttrs {
336    pub pid: u32,
337    pub euid: u32,
338    pub egid: u32,
339    pub ens: u32,
340    pub debug_name: [u8; 32],
341}
342impl Deref for ProcSchemeAttrs {
343    type Target = [u8];
344    fn deref(&self) -> &[u8] {
345        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
346    }
347}
348impl DerefMut for ProcSchemeAttrs {
349    fn deref_mut(&mut self) -> &mut [u8] {
350        unsafe {
351            slice::from_raw_parts_mut(
352                self as *mut ProcSchemeAttrs as *mut u8,
353                mem::size_of::<ProcSchemeAttrs>(),
354            )
355        }
356    }
357}
358#[derive(Copy, Clone, Debug, Default)]
359#[repr(C)]
360pub struct CtxtStsBuf {
361    pub status: usize,
362    pub excp: crate::Exception,
363}
364impl Deref for CtxtStsBuf {
365    type Target = [u8];
366    fn deref(&self) -> &[u8] {
367        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
368    }
369}
370impl DerefMut for CtxtStsBuf {
371    fn deref_mut(&mut self) -> &mut [u8] {
372        unsafe {
373            slice::from_raw_parts_mut(
374                self as *mut CtxtStsBuf as *mut u8,
375                mem::size_of::<CtxtStsBuf>(),
376            )
377        }
378    }
379}
380
381#[derive(Copy, Clone, Debug, Default)]
382#[repr(C)]
383pub struct NewFdParams {
384    pub offset: u64,
385    pub number: usize,
386    pub flags: usize,
387    pub internal_flags: u8,
388}
389
390#[repr(u8)]
391#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
392pub enum GlobalSchemes {
393    Debug = 1,
394    Event = 2,
395    Memory = 3,
396    Pipe = 4,
397    Serio = 5,
398    Irq = 6,
399    Time = 7,
400    Sys = 8,
401    Proc = 9,
402    Acpi = 10,
403    Dtb = 11,
404}
405impl GlobalSchemes {
406    pub fn try_from_raw(raw: u8) -> Option<Self> {
407        match raw {
408            1 => Some(Self::Debug),
409            2 => Some(Self::Event),
410            3 => Some(Self::Memory),
411            4 => Some(Self::Pipe),
412            5 => Some(Self::Serio),
413            6 => Some(Self::Irq),
414            7 => Some(Self::Time),
415            8 => Some(Self::Sys),
416            9 => Some(Self::Proc),
417            10 => Some(Self::Acpi),
418            11 => Some(Self::Dtb),
419            _ => None,
420        }
421    }
422    pub fn as_str(&self) -> &'static str {
423        match self {
424            Self::Debug => "debug",
425            Self::Event => "event",
426            Self::Memory => "memory",
427            Self::Pipe => "pipe",
428            Self::Serio => "serio",
429            Self::Irq => "irq",
430            Self::Time => "time",
431            Self::Sys => "sys",
432            Self::Proc => "kernel.proc",
433            Self::Acpi => "kernel.acpi",
434            Self::Dtb => "kernel.dtb",
435        }
436    }
437}
438
439#[repr(C)]
440#[derive(Debug, Clone, Copy, Default)]
441pub struct KernelSchemeInfo {
442    pub scheme_id: u8,
443    pub fd: usize,
444}
syscall/data.rs

syscall/
data.rs
