From eab01c8621e10fe8f0d8208a0a806f643919ad0e Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Thu, 29 Jun 2023 12:27:10 +0200 Subject: [PATCH 1/7] Add mmap kernel-scheme messages. --- src/number.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/number.rs b/src/number.rs index cb8471f257..dc8281938e 100644 --- a/src/number.rs +++ b/src/number.rs @@ -37,6 +37,11 @@ pub const SYS_FSYNC: usize = SYS_CLASS_FILE | 118; pub const SYS_FTRUNCATE: usize = SYS_CLASS_FILE | 93; pub const SYS_FUTIMENS: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 320; +pub const KSMSG_MMAP: usize = SYS_CLASS_FILE | 72; +pub const KSMSG_MSYNC: usize = SYS_CLASS_FILE | 73; +pub const KSMSG_MUNMAP: usize = SYS_CLASS_FILE | 74; +pub const KSMSG_MMAP_PREP: usize = SYS_CLASS_FILE | 75; + pub const SYS_CLOCK_GETTIME: usize = 265; pub const SYS_EXIT: usize = 1; pub const SYS_FUTEX: usize = 240; From 6024e1e1fa0fdd9d31b1afbe034ebb0d84c1a98c Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 30 Jun 2023 11:39:28 +0200 Subject: [PATCH 2/7] Remove scheme funmap methods. --- src/flag.rs | 8 ++++++- src/number.rs | 7 ++++++ src/scheme/scheme.rs | 39 +--------------------------------- src/scheme/scheme_block.rs | 39 +--------------------------------- src/scheme/scheme_block_mut.rs | 39 +--------------------------------- src/scheme/scheme_mut.rs | 39 +--------------------------------- 6 files changed, 18 insertions(+), 153 deletions(-) diff --git a/src/flag.rs b/src/flag.rs index dff3aa9eee..4b803bf356 100644 --- a/src/flag.rs +++ b/src/flag.rs @@ -54,11 +54,18 @@ pub const FUTEX_WAKE: usize = 1; pub const FUTEX_REQUEUE: usize = 2; pub const FUTEX_WAIT64: usize = 3; +// packet.c = fd pub const SKMSG_FRETURNFD: usize = 0; +// packet.uid:packet.gid = offset, packet.c = page_count +pub const SKMSG_PROVIDE_MMAP: usize = 1; + bitflags! { pub struct MapFlags: usize { + // TODO: Downgrade PROT_NONE to global constant? (bitflags specifically states zero flags + // can cause buggy behavior). const PROT_NONE = 0x0000_0000; + const PROT_EXEC = 0x0001_0000; const PROT_WRITE = 0x0002_0000; const PROT_READ = 0x0004_0000; @@ -66,7 +73,6 @@ bitflags! { const MAP_SHARED = 0x0001; const MAP_PRIVATE = 0x0002; - /// Only accepted for mmap2(2). const MAP_FIXED = 0x0004; const MAP_FIXED_NOREPLACE = 0x000C; } diff --git a/src/number.rs b/src/number.rs index dc8281938e..72daf705ad 100644 --- a/src/number.rs +++ b/src/number.rs @@ -37,9 +37,16 @@ pub const SYS_FSYNC: usize = SYS_CLASS_FILE | 118; pub const SYS_FTRUNCATE: usize = SYS_CLASS_FILE | 93; pub const SYS_FUTIMENS: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 320; +// b = file, c = flags, d = required_page_count, uid:gid = offset pub const KSMSG_MMAP: usize = SYS_CLASS_FILE | 72; + +// b = file, c = flags, d = page_count, uid:gid = offset pub const KSMSG_MSYNC: usize = SYS_CLASS_FILE | 73; + +// b = file, c = page_count, uid:gid = offset pub const KSMSG_MUNMAP: usize = SYS_CLASS_FILE | 74; + +// b = file, c = flags, d = page_count, uid:gid = offset pub const KSMSG_MMAP_PREP: usize = SYS_CLASS_FILE | 75; pub const SYS_CLOCK_GETTIME: usize = 265; diff --git a/src/scheme/scheme.rs b/src/scheme/scheme.rs index 46e3abefac..50927f036d 100644 --- a/src/scheme/scheme.rs +++ b/src/scheme/scheme.rs @@ -36,18 +36,6 @@ pub trait Scheme { SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.bits()), - SYS_FMAP_OLD => if packet.d >= mem::size_of::() { - self.fmap_old(packet.b, unsafe { &*(packet.c as *const OldMap) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FMAP => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FUNMAP_OLD => self.funmap_old(packet.b), - SYS_FUNMAP => self.funmap(packet.b, packet.c), SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } { self.frename(packet.b, path, packet.uid, packet.gid) @@ -72,6 +60,7 @@ pub trait Scheme { Err(Error::new(EFAULT)) }, SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) }; @@ -150,32 +139,6 @@ pub trait Scheme { Err(Error::new(EBADF)) } - #[allow(unused_variables)] - fn fmap_old(&self, id: usize, map: &OldMap) -> Result { - Err(Error::new(EBADF)) - } - #[allow(unused_variables)] - fn fmap(&self, id: usize, map: &Map) -> Result { - if map.flags.contains(MapFlags::MAP_FIXED) { - return Err(Error::new(EINVAL)); - } - self.fmap_old(id, &OldMap { - offset: map.offset, - size: map.size, - flags: map.flags, - }) - } - - #[allow(unused_variables)] - fn funmap_old(&self, address: usize) -> Result { - Ok(0) - } - - #[allow(unused_variables)] - fn funmap(&self, address: usize, length: usize) -> Result { - Ok(0) - } - #[allow(unused_variables)] fn fpath(&self, id: usize, buf: &mut [u8]) -> Result { Err(Error::new(EBADF)) diff --git a/src/scheme/scheme_block.rs b/src/scheme/scheme_block.rs index 2db6c361ae..391882746e 100644 --- a/src/scheme/scheme_block.rs +++ b/src/scheme/scheme_block.rs @@ -36,18 +36,6 @@ pub trait SchemeBlock { SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.map(|f| f.bits())), - SYS_FMAP_OLD => if packet.d >= mem::size_of::() { - self.fmap_old(packet.b, unsafe { &*(packet.c as *const OldMap) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FMAP => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FUNMAP_OLD => self.funmap_old(packet.b), - SYS_FUNMAP => self.funmap(packet.b, packet.c), SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } { self.frename(packet.b, path, packet.uid, packet.gid) @@ -72,6 +60,7 @@ pub trait SchemeBlock { Err(Error::new(EFAULT)) }, SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) }; @@ -150,32 +139,6 @@ pub trait SchemeBlock { Err(Error::new(EBADF)) } - #[allow(unused_variables)] - fn fmap_old(&self, id: usize, map: &OldMap) -> Result> { - Err(Error::new(EBADF)) - } - #[allow(unused_variables)] - fn fmap(&self, id: usize, map: &Map) -> Result> { - if map.flags.contains(MapFlags::MAP_FIXED) { - return Err(Error::new(EINVAL)); - } - self.fmap_old(id, &OldMap { - offset: map.offset, - size: map.size, - flags: map.flags, - }) - } - - #[allow(unused_variables)] - fn funmap_old(&self, address: usize) -> Result> { - Ok(Some(0)) - } - - #[allow(unused_variables)] - fn funmap(&self, address: usize, length: usize) -> Result> { - Ok(Some(0)) - } - #[allow(unused_variables)] fn fpath(&self, id: usize, buf: &mut [u8]) -> Result> { Err(Error::new(EBADF)) diff --git a/src/scheme/scheme_block_mut.rs b/src/scheme/scheme_block_mut.rs index 62302ea2c9..b7ca832479 100644 --- a/src/scheme/scheme_block_mut.rs +++ b/src/scheme/scheme_block_mut.rs @@ -36,18 +36,6 @@ pub trait SchemeBlockMut { SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.map(|f| f.bits())), - SYS_FMAP_OLD => if packet.d >= mem::size_of::() { - self.fmap_old(packet.b, unsafe { &*(packet.c as *const OldMap) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FMAP => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FUNMAP_OLD => self.funmap_old(packet.b), - SYS_FUNMAP => self.funmap(packet.b, packet.c), SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } { self.frename(packet.b, path, packet.uid, packet.gid) @@ -72,6 +60,7 @@ pub trait SchemeBlockMut { Err(Error::new(EFAULT)) }, SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) }; @@ -150,32 +139,6 @@ pub trait SchemeBlockMut { Err(Error::new(EBADF)) } - #[allow(unused_variables)] - fn fmap_old(&mut self, id: usize, map: &OldMap) -> Result> { - Err(Error::new(EBADF)) - } - #[allow(unused_variables)] - fn fmap(&mut self, id: usize, map: &Map) -> Result> { - if map.flags.contains(MapFlags::MAP_FIXED) { - return Err(Error::new(EINVAL)); - } - self.fmap_old(id, &OldMap { - offset: map.offset, - size: map.size, - flags: map.flags, - }) - } - - #[allow(unused_variables)] - fn funmap_old(&mut self, address: usize) -> Result> { - Ok(Some(0)) - } - - #[allow(unused_variables)] - fn funmap(&mut self, address: usize, length: usize) -> Result> { - Ok(Some(0)) - } - #[allow(unused_variables)] fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result> { Err(Error::new(EBADF)) diff --git a/src/scheme/scheme_mut.rs b/src/scheme/scheme_mut.rs index 229a5c866b..a7a7a3a76a 100644 --- a/src/scheme/scheme_mut.rs +++ b/src/scheme/scheme_mut.rs @@ -36,18 +36,6 @@ pub trait SchemeMut { SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32), SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d), SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.bits()), - SYS_FMAP_OLD => if packet.d >= mem::size_of::() { - self.fmap_old(packet.b, unsafe { &*(packet.c as *const OldMap) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FMAP => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) - } else { - Err(Error::new(EFAULT)) - }, - SYS_FUNMAP_OLD => self.funmap_old(packet.b), - SYS_FUNMAP => self.funmap(packet.b, packet.c), SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }), SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } { self.frename(packet.b, path, packet.uid, packet.gid) @@ -72,6 +60,7 @@ pub trait SchemeMut { Err(Error::new(EFAULT)) }, SYS_CLOSE => self.close(packet.b), + _ => Err(Error::new(ENOSYS)) }; @@ -150,32 +139,6 @@ pub trait SchemeMut { Err(Error::new(EBADF)) } - #[allow(unused_variables)] - fn fmap_old(&mut self, id: usize, map: &OldMap) -> Result { - Err(Error::new(EBADF)) - } - #[allow(unused_variables)] - fn fmap(&mut self, id: usize, map: &Map) -> Result { - if map.flags.contains(MapFlags::MAP_FIXED) { - return Err(Error::new(EINVAL)); - } - self.fmap_old(id, &OldMap { - offset: map.offset, - size: map.size, - flags: map.flags, - }) - } - - #[allow(unused_variables)] - fn funmap_old(&mut self, address: usize) -> Result { - Ok(0) - } - - #[allow(unused_variables)] - fn funmap(&mut self, address: usize, length: usize) -> Result { - Ok(0) - } - #[allow(unused_variables)] fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result { Err(Error::new(EBADF)) From d587771fc36eabc07472ad6bb0f00b2d2a931711 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sat, 1 Jul 2023 15:13:26 +0200 Subject: [PATCH 3/7] Add MAP_LAZY. --- src/flag.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/flag.rs b/src/flag.rs index 4b803bf356..6959e23bda 100644 --- a/src/flag.rs +++ b/src/flag.rs @@ -57,7 +57,7 @@ pub const FUTEX_WAIT64: usize = 3; // packet.c = fd pub const SKMSG_FRETURNFD: usize = 0; -// packet.uid:packet.gid = offset, packet.c = page_count +// packet.uid:packet.gid = offset, packet.c = base address, packet.d = page count pub const SKMSG_PROVIDE_MMAP: usize = 1; bitflags! { @@ -75,6 +75,19 @@ bitflags! { const MAP_FIXED = 0x0004; const MAP_FIXED_NOREPLACE = 0x000C; + + /// For *userspace-backed mmaps*, return from the mmap call before all pages have been + /// provided by the scheme. This requires the scheme to be trusted, as the current context + /// can block indefinitely, if the scheme does not respond to the page fault handler's + /// request, as it tries to map the page by requesting it from the scheme. + /// + /// In some cases however, such as the program loader, the data needs to be trusted as much + /// with or without MAP_LAZY, and if so, mapping lazily will not cause insecureness by + /// itself. + /// + /// For kernel-backed mmaps, this flag has no effect at all. It is unspecified whether + /// kernel mmaps are lazy or not. + const MAP_LAZY = 0x0010; } } From ff149946c07628dde39db05997e221b5024ccb95 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Tue, 4 Jul 2023 17:17:25 +0200 Subject: [PATCH 4/7] Add GrantDesc and GrantFlags. --- src/data.rs | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/data.rs b/src/data.rs index 3afb8bb603..c93869793e 100644 --- a/src/data.rs +++ b/src/data.rs @@ -313,3 +313,44 @@ macro_rules! ptrace_event { } } } + +bitflags::bitflags! { + #[derive(Default)] + pub struct GrantFlags: usize { + const GRANT_READ = 0x0000_0001; + const GRANT_WRITE = 0x0000_0002; + const GRANT_EXEC = 0x0000_0004; + + const GRANT_SHARED = 0x0000_0008; + const GRANT_LAZY = 0x0000_0010; + const GRANT_SCHEME = 0x0000_0020; + const GRANT_PHYS = 0x0000_0040; + const GRANT_PINNED = 0x0000_0080; + } +} + +#[derive(Clone, Copy, Debug, Default)] +#[repr(C)] +pub struct GrantDesc { + pub base: usize, + pub size: usize, + pub flags: GrantFlags, + pub offset: u64, +} + +impl Deref for GrantDesc { + type Target = [u8]; + fn deref(&self) -> &[u8] { + unsafe { + slice::from_raw_parts(self as *const GrantDesc as *const u8, mem::size_of::()) + } + } +} + +impl DerefMut for GrantDesc { + fn deref_mut(&mut self) -> &mut [u8] { + unsafe { + slice::from_raw_parts_mut(self as *mut GrantDesc as *mut u8, mem::size_of::()) + } + } +} From ed28083b73ed2b163e2d64ee3753f1d6ff6c94d1 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Wed, 12 Jul 2023 15:32:39 +0200 Subject: [PATCH 5/7] Add MMAP_PREP and MUNMAP to scheme traits. --- src/scheme/scheme.rs | 13 +++++++++++++ src/scheme/scheme_block.rs | 13 +++++++++++++ src/scheme/scheme_block_mut.rs | 13 +++++++++++++ src/scheme/scheme_mut.rs | 13 +++++++++++++ 4 files changed, 52 insertions(+) diff --git a/src/scheme/scheme.rs b/src/scheme/scheme.rs index 50927f036d..735cc0fb3d 100644 --- a/src/scheme/scheme.rs +++ b/src/scheme/scheme.rs @@ -61,6 +61,9 @@ pub trait Scheme { }, SYS_CLOSE => self.close(packet.b), + KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + _ => Err(Error::new(ENOSYS)) }; @@ -178,4 +181,14 @@ pub trait Scheme { fn close(&self, id: usize) -> Result { Err(Error::new(EBADF)) } + + #[allow(unused_variables)] + fn mmap_prep(&self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result { + Err(Error::new(EOPNOTSUPP)) + } + + #[allow(unused_variables)] + fn munmap(&self, id: usize, offset: u64, size: usize) -> Result { + Err(Error::new(EOPNOTSUPP)) + } } diff --git a/src/scheme/scheme_block.rs b/src/scheme/scheme_block.rs index 391882746e..3ac6cf3414 100644 --- a/src/scheme/scheme_block.rs +++ b/src/scheme/scheme_block.rs @@ -61,6 +61,9 @@ pub trait SchemeBlock { }, SYS_CLOSE => self.close(packet.b), + KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + _ => Err(Error::new(ENOSYS)) }; @@ -178,4 +181,14 @@ pub trait SchemeBlock { fn close(&self, id: usize) -> Result> { Err(Error::new(EBADF)) } + + #[allow(unused_variables)] + fn mmap_prep(&self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result> { + Err(Error::new(EOPNOTSUPP)) + } + + #[allow(unused_variables)] + fn munmap(&self, id: usize, offset: u64, size: usize) -> Result> { + Err(Error::new(EOPNOTSUPP)) + } } diff --git a/src/scheme/scheme_block_mut.rs b/src/scheme/scheme_block_mut.rs index b7ca832479..1f65df0451 100644 --- a/src/scheme/scheme_block_mut.rs +++ b/src/scheme/scheme_block_mut.rs @@ -61,6 +61,9 @@ pub trait SchemeBlockMut { }, SYS_CLOSE => self.close(packet.b), + KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + _ => Err(Error::new(ENOSYS)) }; @@ -178,4 +181,14 @@ pub trait SchemeBlockMut { fn close(&mut self, id: usize) -> Result> { Err(Error::new(EBADF)) } + + #[allow(unused_variables)] + fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result> { + Err(Error::new(EOPNOTSUPP)) + } + + #[allow(unused_variables)] + fn munmap(&mut self, id: usize, offset: u64, size: usize) -> Result> { + Err(Error::new(EOPNOTSUPP)) + } } diff --git a/src/scheme/scheme_mut.rs b/src/scheme/scheme_mut.rs index a7a7a3a76a..0b166ca04c 100644 --- a/src/scheme/scheme_mut.rs +++ b/src/scheme/scheme_mut.rs @@ -61,6 +61,9 @@ pub trait SchemeMut { }, SYS_CLOSE => self.close(packet.b), + KSMSG_MMAP_PREP => self.mmap_prep(packet.b, MapFlags::from_bits_truncate(packet.c), packet.d, u64::from(packet.uid) | (u64::from(packet.gid) << 32)), + KSMSG_MUNMAP => self.munmap(packet.b, packet.c, u64::from(packet.uid) | (u64::from(packet.gid) << 32)), + _ => Err(Error::new(ENOSYS)) }; @@ -178,4 +181,14 @@ pub trait SchemeMut { fn close(&mut self, id: usize) -> Result { Err(Error::new(EBADF)) } + + #[allow(unused_variables)] + fn mmap_prep(&mut self, id: usize, flags: MapFlags, size: usize, offset: u64) -> Result { + Err(Error::new(EOPNOTSUPP)) + } + + #[allow(unused_variables)] + fn munmap(&mut self, id: usize, size: usize, offset: u64) -> Result { + Err(Error::new(EOPNOTSUPP)) + } } From 534267760f1388f5577090dc2f5b9443356cb3dc Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Mon, 17 Jul 2023 15:54:24 +0200 Subject: [PATCH 6/7] Add SYS_MREMAP. --- src/flag.rs | 8 ++++++++ src/number.rs | 6 ++++++ 2 files changed, 14 insertions(+) diff --git a/src/flag.rs b/src/flag.rs index 6959e23bda..ef17c1703f 100644 --- a/src/flag.rs +++ b/src/flag.rs @@ -355,3 +355,11 @@ pub fn wexitstatus(status: usize) -> usize { pub fn wcoredump(status: usize) -> bool { (status & 0x80) != 0 } + +bitflags! { + pub struct MremapFlags: usize { + const FIXED = 1; + const FIXED_REPLACE = 3; + // TODO: MAYMOVE, DONTUNMAP + } +} diff --git a/src/number.rs b/src/number.rs index 72daf705ad..d7c911c58b 100644 --- a/src/number.rs +++ b/src/number.rs @@ -25,10 +25,16 @@ pub const SYS_FCHMOD: usize = SYS_CLASS_FILE | 94; pub const SYS_FCHOWN: usize = SYS_CLASS_FILE | 207; pub const SYS_FCNTL: usize = SYS_CLASS_FILE | 55; pub const SYS_FEVENT: usize = SYS_CLASS_FILE | 927; + +// TODO: Rename FMAP/FUNMAP to MMAP/MUNMAP pub const SYS_FMAP_OLD: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 90; pub const SYS_FMAP: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 900; +// TODO: SYS_FUNMAP should be SYS_CLASS_FILE +// TODO: Remove FMAP/FMAP_OLD pub const SYS_FUNMAP_OLD: usize = SYS_CLASS_FILE | 91; pub const SYS_FUNMAP: usize = SYS_CLASS_FILE | 92; +pub const SYS_MREMAP: usize = 155; + pub const SYS_FPATH: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 928; pub const SYS_FRENAME: usize = SYS_CLASS_FILE | SYS_ARG_PATH | 38; pub const SYS_FSTAT: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 28; From f0976e1d6020e6854ca30ed1f6d61b10dfc4fa58 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Fri, 21 Jul 2023 11:08:59 +0200 Subject: [PATCH 7/7] Add MunmapFlags. --- src/flag.rs | 9 +++++++++ src/scheme/scheme.rs | 4 ++-- src/scheme/scheme_block.rs | 4 ++-- src/scheme/scheme_block_mut.rs | 4 ++-- src/scheme/scheme_mut.rs | 8 ++++---- 5 files changed, 19 insertions(+), 10 deletions(-) diff --git a/src/flag.rs b/src/flag.rs index ef17c1703f..45a6e42e80 100644 --- a/src/flag.rs +++ b/src/flag.rs @@ -90,6 +90,15 @@ bitflags! { const MAP_LAZY = 0x0010; } } +bitflags! { + pub struct MunmapFlags: usize { + /// Indicates whether the funmap call must implicitly do an msync, for the changes to + /// become visible later. + /// + /// This flag will currently be set if and only if MAP_SHARED | PROT_WRITE are set. + const NEEDS_SYNC = 1; + } +} pub const MODE_TYPE: u16 = 0xF000; pub const MODE_DIR: u16 = 0x4000; diff --git a/src/scheme/scheme.rs b/src/scheme/scheme.rs index 735cc0fb3d..ee09d697bf 100644 --- a/src/scheme/scheme.rs +++ b/src/scheme/scheme.rs @@ -62,7 +62,7 @@ pub trait Scheme { SYS_CLOSE => self.close(packet.b), KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), - KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)), _ => Err(Error::new(ENOSYS)) }; @@ -188,7 +188,7 @@ pub trait Scheme { } #[allow(unused_variables)] - fn munmap(&self, id: usize, offset: u64, size: usize) -> Result { + fn munmap(&self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result { Err(Error::new(EOPNOTSUPP)) } } diff --git a/src/scheme/scheme_block.rs b/src/scheme/scheme_block.rs index 3ac6cf3414..e74e3b7e2a 100644 --- a/src/scheme/scheme_block.rs +++ b/src/scheme/scheme_block.rs @@ -62,7 +62,7 @@ pub trait SchemeBlock { SYS_CLOSE => self.close(packet.b), KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), - KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)), _ => Err(Error::new(ENOSYS)) }; @@ -188,7 +188,7 @@ pub trait SchemeBlock { } #[allow(unused_variables)] - fn munmap(&self, id: usize, offset: u64, size: usize) -> Result> { + fn munmap(&self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result> { Err(Error::new(EOPNOTSUPP)) } } diff --git a/src/scheme/scheme_block_mut.rs b/src/scheme/scheme_block_mut.rs index 1f65df0451..fd2c59069b 100644 --- a/src/scheme/scheme_block_mut.rs +++ b/src/scheme/scheme_block_mut.rs @@ -62,7 +62,7 @@ pub trait SchemeBlockMut { SYS_CLOSE => self.close(packet.b), KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), - KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)), _ => Err(Error::new(ENOSYS)) }; @@ -188,7 +188,7 @@ pub trait SchemeBlockMut { } #[allow(unused_variables)] - fn munmap(&mut self, id: usize, offset: u64, size: usize) -> Result> { + fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result> { Err(Error::new(EOPNOTSUPP)) } } diff --git a/src/scheme/scheme_mut.rs b/src/scheme/scheme_mut.rs index 0b166ca04c..2eea4dcbc8 100644 --- a/src/scheme/scheme_mut.rs +++ b/src/scheme/scheme_mut.rs @@ -61,8 +61,8 @@ pub trait SchemeMut { }, SYS_CLOSE => self.close(packet.b), - KSMSG_MMAP_PREP => self.mmap_prep(packet.b, MapFlags::from_bits_truncate(packet.c), packet.d, u64::from(packet.uid) | (u64::from(packet.gid) << 32)), - KSMSG_MUNMAP => self.munmap(packet.b, packet.c, u64::from(packet.uid) | (u64::from(packet.gid) << 32)), + KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)), + KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)), _ => Err(Error::new(ENOSYS)) }; @@ -183,12 +183,12 @@ pub trait SchemeMut { } #[allow(unused_variables)] - fn mmap_prep(&mut self, id: usize, flags: MapFlags, size: usize, offset: u64) -> Result { + fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result { Err(Error::new(EOPNOTSUPP)) } #[allow(unused_variables)] - fn munmap(&mut self, id: usize, size: usize, offset: u64) -> Result { + fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result { Err(Error::new(EOPNOTSUPP)) } }