feat: fix mmap memes

* The end_address of a partial mapping needs to be set to the start
  address of the unmap range.
* Similarly for unmap end, the end address needs to be set to the start
  address of the unmap range.

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/fs/cache.rs

@@ -314,6 +314,14 @@ pub type DirCacheKey = (usize, String);
 pub type DirCache = Cache<DirCacheKey, DirEntry>;
 pub type DirCacheItem = CacheArc<CacheItem<DirCacheKey, DirEntry>>;
 
+impl Debug for DirCacheItem {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("DirCacheItem")
+            .field(&self.absolute_path_str())
+            .finish()
+    }
+}
+
 pub struct CachedINode(Arc<dyn INodeInterface>);
 
 impl CachedINode {

src/aero_kernel/src/socket/unix.rs

@@ -410,9 +410,9 @@ impl INodeInterface for UnixSocket {
             .sum::<usize>())
     }
 
-    fn send(&self, message_hdr: &mut MessageHeader, _flags: MessageFlags) -> fs::Result<usize> {
+    fn send(&self, header: &mut MessageHeader, _flags: MessageFlags) -> fs::Result<usize> {
         // FIXME(andyython): figure out the message header stuff...
-        let data = message_hdr
+        let data = header
             .iovecs()
             .iter()
             .flat_map(|e| e.as_slice())

src/aero_kernel/src/syscall/mod.rs

@@ -252,6 +252,7 @@ pub fn generic_do_syscall(
         SYS_SOCK_SHUTDOWN => net::shutdown(b, c),
         SYS_GETPEERNAME => net::get_peername(b, c, d),
         SYS_GETSOCKNAME => net::get_sockname(b, c, d),
+        SYS_SETSOCKOPT => net::setopt(a, b, c, d, e),
 
         SYS_GETTIME => time::gettime(b, c),
         SYS_SLEEP => time::sleep(b),

src/aero_kernel/src/syscall/net.rs

@@ -1,5 +1,5 @@
 use aero_syscall::netlink::sockaddr_nl;
-use aero_syscall::socket::{MessageFlags, MessageHeader};
+use aero_syscall::socket::{MessageFlags, MessageHeader, SocketOptionLevel};
 use aero_syscall::*;
 use alloc::sync::Arc;
 use num_traits::cast::FromPrimitive;
@@ -20,6 +20,8 @@ use crate::socket::{SocketAddr, SocketAddrRef};
 use crate::userland::scheduler;
 use crate::userland::task::TaskId;
 
+use super::FileDescriptor;
+
 /// Creates a [`SocketAddr`] from the provided userland socket structure address. This
 /// is done by looking at the family field present in every socket address structure.
 fn socket_addr_from_addr<'sys>(address: VirtAddr) -> Result<SocketAddrRef<'sys>> {
@@ -76,6 +78,8 @@ pub fn accept(fd: usize, address: usize, length: usize) -> Result<usize> {
 
 #[syscall]
 pub fn sock_send(fd: usize, header: &mut MessageHeader, flags: usize) -> Result<usize> {
+    dbg!(header.control());
+
     let flags = MessageFlags::from_bits(flags).ok_or(SyscallError::EINVAL)?;
 
     let current_task = scheduler::get_scheduler().current_task();
@@ -100,17 +104,32 @@ pub fn sock_recv(sockfd: usize, header: &mut MessageHeader, flags: usize) -> Res
     Ok(socket.inode().recv(header, flags)?)
 }
 
+#[syscall]
+pub fn setopt(fd: FileDescriptor, layer: usize, number: usize, buf: &[u8]) -> Result<usize> {
+    let layer = SocketOptionLevel::from_usize(layer).ok_or(SyscallError::EINVAL)?;
+
+    match layer {
+        SocketOptionLevel::Socket => {
+            unimplemented!(
+                "setsockopt(fd={:?}, layer={:?}, number={:?}, buf={:?})",
+                fd,
+                layer,
+                number,
+                buf
+            )
+        }
+
+        _ => todo!(),
+    }
+
+    Ok(0)
+}
+
 /// Marks the socket as a passive socket (i.e. as a socket that will be used to accept incoming
 /// connection requests).
 #[syscall]
-pub fn listen(fd: usize, backlog: usize) -> Result<usize> {
-    let file = scheduler::get_scheduler()
-        .current_task()
-        .file_table
-        .get_handle(fd)
-        .ok_or(SyscallError::EINVAL)?;
-
-    file.inode().listen(backlog)?;
+pub fn listen(fd: FileDescriptor, backlog: usize) -> Result<usize> {
+    fd.handle()?.inode().listen(backlog)?;
     Ok(0)
 }
 

src/aero_kernel/src/unwind.rs

@@ -169,13 +169,13 @@ pub fn unwind_stack_trace() {
         }
     }
 
-    let thread = scheduler::current_thread();
-    let tags = thread.mem_tags.lock();
-    let mut tags = tags.iter().collect::<alloc::vec::Vec<_>>();
-    tags.sort_by(|x, y| x.0.start.cmp(&y.0.start));
-    for (x, s) in tags.iter() {
-        log::trace!("{:#x}..{:#x} {s}", x.start, x.end);
-    }
+    // let thread = scheduler::current_thread();
+    // let tags = thread.mem_tags.lock();
+    // let mut tags = tags.iter().collect::<alloc::vec::Vec<_>>();
+    // tags.sort_by(|x, y| x.0.start.cmp(&y.0.start));
+    // for (x, s) in tags.iter() {
+    //     log::trace!("{:#x}..{:#x} {s}", x.start, x.end);
+    // }
 }
 
 #[cfg(feature = "ci")]

src/aero_kernel/src/userland/vm.rs

@@ -319,7 +319,7 @@ pub struct LoadedBinary<'header> {
     pub envv: Option<ExecArgs>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct MMapFile {
     offset: usize,
     file: DirCacheItem,
@@ -333,7 +333,7 @@ impl MMapFile {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 struct Mapping {
     protection: MMapProt,
     flags: MMapFlags,
@@ -584,8 +584,7 @@ impl Mapping {
                 refresh_flags: true,
             };
 
-            self.end_addr = end;
-
+            self.end_addr = start;
             Ok(UnmapResult::Partial(new_mapping))
         } else if start <= self.start_addr && end >= self.end_addr {
             // We are unmapping the whole region.
@@ -610,7 +609,7 @@ impl Mapping {
 
             // Update the end address of the mapping since we have unmapped the
             // last chunk of the mapping.
-            self.end_addr = end;
+            self.end_addr = start;
             Ok(UnmapResult::End)
         }
     }

src/aero_syscall/src/consts.rs

@@ -99,6 +99,8 @@ pub const SYS_SOCK_SHUTDOWN: usize = 75;
 pub const SYS_GETPEERNAME: usize = 76;
 pub const SYS_GETSOCKNAME: usize = 77;
 pub const SYS_DEBUG: usize = 78;
+pub const SYS_SETSOCKOPT: usize = 79;
+pub const SYS_GETSOCKOPT: usize = 80;
 
 // constants for fcntl()'s command argument:
 pub const F_DUPFD: usize = 1;

src/aero_syscall/src/socket.rs

@@ -1,12 +1,31 @@
+#![allow(non_camel_case_types)]
+
 use crate::SocketAddr;
 
+mod c {
+    // This should be bindgened.
+    pub type socklen_t = u32;
+
+    pub const SCM_RIGHTS: i32 = 1;
+    pub const SCM_CREDENTIALS: i32 = 2;
+
+    pub const SOL_SOCKET: i32 = 1;
+    pub const SOL_IPV6: i32 = 41;
+    pub const SOL_PACKET: i32 = 263;
+    pub const SOL_NETLINK: i32 = 270;
+}
+
 bitflags::bitflags! {
     // mlibc/abis/mlibc/socket.h
     pub struct MessageFlags: usize {
+        /// Indicates that some control data was discarded due to lack of space in the
+        /// buffer for ancillary data.
         const CTRUNC = 0x1;
         const DONTROUTE = 0x2;
         const EOR = 0x4;
         const OOB = 0x8;
+        /// Requests not to send `SIGPIPE` on errors on stream oriented sockets when the
+        /// other end breaks the connection. The `EPIPE` error is still returned.
         const NOSIGNAL = 0x10;
         const PEEK = 0x20;
         const TRUNC = 0x40;
@@ -29,13 +48,13 @@ pub struct MessageHeader {
     /// Pointer to the socket address structure.
     name: *mut u8,
     /// Size of the socket address structure.
-    name_len: u32,
+    name_len: c::socklen_t,
 
     iovec: *mut IoVec, // todo: use Option<NonNull<IoVec>>
     iovec_len: i32,    // todo: use ffi::c_int
 
     control: *const u8,
-    control_len: u32,
+    control_len: c::socklen_t,
 
     pub flags: i32, // todo: use ffi::c_int
 }
@@ -48,22 +67,21 @@ impl MessageHeader {
 
         assert!(self.name_len >= core::mem::size_of::<T>() as u32);
 
-        // SAFETY: We know that the `name` pointer is valid and we have an exclusive reference to
-        // it. The size of name is checked above with the size of `T` and `T` is a `SocketAddr` so,
-        // its safe to create a mutable reference of `T` from the ptr.
         unsafe { Some(&mut *(self.name as *mut T)) }
     }
 
     pub fn iovecs(&self) -> &[IoVec] {
-        // SAFETY: We know that the `iovec` pointer is valid, initialized.
         unsafe { core::slice::from_raw_parts(self.iovec, self.iovec_len as usize) }
     }
 
     pub fn iovecs_mut(&mut self) -> &mut [IoVec] {
-        // SAFETY: We know that the `iovec` pointer is valid, initialized and we have exclusive
-        // access so, its safe to construct a mutable slice from it.
         unsafe { core::slice::from_raw_parts_mut(self.iovec, self.iovec_len as usize) }
     }
+
+    pub fn control(&self) -> &[ControlMessage] {
+        assert!(self.control_len == 0);
+        &[]
+    }
 }
 
 // options/posix/include/bits/posix/iovec.h
@@ -91,3 +109,32 @@ impl IoVec {
         self.len
     }
 }
+
+/// Control Message Header (`struct cmsghdr`).
+#[derive(Debug)]
+#[repr(C)]
+pub struct ControlMessage {
+    /// Data byte count, including the header.
+    pub cmsg_len: c::socklen_t,
+    /// Originating protocol.
+    pub cmsg_level: SocketOptionLevel,
+    /// Protocol-specific type.
+    pub cmsg_type: ControlMessageType,
+    // followed by cmsg_data: [u8; cmsg_len - sizeof(struct cmsghdr)]
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[repr(i32)]
+pub enum ControlMessageType {
+    Rights = c::SCM_RIGHTS,
+    Credentials = c::SCM_CREDENTIALS,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, FromPrimitive)]
+#[repr(i32)]
+pub enum SocketOptionLevel {
+    Socket = c::SOL_SOCKET,
+    Ipv6 = c::SOL_IPV6,
+    Packet = c::SOL_PACKET,
+    Netlink = c::SOL_NETLINK,
+}

tools/mkimage.sh

@@ -3,15 +3,27 @@
 set -x -e
 
 ANSI_CLEAR="\033[0m"
-ANSI_YELLOW="\033[1;34m"
+ANSI_RED="\033[1;31m"
+ANSI_BOLD="\033[1m"
 
 function warn() {
-	echo -e "${ANSI_YELLOW}$1${ANSI_CLEAR}"
+	echo -e "${ANSI_RED}error${ANSI_CLEAR}: ${ANSI_BOLD}$1${ANSI_CLEAR}"
 }
 
-# check if the pkg-build directory is not newer than the system-root
-if [[ ./sysroot/pkg-build -nt ./sysroot/system-root]]; then
-	warn "mkimage: pkg-build is newer than system-root, run `xbstrap install --all`"
+function newest_file() {
+  local latest file
+  for file; do
+    [[ $file && $file -nt $latest ]] || latest=$file
+  done
+}
+
+function has_newer_files_than() {
+  [[ "$(newest_file "$1"/*)" -nt "$(newest_file "$2" "$2"/*)" ]]
+}
+
+# check if the packages directory is not newer than the system-root
+if has_newer_files_than "./sysroot/packages" "./system/system-root"; then
+	warn "\`./sysroot/packages\` is newer than \`./sysroot/system-root\`, run \`xbstrap install --all\`"
 	exit 1
 fi