Merge remote-tracking branch 'origin/main' into 415-executable-tests-fix

Author: DyanB

skip_test_cases.txt

@@ -33,10 +33,8 @@ memory_tests/deterministic/mmap.c
 memory_tests/deterministic/mmap_complicated.c
 memory_tests/deterministic/mmap_file.c
 memory_tests/deterministic/mmaptest.c
-memory_tests/deterministic/shmtest.c
 memory_tests/deterministic/vtable.c
 memory_tests/non-deterministic/segfault.c
-memory_tests/non-deterministic/shm.c
 networking_tests/deterministic/pipepong.c
 networking_tests/deterministic/uds-getsockname.c
 networking_tests/deterministic/uds-nb-select.c

src/cage/src/cage.rs

@@ -34,7 +34,7 @@ pub struct Cage {
     pub cwd: RwLock<Arc<PathBuf>>,
     // Reverse mapping for shared memory of addresses in cage to shmid, used for attaching and deattaching
     // shared memory segments
-    pub rev_shm: Mutex<Vec<(u32, i32)>>,
+    pub rev_shm: Mutex<Vec<(u64, i32)>>,
     // signalhandler is a hash map where the key is a signal number, and the value is a SigactionStruct, which
     // defines how the cage should handle a specific signal. Interacts with sigaction_syscall() to register or
     // retrieve the handler for a specific signal.

src/cage/src/memory/shared.rs

@@ -51,21 +51,6 @@ pub fn timestamp() -> u64 {
         .as_secs()
 }
 
-/// Calls the system `mmap` via `libc` and returns the mapped address as a 32-bit integer.
-///
-/// In Lind-WASM, addresses are represented as 32-bit values within the linear memory of a
-/// Wasm module. The return value is truncated to 32 bits to match this representation.
-/// On error, returns `-1` (corresponding to `MAP_FAILED`).
-///
-/// # Safety
-/// This function uses raw pointers and directly invokes `libc::mmap`. The caller must ensure
-/// that all arguments are valid and that using the returned address as a 32-bit pointer is safe
-/// in the Lind-WASM context.
-pub fn libc_mmap(addr: *mut u8, len: usize, prot: i32, flags: i32, fildes: i32, off: i64) -> i32 {
-    return ((unsafe { libc::mmap(addr as *mut c_void, len, prot, flags, fildes, off) } as i64)
-        & 0xffffffff) as i32;
-}
-
 // Mimic shared memory in Linux by creating a file backing and truncating it to the segment size
 // We can then safely unlink the file while still holding a descriptor to that segment,
 // which we can use to map shared across cages.
@@ -149,7 +134,7 @@ impl ShmSegment {
     }
     // mmap shared segment into cage, and increase attachments
     // increase in cage references within attached_cages map
-    pub fn map_shm(&mut self, shmaddr: *mut u8, prot: i32, cageid: u64) -> i32 {
+    pub fn map_shm(&mut self, shmaddr: *mut u8, prot: i32, cageid: u64) -> usize {
         let fobjfdno = self.filebacking.as_fd_handle_raw_int();
         self.shminfo.shm_nattch += 1;
         self.shminfo.shm_atime = timestamp() as isize;
@@ -162,27 +147,34 @@ impl ShmSegment {
                 vacant.insert(1);
             }
         };
-        libc_mmap(
-            shmaddr,
-            self.size as usize,
-            prot,
-            (MAP_SHARED as i32) | (MAP_FIXED as i32),
-            fobjfdno,
-            0,
-        )
+
+        unsafe {
+            (libc::mmap(
+                shmaddr as *mut c_void,
+                self.size as usize,
+                prot,
+                (MAP_SHARED as i32) | (MAP_FIXED as i32),
+                fobjfdno,
+                0,
+            ) as usize)
+        }
     }
 
     // unmap shared segment, decrease attachments
     // decrease references within attached cages map
     pub fn unmap_shm(&mut self, shmaddr: *mut u8, cageid: u64) {
-        libc_mmap(
-            shmaddr,
-            self.size as usize,
-            PROT_NONE,
-            (MAP_PRIVATE as i32) | (MAP_ANONYMOUS as i32) | (MAP_FIXED as i32),
-            -1,
-            0,
-        );
+        let mmap_ret = unsafe {
+            (libc::mmap(
+                shmaddr as *mut c_void,
+                self.size as usize,
+                PROT_NONE,
+                (MAP_PRIVATE as i32) | (MAP_ANONYMOUS as i32) | (MAP_FIXED as i32),
+                -1,
+                0,
+            ) as usize)
+        };
+        assert!(mmap_ret == shmaddr as usize);
+
         self.shminfo.shm_nattch -= 1;
         self.shminfo.shm_dtime = timestamp() as isize;
         match self.attached_cages.entry(cageid) {
@@ -269,9 +261,9 @@ pub fn unmap_shm_mappings(cageid: u64) {
 /// # Returns
 /// * `Some(index)` if the address is found in the vector.
 /// * `None` if the address does not exist in the mapping.
-pub fn rev_shm_find_index_by_addr(rev_shm: &Vec<(u32, i32)>, shmaddr: u32) -> Option<usize> {
+pub fn rev_shm_find_index_by_addr(rev_shm: &Vec<(u64, i32)>, shmaddr: u64) -> Option<usize> {
     for (index, val) in rev_shm.iter().enumerate() {
-        if val.0 == shmaddr as u32 {
+        if val.0 == shmaddr as u64 {
             return Some(index);
         }
     }
@@ -285,9 +277,9 @@ pub fn rev_shm_find_index_by_addr(rev_shm: &Vec<(u32, i32)>, shmaddr: u32) -> Op
 /// * `shmid`   – The shared memory ID to search for.
 ///
 /// # Returns
-/// * A vector of all addresses (`u32`) associated with the given `shmid`.
+/// * A vector of all addresses (`u64`) associated with the given `shmid`.
 /// * Returns an empty vector if no addresses are found.
-pub fn rev_shm_find_addrs_by_shmid(rev_shm: &Vec<(u32, i32)>, shmid: i32) -> Vec<u32> {
+pub fn rev_shm_find_addrs_by_shmid(rev_shm: &Vec<(u64, i32)>, shmid: i32) -> Vec<u64> {
     let mut addrvec = Vec::new();
     for val in rev_shm.iter() {
         if val.1 == shmid as i32 {
@@ -308,15 +300,15 @@ pub fn rev_shm_find_addrs_by_shmid(rev_shm: &Vec<(u32, i32)>, shmid: i32) -> Vec
 /// * `Some((base_addr, shmid))` if `search_addr` falls within the range of a known segment.
 /// * `None` if the address is not within any tracked region.
 pub fn search_for_addr_in_region(
-    rev_shm: &Vec<(u32, i32)>,
-    search_addr: u32,
-) -> Option<(u32, i32)> {
+    rev_shm: &Vec<(u64, i32)>,
+    search_addr: u64,
+) -> Option<(u64, i32)> {
     let metadata = &SHM_METADATA;
     for val in rev_shm.iter() {
         let addr = val.0;
         let shmid = val.1;
         if let Some(segment) = metadata.shmtable.get_mut(&shmid) {
-            let range = addr..(addr + segment.size as u32);
+            let range = addr..(addr + segment.size as u64);
             if range.contains(&search_addr) {
                 return Some((addr, shmid));
             }
@@ -329,7 +321,7 @@ pub fn search_for_addr_in_region(
 ///
 /// # Arguments
 /// * `cageid` – ID of the calling cage.
-/// * `shmaddr` – Address where the shared memory segment should be mapped.
+/// * `shmaddr` – System Address where the shared memory segment should be mapped.
 /// * `shmflg` – Flags controlling access (e.g., `SHM_RDONLY`).
 /// * `shmid` – Identifier of the shared memory segment to attach.
 ///
@@ -339,9 +331,9 @@ pub fn search_for_addr_in_region(
 /// invalid, it returns an error.
 ///
 /// # Returns
-/// * On success – the mapped address as a `u32`.
-/// * On error – a negative errno value as a `u32`.
-pub fn shmat_helper(cageid: u64, shmaddr: *mut u8, shmflg: i32, shmid: i32) -> u32 {
+/// * On success – the mapped address as a `usize`.
+/// * On error – a negative errno value as a `usize`.
+pub fn shmat_helper(cageid: u64, shmaddr: *mut u8, shmflg: i32, shmid: i32) -> usize {
     let metadata = &SHM_METADATA;
     let prot: i32;
 
@@ -354,20 +346,20 @@ pub fn shmat_helper(cageid: u64, shmaddr: *mut u8, shmflg: i32, shmid: i32) -> u
             prot = PROT_READ | PROT_WRITE;
         }
         let mut rev_shm = cage.rev_shm.lock();
-        rev_shm.push((shmaddr as u32, shmid));
+        rev_shm.push((shmaddr as u64, shmid));
         drop(rev_shm);
 
-        segment.map_shm(shmaddr, prot, cageid) as u32
+        segment.map_shm(shmaddr, prot, cageid) as usize
     } else {
-        syscall_error(Errno::EINVAL, "shmat", "Invalid shmid value") as u32
+        syscall_error(Errno::EINVAL, "shmat", "Invalid shmid value") as usize
     }
 }
 
 /// Helper function that detaches a shared memory segment from the calling cage’s address space.
 ///
 /// # Arguments
 /// * `cageid` – ID of the calling cage.
-/// * `shmaddr` – Address of the shared memory segment to detach.
+/// * `shmaddr` – System Address of the shared memory segment to detach.
 ///
 /// This function searches the cage’s reverse mapping table for the segment mapped at `shmaddr`,
 /// detaches it with `unmap_shm`, and removes the reverse mapping entry. If the segment was marked
@@ -382,7 +374,7 @@ pub fn shmdt_helper(cageid: u64, shmaddr: *mut u8) -> i32 {
     let mut rm = false;
     let cage = get_cage(cageid).unwrap();
     let mut rev_shm = cage.rev_shm.lock();
-    let rev_shm_index = rev_shm_find_index_by_addr(&rev_shm, shmaddr as u32);
+    let rev_shm_index = rev_shm_find_index_by_addr(&rev_shm, shmaddr as u64);
 
     if let Some(index) = rev_shm_index {
         let shmid = rev_shm[index].1;

src/cage/src/memory/vmmap.rs

@@ -868,7 +868,7 @@ impl VmmapOps for Vmmap {
     ///
     /// Arguments:
     /// - npages: Number of pages needed
-    /// - hint: Starting address to search from
+    /// - hint: Starting address (in pages) to search from
     ///
     /// Returns:
     /// - Some(Interval) containing the found space
@@ -932,7 +932,7 @@ impl VmmapOps for Vmmap {
     /// Arguments:
     /// - num_pages: Number of pages needed
     /// - pages_per_map: Alignment requirement in pages
-    /// - hint: Starting address to search from
+    /// - hint: Starting address (in pages) to search from
     ///
     /// Returns:
     /// - Some(Interval) containing aligned space

src/glibc/sysdeps/unix/sysv/linux/shmctl.c

@@ -23,6 +23,9 @@
 #include <errno.h>
 #include <linux/posix_types.h>  /* For __kernel_mode_t.  */
 
+#include <syscall-template.h>
+#include <lind_syscall_num.h>
+
 /* POSIX states ipc_perm mode should have type of mode_t.  */
 _Static_assert (sizeof ((struct shmid_ds){0}.shm_perm.mode)
 		== sizeof (mode_t),
@@ -73,12 +76,8 @@ typedef struct kernel_shmid64_ds shmctl_arg_t;
 static int
 shmctl_syscall (int shmid, int cmd, shmctl_arg_t *buf)
 {
-#ifdef __ASSUME_DIRECT_SYSVIPC_SYSCALLS
-  return INLINE_SYSCALL_CALL (shmctl, shmid, cmd | __IPC_64, buf);
-#else
-  return INLINE_SYSCALL_CALL (ipc, IPCOP_shmctl, shmid, cmd | __IPC_64, 0,
-			      buf);
-#endif
+// #endif
+	return MAKE_SYSCALL(SHMCTL_SYSCALL, "syscall|shmctl", (uint64_t) shmid, (uint64_t) cmd, (uint64_t) buf, NOTUSED, NOTUSED, NOTUSED);
 }
 
 /* Provide operations to control over shared memory segments.  */
@@ -277,15 +276,7 @@ int
 attribute_compat_text_section
 __old_shmctl (int shmid, int cmd, struct __old_shmid_ds *buf)
 {
-#if defined __ASSUME_DIRECT_SYSVIPC_SYSCALLS \
-    && !defined __ASSUME_SYSVIPC_DEFAULT_IPC_64
-  /* For architecture that have wire-up shmctl but also have __IPC_64 to a
-     value different than default (0x0), it means the compat symbol used the
-     __NR_ipc syscall.  */
-  return INLINE_SYSCALL_CALL (shmctl, shmid, cmd, buf);
-#else
-  return INLINE_SYSCALL_CALL (ipc, IPCOP_shmctl, shmid, cmd, 0, buf);
-#endif
+	return MAKE_SYSCALL(SHMCTL_SYSCALL, "syscall|shmctl", (uint64_t) shmid, (uint64_t) cmd, (uint64_t) buf, NOTUSED, NOTUSED, NOTUSED);
 }
 compat_symbol (libc, __old_shmctl, shmctl, GLIBC_2_0);
 #endif