diff options
Diffstat (limited to 'vendor/rustix/src/ioctl')
| -rw-r--r-- | vendor/rustix/src/ioctl/bsd.rs | 27 | ||||
| -rw-r--r-- | vendor/rustix/src/ioctl/linux.rs | 124 | ||||
| -rw-r--r-- | vendor/rustix/src/ioctl/mod.rs | 376 | ||||
| -rw-r--r-- | vendor/rustix/src/ioctl/patterns.rs | 268 |
4 files changed, 795 insertions, 0 deletions
diff --git a/vendor/rustix/src/ioctl/bsd.rs b/vendor/rustix/src/ioctl/bsd.rs new file mode 100644 index 00000000..965b31d1 --- /dev/null +++ b/vendor/rustix/src/ioctl/bsd.rs @@ -0,0 +1,27 @@ +//! `ioctl` opcode behavior for BSD platforms. + +use super::{Direction, Opcode}; + +pub(super) const fn compose_opcode( + dir: Direction, + group: Opcode, + num: Opcode, + size: Opcode, +) -> Opcode { + let dir = match dir { + Direction::None => NONE, + Direction::Read => READ, + Direction::Write => WRITE, + Direction::ReadWrite => READ | WRITE, + }; + + dir | num | (group << 8) | ((size & IOCPARAM_MASK) << 16) +} + +// `IOC_VOID` +pub const NONE: Opcode = 0x2000_0000; +// `IOC_OUT` (“out” is from the perspective of the kernel) +pub const READ: Opcode = 0x4000_0000; +// `IOC_IN` (“in” is from the perspective of the kernel) +pub const WRITE: Opcode = 0x8000_0000; +pub const IOCPARAM_MASK: Opcode = 0x1FFF; diff --git a/vendor/rustix/src/ioctl/linux.rs b/vendor/rustix/src/ioctl/linux.rs new file mode 100644 index 00000000..7215228a --- /dev/null +++ b/vendor/rustix/src/ioctl/linux.rs @@ -0,0 +1,124 @@ +//! `ioctl` opcode behavior for Linux platforms. + +use super::{Direction, Opcode}; +use consts::*; + +/// Compose an opcode from its component parts. +pub(super) const fn compose_opcode( + dir: Direction, + group: Opcode, + num: Opcode, + size: Opcode, +) -> Opcode { + macro_rules! mask_and_shift { + ($val:expr, $shift:expr, $mask:expr) => {{ + ($val & $mask) << $shift + }}; + } + + let dir = match dir { + Direction::None => NONE, + Direction::Read => READ, + Direction::Write => WRITE, + Direction::ReadWrite => READ | WRITE, + }; + + mask_and_shift!(group, GROUP_SHIFT, GROUP_MASK) + | mask_and_shift!(num, NUM_SHIFT, NUM_MASK) + | mask_and_shift!(size, SIZE_SHIFT, SIZE_MASK) + | mask_and_shift!(dir, DIR_SHIFT, DIR_MASK) +} + +const NUM_BITS: Opcode = 8; +const GROUP_BITS: Opcode = 8; + +const NUM_SHIFT: Opcode = 0; +const GROUP_SHIFT: Opcode = NUM_SHIFT + NUM_BITS; +const SIZE_SHIFT: Opcode = GROUP_SHIFT + GROUP_BITS; +const DIR_SHIFT: Opcode = SIZE_SHIFT + SIZE_BITS; + +const NUM_MASK: Opcode = (1 << NUM_BITS) - 1; +const GROUP_MASK: Opcode = (1 << GROUP_BITS) - 1; +const SIZE_MASK: Opcode = (1 << SIZE_BITS) - 1; +const DIR_MASK: Opcode = (1 << DIR_BITS) - 1; + +#[cfg(any( + target_arch = "x86", + target_arch = "arm", + target_arch = "s390x", + target_arch = "x86_64", + target_arch = "aarch64", + target_arch = "riscv32", + target_arch = "riscv64", + target_arch = "loongarch64", + target_arch = "csky" +))] +mod consts { + use super::Opcode; + + pub(super) const NONE: Opcode = 0; + pub(super) const READ: Opcode = 2; + pub(super) const WRITE: Opcode = 1; + pub(super) const SIZE_BITS: Opcode = 14; + pub(super) const DIR_BITS: Opcode = 2; +} + +#[cfg(any( + target_arch = "mips", + target_arch = "mips32r6", + target_arch = "mips64", + target_arch = "mips64r6", + target_arch = "powerpc", + target_arch = "powerpc64", + target_arch = "sparc", + target_arch = "sparc64" +))] +mod consts { + use super::Opcode; + + pub(super) const NONE: Opcode = 1; + pub(super) const READ: Opcode = 2; + pub(super) const WRITE: Opcode = 4; + pub(super) const SIZE_BITS: Opcode = 13; + pub(super) const DIR_BITS: Opcode = 3; +} + +#[cfg(test)] +mod tests { + #[allow(unused_imports)] + use super::*; + + #[cfg(not(any( + // These have no ioctl opcodes defined in linux_raw_sys so we can't use + // that as a known-good value for this test. + target_arch = "sparc", + target_arch = "sparc64" +)))] + #[test] + fn check_known_opcodes() { + use crate::backend::c::{c_long, c_uint}; + use core::mem::size_of; + + // _IOR('U', 15, unsigned int) + assert_eq!( + compose_opcode( + Direction::Read, + b'U' as Opcode, + 15, + size_of::<c_uint>() as Opcode + ), + linux_raw_sys::ioctl::USBDEVFS_CLAIMINTERFACE as Opcode + ); + + // _IOW('v', 2, long) + assert_eq!( + compose_opcode( + Direction::Write, + b'v' as Opcode, + 2, + size_of::<c_long>() as Opcode + ), + linux_raw_sys::ioctl::FS_IOC_SETVERSION as Opcode + ); + } +} diff --git a/vendor/rustix/src/ioctl/mod.rs b/vendor/rustix/src/ioctl/mod.rs new file mode 100644 index 00000000..e3e8f8e1 --- /dev/null +++ b/vendor/rustix/src/ioctl/mod.rs @@ -0,0 +1,376 @@ +//! Unsafe `ioctl` API. +//! +//! Unix systems expose a number of `ioctl`'s. `ioctl`s have been adopted as a +//! general purpose system call for making calls into the kernel. In addition +//! to the wide variety of system calls that are included by default in the +//! kernel, many drivers expose their own `ioctl`'s for controlling their +//! behavior, some of which are proprietary. Therefore it is impossible to make +//! a safe interface for every `ioctl` call, as they all have wildly varying +//! semantics. +//! +//! This module provides an unsafe interface to write your own `ioctl` API. To +//! start, create a type that implements [`Ioctl`]. Then, pass it to [`ioctl`] +//! to make the `ioctl` call. + +#![allow(unsafe_code)] + +use crate::fd::{AsFd, BorrowedFd}; +use crate::ffi as c; +use crate::io::Result; + +#[cfg(any(linux_kernel, bsd))] +use core::mem; + +pub use patterns::*; + +mod patterns; + +#[cfg(linux_kernel)] +mod linux; + +#[cfg(bsd)] +mod bsd; + +#[cfg(linux_kernel)] +use linux as platform; + +#[cfg(bsd)] +use bsd as platform; + +/// Perform an `ioctl` call. +/// +/// `ioctl` was originally intended to act as a way of modifying the behavior +/// of files, but has since been adopted as a general purpose system call for +/// making calls into the kernel. In addition to the default calls exposed by +/// generic file descriptors, many drivers expose their own `ioctl` calls for +/// controlling their behavior, some of which are proprietary. +/// +/// This crate exposes many other `ioctl` interfaces with safe and idiomatic +/// wrappers, like [`ioctl_fionbio`] and [`ioctl_fionread`]. It is recommended +/// to use those instead of this function, as they are safer and more +/// idiomatic. For other cases, implement the [`Ioctl`] API and pass it to this +/// function. +/// +/// See documentation for [`Ioctl`] for more information. +/// +/// [`ioctl_fionbio`]: crate::io::ioctl_fionbio +/// [`ioctl_fionread`]: crate::io::ioctl_fionread +/// +/// # Safety +/// +/// While [`Ioctl`] takes much of the unsafety out of `ioctl` calls, callers +/// must still ensure that the opcode value, operand type, and data access +/// correctly reflect what's in the device driver servicing the call. `ioctl` +/// calls form a protocol between the userspace `ioctl` callers and the device +/// drivers in the kernel, and safety depends on both sides agreeing and +/// upholding the expectations of the other. +/// +/// And, `ioctl` calls can read and write arbitrary memory and have arbitrary +/// side effects. Callers must ensure that any memory accesses and side effects +/// are compatible with Rust language invariants. +/// +/// # References +/// - [Linux] +/// - [Winsock] +/// - [FreeBSD] +/// - [NetBSD] +/// - [OpenBSD] +/// - [Apple] +/// - [Solaris] +/// - [illumos] +/// +/// [Linux]: https://man7.org/linux/man-pages/man2/ioctl.2.html +/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-ioctlsocket +/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?query=ioctl&sektion=2 +/// [NetBSD]: https://man.netbsd.org/ioctl.2 +/// [OpenBSD]: https://man.openbsd.org/ioctl.2 +/// [Apple]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/ioctl.2.html +/// [Solaris]: https://docs.oracle.com/cd/E23824_01/html/821-1463/ioctl-2.html +/// [illumos]: https://illumos.org/man/2/ioctl +#[inline] +pub unsafe fn ioctl<F: AsFd, I: Ioctl>(fd: F, mut ioctl: I) -> Result<I::Output> { + let fd = fd.as_fd(); + let request = ioctl.opcode(); + let arg = ioctl.as_ptr(); + + // SAFETY: The variant of `Ioctl` asserts that this is a valid IOCTL call + // to make. + let output = if I::IS_MUTATING { + _ioctl(fd, request, arg)? + } else { + _ioctl_readonly(fd, request, arg)? + }; + + // SAFETY: The variant of `Ioctl` asserts that this is a valid pointer to + // the output data. + I::output_from_ptr(output, arg) +} + +unsafe fn _ioctl(fd: BorrowedFd<'_>, request: Opcode, arg: *mut c::c_void) -> Result<IoctlOutput> { + crate::backend::io::syscalls::ioctl(fd, request, arg) +} + +unsafe fn _ioctl_readonly( + fd: BorrowedFd<'_>, + request: Opcode, + arg: *mut c::c_void, +) -> Result<IoctlOutput> { + crate::backend::io::syscalls::ioctl_readonly(fd, request, arg) +} + +/// A trait defining the properties of an `ioctl` command. +/// +/// Objects implementing this trait can be passed to [`ioctl`] to make an +/// `ioctl` call. The contents of the object represent the inputs to the +/// `ioctl` call. The inputs must be convertible to a pointer through the +/// `as_ptr` method. In most cases, this involves either casting a number to a +/// pointer, or creating a pointer to the actual data. The latter case is +/// necessary for `ioctl` calls that modify userspace data. +/// +/// # Safety +/// +/// This trait is unsafe to implement because it is impossible to guarantee +/// that the `ioctl` call is safe. The `ioctl` call may be proprietary, or it +/// may be unsafe to call in certain circumstances. +/// +/// By implementing this trait, you guarantee that: +/// +/// - The `ioctl` call expects the input provided by `as_ptr` and produces the +/// output as indicated by `output`. +/// - That `output_from_ptr` can safely take the pointer from `as_ptr` and +/// cast it to the correct type, *only* after the `ioctl` call. +/// - That the return value of `opcode` uniquely identifies the `ioctl` call. +/// - That, for whatever platforms you are targeting, the `ioctl` call is safe +/// to make. +/// - If `IS_MUTATING` is false, that no userspace data will be modified by +/// the `ioctl` call. +pub unsafe trait Ioctl { + /// The type of the output data. + /// + /// Given a pointer, one should be able to construct an instance of this + /// type. + type Output; + + /// Does the `ioctl` mutate any data in the userspace? + /// + /// If the `ioctl` call does not mutate any data in the userspace, then + /// making this `false` enables optimizations that can make the call + /// faster. When in doubt, set this to `true`. + /// + /// # Safety + /// + /// This should only be set to `false` if the `ioctl` call does not mutate + /// any data in the userspace. Undefined behavior may occur if this is set + /// to `false` when it should be `true`. + const IS_MUTATING: bool; + + /// Get the opcode used by this `ioctl` command. + /// + /// There are different types of opcode depending on the operation. See + /// documentation for [`opcode`] for more information. + fn opcode(&self) -> Opcode; + + /// Get a pointer to the data to be passed to the `ioctl` command. + /// + /// See trait-level documentation for more information. + fn as_ptr(&mut self) -> *mut c::c_void; + + /// Cast the output data to the correct type. + /// + /// # Safety + /// + /// The `extract_output` value must be the resulting value after a + /// successful `ioctl` call, and `out` is the direct return value of an + /// `ioctl` call that did not fail. In this case `extract_output` is the + /// pointer that was passed to the `ioctl` call. + unsafe fn output_from_ptr( + out: IoctlOutput, + extract_output: *mut c::c_void, + ) -> Result<Self::Output>; +} + +/// Const functions for computing opcode values. +/// +/// Linux's headers define macros such as `_IO`, `_IOR`, `_IOW`, and `_IOWR` +/// for defining ioctl values in a structured way that encode whether they +/// are reading and/or writing, and other information about the ioctl. The +/// functions in this module correspond to those macros. +/// +/// If you're writing a driver and defining your own ioctl numbers, it's +/// recommended to use these functions to compute them. +#[cfg(any(linux_kernel, bsd))] +pub mod opcode { + use super::*; + + /// Create a new opcode from a direction, group, number, and size. + /// + /// This corresponds to the C macro `_IOC(direction, group, number, size)` + #[doc(alias = "_IOC")] + #[inline] + pub const fn from_components( + direction: Direction, + group: u8, + number: u8, + data_size: usize, + ) -> Opcode { + assert!(data_size <= Opcode::MAX as usize, "data size is too large"); + + platform::compose_opcode( + direction, + group as Opcode, + number as Opcode, + data_size as Opcode, + ) + } + + /// Create a new opcode from a group, a number, that uses no data. + /// + /// This corresponds to the C macro `_IO(group, number)`. + #[doc(alias = "_IO")] + #[inline] + pub const fn none(group: u8, number: u8) -> Opcode { + from_components(Direction::None, group, number, 0) + } + + /// Create a new reading opcode from a group, a number and the type of + /// data. + /// + /// This corresponds to the C macro `_IOR(group, number, T)`. + #[doc(alias = "_IOR")] + #[inline] + pub const fn read<T>(group: u8, number: u8) -> Opcode { + from_components(Direction::Read, group, number, mem::size_of::<T>()) + } + + /// Create a new writing opcode from a group, a number and the type of + /// data. + /// + /// This corresponds to the C macro `_IOW(group, number, T)`. + #[doc(alias = "_IOW")] + #[inline] + pub const fn write<T>(group: u8, number: u8) -> Opcode { + from_components(Direction::Write, group, number, mem::size_of::<T>()) + } + + /// Create a new reading and writing opcode from a group, a number and the + /// type of data. + /// + /// This corresponds to the C macro `_IOWR(group, number, T)`. + #[doc(alias = "_IOWR")] + #[inline] + pub const fn read_write<T>(group: u8, number: u8) -> Opcode { + from_components(Direction::ReadWrite, group, number, mem::size_of::<T>()) + } +} + +/// The direction that an `ioctl` is going. +/// +/// The direction is relative to userspace: `Read` means reading data from the +/// kernel, and `Write` means the kernel writing data to userspace. +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum Direction { + /// None of the above. + None, + + /// Read data from the kernel. + Read, + + /// Write data to the kernel. + Write, + + /// Read and write data to the kernel. + ReadWrite, +} + +/// The type used by the `ioctl` to signify the output. +pub type IoctlOutput = c::c_int; + +/// The type used by the `ioctl` to signify the command. +pub type Opcode = _Opcode; + +// Under raw Linux, this is an `unsigned int`. +#[cfg(linux_raw)] +type _Opcode = c::c_uint; + +// On libc Linux with GNU libc or uclibc, this is an `unsigned long`. +#[cfg(all( + not(linux_raw), + target_os = "linux", + any(target_env = "gnu", target_env = "uclibc") +))] +type _Opcode = c::c_ulong; + +// Musl uses `c_int`. +#[cfg(all( + not(linux_raw), + target_os = "linux", + not(target_env = "gnu"), + not(target_env = "uclibc") +))] +type _Opcode = c::c_int; + +// Android uses `c_int`. +#[cfg(all(not(linux_raw), target_os = "android"))] +type _Opcode = c::c_int; + +// BSD, Haiku, Hurd, Redox, and Vita use `unsigned long`. +#[cfg(any( + bsd, + target_os = "redox", + target_os = "haiku", + target_os = "horizon", + target_os = "hurd", + target_os = "vita" +))] +type _Opcode = c::c_ulong; + +// AIX, Emscripten, Fuchsia, Solaris, and WASI use a `int`. +#[cfg(any( + solarish, + target_os = "aix", + target_os = "cygwin", + target_os = "fuchsia", + target_os = "emscripten", + target_os = "nto", + target_os = "wasi", +))] +type _Opcode = c::c_int; + +// ESP-IDF uses a `c_uint`. +#[cfg(target_os = "espidf")] +type _Opcode = c::c_uint; + +// Windows has `ioctlsocket`, which uses `i32`. +#[cfg(windows)] +type _Opcode = i32; + +#[cfg(linux_kernel)] +#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))] +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_opcode_funcs() { + // `TUNGETDEVNETNS` is defined as `_IO('T', 227)`. + assert_eq!( + linux_raw_sys::ioctl::TUNGETDEVNETNS as Opcode, + opcode::none(b'T', 227) + ); + // `FS_IOC_GETVERSION` is defined as `_IOR('v', 1, long)`. + assert_eq!( + linux_raw_sys::ioctl::FS_IOC_GETVERSION as Opcode, + opcode::read::<c::c_long>(b'v', 1) + ); + // `TUNSETNOCSUM` is defined as `_IOW('T', 200, int)`. + assert_eq!( + linux_raw_sys::ioctl::TUNSETNOCSUM as Opcode, + opcode::write::<c::c_int>(b'T', 200) + ); + // `FIFREEZE` is defined as `_IOWR('X', 119, int)`. + assert_eq!( + linux_raw_sys::ioctl::FIFREEZE as Opcode, + opcode::read_write::<c::c_int>(b'X', 119) + ); + } +} diff --git a/vendor/rustix/src/ioctl/patterns.rs b/vendor/rustix/src/ioctl/patterns.rs new file mode 100644 index 00000000..a08aae74 --- /dev/null +++ b/vendor/rustix/src/ioctl/patterns.rs @@ -0,0 +1,268 @@ +//! Implements typical patterns for `ioctl` usage. + +use super::{Ioctl, IoctlOutput, Opcode}; + +use crate::backend::c; +use crate::io::Result; + +use core::ptr::addr_of_mut; +use core::{fmt, mem}; + +/// Implements an `ioctl` with no real arguments. +/// +/// To compute a value for the `OPCODE` argument, see the functions in the +/// [`opcode`] module. +/// +/// [`opcode`]: crate::ioctl::opcode +pub struct NoArg<const OPCODE: Opcode> {} + +impl<const OPCODE: Opcode> fmt::Debug for NoArg<OPCODE> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("NoArg").field(&OPCODE).finish() + } +} + +impl<const OPCODE: Opcode> NoArg<OPCODE> { + /// Create a new no-argument `ioctl` object. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + #[inline] + pub const unsafe fn new() -> Self { + Self {} + } +} + +unsafe impl<const OPCODE: Opcode> Ioctl for NoArg<OPCODE> { + type Output = (); + + const IS_MUTATING: bool = false; + + fn opcode(&self) -> self::Opcode { + OPCODE + } + + fn as_ptr(&mut self) -> *mut c::c_void { + core::ptr::null_mut() + } + + unsafe fn output_from_ptr(_: IoctlOutput, _: *mut c::c_void) -> Result<Self::Output> { + Ok(()) + } +} + +/// Implements the traditional “getter” pattern for `ioctl`s. +/// +/// Some `ioctl`s just read data into the userspace. As this is a popular +/// pattern, this structure implements it. +/// +/// To compute a value for the `OPCODE` argument, see the functions in the +/// [`opcode`] module. +/// +/// [`opcode`]: crate::ioctl::opcode +pub struct Getter<const OPCODE: Opcode, Output> { + /// The output data. + output: mem::MaybeUninit<Output>, +} + +impl<const OPCODE: Opcode, Output> fmt::Debug for Getter<OPCODE, Output> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Getter").field(&OPCODE).finish() + } +} + +impl<const OPCODE: Opcode, Output> Getter<OPCODE, Output> { + /// Create a new getter-style `ioctl` object. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + /// - For this opcode, `Output` must be the type that the kernel expects + /// to write into. + #[inline] + pub const unsafe fn new() -> Self { + Self { + output: mem::MaybeUninit::uninit(), + } + } +} + +unsafe impl<const OPCODE: Opcode, Output> Ioctl for Getter<OPCODE, Output> { + type Output = Output; + + const IS_MUTATING: bool = true; + + fn opcode(&self) -> self::Opcode { + OPCODE + } + + fn as_ptr(&mut self) -> *mut c::c_void { + self.output.as_mut_ptr().cast() + } + + unsafe fn output_from_ptr(_: IoctlOutput, ptr: *mut c::c_void) -> Result<Self::Output> { + Ok(ptr.cast::<Output>().read()) + } +} + +/// Implements the pattern for `ioctl`s where a pointer argument is given to +/// the `ioctl`. +/// +/// The opcode must be read-only. +/// +/// To compute a value for the `OPCODE` argument, see the functions in the +/// [`opcode`] module. +/// +/// [`opcode`]: crate::ioctl::opcode +pub struct Setter<const OPCODE: Opcode, Input> { + /// The input data. + input: Input, +} + +impl<const OPCODE: Opcode, Input: fmt::Debug> fmt::Debug for Setter<OPCODE, Input> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Setter") + .field(&OPCODE) + .field(&self.input) + .finish() + } +} + +impl<const OPCODE: Opcode, Input> Setter<OPCODE, Input> { + /// Create a new pointer setter-style `ioctl` object. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + /// - For this opcode, `Input` must be the type that the kernel expects to + /// get. + #[inline] + pub const unsafe fn new(input: Input) -> Self { + Self { input } + } +} + +unsafe impl<const OPCODE: Opcode, Input> Ioctl for Setter<OPCODE, Input> { + type Output = (); + + const IS_MUTATING: bool = false; + + fn opcode(&self) -> self::Opcode { + OPCODE + } + + fn as_ptr(&mut self) -> *mut c::c_void { + addr_of_mut!(self.input).cast::<c::c_void>() + } + + unsafe fn output_from_ptr(_: IoctlOutput, _: *mut c::c_void) -> Result<Self::Output> { + Ok(()) + } +} + +/// Implements an “updater” pattern for `ioctl`s. +/// +/// The ioctl takes a reference to a struct that it reads its input from, +/// then writes output to the same struct. +/// +/// To compute a value for the `OPCODE` argument, see the functions in the +/// [`opcode`] module. +/// +/// [`opcode`]: crate::ioctl::opcode +pub struct Updater<'a, const OPCODE: Opcode, Value> { + /// Reference to input/output data. + value: &'a mut Value, +} + +impl<'a, const OPCODE: Opcode, Value> Updater<'a, OPCODE, Value> { + /// Create a new pointer updater-style `ioctl` object. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + /// - For this opcode, `Value` must be the type that the kernel expects to + /// get. + #[inline] + pub unsafe fn new(value: &'a mut Value) -> Self { + Self { value } + } +} + +unsafe impl<'a, const OPCODE: Opcode, T> Ioctl for Updater<'a, OPCODE, T> { + type Output = (); + + const IS_MUTATING: bool = true; + + fn opcode(&self) -> self::Opcode { + OPCODE + } + + fn as_ptr(&mut self) -> *mut c::c_void { + (self.value as *mut T).cast() + } + + unsafe fn output_from_ptr(_output: IoctlOutput, _ptr: *mut c::c_void) -> Result<()> { + Ok(()) + } +} + +/// Implements an `ioctl` that passes an integer into the `ioctl`. +/// +/// To compute a value for the `OPCODE` argument, see the functions in the +/// [`opcode`] module. +/// +/// [`opcode`]: crate::ioctl::opcode +pub struct IntegerSetter<const OPCODE: Opcode> { + /// The value to pass in. + /// + /// For strict provenance preservation, this is a pointer. + value: *mut c::c_void, +} + +impl<const OPCODE: Opcode> IntegerSetter<OPCODE> { + /// Create a new integer `Ioctl` helper containing a `usize`. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + /// - For this opcode, it must expect an integer. + /// - The integer is in the valid range for this opcode. + #[inline] + pub const unsafe fn new_usize(value: usize) -> Self { + Self { value: value as _ } + } + + /// Create a new integer `Ioctl` helper containing a `*mut c_void`. + /// + /// # Safety + /// + /// - `OPCODE` must provide a valid opcode. + /// - For this opcode, it must expect an integer. + /// - The integer is in the valid range for this opcode. + #[inline] + pub const unsafe fn new_pointer(value: *mut c::c_void) -> Self { + Self { value } + } +} + +unsafe impl<const OPCODE: Opcode> Ioctl for IntegerSetter<OPCODE> { + type Output = (); + + const IS_MUTATING: bool = false; + + fn opcode(&self) -> self::Opcode { + OPCODE + } + + fn as_ptr(&mut self) -> *mut c::c_void { + self.value + } + + unsafe fn output_from_ptr( + _out: IoctlOutput, + _extract_output: *mut c::c_void, + ) -> Result<Self::Output> { + Ok(()) + } +} |