mmap for windows

youknowone · youknowone · commit 01cdaa3b26b1 · 2025-12-06T08:42:39.000+09:00
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
@@ -53,7 +53,12 @@ mod mmap {
             | libc::MADV_SEQUENTIAL
             | libc::MADV_WILLNEED
             | libc::MADV_DONTNEED => Ok(advice),
-            #[cfg(any(target_os = "linux", target_os = "macos", target_os = "ios"))]
+            #[cfg(any(
+                target_os = "linux",
+                target_os = "macos",
+                target_os = "ios",
+                target_os = "freebsd"
+            ))]
             libc::MADV_FREE => Ok(advice),
             #[cfg(target_os = "linux")]
             libc::MADV_DONTFORK
@@ -66,6 +71,12 @@ mod mmap {
             | libc::MADV_DONTDUMP
             | libc::MADV_DODUMP
             | libc::MADV_HWPOISON => Ok(advice),
+            #[cfg(target_os = "freebsd")]
+            libc::MADV_NOSYNC
+            | libc::MADV_AUTOSYNC
+            | libc::MADV_NOCORE
+            | libc::MADV_CORE
+            | libc::MADV_PROTECT => Ok(advice),
             _ => Err(vm.new_value_error("Not a valid Advice value")),
         }
     }
@@ -96,7 +107,7 @@ mod mmap {
     #[pyattr]
     use libc::{
         MADV_DONTNEED, MADV_NORMAL, MADV_RANDOM, MADV_SEQUENTIAL, MADV_WILLNEED, MAP_ANON,
-        MAP_ANONYMOUS, MAP_PRIVATE, MAP_SHARED, PROT_READ, PROT_WRITE,
+        MAP_ANONYMOUS, MAP_PRIVATE, MAP_SHARED, PROT_EXEC, PROT_READ, PROT_WRITE,
     };
 
     #[cfg(target_os = "macos")]
@@ -146,6 +157,16 @@ mod mmap {
     #[pyattr]
     use libc::{MAP_DENYWRITE, MAP_EXECUTABLE, MAP_POPULATE};
 
+    // MAP_STACK is available on Linux, OpenBSD, and NetBSD
+    #[cfg(any(target_os = "linux", target_os = "openbsd", target_os = "netbsd"))]
+    #[pyattr]
+    use libc::MAP_STACK;
+
+    // FreeBSD-specific MADV constants
+    #[cfg(target_os = "freebsd")]
+    #[pyattr]
+    use libc::{MADV_AUTOSYNC, MADV_CORE, MADV_NOCORE, MADV_NOSYNC, MADV_PROTECT};
+
     #[pyattr]
     const ACCESS_DEFAULT: u32 = AccessMode::Default as u32;
     #[pyattr]
@@ -404,6 +425,15 @@ mod mmap {
             };
 
             let fd = unsafe { crt_fd::Borrowed::try_borrow_raw(fd) };
+
+            // macOS: Issue #11277: fsync(2) is not enough on OS X - a special, OS X specific
+            // fcntl(2) is necessary to force DISKSYNC and get around mmap(2) bug
+            #[cfg(target_os = "macos")]
+            if let Ok(fd) = fd {
+                use std::os::fd::AsRawFd;
+                unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_FULLFSYNC) };
+            }
+
             if let Ok(fd) = fd {
                 let metadata = fstat(fd)
                     .map_err(|err| io::Error::from_raw_os_error(err as i32).to_pyexception(vm))?;
@@ -799,8 +829,9 @@ mod mmap {
 
             let sub = &options.sub;
 
+            // returns start position for empty string
             if sub.is_empty() {
-                return Ok(PyInt::from(0isize));
+                return Ok(PyInt::from(start as isize));
             }
 
             let mmap = self.check_valid(vm)?;
@@ -815,8 +846,9 @@ mod mmap {
             let (start, end) = self.get_find_range(options.clone());
 
             let sub = &options.sub;
+            // returns start position for empty string
             if sub.is_empty() {
-                return Ok(PyInt::from(0isize));
+                return Ok(PyInt::from(start as isize));
             }
 
             let mmap = self.check_valid(vm)?;
@@ -850,18 +882,20 @@ mod mmap {
         #[cfg(all(unix, not(target_os = "redox")))]
         #[pymethod]
         fn madvise(&self, options: AdviseOptions, vm: &VirtualMachine) -> PyResult<()> {
-            let (option, _start, _length) = options.values(self.__len__(), vm)?;
+            let (option, start, length) = options.values(self.__len__(), vm)?;
             let advice = validate_advice(vm, option)?;
 
             let guard = self.check_valid(vm)?;
             let mmap = guard.deref().as_ref().unwrap();
-            let (ptr, len) = match mmap {
-                MmapObj::Read(m) => (m.as_ptr(), m.len()),
-                MmapObj::Write(m) => (m.as_ptr(), m.len()),
+            let ptr = match mmap {
+                MmapObj::Read(m) => m.as_ptr(),
+                MmapObj::Write(m) => m.as_ptr(),
             };
 
-            // Call libc::madvise directly
-            let result = unsafe { libc::madvise(ptr as *mut libc::c_void, len, advice) };
+            // Apply madvise to the specified range (start, length)
+            let ptr_with_offset = unsafe { ptr.add(start) };
+            let result =
+                unsafe { libc::madvise(ptr_with_offset as *mut libc::c_void, length, advice) };
             if result != 0 {
                 return Err(io::Error::last_os_error().to_pyexception(vm));
             }
@@ -1063,13 +1097,14 @@ mod mmap {
                     // Restore original mmap on error
                     let err = io::Error::last_os_error();
                     let old_size = self.size.load();
-                    if let Ok(mmap) = Self::create_mmap_windows(
+                    match Self::create_mmap_windows(
                         handle as HANDLE,
                         self.offset,
                         old_size,
                         &self.access,
                     ) {
-                        *mmap_guard = Some(mmap);
+                        Ok(mmap) => *mmap_guard = Some(mmap),
+                        Err(_) => self.closed.store(true),
                     }
                     return Err(err.to_pyexception(vm));
                 }
@@ -1078,13 +1113,14 @@ mod mmap {
                 if result == 0 {
                     let err = io::Error::last_os_error();
                     let old_size = self.size.load();
-                    if let Ok(mmap) = Self::create_mmap_windows(
+                    match Self::create_mmap_windows(
                         handle as HANDLE,
                         self.offset,
                         old_size,
                         &self.access,
                     ) {
-                        *mmap_guard = Some(mmap);
+                        Ok(mmap) => *mmap_guard = Some(mmap),
+                        Err(_) => self.closed.store(true),
                     }
                     return Err(err.to_pyexception(vm));
                 }
@@ -1248,6 +1284,12 @@ mod mmap {
         fn __exit__(zelf: &Py<Self>, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             zelf.close(vm)
         }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn __sizeof__(&self) -> usize {
+            std::mem::size_of::<Self>()
+        }
     }
 
     impl PyMmap {
