summaryrefslogtreecommitdiffstats
path: root/vendor/rustix/src/imp/linux_raw/mm
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/rustix/src/imp/linux_raw/mm')
-rw-r--r--vendor/rustix/src/imp/linux_raw/mm/mod.rs2
-rw-r--r--vendor/rustix/src/imp/linux_raw/mm/syscalls.rs214
-rw-r--r--vendor/rustix/src/imp/linux_raw/mm/types.rs208
3 files changed, 424 insertions, 0 deletions
diff --git a/vendor/rustix/src/imp/linux_raw/mm/mod.rs b/vendor/rustix/src/imp/linux_raw/mm/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/imp/linux_raw/mm/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/linux_raw/mm/syscalls.rs b/vendor/rustix/src/imp/linux_raw/mm/syscalls.rs
new file mode 100644
index 000000000..8b230be3d
--- /dev/null
+++ b/vendor/rustix/src/imp/linux_raw/mm/syscalls.rs
@@ -0,0 +1,214 @@
+//! linux_raw syscalls supporting `rustix::io`.
+//!
+//! # Safety
+//!
+//! See the `rustix::imp` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use super::super::c;
+#[cfg(target_pointer_width = "64")]
+use super::super::conv::loff_t_from_u64;
+use super::super::conv::{c_uint, no_fd, pass_usize, ret, ret_owned_fd, ret_void_star};
+use super::types::{
+ Advice, MapFlags, MlockFlags, MprotectFlags, MremapFlags, MsyncFlags, ProtFlags,
+ UserfaultfdFlags,
+};
+use crate::fd::BorrowedFd;
+use crate::io::{self, OwnedFd};
+#[cfg(target_pointer_width = "32")]
+use core::convert::TryInto;
+use linux_raw_sys::general::MAP_ANONYMOUS;
+
+#[inline]
+pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::Result<()> {
+ unsafe {
+ ret(syscall!(
+ __NR_madvise,
+ addr,
+ pass_usize(len),
+ c_uint(advice as c::c_uint)
+ ))
+ }
+}
+
+#[inline]
+pub(crate) unsafe fn msync(addr: *mut c::c_void, len: usize, flags: MsyncFlags) -> io::Result<()> {
+ ret(syscall!(__NR_msync, addr, pass_usize(len), flags))
+}
+
+/// # Safety
+///
+/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
+/// with memory pointed to by raw pointers is unsafe.
+#[inline]
+pub(crate) unsafe fn mmap(
+ addr: *mut c::c_void,
+ length: usize,
+ prot: ProtFlags,
+ flags: MapFlags,
+ fd: BorrowedFd<'_>,
+ offset: u64,
+) -> io::Result<*mut c::c_void> {
+ #[cfg(target_pointer_width = "32")]
+ {
+ ret_void_star(syscall!(
+ __NR_mmap2,
+ addr,
+ pass_usize(length),
+ prot,
+ flags,
+ fd,
+ (offset / 4096)
+ .try_into()
+ .map(|scaled_offset| pass_usize(scaled_offset))
+ .map_err(|_| io::Errno::INVAL)?
+ ))
+ }
+ #[cfg(target_pointer_width = "64")]
+ {
+ ret_void_star(syscall!(
+ __NR_mmap,
+ addr,
+ pass_usize(length),
+ prot,
+ flags,
+ fd,
+ loff_t_from_u64(offset)
+ ))
+ }
+}
+
+/// # Safety
+///
+/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
+/// with memory pointed to by raw pointers is unsafe.
+#[inline]
+pub(crate) unsafe fn mmap_anonymous(
+ addr: *mut c::c_void,
+ length: usize,
+ prot: ProtFlags,
+ flags: MapFlags,
+) -> io::Result<*mut c::c_void> {
+ #[cfg(target_pointer_width = "32")]
+ {
+ ret_void_star(syscall!(
+ __NR_mmap2,
+ addr,
+ pass_usize(length),
+ prot,
+ c_uint(flags.bits() | MAP_ANONYMOUS),
+ no_fd(),
+ pass_usize(0)
+ ))
+ }
+ #[cfg(target_pointer_width = "64")]
+ {
+ ret_void_star(syscall!(
+ __NR_mmap,
+ addr,
+ pass_usize(length),
+ prot,
+ c_uint(flags.bits() | MAP_ANONYMOUS),
+ no_fd(),
+ loff_t_from_u64(0)
+ ))
+ }
+}
+
+#[inline]
+pub(crate) unsafe fn mprotect(
+ ptr: *mut c::c_void,
+ len: usize,
+ flags: MprotectFlags,
+) -> io::Result<()> {
+ ret(syscall!(__NR_mprotect, ptr, pass_usize(len), flags))
+}
+
+/// # Safety
+///
+/// `munmap` is primarily unsafe due to the `addr` parameter, as anything
+/// working with memory pointed to by raw pointers is unsafe.
+#[inline]
+pub(crate) unsafe fn munmap(addr: *mut c::c_void, length: usize) -> io::Result<()> {
+ ret(syscall!(__NR_munmap, addr, pass_usize(length)))
+}
+
+/// # Safety
+///
+/// `mremap` is primarily unsafe due to the `old_address` parameter, as
+/// anything working with memory pointed to by raw pointers is unsafe.
+#[inline]
+pub(crate) unsafe fn mremap(
+ old_address: *mut c::c_void,
+ old_size: usize,
+ new_size: usize,
+ flags: MremapFlags,
+) -> io::Result<*mut c::c_void> {
+ ret_void_star(syscall!(
+ __NR_mremap,
+ old_address,
+ pass_usize(old_size),
+ pass_usize(new_size),
+ flags
+ ))
+}
+
+/// # Safety
+///
+/// `mremap_fixed` is primarily unsafe due to the `old_address` and
+/// `new_address` parameters, as anything working with memory pointed to by raw
+/// pointers is unsafe.
+#[inline]
+pub(crate) unsafe fn mremap_fixed(
+ old_address: *mut c::c_void,
+ old_size: usize,
+ new_size: usize,
+ flags: MremapFlags,
+ new_address: *mut c::c_void,
+) -> io::Result<*mut c::c_void> {
+ ret_void_star(syscall!(
+ __NR_mremap,
+ old_address,
+ pass_usize(old_size),
+ pass_usize(new_size),
+ flags,
+ new_address
+ ))
+}
+
+/// # Safety
+///
+/// `mlock` operates on raw pointers and may round out to the nearest page
+/// boundaries.
+#[inline]
+pub(crate) unsafe fn mlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
+ ret(syscall!(__NR_mlock, addr, pass_usize(length)))
+}
+
+/// # Safety
+///
+/// `mlock_with` operates on raw pointers and may round out to the nearest page
+/// boundaries.
+#[inline]
+pub(crate) unsafe fn mlock_with(
+ addr: *mut c::c_void,
+ length: usize,
+ flags: MlockFlags,
+) -> io::Result<()> {
+ ret(syscall!(__NR_mlock2, addr, pass_usize(length), flags))
+}
+
+/// # Safety
+///
+/// `munlock` operates on raw pointers and may round out to the nearest page
+/// boundaries.
+#[inline]
+pub(crate) unsafe fn munlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
+ ret(syscall!(__NR_munlock, addr, pass_usize(length)))
+}
+
+#[inline]
+pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> {
+ ret_owned_fd(syscall_readonly!(__NR_userfaultfd, flags))
+}
diff --git a/vendor/rustix/src/imp/linux_raw/mm/types.rs b/vendor/rustix/src/imp/linux_raw/mm/types.rs
new file mode 100644
index 000000000..a58dd76be
--- /dev/null
+++ b/vendor/rustix/src/imp/linux_raw/mm/types.rs
@@ -0,0 +1,208 @@
+use super::super::c;
+use bitflags::bitflags;
+
+bitflags! {
+ /// `PROT_*` flags for use with [`mmap`].
+ ///
+ /// For `PROT_NONE`, use `ProtFlags::empty()`.
+ ///
+ /// [`mmap`]: crate::io::mmap
+ pub struct ProtFlags: u32 {
+ /// `PROT_READ`
+ const READ = linux_raw_sys::general::PROT_READ;
+ /// `PROT_WRITE`
+ const WRITE = linux_raw_sys::general::PROT_WRITE;
+ /// `PROT_EXEC`
+ const EXEC = linux_raw_sys::general::PROT_EXEC;
+ }
+}
+
+bitflags! {
+ /// `PROT_*` flags for use with [`mprotect`].
+ ///
+ /// For `PROT_NONE`, use `MprotectFlags::empty()`.
+ ///
+ /// [`mprotect`]: crate::io::mprotect
+ pub struct MprotectFlags: u32 {
+ /// `PROT_READ`
+ const READ = linux_raw_sys::general::PROT_READ;
+ /// `PROT_WRITE`
+ const WRITE = linux_raw_sys::general::PROT_WRITE;
+ /// `PROT_EXEC`
+ const EXEC = linux_raw_sys::general::PROT_EXEC;
+ /// `PROT_GROWSUP`
+ const GROWSUP = linux_raw_sys::general::PROT_GROWSUP;
+ /// `PROT_GROWSDOWN`
+ const GROWSDOWN = linux_raw_sys::general::PROT_GROWSDOWN;
+ }
+}
+
+bitflags! {
+ /// `MAP_*` flags for use with [`mmap`].
+ ///
+ /// For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`].
+ ///
+ /// [`mmap`]: crate::io::mmap
+ /// [`mmap_anonymous`]: crates::io::mmap_anonymous
+ pub struct MapFlags: u32 {
+ /// `MAP_SHARED`
+ const SHARED = linux_raw_sys::general::MAP_SHARED;
+ /// `MAP_SHARED_VALIDATE` (since Linux 4.15)
+ const SHARED_VALIDATE = linux_raw_sys::general::MAP_SHARED_VALIDATE;
+ /// `MAP_PRIVATE`
+ const PRIVATE = linux_raw_sys::general::MAP_PRIVATE;
+ /// `MAP_DENYWRITE`
+ const DENYWRITE = linux_raw_sys::general::MAP_DENYWRITE;
+ /// `MAP_FIXED`
+ const FIXED = linux_raw_sys::general::MAP_FIXED;
+ /// `MAP_FIXED_NOREPLACE` (since Linux 4.17)
+ const FIXED_NOREPLACE = linux_raw_sys::general::MAP_FIXED_NOREPLACE;
+ /// `MAP_GROWSDOWN`
+ const GROWSDOWN = linux_raw_sys::general::MAP_GROWSDOWN;
+ /// `MAP_HUGETLB`
+ const HUGETLB = linux_raw_sys::general::MAP_HUGETLB;
+ /// `MAP_HUGE_2MB` (since Linux 3.8)
+ const HUGE_2MB = linux_raw_sys::general::MAP_HUGE_2MB;
+ /// `MAP_HUGE_1GB` (since Linux 3.8)
+ const HUGE_1GB = linux_raw_sys::general::MAP_HUGE_1GB;
+ /// `MAP_LOCKED`
+ const LOCKED = linux_raw_sys::general::MAP_LOCKED;
+ /// `MAP_NORESERVE`
+ const NORESERVE = linux_raw_sys::general::MAP_NORESERVE;
+ /// `MAP_POPULATE`
+ const POPULATE = linux_raw_sys::general::MAP_POPULATE;
+ /// `MAP_STACK`
+ const STACK = linux_raw_sys::general::MAP_STACK;
+ /// `MAP_SYNC` (since Linux 4.15)
+ #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
+ const SYNC = linux_raw_sys::general::MAP_SYNC;
+ /// `MAP_UNINITIALIZED`
+ #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
+ const UNINITIALIZED = linux_raw_sys::general::MAP_UNINITIALIZED;
+ }
+}
+
+bitflags! {
+ /// `MREMAP_*` flags for use with [`mremap`].
+ ///
+ /// For `MREMAP_FIXED`, see [`mremap_fixed`].
+ ///
+ /// [`mremap`]: crate::io::mremap
+ /// [`mremap_fixed`]: crate::io::mremap_fixed
+ pub struct MremapFlags: u32 {
+ /// `MREMAP_MAYMOVE`
+ const MAYMOVE = linux_raw_sys::general::MREMAP_MAYMOVE;
+ /// `MREMAP_DONTUNMAP` (since Linux 5.7)
+ const DONTUNMAP = linux_raw_sys::general::MREMAP_DONTUNMAP;
+ }
+}
+
+bitflags! {
+ /// `MLOCK_*` flags for use with [`mlock_with`].
+ ///
+ /// [`mlock_with`]: crate::io::mlock_with
+ pub struct MlockFlags: u32 {
+ /// `MLOCK_ONFAULT`
+ const ONFAULT = linux_raw_sys::general::MLOCK_ONFAULT;
+ }
+}
+
+bitflags! {
+ /// `MS_*` flags for use with [`msync`].
+ ///
+ /// [`msync`]: crate::io::msync
+ pub struct MsyncFlags: u32 {
+ /// `MS_SYNC`—Requests an update and waits for it to complete.
+ const SYNC = linux_raw_sys::general::MS_SYNC;
+ /// `MS_ASYNC`—Specifies that an update be scheduled, but the call
+ /// returns immediately.
+ const ASYNC = linux_raw_sys::general::MS_ASYNC;
+ /// `MS_INVALIDATE`—Asks to invalidate other mappings of the same
+ /// file (so that they can be updated with the fresh values just
+ /// written).
+ const INVALIDATE = linux_raw_sys::general::MS_INVALIDATE;
+ }
+}
+
+bitflags! {
+ /// `O_*` flags for use with [`userfaultfd`].
+ ///
+ /// [`userfaultfd`]: crate::io::userfaultfd
+ pub struct UserfaultfdFlags: c::c_uint {
+ /// `O_CLOEXEC`
+ const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
+ /// `O_NONBLOCK`
+ const NONBLOCK = linux_raw_sys::general::O_NONBLOCK;
+ }
+}
+
+/// `POSIX_MADV_*` constants for use with [`madvise`].
+///
+/// [`madvise`]: crate::mm::madvise
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[repr(u32)]
+#[non_exhaustive]
+pub enum Advice {
+ /// `POSIX_MADV_NORMAL`
+ Normal = linux_raw_sys::general::MADV_NORMAL,
+
+ /// `POSIX_MADV_SEQUENTIAL`
+ Sequential = linux_raw_sys::general::MADV_SEQUENTIAL,
+
+ /// `POSIX_MADV_RANDOM`
+ Random = linux_raw_sys::general::MADV_RANDOM,
+
+ /// `POSIX_MADV_WILLNEED`
+ WillNeed = linux_raw_sys::general::MADV_WILLNEED,
+
+ /// `MADV_DONTNEED`
+ LinuxDontNeed = linux_raw_sys::general::MADV_DONTNEED,
+
+ /// `MADV_FREE` (since Linux 4.5)
+ LinuxFree = linux_raw_sys::general::MADV_FREE,
+ /// `MADV_REMOVE`
+ LinuxRemove = linux_raw_sys::general::MADV_REMOVE,
+ /// `MADV_DONTFORK`
+ LinuxDontFork = linux_raw_sys::general::MADV_DONTFORK,
+ /// `MADV_DOFORK`
+ LinuxDoFork = linux_raw_sys::general::MADV_DOFORK,
+ /// `MADV_HWPOISON`
+ LinuxHwPoison = linux_raw_sys::general::MADV_HWPOISON,
+ /// `MADV_SOFT_OFFLINE`
+ #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
+ LinuxSoftOffline = linux_raw_sys::general::MADV_SOFT_OFFLINE,
+ /// `MADV_MERGEABLE`
+ LinuxMergeable = linux_raw_sys::general::MADV_MERGEABLE,
+ /// `MADV_UNMERGEABLE`
+ LinuxUnmergeable = linux_raw_sys::general::MADV_UNMERGEABLE,
+ /// `MADV_HUGEPAGE` (since Linux 2.6.38)
+ LinuxHugepage = linux_raw_sys::general::MADV_HUGEPAGE,
+ /// `MADV_NOHUGEPAGE` (since Linux 2.6.38)
+ LinuxNoHugepage = linux_raw_sys::general::MADV_NOHUGEPAGE,
+ /// `MADV_DONTDUMP` (since Linux 3.4)
+ LinuxDontDump = linux_raw_sys::general::MADV_DONTDUMP,
+ /// `MADV_DODUMP` (since Linux 3.4)
+ LinuxDoDump = linux_raw_sys::general::MADV_DODUMP,
+ /// `MADV_WIPEONFORK` (since Linux 4.14)
+ LinuxWipeOnFork = linux_raw_sys::general::MADV_WIPEONFORK,
+ /// `MADV_KEEPONFORK` (since Linux 4.14)
+ LinuxKeepOnFork = linux_raw_sys::general::MADV_KEEPONFORK,
+ /// `MADV_COLD` (since Linux 5.4)
+ LinuxCold = linux_raw_sys::general::MADV_COLD,
+ /// `MADV_PAGEOUT` (since Linux 5.4)
+ LinuxPageOut = linux_raw_sys::general::MADV_PAGEOUT,
+ /// `MADV_POPULATE_READ` (since Linux 5.14)
+ LinuxPopulateRead = linux_raw_sys::general::MADV_POPULATE_READ,
+ /// `MADV_POPULATE_WRITE` (since Linux 5.14)
+ LinuxPopulateWrite = linux_raw_sys::general::MADV_POPULATE_WRITE,
+}
+
+impl Advice {
+ /// `POSIX_MADV_DONTNEED`
+ ///
+ /// On Linux, this is mapped to `POSIX_MADV_NORMAL` because
+ /// Linux's `MADV_DONTNEED` differs from `POSIX_MADV_DONTNEED`. See
+ /// `LinuxDontNeed` for the Linux behavior.
+ #[allow(non_upper_case_globals)]
+ pub const DontNeed: Self = Self::Normal;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-29 16:55:33 +0000