Switch to libredox where applicable (fixed)

common/src/dma.rs

@@ -2,10 +2,10 @@ use std::mem::{self, size_of, MaybeUninit};
 use std::ops::{Deref, DerefMut};
 use std::ptr;
 
+use libredox::call::MmapArgs;
+use libredox::{flag, error::Result, Fd};
 use syscall::PAGE_SIZE;
 
-use syscall::Result;
-
 use crate::MemoryType;
 
 const DMA_MEMTY: MemoryType = {
@@ -20,30 +20,26 @@ const DMA_MEMTY: MemoryType = {
     }
 };
 
-fn alloc_and_map(len: usize) -> Result<(usize, *mut ())> {
-    assert_eq!(len % PAGE_SIZE, 0);
+fn alloc_and_map(length: usize) -> Result<(usize, *mut ())> {
+    assert_eq!(length % PAGE_SIZE, 0);
     unsafe {
-        let fd = syscall::open(
-            format!("memory:zeroed@{DMA_MEMTY}?phys_contiguous"),
-            syscall::O_CLOEXEC,
+        let fd = Fd::open(
+            &format!("memory:zeroed@{DMA_MEMTY}?phys_contiguous"),
+            flag::O_CLOEXEC,
+            0,
         )?;
-        let virt = syscall::fmap(
-            fd,
-            &syscall::Map {
-                offset: 0,  // ignored
-                address: 0, // ignored
-                size: len,
-                flags: syscall::MapFlags::MAP_PRIVATE
-                    | syscall::MapFlags::PROT_READ
-                    | syscall::MapFlags::PROT_WRITE,
-            },
-        );
-        let _ = syscall::close(fd);
-        let virt = virt?;
-        let phys = syscall::virttophys(virt)?;
-        /*for i in 1..len.div_ceil(PAGE_SIZE) {
-            assert_eq!(syscall::virttophys(virt + i * PAGE_SIZE), Ok(phys + i * PAGE_SIZE), "NOT CONTIGUOUS");
-        }*/
+        let virt = libredox::call::mmap(MmapArgs {
+            fd: fd.raw(),
+            offset: 0,  // ignored
+            addr: core::ptr::null_mut(), // ignored
+            length,
+            flags: flag::MAP_PRIVATE,
+            prot: flag::PROT_READ | flag::PROT_WRITE,
+        })?;
+        let phys = syscall::virttophys(virt as usize)?;
+        for i in 1..length.div_ceil(PAGE_SIZE) {
+            debug_assert_eq!(syscall::virttophys(virt as usize + i * PAGE_SIZE), Ok(phys + i * PAGE_SIZE), "NOT CONTIGUOUS");
+        }
         Ok((phys, virt as *mut ()))
     }
 }
@@ -159,7 +155,7 @@ impl<T: ?Sized> Drop for Dma<T> {
     fn drop(&mut self) {
         unsafe {
             ptr::drop_in_place(self.virt);
-            let _ = syscall::funmap(self.virt as *mut u8 as usize, self.aligned_len);
+            let _ = libredox::call::munmap(self.virt as *mut (), self.aligned_len);
         }
     }
 }

common/src/lib.rs

@@ -1,7 +1,8 @@
 #![feature(int_roundings)]
 
-use syscall::error::{Error, Result, EINVAL};
-use syscall::flag::{MapFlags, O_CLOEXEC, O_RDONLY, O_RDWR, O_WRONLY};
+use libredox::call::MmapArgs;
+use libredox::{Fd, error::*, errno::EINVAL};
+use libredox::flag::{self, O_CLOEXEC, O_RDONLY, O_RDWR, O_WRONLY};
 use syscall::PAGE_SIZE;
 
 pub mod dma;
@@ -63,23 +64,23 @@ pub unsafe fn physmap(
         (false, true) => O_WRONLY,
         (false, false) => return Err(Error::new(EINVAL)),
     };
-    let mut prot = MapFlags::empty();
-    prot.set(MapFlags::PROT_READ, read);
-    prot.set(MapFlags::PROT_WRITE, write);
+    let mut prot = 0;
+    if read {
+        prot |= flag::PROT_READ;
+    }
+    if write {
+        prot |= flag::PROT_WRITE;
+    }
 
-    let file = syscall::open(path, O_CLOEXEC | mode)?;
-    let base = syscall::fmap(
-        file,
-        &syscall::Map {
-            offset: base_phys,
-            size: len.next_multiple_of(PAGE_SIZE),
-            flags: MapFlags::MAP_SHARED | prot,
-            address: 0,
-        },
-    );
-    let _ = syscall::close(file);
-
-    Ok(base? as *mut ())
+    let fd = Fd::open(&path, O_CLOEXEC | mode, 0)?;
+    Ok(libredox::call::mmap(MmapArgs {
+        fd: fd.raw(),
+        offset: base_phys as u64,
+        length: len.next_multiple_of(PAGE_SIZE),
+        flags: flag::MAP_SHARED,
+        prot,
+        addr: core::ptr::null_mut(),
+    })? as *mut ())
 }
 
 impl std::fmt::Display for MemoryType {
@@ -119,7 +120,14 @@ impl PhysBorrowed {
 impl Drop for PhysBorrowed {
     fn drop(&mut self) {
         unsafe {
-            let _ = syscall::funmap(self.mem as usize, self.len);
+            let _ = libredox::call::munmap(self.mem, self.len);
         }
     }
 }
+
+pub fn acquire_port_io_rights() -> Result<()> {
+    unsafe {
+        syscall::iopl(3)?;
+    }
+    Ok(())
+}