From 2bc9acc5c2e8c24dd150c2247a40922e6f3ba6c2 Mon Sep 17 00:00:00 2001 From: jD91mZM2 Date: Fri, 14 Aug 2020 15:04:35 +0200 Subject: [PATCH] Breaking Change: Goodbye, deprecated functions --- src/call.rs | 21 ++++------------ src/data.rs | 20 ++++++++-------- src/number.rs | 44 +++++++++++++++++----------------- src/scheme/scheme.rs | 22 ++++++++--------- src/scheme/scheme_block.rs | 22 ++++++++--------- src/scheme/scheme_block_mut.rs | 22 ++++++++--------- src/scheme/scheme_mut.rs | 22 ++++++++--------- 7 files changed, 81 insertions(+), 92 deletions(-) diff --git a/src/call.rs b/src/call.rs index 26e2a0c..e4423aa 100644 --- a/src/call.rs +++ b/src/call.rs @@ -1,5 +1,5 @@ use super::arch::*; -use super::data::{Map, Map2, SigAction, Stat, StatVfs, TimeSpec}; +use super::data::{Map, SigAction, Stat, StatVfs, TimeSpec}; use super::error::Result; use super::flag::*; use super::number::*; @@ -104,12 +104,6 @@ pub fn fexec(fd: usize, args: &[[usize; 2]], vars: &[[usize; 2]]) -> Result Result { - syscall3(SYS_FMAP, fd, map as *const Map as usize, mem::size_of::()) -} - -/// /// Map a file into memory, but with the ability to set the address to map into, either as a hint /// or as a requirement of the map. /// @@ -120,18 +114,13 @@ pub unsafe fn fmap(fd: usize, map: &Map) -> Result { /// `EINVAL` - invalid combination of flags /// `EEXIST` - if [`MapFlags::MAP_FIXED`] was set, and the address specified was already in use. /// -pub unsafe fn fmap2(fd: usize, map: &Map2) -> Result { - syscall3(SYS_FMAP2, fd, map as *const Map2 as usize, mem::size_of::()) -} - -/// Unmap a memory-mapped file -pub unsafe fn funmap(addr: usize) -> Result { - syscall1(SYS_FUNMAP, addr) +pub unsafe fn fmap(fd: usize, map: &Map) -> Result { + syscall3(SYS_FMAP, fd, map as *const Map as usize, mem::size_of::()) } /// Unmap whole (or partial) continous memory-mapped files -pub unsafe fn funmap2(addr: usize, len: usize) -> Result { - syscall2(SYS_FUNMAP2, addr, len) +pub unsafe fn funmap(addr: usize, len: usize) -> Result { + syscall2(SYS_FUNMAP, addr, len) } /// Retrieve the canonical path of a file diff --git a/src/data.rs b/src/data.rs index 0635d05..9f4d452 100644 --- a/src/data.rs +++ b/src/data.rs @@ -55,31 +55,31 @@ impl DerefMut for ITimerSpec { #[derive(Copy, Clone, Debug, Default)] #[repr(C)] -pub struct Map { +pub struct OldMap { pub offset: usize, pub size: usize, pub flags: MapFlags, } -impl Deref for Map { +impl Deref for OldMap { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { - slice::from_raw_parts(self as *const Map as *const u8, mem::size_of::()) + slice::from_raw_parts(self as *const OldMap as *const u8, mem::size_of::()) } } } -impl DerefMut for Map { +impl DerefMut for OldMap { fn deref_mut(&mut self) -> &mut [u8] { unsafe { - slice::from_raw_parts_mut(self as *mut Map as *mut u8, mem::size_of::()) + slice::from_raw_parts_mut(self as *mut OldMap as *mut u8, mem::size_of::()) } } } #[derive(Copy, Clone, Debug, Default)] #[repr(C)] -pub struct Map2 { +pub struct Map { /// The offset inside the file that is being mapped. pub offset: usize, @@ -95,19 +95,19 @@ pub struct Map2 { pub address: usize, } -impl Deref for Map2 { +impl Deref for Map { type Target = [u8]; fn deref(&self) -> &[u8] { unsafe { - slice::from_raw_parts(self as *const Map2 as *const u8, mem::size_of::()) + slice::from_raw_parts(self as *const Map as *const u8, mem::size_of::()) } } } -impl DerefMut for Map2 { +impl DerefMut for Map { fn deref_mut(&mut self) -> &mut [u8] { unsafe { - slice::from_raw_parts_mut(self as *mut Map2 as *mut u8, mem::size_of::()) + slice::from_raw_parts_mut(self as *mut Map as *mut u8, mem::size_of::()) } } } diff --git a/src/number.rs b/src/number.rs index 2e69098..cc50580 100644 --- a/src/number.rs +++ b/src/number.rs @@ -16,28 +16,28 @@ pub const SYS_CHMOD: usize = SYS_CLASS_PATH | 15; pub const SYS_RMDIR: usize = SYS_CLASS_PATH | 84; pub const SYS_UNLINK: usize = SYS_CLASS_PATH | 10; -pub const SYS_CLOSE: usize = SYS_CLASS_FILE | 6; -pub const SYS_DUP: usize = SYS_CLASS_FILE | SYS_RET_FILE | 41; -pub const SYS_DUP2: usize = SYS_CLASS_FILE | SYS_RET_FILE | 63; -pub const SYS_READ: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 3; -pub const SYS_WRITE: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 4; -pub const SYS_LSEEK: usize = SYS_CLASS_FILE | 19; -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; -pub const SYS_FEXEC: usize = SYS_CLASS_FILE | 11; -pub const SYS_FMAP: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 90; -pub const SYS_FMAP2: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 900; -pub const SYS_FUNMAP: usize = SYS_CLASS_FILE | 91; -pub const SYS_FUNMAP2: usize = SYS_CLASS_FILE | 92; -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; -pub const SYS_FSTATVFS: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 100; -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 SYS_CLOSE: usize = SYS_CLASS_FILE | 6; +pub const SYS_DUP: usize = SYS_CLASS_FILE | SYS_RET_FILE | 41; +pub const SYS_DUP2: usize = SYS_CLASS_FILE | SYS_RET_FILE | 63; +pub const SYS_READ: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 3; +pub const SYS_WRITE: usize = SYS_CLASS_FILE | SYS_ARG_SLICE | 4; +pub const SYS_LSEEK: usize = SYS_CLASS_FILE | 19; +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; +pub const SYS_FEXEC: usize = SYS_CLASS_FILE | 11; +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; +pub const SYS_FUNMAP_OLD: usize = SYS_CLASS_FILE | 91; +pub const SYS_FUNMAP: usize = SYS_CLASS_FILE | 92; +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; +pub const SYS_FSTATVFS: usize = SYS_CLASS_FILE | SYS_ARG_MSLICE | 100; +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 SYS_BRK: usize = 45; pub const SYS_CHDIR: usize = 12; diff --git a/src/scheme/scheme.rs b/src/scheme/scheme.rs index bc2476d..6a1a451 100644 --- a/src/scheme/scheme.rs +++ b/src/scheme/scheme.rs @@ -21,18 +21,18 @@ 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 => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) + 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_FMAP2 => if packet.d >= mem::size_of::() { - self.fmap2(packet.b, unsafe { &*(packet.c as *const Map2) }) + 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 => self.funmap(packet.b), - SYS_FUNMAP2 => self.funmap2(packet.b, packet.c), + 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 => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), SYS_FSTAT => if packet.d >= mem::size_of::() { @@ -123,15 +123,15 @@ pub trait Scheme { } #[allow(unused_variables)] - fn fmap(&self, id: usize, map: &Map) -> Result { + fn fmap_old(&self, id: usize, map: &OldMap) -> Result { Err(Error::new(EBADF)) } #[allow(unused_variables)] - fn fmap2(&self, id: usize, map: &Map2) -> Result { + fn fmap(&self, id: usize, map: &Map) -> Result { if map.flags.contains(MapFlags::MAP_FIXED) { return Err(Error::new(EINVAL)); } - self.fmap(id, &Map { + self.fmap_old(id, &OldMap { offset: map.offset, size: map.size, flags: map.flags, @@ -139,12 +139,12 @@ pub trait Scheme { } #[allow(unused_variables)] - fn funmap(&self, address: usize) -> Result { + fn funmap_old(&self, address: usize) -> Result { Ok(0) } #[allow(unused_variables)] - fn funmap2(&self, address: usize, length: usize) -> Result { + fn funmap(&self, address: usize, length: usize) -> Result { Ok(0) } diff --git a/src/scheme/scheme_block.rs b/src/scheme/scheme_block.rs index 772a74c..2ff867c 100644 --- a/src/scheme/scheme_block.rs +++ b/src/scheme/scheme_block.rs @@ -21,18 +21,18 @@ 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 => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) + 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_FMAP2 => if packet.d >= mem::size_of::() { - self.fmap2(packet.b, unsafe { &*(packet.c as *const Map2) }) + 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 => self.funmap(packet.b), - SYS_FUNMAP2 => self.funmap2(packet.b, packet.c), + 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 => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), SYS_FSTAT => if packet.d >= mem::size_of::() { @@ -123,15 +123,15 @@ pub trait SchemeBlock { } #[allow(unused_variables)] - fn fmap(&self, id: usize, map: &Map) -> Result> { + fn fmap_old(&self, id: usize, map: &OldMap) -> Result> { Err(Error::new(EBADF)) } #[allow(unused_variables)] - fn fmap2(&self, id: usize, map: &Map2) -> Result> { + fn fmap(&self, id: usize, map: &Map) -> Result> { if map.flags.contains(MapFlags::MAP_FIXED) { return Err(Error::new(EINVAL)); } - self.fmap(id, &Map { + self.fmap_old(id, &OldMap { offset: map.offset, size: map.size, flags: map.flags, @@ -139,12 +139,12 @@ pub trait SchemeBlock { } #[allow(unused_variables)] - fn funmap(&self, address: usize) -> Result> { + fn funmap_old(&self, address: usize) -> Result> { Ok(Some(0)) } #[allow(unused_variables)] - fn funmap2(&self, address: usize, length: usize) -> Result> { + fn funmap(&self, address: usize, length: usize) -> Result> { Ok(Some(0)) } diff --git a/src/scheme/scheme_block_mut.rs b/src/scheme/scheme_block_mut.rs index e2f9040..66f34d5 100644 --- a/src/scheme/scheme_block_mut.rs +++ b/src/scheme/scheme_block_mut.rs @@ -21,18 +21,18 @@ 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 => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) + 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_FMAP2 => if packet.d >= mem::size_of::() { - self.fmap2(packet.b, unsafe { &*(packet.c as *const Map2) }) + 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 => self.funmap(packet.b), - SYS_FUNMAP2 => self.funmap2(packet.b, packet.c), + 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 => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), SYS_FSTAT => if packet.d >= mem::size_of::() { @@ -123,15 +123,15 @@ pub trait SchemeBlockMut { } #[allow(unused_variables)] - fn fmap(&mut self, id: usize, map: &Map) -> Result> { + fn fmap_old(&mut self, id: usize, map: &OldMap) -> Result> { Err(Error::new(EBADF)) } #[allow(unused_variables)] - fn fmap2(&mut self, id: usize, map: &Map2) -> Result> { + fn fmap(&mut self, id: usize, map: &Map) -> Result> { if map.flags.contains(MapFlags::MAP_FIXED) { return Err(Error::new(EINVAL)); } - self.fmap(id, &Map { + self.fmap_old(id, &OldMap { offset: map.offset, size: map.size, flags: map.flags, @@ -139,12 +139,12 @@ pub trait SchemeBlockMut { } #[allow(unused_variables)] - fn funmap(&mut self, address: usize) -> Result> { + fn funmap_old(&mut self, address: usize) -> Result> { Ok(Some(0)) } #[allow(unused_variables)] - fn funmap2(&mut self, address: usize, length: usize) -> Result> { + fn funmap(&mut self, address: usize, length: usize) -> Result> { Ok(Some(0)) } diff --git a/src/scheme/scheme_mut.rs b/src/scheme/scheme_mut.rs index 8cfe110..ff27444 100644 --- a/src/scheme/scheme_mut.rs +++ b/src/scheme/scheme_mut.rs @@ -21,18 +21,18 @@ 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 => if packet.d >= mem::size_of::() { - self.fmap(packet.b, unsafe { &*(packet.c as *const Map) }) + 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_FMAP2 => if packet.d >= mem::size_of::() { - self.fmap2(packet.b, unsafe { &*(packet.c as *const Map2) }) + 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 => self.funmap(packet.b), - SYS_FUNMAP2 => self.funmap2(packet.b, packet.c), + 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 => self.frename(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, packet.uid, packet.gid), SYS_FSTAT => if packet.d >= mem::size_of::() { @@ -123,15 +123,15 @@ pub trait SchemeMut { } #[allow(unused_variables)] - fn fmap(&mut self, id: usize, map: &Map) -> Result { + fn fmap_old(&mut self, id: usize, map: &OldMap) -> Result { Err(Error::new(EBADF)) } #[allow(unused_variables)] - fn fmap2(&mut self, id: usize, map: &Map2) -> Result { + fn fmap(&mut self, id: usize, map: &Map) -> Result { if map.flags.contains(MapFlags::MAP_FIXED) { return Err(Error::new(EINVAL)); } - self.fmap(id, &Map { + self.fmap_old(id, &OldMap { offset: map.offset, size: map.size, flags: map.flags, @@ -139,12 +139,12 @@ pub trait SchemeMut { } #[allow(unused_variables)] - fn funmap(&mut self, address: usize) -> Result { + fn funmap_old(&mut self, address: usize) -> Result { Ok(0) } #[allow(unused_variables)] - fn funmap2(&mut self, address: usize, length: usize) -> Result { + fn funmap(&mut self, address: usize, length: usize) -> Result { Ok(0) } -- GitLab