feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

4 files changed, 0 insertions, 795 deletions

diff --git a/vendor/rustix/src/ioctl/bsd.rs b/vendor/rustix/src/ioctl/bsd.rs
deleted file mode 100644
index 965b31d1..00000000
--- a/vendor/rustix/src/ioctl/bsd.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//! `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
deleted file mode 100644
index 7215228a..00000000
--- a/vendor/rustix/src/ioctl/linux.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! `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
deleted file mode 100644
index e3e8f8e1..00000000
--- a/vendor/rustix/src/ioctl/mod.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-//! 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
deleted file mode 100644
index a08aae74..00000000
--- a/vendor/rustix/src/ioctl/patterns.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-//! 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(())
-    }
-}