stash

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

Author: Andy-Python-Programmer

.gitignore

@@ -22,3 +22,6 @@ base-files/doom1.wad
 # Wayland test client and server executables: (todo: remove these)
 base-files/client
 base-files/server
+
+# todo: remove these
+debug

bootstrap/net.yml

@@ -724,10 +724,10 @@ packages:
         - '-DUSE_SOUP2=ON'
         - '-DUSE_LCMS=OFF'
         - '@THIS_SOURCE_DIR@'
+        environ:
+          CXXFLAGS: '-DLOG_DISABLED=0'
     build:
       - args: ['ninja', '-j6']
-        # environ:
-        #   CXXFLAGS: '-std=c++11'
       - args: ['ninja', 'install']
         environ:
           DESTDIR: '@THIS_COLLECT_DIR@'

src/aero_kernel/src/main.rs

@@ -48,7 +48,8 @@
     trait_upcasting, // https://github.com/rust-lang/rust/issues/65991
     naked_functions, // https://github.com/rust-lang/rust/issues/32408
     cfg_match, // https://github.com/rust-lang/rust/issues/115585
-    strict_provenance
+    strict_provenance,
+    offset_of
 )]
 // TODO(andypython): can we remove the dependency of "prelude_import" and "lang_items"?
 //     `lang_items`     => is currently used for the personality function (`rust_eh_personality`).

src/aero_kernel/src/socket/unix.rs

@@ -42,6 +42,7 @@ fn path_from_unix_sock(address: &SocketAddrUnix) -> fs::Result<&Path> {
     // connection which does not require a path to be created.
     let abstract_namespaced = address.path[0] == 0;
     assert!(!abstract_namespaced);
+    assert!(address.path[1] != 0, "unnamed UNIX socket");
 
     let path_len = address
         .path
@@ -351,6 +352,7 @@ impl INodeInterface for UnixSocket {
 
         let peer = queue.pop().expect("UnixSocket::accept(): backlog is empty");
         let sock = Self::new();
+        sock.inner.lock_irq().address = inner.address.clone();
 
         {
             let mut sock_inner = sock.inner.lock_irq();
@@ -362,16 +364,18 @@ impl INodeInterface for UnixSocket {
             peer_data.state = UnixSocketState::Connected(sock.clone());
         }
 
+        // THIS SHOULD NOT BE DONE HERE
         if let Some((address, length)) = address {
             let mut address = unsafe { UserRef::new(address) };
 
-            if let Some(paddr) = peer.inner.lock_irq().address.as_ref() {
+            if let Some(paddr) = inner.address.as_ref() {
                 *address = paddr.clone();
             } else {
                 *address = SocketAddrUnix::default();
                 address.family = AF_UNIX;
             }
 
+            // THIS IS WRONG use addr.name_len() + offset_of!(sockaddr_un, path)
             *length = core::mem::size_of::<SocketAddrUnix>() as u32;
         }
 

src/aero_kernel/src/syscall/mod.rs

@@ -259,6 +259,8 @@ pub fn generic_do_syscall(
         // Syscall aliases (this should be handled in aero_syscall)
         SYS_MKDIR => fs::mkdirat(aero_syscall::AT_FDCWD as _, b, c),
 
+        SYS_DEBUG => tag_memory(b, c, d, e),
+
         _ => {
             log::error!("invalid syscall: {:#x}", a);
             Err(SyscallError::ENOSYS)
@@ -267,3 +269,19 @@ pub fn generic_do_syscall(
 
     aero_syscall::syscall_result_as_usize(result)
 }
+
+#[syscall]
+pub fn tag_memory(ptr: *const u8, size: usize, tag: &str) -> Result<usize, SyscallError> {
+    use crate::userland::scheduler;
+    use alloc::string::ToString;
+
+    let addr = ptr as usize;
+
+    let thread = scheduler::current_thread();
+    thread
+        .mem_tags
+        .lock()
+        .insert(addr..(addr + size), tag.to_string());
+
+    Ok(0)
+}

src/aero_kernel/src/syscall/net.rs

@@ -178,12 +178,12 @@ pub fn socket(___domain: usize, socket_type: usize, protocol: usize) -> Result<usiz
 
     let sockfd_flags = SocketFlags::from_bits_truncate(socket_type).into();
     let fd = dbg!(current_task.file_table.debug_open_file(entry, sockfd_flags))?;
-    if fd == 17 {
-        scheduler::get_scheduler()
-            .find_task(TaskId::new(40))
-            .unwrap()
-            .enable_systrace();
-    }
+    // if fd == 17 {
+    //     scheduler::get_scheduler()
+    //         .find_task(TaskId::new(40))
+    //         .unwrap()
+    //         .enable_systrace();
+    // }
 
     Ok(fd)
 }
@@ -237,13 +237,12 @@ pub fn get_peername(fd: usize, addr: usize, len: &mut u32) -> Result<usize, Sysc
 
         SocketAddr::Netlink(peer) => unimplemented!("{:?}", peer),
         SocketAddr::Unix(peer) => {
-            // let size = core::mem::size_of::<SocketAddrUnix>() as u32;
-            // assert!(*len >= size);
+            let size = core::mem::size_of::<SocketAddrUnix>() as u32;
+            assert!(*len >= size);
 
-            // let mut target = unsafe { UserRef::<SocketAddrUnix>::new(VirtAddr::new(addr as u64))
-            // }; *target = peer;
-            // *len = size;
-            return Err(SyscallError::ENOSYS);
+            let mut target = unsafe { &mut *(addr as *mut SocketAddrUnix) };
+            *len = peer.path_len() as u32 + core::mem::offset_of!(SocketAddrUnix, path) as u32;
+            *target = peer;
         }
     }
 
@@ -290,8 +289,8 @@ pub fn get_sockname(fd: usize, addr: usize, len: &mut u32) -> Result<usize, Sysc
             assert!(*len >= size);
 
             let mut target = unsafe { UserRef::<SocketAddrUnix>::new(VirtAddr::new(addr as u64)) };
+            *len = name.path_len() as u32 + core::mem::offset_of!(SocketAddrUnix, path) as u32;
             *target = name;
-            *len = size;
         }
     }
 

src/aero_kernel/src/unwind.rs

@@ -26,6 +26,7 @@ use xmas_elf::ElfFile;
 use crate::mem::paging::{Translate, VirtAddr};
 use crate::mem::AddressSpace;
 
+use crate::userland::scheduler;
 use crate::{logger, rendy};
 
 use crate::arch::interrupts;
@@ -145,6 +146,20 @@ pub fn unwind_stack_trace() {
 
             if let Some(name) = name {
                 log::trace!("{:>2}: 0x{:016x} - {}", depth, rip, name);
+            } else if scheduler::is_initialized() {
+                if let Some((region, tag)) = scheduler::current_thread()
+                    .mem_tags
+                    .lock()
+                    .iter()
+                    .find(|(region, _tag)| region.contains(&rip))
+                {
+                    let resolved_addr = rip - region.start;
+                    log::trace!(
+                        "{depth:>2}: 0x{rip:016x} - <userland, in={tag}, resolved_addr={resolved_addr:#x}>"
+                    );
+                } else {
+                    log::trace!("{depth:>2}: 0x{rip:016x} - <unknown>");
+                }
             } else {
                 log::trace!("{:>2}: 0x{:016x} - <unknown>", depth, rip);
             }
@@ -153,6 +168,14 @@ pub fn unwind_stack_trace() {
             break;
         }
     }
+
+    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/task/mod.rs

@@ -20,9 +20,11 @@ pub mod sessions;
 use aero_syscall::WaitPidFlags;
 use alloc::sync::{Arc, Weak};
 
+use hashbrown::HashMap;
 use spin::{Once, RwLock};
 
 use core::cell::UnsafeCell;
+use core::ops::Range;
 use core::sync::atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering};
 
 use crate::fs::cache::{DirCacheImpl, DirCacheItem};
@@ -221,6 +223,9 @@ pub struct Task {
 
     controlling_terminal: Mutex<Option<Arc<dyn TerminalDevice>>>,
     systrace: AtomicBool,
+
+    // for debugging only. may remove in the future.
+    pub mem_tags: Mutex<HashMap<Range<usize>, String>>,
 }
 
 impl Task {
@@ -265,6 +270,8 @@ impl Task {
 
             systrace: AtomicBool::new(false),
             controlling_terminal: Mutex::new(None),
+
+            mem_tags: Mutex::new(HashMap::new()),
         })
     }
 
