cloudfox-coreshift-core 1.2.37

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Direct Rendering Manager (DRM) vblank primitives.
//!
//! The public API is intentionally narrow: open a card node, then block on
//! `DRM_IOCTL_WAIT_VBLANK` until the next vertical blank, reporting the
//! monotonic instant the wait returned. Android's `msm` display stack zeroes
//! the ioctl reply timestamps (`t_sec`/`t_usec`), so callers must use a
//! monotonic clock taken at the moment the wait unblocks — this module does
//! exactly that and never exposes the (unreliable) reply fields.

use std::os::unix::io::AsRawFd;
use std::time::Instant;

use crate::error::syscall_ret;
use crate::reactor::Fd;
use crate::CoreError;

const O_RDWR: i32 = libc::O_RDWR;
const O_CLOEXEC: i32 = libc::O_CLOEXEC;

// _IOC(dir, type, nr, size) = (dir << 30) | (type << 8) | (nr << 0) | (size << 16)
// DRM_IOCTL_BASE is 'd' (0x64); DRM_IOCTL_WAIT_VBLANK is _IOWR(0x3a, drm_wait_vblank).
const DRM_IOCTL_BASE: u32 = 0x64; // 'd'
const DRM_IOCTL_WAIT_VBLANK_NR: u32 = 0x3a;

// DRM_VBLANK_RELATIVE (wait relative to current counter), as used for the
// common "wake me at the next vblank" blocking call.
const DRM_VBLANK_RELATIVE: u32 = 0x1;

#[repr(C)]
#[derive(Clone, Copy)]
struct DrmWaitVBlank {
    // union drm_wait_vblank_request
    request_type: u32,
    request_sequence: u32,
    request_signal: u64, // __aligned_u64
    // union drm_wait_vblank_reply
    reply_sequence: u32,
    reply_t_sec: u32,
    reply_t_usec: u32,
}

const _: () = assert!(std::mem::size_of::<DrmWaitVBlank>() == 32);

/// An open DRM card node (e.g. `/dev/dri/card0`).
///
/// The fd is `O_CLOEXEC` and owned by this wrapper; it is closed on drop.
pub struct DrmCard {
    fd: Fd,
}

impl DrmCard {
    /// Open a DRM primary node by device path.
    ///
    /// ### Errors
    /// - `ENOENT`/`ENODEV`: no such card node.
    /// - `EACCES`/`EPERM`: insufficient privilege for the device node.
    pub fn open(path: &str) -> Result<Self, CoreError> {
        let c_path = std::ffi::CString::new(path).map_err(|_| {
            CoreError::sys(libc::EINVAL, "drm open path contains NUL")
        })?;
        let fd = unsafe { libc::open(c_path.as_ptr(), O_RDWR | O_CLOEXEC) };
        syscall_ret(fd, "open(drm)")?;
        // SAFETY: `fd` is a freshly opened owned descriptor from `open`.
        let fd = unsafe { Fd::from_owned_raw_fd(fd, "drm") }?;
        Ok(Self { fd })
    }

    /// Block until the next vblank and return the monotonic instant the wait
    /// returned.
    ///
    /// The reply `t_sec`/`t_usec` fields are deliberately ignored: they are
    /// zeroed on `msm` display stacks. Only the wait-unblock instant is
    /// trustworthy, so callers diff consecutive return values.
    ///
    /// ### Errors
    /// - `EINTR`: interrupted by a signal (safe to retry).
    /// - `EINVAL`: the card does not support vblank waits.
    /// - `EBADF`: the card fd was closed.
    pub fn wait_vblank(&self) -> Result<Instant, CoreError> {
        let mut vblank = DrmWaitVBlank {
            request_type: DRM_VBLANK_RELATIVE,
            request_sequence: 1,
            request_signal: 0,
            reply_sequence: 0,
            reply_t_sec: 0,
            reply_t_usec: 0,
        };

        let nr = DRM_IOCTL_WAIT_VBLANK_NR;
        let size = std::mem::size_of::<DrmWaitVBlank>() as u32;
        let ioctl_nr: libc::Ioctl = ((3u32 << 30)
            | (DRM_IOCTL_BASE << 8)
            | (nr << 0)
            | (size << 16)) as libc::Ioctl;

        // The vblank wait is a blocking ioctl; a signal (e.g. the per-thread
        // shutdown interrupt) surfaces as EINTR and is propagated to the caller.
        let ret = unsafe { libc::ioctl(self.fd.as_raw_fd(), ioctl_nr, &mut vblank) };
        syscall_ret(ret, "DRM_IOCTL_WAIT_VBLANK")?;
        Ok(Instant::now())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn wait_vblank_ioctl_matches_known_constant() {
        // (3 << 30) | ('d' << 8) | (0x3a) | (size(32) << 16) == 0xC020643A.
        let size = std::mem::size_of::<DrmWaitVBlank>() as u32;
        let computed: libc::Ioctl =
            ((3u32 << 30) | (DRM_IOCTL_BASE << 8) | (0x3au32) | (size << 16)) as libc::Ioctl;
        assert_eq!(computed, 0xC020643Au32 as libc::Ioctl);
        assert_eq!(size, 32);
    }

    #[test]
    fn vblank_request_struct_layout_is_32_bytes() {
        assert_eq!(std::mem::size_of::<DrmWaitVBlank>(), 32);
    }
}