Use scheme trait for mmap_prep.

vesad/src/main.rs

@@ -112,7 +112,7 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[b
         if packet.a == syscall::number::SYS_READ && packet.d > 0 && scheme.can_read(packet.b).is_none() {
             blocked.push(packet);
         } else {
-            scheme.do_handle(&mut packet);
+            scheme.handle(&mut packet);
             socket.write(&packet).expect("vesad: failed to write display scheme");
         }
 
@@ -122,7 +122,7 @@ fn inner(daemon: redox_daemon::Daemon, framebuffers: Vec<FrameBuffer>, spec: &[b
             while i < blocked.len() {
                 if scheme.can_read(blocked[i].b).is_some() {
                     let mut packet = blocked.remove(i);
-                    scheme.do_handle(&mut packet);
+                    scheme.handle(&mut packet);
                     socket.write(&packet).expect("vesad: failed to write display scheme");
                 } else {
                     i += 1;

vesad/src/scheme.rs

@@ -377,42 +377,7 @@ impl SchemeMut for DisplayScheme {
         self.handles.remove(&id).ok_or(Error::new(EBADF))?;
         Ok(0)
     }
-}
-impl DisplayScheme {
-    pub fn do_handle(&mut self, packet: &mut Packet) {
-        match packet.a {
-            KSMSG_MMAP | KSMSG_MMAP_PREP => {
-                let off_lo = packet.uid;
-                let off_hi = packet.gid;
-                let req_off = u64::from(off_lo) | (u64::from(off_hi) << 32);
-                let req_flags = MapFlags::from_bits_truncate(packet.c);
-                let req_file_id = packet.b;
-                let req_page_count = packet.d;
-
-                let is_lazy_mmap = packet.a == KSMSG_MMAP || req_flags.contains(MapFlags::MAP_LAZY);
-
-                match self.mmap(req_file_id, req_flags, req_page_count * PAGE_SIZE, req_off) {
-                    Ok(res) => if is_lazy_mmap {
-                        packet.a = Error::mux(Err(Error::new(ESKMSG)));
-                        packet.b = SKMSG_PROVIDE_MMAP;
-                        packet.c = res;
-                        packet.d = req_page_count;
-
-                        packet.uid = off_lo;
-                        packet.gid = off_hi;
-                    } else {
-                        packet.a = Error::mux(Ok(res));
-                    },
-                    Err(err) => {
-                        packet.a = Error::mux(Err(err));
-                    }
-                };
-
-            }
-            _ => self.handle(packet),
-        }
-    }
-    pub fn mmap(&mut self, id: usize, _flags: MapFlags, size: usize, off: u64) -> Result<usize> {
+    fn mmap_prep(&mut self, id: usize, _flags: MapFlags, size: usize, off: u64) -> Result<usize> {
         let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
         if let HandleKind::Screen(vt_i, screen_i) = handle.kind {

virtio-gpud/src/main.rs

@@ -453,7 +453,7 @@ fn deamon(deamon: redox_daemon::Daemon) -> anyhow::Result<()> {
         socket_file
             .read(&mut packet)
             .expect("virtio-gpud: failed to read disk scheme");
-        scheme.handle(&mut packet);
+        unsafe { scheme.handle(&mut packet); }
         socket_file
             .write(&packet)
             .expect("virtio-gpud: failed to read disk scheme");

virtio-gpud/src/scheme.rs

@@ -4,9 +4,9 @@ use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
 use std::sync::Arc;
 
 use inputd::Damage;
-
 use common::dma::Dma;
-use syscall::{Error as SysError, SchemeMut, EAGAIN, EINVAL};
+
+use syscall::{Error as SysError, SchemeMut, EAGAIN, EINVAL, MapFlags, PAGE_SIZE, KSMSG_MMAP, KSMSG_MMAP_PREP, KSMSG_MSYNC, KSMSG_MUNMAP};
 
 use virtio_core::spec::{Buffer, ChainBuilder, DescriptorFlags};
 use virtio_core::transport::{Error, Queue, StandardTransport};
@@ -368,27 +368,6 @@ impl<'a> SchemeMut for Scheme<'a> {
         }
     }
 
-    fn fmap_old(&mut self, id: usize, map: &syscall::OldMap) -> syscall::Result<usize> {
-        self.fmap(
-            id,
-            &syscall::Map {
-                offset: map.offset,
-                size: map.size,
-                flags: map.flags,
-                address: 0,
-            },
-        )
-    }
-
-    fn fmap(&mut self, id: usize, map: &syscall::Map) -> syscall::Result<usize> {
-        match self.handles.get(&id).ok_or(SysError::new(EINVAL))? {
-            Handle::Vt { display, .. } => {
-                Ok(futures::executor::block_on(display.map_screen(map.offset)).unwrap())
-            }
-            _ => unreachable!(),
-        }
-    }
-
     fn fsync(&mut self, id: usize) -> syscall::Result<usize> {
         match self.handles.get(&id).ok_or(SysError::new(EINVAL))? {
             Handle::Vt { display, .. } => {
@@ -484,4 +463,13 @@ impl<'a> SchemeMut for Scheme<'a> {
     fn close(&mut self, _id: usize) -> syscall::Result<usize> {
         Ok(0)
     }
+    fn mmap_prep(&mut self, id: usize, flags: MapFlags, size: usize, offset: u64) -> syscall::Result<usize> {
+        log::info!("KSMSG MMAP {} {:?} {} {}", id, flags, offset, size);
+        match self.handles.get(&id).ok_or(SysError::new(EINVAL))? {
+            Handle::Vt { display, .. } => {
+                Ok(futures::executor::block_on(display.map_screen(offset as usize)).unwrap())
+            }
+            _ => unreachable!(),
+        }
+    }
 }