@@ -307,6 +314,8 @@ impl Task {
 
             systrace: AtomicBool::new(false),
             controlling_terminal: Mutex::new(None),
+
+            mem_tags: Mutex::new(HashMap::new()),
         })
     }
 
@@ -345,6 +354,8 @@ impl Task {
 
             systrace: AtomicBool::new(self.systrace()),
             controlling_terminal: Mutex::new(self.controlling_terminal.lock_irq().clone()),
+
+            mem_tags: Mutex::new(self.mem_tags.lock().clone()),
         });
 
         self.add_child(this.clone());
@@ -413,6 +424,8 @@ impl Task {
                     .lock_irq()
                     .clone(),
             ),
+
+            mem_tags: Mutex::new(self.mem_tags.lock().clone()),
         });
 
         self.add_child(this.clone());
@@ -514,6 +527,7 @@ impl Task {
             *self.cwd.write() = Some(Cwd::new())
         }
 
+        *self.mem_tags.lock() = HashMap::new();
         self.file_table.close_on_exec();
 
         self.file_table.log();

src/aero_kernel/src/userland/vm.rs

@@ -782,6 +782,8 @@ impl VmProtected {
         offset: usize,
         file: Option<DirCacheItem>,
     ) -> Option<VirtAddr> {
+        let z = file.clone();
+
         // Offset is required to be a multiple of page size.
         if (offset as u64 & (Size4KiB::SIZE - 1)) != 0 {
             log::warn!("mmap: offset is not a multiple of page size");
@@ -864,6 +866,17 @@ impl VmProtected {
         if x.is_none() {
             log::warn!("mmap failed");
             self.log();
+
+            dbg!(
+                address,
+                size,
+                protection,
+                flags,
+                offset,
+                z.map(|f| f.absolute_path_str())
+            );
+
+            crate::unwind::unwind_stack_trace();
         }
 
         x

src/aero_syscall/src/consts.rs

@@ -98,6 +98,7 @@ pub const SYS_GETPGID: usize = 74;
 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;
 
 // constants for fcntl()'s command argument:
 pub const F_DUPFD: usize = 1;