From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:02:58 +0200
Subject: Adding upstream version 1.64.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/rustix/tests/mm/mmap.rs | 163 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 vendor/rustix/tests/mm/mmap.rs

(limited to 'vendor/rustix/tests/mm/mmap.rs')

diff --git a/vendor/rustix/tests/mm/mmap.rs b/vendor/rustix/tests/mm/mmap.rs
new file mode 100644
index 000000000..6b27287d7
--- /dev/null
+++ b/vendor/rustix/tests/mm/mmap.rs
@@ -0,0 +1,163 @@
+#![cfg(not(target_os = "wasi"))]
+
+#[cfg(feature = "fs")]
+#[cfg(not(target_os = "redox"))]
+#[test]
+fn test_mmap() {
+    use rustix::fs::{cwd, openat, Mode, OFlags};
+    use rustix::io::write;
+    use rustix::mm::{mmap, munmap, MapFlags, ProtFlags};
+    use std::ptr::null_mut;
+    use std::slice;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap();
+
+    let file = openat(
+        &dir,
+        "foo",
+        OFlags::CREATE | OFlags::WRONLY | OFlags::TRUNC,
+        Mode::RUSR,
+    )
+    .unwrap();
+    write(&file, &[b'a'; 8192]).unwrap();
+    drop(file);
+
+    let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap();
+    unsafe {
+        let addr = mmap(
+            null_mut(),
+            8192,
+            ProtFlags::READ,
+            MapFlags::PRIVATE,
+            &file,
+            0,
+        )
+        .unwrap();
+        let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192);
+        assert_eq!(slice, &[b'a'; 8192]);
+
+        munmap(addr, 8192).unwrap();
+    }
+
+    let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap();
+    unsafe {
+        assert_eq!(
+            mmap(
+                null_mut(),
+                8192,
+                ProtFlags::READ,
+                MapFlags::PRIVATE,
+                &file,
+                u64::MAX,
+            )
+            .unwrap_err()
+            .raw_os_error(),
+            libc::EINVAL
+        );
+    }
+}
+
+#[test]
+fn test_mmap_anonymous() {
+    use rustix::mm::{mmap_anonymous, munmap, MapFlags, ProtFlags};
+    use std::ptr::null_mut;
+    use std::slice;
+
+    unsafe {
+        let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
+        let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192);
+        assert_eq!(slice, &[b'\0'; 8192]);
+
+        munmap(addr, 8192).unwrap();
+    }
+}
+
+#[test]
+fn test_mprotect() {
+    use rustix::mm::{mmap_anonymous, mprotect, munmap, MapFlags, MprotectFlags, ProtFlags};
+    use std::ptr::null_mut;
+    use std::slice;
+
+    unsafe {
+        let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
+
+        mprotect(addr, 8192, MprotectFlags::empty()).unwrap();
+        mprotect(addr, 8192, MprotectFlags::READ).unwrap();
+
+        let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192);
+        assert_eq!(slice, &[b'\0'; 8192]);
+
+        munmap(addr, 8192).unwrap();
+    }
+}
+
+#[test]
+fn test_mlock() {
+    use rustix::mm::{mlock, mmap_anonymous, munlock, munmap, MapFlags, ProtFlags};
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    use rustix::mm::{mlock_with, MlockFlags};
+    use std::ptr::null_mut;
+
+    unsafe {
+        let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
+
+        mlock(addr, 8192).unwrap();
+        munlock(addr, 8192).unwrap();
+
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        {
+            match mlock_with(addr, 8192, MlockFlags::empty()) {
+                Err(rustix::io::Errno::NOSYS) => (),
+                Err(err) => Err(err).unwrap(),
+                Ok(()) => munlock(addr, 8192).unwrap(),
+            }
+
+            #[cfg(linux_raw)] // libc doesn't expose `MLOCK_UNFAULT` yet.
+            {
+                match mlock_with(addr, 8192, MlockFlags::ONFAULT) {
+                    Err(rustix::io::Errno::NOSYS) => (),
+                    Err(err) => Err(err).unwrap(),
+                    Ok(()) => munlock(addr, 8192).unwrap(),
+                }
+                munlock(addr, 8192).unwrap();
+            }
+        }
+
+        munmap(addr, 8192).unwrap();
+    }
+}
+
+#[cfg(not(target_os = "redox"))]
+#[test]
+fn test_madvise() {
+    use rustix::mm::{madvise, mmap_anonymous, munmap, Advice, MapFlags, ProtFlags};
+    use std::ptr::null_mut;
+
+    unsafe {
+        let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
+
+        madvise(addr, 8192, Advice::Normal).unwrap();
+        madvise(addr, 8192, Advice::DontNeed).unwrap();
+
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        madvise(addr, 8192, Advice::LinuxDontNeed).unwrap();
+
+        munmap(addr, 8192).unwrap();
+    }
+}
+
+#[test]
+fn test_msync() {
+    use rustix::mm::{mmap_anonymous, msync, munmap, MapFlags, MsyncFlags, ProtFlags};
+    use std::ptr::null_mut;
+
+    unsafe {
+        let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
+
+        msync(addr, 8192, MsyncFlags::SYNC).unwrap();
+        msync(addr, 8192, MsyncFlags::ASYNC).unwrap();
+
+        munmap(addr, 8192).unwrap();
+    }
+}
-- 
cgit v1.2.3