syscall/scheme/
scheme_mut.rs

1use core::{mem, slice};
2
3use crate::{data::*, error::*, flag::*, number::*, scheme::*, CallerCtx, OpenResult};
4
5pub trait SchemeMut {
6    fn handle(&mut self, packet: &mut Packet) {
7        let res = match packet.a {
8            SYS_OPEN => {
9                if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
10                    convert_in_scheme_handle(
11                        packet,
12                        self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)),
13                    )
14                } else {
15                    Err(Error::new(EINVAL))
16                }
17            }
18            SYS_RMDIR => {
19                if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
20                    self.rmdir(path, packet.uid, packet.gid)
21                } else {
22                    Err(Error::new(EINVAL))
23                }
24            }
25            SYS_UNLINK => {
26                if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
27                    self.unlink(path, packet.uid, packet.gid)
28                } else {
29                    Err(Error::new(EINVAL))
30                }
31            }
32
33            SYS_DUP => convert_in_scheme_handle(
34                packet,
35                self.xdup(
36                    packet.b,
37                    unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) },
38                    &CallerCtx::from_packet(&packet),
39                ),
40            ),
41            SYS_READ => self.read(packet.b, unsafe {
42                slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
43            }),
44            SYS_WRITE => self.write(packet.b, unsafe {
45                slice::from_raw_parts(packet.c as *const u8, packet.d)
46            }),
47            SYS_LSEEK => self
48                .seek(packet.b, packet.c as isize, packet.d)
49                .map(|o| o as usize),
50            SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16),
51            SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32),
52            SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d),
53            SYS_FEVENT => self
54                .fevent(packet.b, EventFlags::from_bits_truncate(packet.c))
55                .map(|f| f.bits()),
56            SYS_FPATH => self.fpath(packet.b, unsafe {
57                slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
58            }),
59            SYS_FRENAME => {
60                if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
61                    self.frename(packet.b, path, packet.uid, packet.gid)
62                } else {
63                    Err(Error::new(EINVAL))
64                }
65            }
66            SYS_FSTAT => {
67                if packet.d >= mem::size_of::<Stat>() {
68                    self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
69                } else {
70                    Err(Error::new(EFAULT))
71                }
72            }
73            SYS_FSTATVFS => {
74                if packet.d >= mem::size_of::<StatVfs>() {
75                    self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
76                } else {
77                    Err(Error::new(EFAULT))
78                }
79            }
80            SYS_FSYNC => self.fsync(packet.b),
81            SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
82            SYS_FUTIMENS => {
83                if packet.d >= mem::size_of::<TimeSpec>() {
84                    self.futimens(packet.b, unsafe {
85                        slice::from_raw_parts(
86                            packet.c as *const TimeSpec,
87                            packet.d / mem::size_of::<TimeSpec>(),
88                        )
89                    })
90                } else {
91                    Err(Error::new(EFAULT))
92                }
93            }
94            SYS_CLOSE => self.close(packet.b),
95
96            KSMSG_MMAP_PREP => self.mmap_prep(
97                packet.b,
98                u64::from(packet.uid) | (u64::from(packet.gid) << 32),
99                packet.c,
100                MapFlags::from_bits_truncate(packet.d),
101            ),
102            KSMSG_MUNMAP => self.munmap(
103                packet.b,
104                u64::from(packet.uid) | (u64::from(packet.gid) << 32),
105                packet.c,
106                MunmapFlags::from_bits_truncate(packet.d),
107            ),
108
109            _ => Err(Error::new(ENOSYS)),
110        };
111
112        packet.a = Error::mux(res);
113    }
114
115    /* Scheme operations */
116
117    #[allow(unused_variables)]
118    fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<usize> {
119        Err(Error::new(ENOENT))
120    }
121    #[allow(unused_variables)]
122    fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
123        convert_to_this_scheme(self.open(path, flags, ctx.uid, ctx.gid))
124    }
125
126    #[allow(unused_variables)]
127    fn chmod(&mut self, path: &str, mode: u16, uid: u32, gid: u32) -> Result<usize> {
128        Err(Error::new(ENOENT))
129    }
130
131    #[allow(unused_variables)]
132    fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
133        Err(Error::new(ENOENT))
134    }
135
136    #[allow(unused_variables)]
137    fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
138        Err(Error::new(ENOENT))
139    }
140
141    /* Resource operations */
142    #[allow(unused_variables)]
143    fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result<usize> {
144        Err(Error::new(EBADF))
145    }
146
147    #[allow(unused_variables)]
148    fn xdup(&mut self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<OpenResult> {
149        convert_to_this_scheme(self.dup(old_id, buf))
150    }
151
152    #[allow(unused_variables)]
153    fn read(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
154        Err(Error::new(EBADF))
155    }
156
157    #[allow(unused_variables)]
158    fn write(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
159        Err(Error::new(EBADF))
160    }
161
162    #[allow(unused_variables)]
163    fn seek(&mut self, id: usize, pos: isize, whence: usize) -> Result<isize> {
164        Err(Error::new(EBADF))
165    }
166
167    #[allow(unused_variables)]
168    fn fchmod(&mut self, id: usize, mode: u16) -> Result<usize> {
169        Err(Error::new(EBADF))
170    }
171
172    #[allow(unused_variables)]
173    fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result<usize> {
174        Err(Error::new(EBADF))
175    }
176
177    #[allow(unused_variables)]
178    fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
179        Err(Error::new(EBADF))
180    }
181
182    #[allow(unused_variables)]
183    fn fevent(&mut self, id: usize, flags: EventFlags) -> Result<EventFlags> {
184        Err(Error::new(EBADF))
185    }
186
187    #[allow(unused_variables)]
188    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
189        Err(Error::new(EBADF))
190    }
191
192    #[allow(unused_variables)]
193    fn frename(&mut self, id: usize, path: &str, uid: u32, gid: u32) -> Result<usize> {
194        Err(Error::new(EBADF))
195    }
196
197    #[allow(unused_variables)]
198    fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<usize> {
199        Err(Error::new(EBADF))
200    }
201
202    #[allow(unused_variables)]
203    fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result<usize> {
204        Err(Error::new(EBADF))
205    }
206
207    #[allow(unused_variables)]
208    fn fsync(&mut self, id: usize) -> Result<usize> {
209        Err(Error::new(EBADF))
210    }
211
212    #[allow(unused_variables)]
213    fn ftruncate(&mut self, id: usize, len: usize) -> Result<usize> {
214        Err(Error::new(EBADF))
215    }
216
217    #[allow(unused_variables)]
218    fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result<usize> {
219        Err(Error::new(EBADF))
220    }
221
222    #[allow(unused_variables)]
223    fn close(&mut self, id: usize) -> Result<usize> {
224        Err(Error::new(EBADF))
225    }
226
227    #[allow(unused_variables)]
228    fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<usize> {
229        Err(Error::new(EOPNOTSUPP))
230    }
231
232    #[allow(unused_variables)]
233    fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<usize> {
234        Err(Error::new(EOPNOTSUPP))
235    }
236}
syscall/scheme/scheme_mut.rs

syscall/scheme/
scheme_mut.rs
