Implement improved mmap in vesad.

Cargo.lock

@@ -1123,8 +1123,6 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
 dependencies = [
  "bitflags 1.3.2",
 ]

Cargo.toml

@@ -39,3 +39,4 @@ lto = "fat"
 mio = { git = "https://gitlab.redox-os.org/redox-os/mio.git", branch = "redox-unix" }
 net2 = { git = "https://gitlab.redox-os.org/redox-os/net2-rs.git", branch = "master" }
 orbclient = { git = "https://gitlab.redox-os.org/redox-os/orbclient.git", version = "0.3.44" }
+redox_syscall = { path = "../../kernel/source/syscall" }

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.handle(&mut packet);
+            scheme.do_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.handle(&mut packet);
+                    scheme.do_handle(&mut packet);
                     socket.write(&packet).expect("vesad: failed to write display scheme");
                 } else {
                     i += 1;

vesad/src/scheme.rs

@@ -1,7 +1,8 @@
 use std::collections::BTreeMap;
 use std::{mem, ptr, slice, str};
 
-use syscall::{Error, EventFlags, EBADF, EINVAL, ENOENT, Map, O_NONBLOCK, Result, SchemeMut, PAGE_SIZE};
+use orbclient::{Event, EventOption};
+use syscall::{Error, EventFlags, EACCES, EBADF, EINVAL, ENOENT, Map, O_NONBLOCK, Result, SchemeMut, PAGE_SIZE, Packet, KSMSG_MMAP_PREP, KSMSG_MMAP, MapFlags, ESKMSG, SKMSG_PROVIDE_MMAP};
 
 use crate::{
     display::Display,
@@ -213,6 +214,7 @@ impl SchemeMut for DisplayScheme {
         }
     }
 
+    /*
     fn fmap(&mut self, id: usize, map: &Map) -> Result<usize> {
         let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
 
@@ -226,14 +228,7 @@ impl SchemeMut for DisplayScheme {
 
         Err(Error::new(EBADF))
     }
-    fn fmap_old(&mut self, id: usize, map: &syscall::OldMap) -> syscall::Result<usize> {
-        self.fmap(id, &Map {
-            offset: map.offset,
-            size: map.size,
-            flags: map.flags,
-            address: 0,
-        })
-    }
+    */
 
     fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
         let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
@@ -383,3 +378,51 @@ impl SchemeMut for DisplayScheme {
         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> {
+        let handle = self.handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        if let HandleKind::Screen(vt_i, screen_i) = handle.kind {
+            if let Some(screens) = self.vts.get(&vt_i) {
+                if let Some(screen) = screens.get(&screen_i) {
+                    return screen.map(off as usize, size);
+                }
+            }
+        }
+
+        Err(Error::new(EBADF))
+    }
+}