Support new fmap stuff!

Cargo.lock

@@ -2,13 +2,13 @@
 name = "ipcd"
 version = "0.1.0"
 dependencies = [
- "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.1.40"
+version = "0.1.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [metadata]
-"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
+"checksum redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)" = "f22c50afdcf3f0a31ebb6b47697f6a7c5e5a24967e842858118bce0615f0afad"

Cargo.toml

@@ -1,7 +1,6 @@
 [package]
+edition = "2018"
 name = "ipcd"
 version = "0.1.0"
-edition = "2018"
-
 [dependencies]
-redox_syscall = "0.1.40"
+redox_syscall = "0.1.49"

examples/event.rs

@@ -1,20 +1,20 @@
 use std::{
     fs::File,
     io::{self, prelude::*},
-    os::unix::io::{AsRawFd, FromRawFd}
+    os::unix::io::{AsRawFd, FromRawFd, RawFd}
 };
 
 fn from_syscall_error(error: syscall::Error) -> io::Error {
     io::Error::from_raw_os_error(error.errno as i32)
 }
 fn nonblock(file: &File) -> io::Result<()> {
-    syscall::fcntl(file.as_raw_fd(), syscall::F_SETFL, syscall::O_NONBLOCK)
+    syscall::fcntl(file.as_raw_fd() as usize, syscall::F_SETFL, syscall::O_NONBLOCK)
         .map(|_| ())
         .map_err(from_syscall_error)
 }
 fn dup(file: &File, buf: &str) -> io::Result<File> {
-    let stream = syscall::dup(file.as_raw_fd(), buf.as_bytes()).map_err(from_syscall_error)?;
-    Ok(unsafe { File::from_raw_fd(stream) })
+    let stream = syscall::dup(file.as_raw_fd() as usize, buf.as_bytes()).map_err(from_syscall_error)?;
+    Ok(unsafe { File::from_raw_fd(stream as RawFd) })
 }
 
 fn main() -> io::Result<()> {
@@ -40,12 +40,12 @@ fn main() -> io::Result<()> {
     const TOKEN_CLIENT: usize = 3;
 
     event_file.write(&syscall::Event {
-        id: time_file.as_raw_fd(),
+        id: time_file.as_raw_fd() as usize,
         flags: syscall::EVENT_READ,
         data: TOKEN_TIMER
     })?;
     event_file.write(&syscall::Event {
-        id: server.as_raw_fd(),
+        id: server.as_raw_fd() as usize,
         flags: syscall::EVENT_WRITE | syscall::EVENT_READ,
         data: TOKEN_SERVER
     })?;
@@ -61,7 +61,7 @@ fn main() -> io::Result<()> {
 
     let mut client = File::open("chan:hello_world")?;
     event_file.write(&syscall::Event {
-        id: client.as_raw_fd(),
+        id: client.as_raw_fd() as usize,
         flags: syscall::EVENT_WRITE | syscall::EVENT_READ,
         data: TOKEN_CLIENT
     })?;
@@ -81,7 +81,7 @@ fn main() -> io::Result<()> {
     println!("-> Writable event");
 
     event_file.write(&syscall::Event {
-        id: stream.as_raw_fd(),
+        id: stream.as_raw_fd() as usize,
         flags: syscall::EVENT_READ | syscall::EVENT_WRITE,
         data: TOKEN_STREAM
     })?;

examples/main.rs

@@ -1,7 +1,7 @@
 use std::{
     fs::File,
     io::{self, prelude::*},
-    os::unix::io::{AsRawFd, FromRawFd},
+    os::unix::io::{AsRawFd, FromRawFd, RawFd},
     thread,
     time::Duration
 };
@@ -10,13 +10,13 @@ fn from_syscall_error(error: syscall::Error) -> io::Error {
     io::Error::from_raw_os_error(error.errno as i32)
 }
 fn nonblock(file: &File) -> io::Result<()> {
-    syscall::fcntl(file.as_raw_fd(), syscall::F_SETFL, syscall::O_NONBLOCK)
+    syscall::fcntl(file.as_raw_fd() as usize, syscall::F_SETFL, syscall::O_NONBLOCK)
         .map(|_| ())
         .map_err(from_syscall_error)
 }
 fn dup(file: &File, buf: &str) -> io::Result<File> {
-    let stream = syscall::dup(file.as_raw_fd(), buf.as_bytes()).map_err(from_syscall_error)?;
-    Ok(unsafe { File::from_raw_fd(stream) })
+    let stream = syscall::dup(file.as_raw_fd() as usize, buf.as_bytes()).map_err(from_syscall_error)?;
+    Ok(unsafe { File::from_raw_fd(stream as RawFd) })
 }
 
 fn main() -> io::Result<()> {

examples/server.rs

@@ -1,7 +1,7 @@
 use std::{
     fs::File,
     io::{self, prelude::*},
-    os::unix::io::{AsRawFd, FromRawFd}
+    os::unix::io::{AsRawFd, FromRawFd, RawFd}
 };
 
 fn from_syscall_error(error: syscall::Error) -> io::Error {
@@ -12,8 +12,8 @@ fn main() -> io::Result<()> {
     let server = File::create("chan:hello")?;
 
     loop {
-        let stream = syscall::dup(server.as_raw_fd(), b"listen").map_err(from_syscall_error)?;
-        let mut stream = unsafe { File::from_raw_fd(stream) };
+        let stream = syscall::dup(server.as_raw_fd() as usize, b"listen").map_err(from_syscall_error)?;
+        let mut stream = unsafe { File::from_raw_fd(stream as RawFd) };
 
         stream.write(b"Hello World!\n")?;
     }

examples/shm.rs

@@ -14,13 +14,21 @@ fn main() -> Result<(), io::Error> {
 
     let one = unsafe {
         slice::from_raw_parts_mut(
-            syscall::fmap(file1.as_raw_fd(), 0, 128).map_err(from_syscall_error)? as *mut u8,
+            syscall::fmap(file1.as_raw_fd() as usize, &syscall::Map {
+                offset: 0,
+                size: 128,
+                flags: syscall::PROT_READ | syscall::PROT_WRITE
+            }).map_err(from_syscall_error)? as *mut u8,
             128
         )
     };
     let two = unsafe {
         slice::from_raw_parts_mut(
-            syscall::fmap(file2.as_raw_fd(), 64, 64).map_err(from_syscall_error)? as *mut u8,
+            syscall::fmap(file2.as_raw_fd() as usize, &syscall::Map {
+                offset: 64,
+                size: 64,
+                flags: syscall::PROT_READ | syscall::PROT_WRITE
+            }).map_err(from_syscall_error)? as *mut u8,
             64
         )
     };
@@ -35,7 +43,7 @@ fn main() -> Result<(), io::Error> {
 
     println!("Testing fpath");
     let mut buf = [0; 128];
-    let len = syscall::fpath(file1.as_raw_fd(), &mut buf).map_err(from_syscall_error)?;
+    let len = syscall::fpath(file1.as_raw_fd() as usize, &mut buf).map_err(from_syscall_error)?;
     assert_eq!(&buf[..len], b"shm:example");
     Ok(())
 }

examples/shm_demo.rs

@@ -14,7 +14,11 @@ fn main() -> Result<(), io::Error> {
     let file = File::open("shm:counter")?;
     println!("Reading from map... ");
     let counter = unsafe {
-        &mut *(syscall::fmap(file.as_raw_fd(), 0, mem::size_of::<usize>()).map_err(from_syscall_error)? as *mut usize)
+        &mut *(syscall::fmap(file.as_raw_fd() as usize, &syscall::Map {
+            offset: 0,
+            size: mem::size_of::<usize>(),
+            flags: syscall::PROT_READ | syscall::PROT_WRITE
+        }).map_err(from_syscall_error)? as *mut usize)
     };
     println!("Read value {}", counter);
     *counter += 1;

examples/unnamed.rs

@@ -1,15 +1,15 @@
 use std::{
     fs::File,
     io::{self, prelude::*},
-    os::unix::io::{AsRawFd, FromRawFd}
+    os::unix::io::{AsRawFd, FromRawFd, RawFd}
 };
 
 fn from_syscall_error(error: syscall::Error) -> io::Error {
     io::Error::from_raw_os_error(error.errno as i32)
 }
 fn dup(file: &File, buf: &str) -> io::Result<File> {
-    let stream = syscall::dup(file.as_raw_fd(), buf.as_bytes()).map_err(from_syscall_error)?;
-    Ok(unsafe { File::from_raw_fd(stream) })
+    let stream = syscall::dup(file.as_raw_fd() as usize, buf.as_bytes()).map_err(from_syscall_error)?;
+    Ok(unsafe { File::from_raw_fd(stream as RawFd) })
 }
 
 fn main() -> io::Result<()> {

src/shm.rs

@@ -3,7 +3,7 @@ use std::{
     collections::{HashMap, hash_map::Entry},
     rc::Rc
 };
-use syscall::{error::*, Error, SchemeMut, Result};
+use syscall::{error::*, Error, Map, SchemeMut, Result};
 
 #[derive(Default)]
 pub struct ShmHandle {
@@ -28,18 +28,19 @@ impl SchemeMut for ShmScheme {
         self.next_id += 1;
         Ok(id)
     }
-    fn fmap(&mut self, id: usize, offset: usize, len: usize) -> Result<usize> {
+    fn fmap(&mut self, id: usize, map: &Map) -> Result<usize> {
         let path = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+        let total_size = map.offset + map.size;
         match self.maps.get_mut(path).expect("handle pointing to nothing").buffer {
             Some(ref mut buf) => {
-                if offset + len != buf.len() {
+                if total_size != buf.len() {
                     return Err(Error::new(ERANGE));
                 }
-                Ok(buf[offset..].as_mut_ptr() as usize)
+                Ok(buf[map.offset..].as_mut_ptr() as usize)
             },
             ref mut buf @ None => {
-                *buf = Some(vec![0; offset+len].into_boxed_slice());
-                Ok(buf.as_mut().unwrap()[offset..].as_mut_ptr() as usize)
+                *buf = Some(vec![0; total_size].into_boxed_slice());
+                Ok(buf.as_mut().unwrap()[map.offset..].as_mut_ptr() as usize)
             }
         }
     }