syscall/
data.rs

1use core::{
2    mem,
3    ops::{Deref, DerefMut},
4    slice,
5};
6
7use crate::flag::{EventFlags, MapFlags, PtraceFlags, StdFsCallKind};
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, packed)]
179pub struct StdFsCallMeta {
180    pub kind: u8, // enum StdFsCallKind
181    _rsvd: [u8; 7],
182    pub arg1: u64,
183    pub arg2: u64,
184}
185
186impl StdFsCallMeta {
187    pub fn new(kind: StdFsCallKind, arg1: u64, arg2: u64) -> Self {
188        Self {
189            kind: kind as u8,
190            _rsvd: [0; 7],
191            arg1,
192            arg2,
193        }
194    }
195}
196
197impl Deref for StdFsCallMeta {
198    type Target = [u64];
199    fn deref(&self) -> &[u64] {
200        unsafe {
201            slice::from_raw_parts(
202                self as *const StdFsCallMeta as *const u64,
203                mem::size_of::<StdFsCallMeta>() / mem::size_of::<u64>(),
204            )
205        }
206    }
207}
208
209impl DerefMut for StdFsCallMeta {
210    fn deref_mut(&mut self) -> &mut [u64] {
211        unsafe {
212            slice::from_raw_parts_mut(
213                self as *mut StdFsCallMeta as *mut u64,
214                mem::size_of::<StdFsCallMeta>() / mem::size_of::<u64>(),
215            )
216        }
217    }
218}
219
220#[derive(Copy, Clone, Debug, Default, PartialEq)]
221#[repr(C)]
222pub struct TimeSpec {
223    pub tv_sec: i64,
224    pub tv_nsec: i32,
225}
226
227const NANOS_PER_SEC: u128 = 1_000_000_000;
228
229impl TimeSpec {
230    pub fn from_nanos(nanos: u128) -> Self {
231        Self {
232            tv_sec: i64::try_from(nanos / NANOS_PER_SEC).unwrap_or(i64::MAX),
233            tv_nsec: (nanos % NANOS_PER_SEC) as i32, // guaranteed to never overflow
234        }
235    }
236    pub fn to_nanos(&self) -> u128 {
237        self.tv_sec as u128 * NANOS_PER_SEC + self.tv_nsec as u128
238    }
239}
240
241impl Deref for TimeSpec {
242    type Target = [u8];
243    fn deref(&self) -> &[u8] {
244        unsafe {
245            slice::from_raw_parts(
246                self as *const TimeSpec as *const u8,
247                mem::size_of::<TimeSpec>(),
248            )
249        }
250    }
251}
252
253impl DerefMut for TimeSpec {
254    fn deref_mut(&mut self) -> &mut [u8] {
255        unsafe {
256            slice::from_raw_parts_mut(self as *mut TimeSpec as *mut u8, mem::size_of::<TimeSpec>())
257        }
258    }
259}
260
261#[derive(Clone, Copy, Debug, Default)]
262#[repr(C)]
263pub struct PtraceEvent {
264    pub cause: PtraceFlags,
265    pub a: usize,
266    pub b: usize,
267    pub c: usize,
268    pub d: usize,
269    pub e: usize,
270    pub f: usize,
271}
272
273impl Deref for PtraceEvent {
274    type Target = [u8];
275    fn deref(&self) -> &[u8] {
276        unsafe {
277            slice::from_raw_parts(
278                self as *const PtraceEvent as *const u8,
279                mem::size_of::<PtraceEvent>(),
280            )
281        }
282    }
283}
284
285impl DerefMut for PtraceEvent {
286    fn deref_mut(&mut self) -> &mut [u8] {
287        unsafe {
288            slice::from_raw_parts_mut(
289                self as *mut PtraceEvent as *mut u8,
290                mem::size_of::<PtraceEvent>(),
291            )
292        }
293    }
294}
295
296#[macro_export]
297macro_rules! ptrace_event {
298    ($cause:expr $(, $a:expr $(, $b:expr $(, $c:expr)?)?)?) => {
299        $crate::data::PtraceEvent {
300            cause: $cause,
301            $(a: $a,
302              $(b: $b,
303                $(c: $c,)?
304              )?
305            )?
306            ..Default::default()
307        }
308    }
309}
310
311bitflags::bitflags! {
312    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy, Default)]
313    pub struct GrantFlags: usize {
314        const GRANT_READ = 0x0000_0001;
315        const GRANT_WRITE = 0x0000_0002;
316        const GRANT_EXEC = 0x0000_0004;
317
318        const GRANT_SHARED = 0x0000_0008;
319        const GRANT_LAZY = 0x0000_0010;
320        const GRANT_SCHEME = 0x0000_0020;
321        const GRANT_PHYS = 0x0000_0040;
322        const GRANT_PINNED = 0x0000_0080;
323        const GRANT_PHYS_CONTIGUOUS = 0x0000_0100;
324    }
325}
326
327impl GrantFlags {
328    #[deprecated = "use the safe `from_bits_retain` method instead"]
329    pub unsafe fn from_bits_unchecked(bits: usize) -> Self {
330        Self::from_bits_retain(bits)
331    }
332}
333
334#[derive(Clone, Copy, Debug, Default)]
335#[repr(C)]
336pub struct GrantDesc {
337    pub base: usize,
338    pub size: usize,
339    pub flags: GrantFlags,
340    pub offset: u64,
341}
342
343impl Deref for GrantDesc {
344    type Target = [u8];
345    fn deref(&self) -> &[u8] {
346        unsafe {
347            slice::from_raw_parts(
348                self as *const GrantDesc as *const u8,
349                mem::size_of::<GrantDesc>(),
350            )
351        }
352    }
353}
354
355impl DerefMut for GrantDesc {
356    fn deref_mut(&mut self) -> &mut [u8] {
357        unsafe {
358            slice::from_raw_parts_mut(
359                self as *mut GrantDesc as *mut u8,
360                mem::size_of::<GrantDesc>(),
361            )
362        }
363    }
364}
365
366#[derive(Clone, Copy, Debug, Default)]
367#[repr(C)]
368pub struct SetSighandlerData {
369    pub user_handler: usize,
370    pub excp_handler: usize,
371    pub thread_control_addr: usize,
372    pub proc_control_addr: usize,
373}
374
375impl Deref for SetSighandlerData {
376    type Target = [u8];
377    fn deref(&self) -> &[u8] {
378        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
379    }
380}
381
382impl DerefMut for SetSighandlerData {
383    fn deref_mut(&mut self) -> &mut [u8] {
384        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut u8, mem::size_of::<Self>()) }
385    }
386}
387pub use crate::sigabi::*;
388
389/// UNSTABLE
390#[derive(Copy, Clone, Debug, Default, PartialEq)]
391#[repr(C)]
392pub struct ProcSchemeAttrs {
393    pub pid: u32,
394    pub euid: u32,
395    pub egid: u32,
396    pub prio: u32,
397    pub debug_name: [u8; 32],
398}
399impl Deref for ProcSchemeAttrs {
400    type Target = [u8];
401    fn deref(&self) -> &[u8] {
402        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
403    }
404}
405impl DerefMut for ProcSchemeAttrs {
406    fn deref_mut(&mut self) -> &mut [u8] {
407        unsafe {
408            slice::from_raw_parts_mut(
409                self as *mut ProcSchemeAttrs as *mut u8,
410                mem::size_of::<ProcSchemeAttrs>(),
411            )
412        }
413    }
414}
415#[derive(Copy, Clone, Debug, Default)]
416#[repr(C)]
417pub struct CtxtStsBuf {
418    pub status: usize,
419    pub excp: crate::Exception,
420}
421impl Deref for CtxtStsBuf {
422    type Target = [u8];
423    fn deref(&self) -> &[u8] {
424        unsafe { slice::from_raw_parts(self as *const Self as *const u8, mem::size_of::<Self>()) }
425    }
426}
427impl DerefMut for CtxtStsBuf {
428    fn deref_mut(&mut self) -> &mut [u8] {
429        unsafe {
430            slice::from_raw_parts_mut(
431                self as *mut CtxtStsBuf as *mut u8,
432                mem::size_of::<CtxtStsBuf>(),
433            )
434        }
435    }
436}
437
438#[derive(Copy, Clone, Debug, Default)]
439#[repr(C)]
440pub struct NewFdParams {
441    pub offset: u64,
442    pub number: usize,
443    pub flags: usize,
444    pub internal_flags: u8,
445}
446
447#[repr(u8)]
448#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
449pub enum GlobalSchemes {
450    Debug = 1,
451    Event = 2,
452    Memory = 3,
453    Pipe = 4,
454    Serio = 5,
455    Irq = 6,
456    Time = 7,
457    Sys = 8,
458    Proc = 9,
459    Acpi = 10,
460    Dtb = 11,
461}
462impl GlobalSchemes {
463    pub fn try_from_raw(raw: u8) -> Option<Self> {
464        match raw {
465            1 => Some(Self::Debug),
466            2 => Some(Self::Event),
467            3 => Some(Self::Memory),
468            4 => Some(Self::Pipe),
469            5 => Some(Self::Serio),
470            6 => Some(Self::Irq),
471            7 => Some(Self::Time),
472            8 => Some(Self::Sys),
473            9 => Some(Self::Proc),
474            10 => Some(Self::Acpi),
475            11 => Some(Self::Dtb),
476            _ => None,
477        }
478    }
479    pub fn as_str(&self) -> &'static str {
480        match self {
481            Self::Debug => "debug",
482            Self::Event => "event",
483            Self::Memory => "memory",
484            Self::Pipe => "pipe",
485            Self::Serio => "serio",
486            Self::Irq => "irq",
487            Self::Time => "time",
488            Self::Sys => "sys",
489            Self::Proc => "kernel.proc",
490            Self::Acpi => "kernel.acpi",
491            Self::Dtb => "kernel.dtb",
492        }
493    }
494}
495
496#[repr(C)]
497#[derive(Debug, Clone, Copy, Default)]
498pub struct KernelSchemeInfo {
499    pub scheme_id: u8,
500    pub fd: usize,
501}
syscall/data.rs

syscall/
data.rs
