use alloc::{
borrow::Cow,
collections::{BTreeMap, BTreeSet, VecDeque},
format,
string::String,
sync::{Arc, Weak},
vec,
vec::Vec,
};
use core::{
any::Any,
sync::atomic::{AtomicU32, AtomicU64, Ordering},
};
use ax_alloc::GlobalPage;
use ax_memory_addr::{PAGE_SIZE_4K, PhysAddrRange};
use ax_runtime::hal::{mem::virt_to_phys, time::monotonic_time};
use axfs_ng_vfs::{NodeFlags, VfsError, VfsResult};
use axpoll::{IoEvents, Pollable};
use axpoll_set::PollSet;
use bytemuck::bytes_of;
use linux_raw_sys::general::O_CLOEXEC;
use super::drm::{
DRM_CAP_ADDFB2_MODIFIERS,
DRM_CAP_CRTC_IN_VBLANK_EVENT,
DRM_CAP_DUMB_BUFFER,
DRM_CAP_PRIME,
DRM_CAP_TIMESTAMP_MONOTONIC,
DRM_EVENT_FLIP_COMPLETE,
DRM_FORMAT_ARGB8888,
DRM_FORMAT_MOD_INVALID,
DRM_FORMAT_MOD_LINEAR,
DRM_FORMAT_XRGB8888,
DRM_IOCTL_AUTH_MAGIC,
DRM_IOCTL_DROP_MASTER,
DRM_IOCTL_GEM_CLOSE,
DRM_IOCTL_GET_CAP,
DRM_IOCTL_GET_MAGIC,
DRM_IOCTL_GET_UNIQUE,
DRM_IOCTL_MODE_ADDFB2,
DRM_IOCTL_MODE_ATOMIC,
DRM_IOCTL_MODE_CREATE_DUMB,
DRM_IOCTL_MODE_CREATEPROPBLOB,
DRM_IOCTL_MODE_DESTROY_DUMB,
DRM_IOCTL_MODE_DESTROYPROPBLOB,
DRM_IOCTL_MODE_DIRTYFB,
DRM_IOCTL_MODE_GETCONNECTOR,
DRM_IOCTL_MODE_GETCRTC,
DRM_IOCTL_MODE_GETENCODER,
DRM_IOCTL_MODE_GETPLANE,
DRM_IOCTL_MODE_GETPLANERESOURCES,
DRM_IOCTL_MODE_GETPROPBLOB,
DRM_IOCTL_MODE_GETPROPERTY,
DRM_IOCTL_MODE_GETRESOURCES,
DRM_IOCTL_MODE_MAP_DUMB,
DRM_IOCTL_MODE_OBJ_GETPROPERTIES,
DRM_IOCTL_MODE_PAGE_FLIP,
DRM_IOCTL_MODE_RMFB,
DRM_IOCTL_MODE_SETCRTC,
DRM_IOCTL_PRIME_FD_TO_HANDLE,
DRM_IOCTL_PRIME_HANDLE_TO_FD,
DRM_IOCTL_SET_CLIENT_CAP,
DRM_IOCTL_SET_MASTER,
DRM_IOCTL_SET_VERSION,
DRM_IOCTL_VERSION,
DRM_IOCTL_VIRTGPU_CONTEXT_INIT,
DRM_IOCTL_VIRTGPU_EXECBUFFER,
DRM_IOCTL_VIRTGPU_GET_CAPS,
DRM_IOCTL_VIRTGPU_GETPARAM,
DRM_IOCTL_VIRTGPU_MAP,
DRM_IOCTL_VIRTGPU_RESOURCE_CREATE,
DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB,
DRM_IOCTL_VIRTGPU_RESOURCE_INFO,
DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST,
DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST,
DRM_IOCTL_VIRTGPU_WAIT,
DRM_IOCTL_WAIT_VBLANK,
DRM_MODE_ATOMIC_ALLOW_MODESET,
DRM_MODE_ATOMIC_NONBLOCK,
DRM_MODE_ATOMIC_TEST_ONLY,
DRM_MODE_CONNECTED,
DRM_MODE_CONNECTOR_VIRTUAL,
DRM_MODE_ENCODER_VIRTUAL,
DRM_MODE_FB_MODIFIERS,
DRM_MODE_OBJECT_CONNECTOR,
DRM_MODE_OBJECT_CRTC,
DRM_MODE_OBJECT_FB,
DRM_MODE_OBJECT_PLANE,
DRM_MODE_PAGE_FLIP_EVENT,
DRM_MODE_PROP_ATOMIC,
DRM_MODE_PROP_BLOB,
DRM_MODE_PROP_ENUM,
DRM_MODE_PROP_IMMUTABLE,
DRM_MODE_PROP_OBJECT,
DRM_MODE_PROP_RANGE,
DRM_MODE_PROP_SIGNED_RANGE,
DRM_PLANE_TYPE_PRIMARY,
DRM_PRIME_CAP_EXPORT,
DRM_PRIME_CAP_IMPORT,
DRM_PROP_NAME_LEN,
DrmAuth,
DrmEvent,
DrmEventVblank,
DrmGemClose,
DrmGetCap,
DrmModeAtomic,
DrmModeCardRes,
DrmModeCreateBlob,
DrmModeCreateDumb,
DrmModeCrtc,
DrmModeCrtcPageFlip,
DrmModeDestroyBlob,
DrmModeDestroyDumb,
DrmModeDirtyFB,
DrmModeFbCmd2,
DrmModeGetBlob,
DrmModeGetConnector,
DrmModeGetEncoder,
DrmModeGetPlane,
DrmModeGetPlaneRes,
DrmModeGetProperty,
DrmModeMapDumb,
DrmModeModeInfo,
DrmModeObjGetProperties,
DrmModePropertyEnum,
DrmPrimeHandle,
DrmSetClientCap,
DrmSetVersion,
DrmUnique,
DrmVersion,
DrmVirtgpu3dTransferFromHost,
DrmVirtgpu3dTransferToHost,
DrmVirtgpu3dWait,
DrmVirtgpuContextInit,
DrmVirtgpuContextSetParam,
DrmVirtgpuExecbuffer,
DrmVirtgpuGetCaps,
DrmVirtgpuGetparam,
DrmVirtgpuMap,
DrmVirtgpuResourceCreate,
DrmVirtgpuResourceCreateBlob,
DrmVirtgpuResourceInfo,
DrmWaitVblank,
VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE,
VIRTGPU_BLOB_MEM_GUEST,
VIRTGPU_BLOB_MEM_HOST3D,
VIRTGPU_BLOB_MEM_HOST3D_GUEST,
VIRTGPU_CONTEXT_PARAM_CAPSET_ID,
VIRTGPU_CONTEXT_PARAM_NUM_RINGS,
VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK,
VIRTGPU_DRM_CAPSET_DRM,
VIRTGPU_DRM_CAPSET_VIRGL,
VIRTGPU_DRM_CAPSET_VIRGL2,
VIRTGPU_EXECBUF_FENCE_FD_IN,
VIRTGPU_EXECBUF_FENCE_FD_OUT,
VIRTGPU_PARAM_3D_FEATURES,
VIRTGPU_PARAM_CAPSET_QUERY_FIX,
VIRTGPU_PARAM_CONTEXT_INIT,
VIRTGPU_PARAM_CROSS_DEVICE,
VIRTGPU_PARAM_HOST_VISIBLE,
VIRTGPU_PARAM_RESOURCE_BLOB,
VIRTGPU_PARAM_SUPPORTED_CAPSET_IDS,
};
use super::sync_file::SyncFile;
use crate::{
StarryError, StarryResult,
file::{
File as KernelFile, FileLike, IoDst, IoSrc, Kstat, add_file_like, current_fd_table,
dma_buf_seek, prepare_file_like, release_locks_on_close,
},
mm::{VmMutPtr, VmPtr, vm_load, vm_write_slice},
pseudofs::{DeviceMmap, DeviceOps},
sync::Mutex,
task::{
UserTaskRef, current_user_task,
future::{block_on_user, poll_io},
},
};
pub const DRIVER_NAME: &str = "virtio_gpu";
pub const DRIVER_DATE: &str = "20260921";
pub const DRIVER_DESC: &str = "StarryOS virtio-gpu DRM driver";
pub const DRIVER_VERSION_MAJOR: i32 = 0;
pub const DRIVER_VERSION_MINOR: i32 = 1;
pub const DRIVER_VERSION_PATCHLEVEL: i32 = 0;
const CRTC_ID: u32 = 0x10;
const ENCODER_ID: u32 = 0x20;
const CONNECTOR_ID: u32 = 0x30;
const PLANE_ID: u32 = 0x40;
const FIRST_VIRGL_CTX_ID: u32 = 1;
const FIRST_GPU_RESOURCE_ID: u32 = 1;
enum CreateKind {
Legacy,
Explicit { capset_id: u32, num_rings: u32 },
}
const FIRST_DUMB_HANDLE: u32 = 1;
const FIRST_FB_ID: u32 = 1;
const MAX_CAPSET_ENUM: u32 = 64;
const DUMB_BUFFER_MAX_SIZE: usize = 8 * 1024 * 1024;
const DUMB_BUFFER_OFFSET_STRIDE: u64 = DUMB_BUFFER_MAX_SIZE as u64;
const PROP_PLANE_TYPE: u32 = 0x100;
const PROP_PLANE_FB_ID: u32 = 0x101;
const PROP_PLANE_CRTC_ID: u32 = 0x102;
const PROP_PLANE_SRC_X: u32 = 0x103;
const PROP_PLANE_SRC_Y: u32 = 0x104;
const PROP_PLANE_SRC_W: u32 = 0x105;
const PROP_PLANE_SRC_H: u32 = 0x106;
const PROP_PLANE_CRTC_X: u32 = 0x107;
const PROP_PLANE_CRTC_Y: u32 = 0x108;
const PROP_PLANE_CRTC_W: u32 = 0x109;
const PROP_PLANE_CRTC_H: u32 = 0x10A;
const PROP_PLANE_IN_FORMATS: u32 = 0x10B;
const PROP_PLANE_IN_FENCE_FD: u32 = 0x10C;
const PROP_CRTC_ACTIVE: u32 = 0x200;
const PROP_CRTC_MODE_ID: u32 = 0x201;
const PROP_CONN_CRTC_ID: u32 = 0x300;
const PLANE_PROPS: &[u32] = &[
PROP_PLANE_TYPE,
PROP_PLANE_FB_ID,
PROP_PLANE_CRTC_ID,
PROP_PLANE_SRC_X,
PROP_PLANE_SRC_Y,
PROP_PLANE_SRC_W,
PROP_PLANE_SRC_H,
PROP_PLANE_CRTC_X,
PROP_PLANE_CRTC_Y,
PROP_PLANE_CRTC_W,
PROP_PLANE_CRTC_H,
PROP_PLANE_IN_FORMATS,
PROP_PLANE_IN_FENCE_FD,
];
const CRTC_PROPS: &[u32] = &[PROP_CRTC_ACTIVE, PROP_CRTC_MODE_ID];
const CONN_PROPS: &[u32] = &[PROP_CONN_CRTC_ID];
const SUPPORTED_FORMATS: &[u32] = &[DRM_FORMAT_XRGB8888, DRM_FORMAT_ARGB8888];
const MAX_EVENTS: usize = 128;
const FIRST_BLOB_ID: u32 = 0x1000;
const MAX_BLOB_BYTES: usize = 64 * 1024;
const MAX_VIRGL_COMMAND_BYTES: usize = 16 * 1024 * 1024;
struct DumbBuffer {
owner: u64,
width: u32,
height: u32,
bpp: u32,
pitch: u32,
size: u64,
offset: u64,
pages: Arc<GlobalPage>,
mappable: bool,
resource: Option<Arc<GpuResource>>,
}
struct Framebuffer {
owner: u64,
size: u64,
stride: u32,
width: u32,
height: u32,
kind: FbBacking,
}
#[derive(Clone)]
enum FbBacking {
Dumb { pages: Arc<GlobalPage> },
Gpu3d { resource: Arc<GpuResource> },
}
struct DmaBufGem {
range: PhysAddrRange,
pages: Arc<GlobalPage>,
size: u64,
}
impl FileLike for DmaBufGem {
fn validate_write_access(&self) -> StarryResult {
Err(StarryError::InvalidInput)
}
fn path(&self) -> Cow<'_, str> {
"anon_inode:dmabuf".into()
}
fn seek(&self, pos: ax_io::SeekFrom) -> StarryResult<u64> {
dma_buf_seek(self.size, pos)
}
fn device_mmap(&self, offset: u64, length: u64) -> StarryResult<DeviceMmap> {
let end = offset
.checked_add(length)
.ok_or(StarryError::InvalidInput)?;
if end > self.size {
return Err(StarryError::InvalidInput);
}
Ok(DeviceMmap::Physical(self.range, Some(self.pages.clone())))
}
}
impl Pollable for DmaBufGem {
fn poll(&self) -> IoEvents {
IoEvents::IN | IoEvents::OUT
}
unsafe fn register_shared(
&self,
_sink: &mut dyn axpoll::SharedRegistrationSink,
_events: IoEvents,
) {
}
}
#[derive(Debug, Clone)]
struct ModeBlob {
id: u32,
info: DrmModeModeInfo,
bytes: Arc<Vec<u8>>,
}
#[derive(Debug, Default, Clone)]
struct ModesetState {
crtc_active: u64,
mode: Option<ModeBlob>,
conn_crtc_id: u32,
plane_fb_id: u32,
plane_crtc_id: u32,
plane_src_x: u64,
plane_src_y: u64,
plane_src_w: u64,
plane_src_h: u64,
plane_crtc_x: i64,
plane_crtc_y: i64,
plane_crtc_w: u64,
plane_crtc_h: u64,
}
#[allow(dead_code)]
struct GpuResource {
owner: u64,
res_handle: u32,
bo_handle: u32,
width: u32,
height: u32,
stride: u32,
size: u64,
blob_mem: u32,
blob_flags: u32,
is_dumb_2d: bool,
last_fence: AtomicU64,
}
impl Drop for GpuResource {
fn drop(&mut self) {
if ax_display::has_display() {
let _ = ax_display::gpu3d_resource_unref(self.res_handle);
}
}
}
struct HostResourceDmaBuf {
resource: Arc<GpuResource>,
}
impl FileLike for HostResourceDmaBuf {
fn validate_write_access(&self) -> StarryResult {
Err(StarryError::InvalidInput)
}
fn seek(&self, pos: ax_io::SeekFrom) -> StarryResult<u64> {
dma_buf_seek(self.resource.size, pos)
}
fn path(&self) -> Cow<'_, str> {
"anon_inode:dmabuf".into()
}
fn device_mmap(&self, _offset: u64, _length: u64) -> StarryResult<DeviceMmap> {
Err(StarryError::Unsupported)
}
}
impl Pollable for HostResourceDmaBuf {
fn poll(&self) -> IoEvents {
IoEvents::IN | IoEvents::OUT
}
unsafe fn register_shared(
&self,
_sink: &mut dyn axpoll::SharedRegistrationSink,
_events: IoEvents,
) {
}
}
struct ImportedBlob {
owner: u64,
resource: Arc<GpuResource>,
}
struct PerFdCtx {
#[allow(dead_code)]
capset_id: u32,
#[allow(dead_code)]
num_rings: u32,
ctx_id: u32,
attached_resources: BTreeSet<u32>,
}
struct Card0File {
base: KernelFile,
card: Arc<Card0>,
file_id: u64,
events: Mutex<VecDeque<DrmEventVblank>>,
poll_rx: PollSet,
context: Mutex<Option<PerFdCtx>>,
operation: Mutex<()>,
}
pub struct Card0 {
self_weak: Weak<Card0>,
sequence: AtomicU32,
state: Mutex<ModesetState>,
dumbs: Mutex<BTreeMap<u32, DumbBuffer>>,
next_dumb_handle: AtomicU32,
next_offset: AtomicU64,
fbs: Mutex<BTreeMap<u32, Framebuffer>>,
scanout_resource: Mutex<Option<Arc<GpuResource>>>,
next_fb_id: AtomicU32,
blobs: Mutex<BTreeMap<u32, Arc<Vec<u8>>>>,
next_blob_id: AtomicU32,
system_blobs: Mutex<BTreeMap<u32, Arc<Vec<u8>>>>,
in_formats_blob: AtomicU32,
system_blobs_init: Mutex<()>,
irq_handle: ax_lazyinit::OnceLock<ax_runtime::hal::irq::IrqHandle>,
gpu_resources: Mutex<BTreeMap<u32, Arc<GpuResource>>>,
blob_aliases: Mutex<BTreeMap<u32, ImportedBlob>>,
next_res_handle: AtomicU32,
next_ctx_id: AtomicU32,
next_file_id: AtomicU64,
capset_cache: Mutex<BTreeMap<(u32, u32), Vec<u8>>>,
}
impl Card0 {
pub fn new() -> Arc<Self> {
let card = Arc::new_cyclic(|weak| Self {
self_weak: weak.clone(),
sequence: AtomicU32::new(0),
state: Mutex::new(ModesetState::default()),
dumbs: Mutex::new(BTreeMap::new()),
next_dumb_handle: AtomicU32::new(FIRST_DUMB_HANDLE),
next_offset: AtomicU64::new(DUMB_BUFFER_OFFSET_STRIDE),
fbs: Mutex::new(BTreeMap::new()),
scanout_resource: Mutex::new(None),
next_fb_id: AtomicU32::new(FIRST_FB_ID),
blobs: Mutex::new(BTreeMap::new()),
next_blob_id: AtomicU32::new(FIRST_BLOB_ID),
system_blobs: Mutex::new(BTreeMap::new()),
in_formats_blob: AtomicU32::new(0),
system_blobs_init: Mutex::new(()),
irq_handle: ax_lazyinit::OnceLock::new(),
gpu_resources: Mutex::new(BTreeMap::new()),
blob_aliases: Mutex::new(BTreeMap::new()),
next_res_handle: AtomicU32::new(FIRST_GPU_RESOURCE_ID),
next_ctx_id: AtomicU32::new(FIRST_VIRGL_CTX_ID),
next_file_id: AtomicU64::new(1),
capset_cache: Mutex::new(BTreeMap::new()),
});
card.register_irq();
card
}
fn register_irq(self: &Arc<Self>) {
if !ax_display::has_display() {
return;
}
let Some(irq) = ax_display::framebuffer_irq_id() else {
return;
};
let request = ax_runtime::hal::irq::IrqRequest::new(|_| {
if ax_display::framebuffer_handle_irq() {
ax_runtime::hal::irq::IrqReturn::Handled
} else {
ax_runtime::hal::irq::IrqReturn::Unhandled
}
})
.share_mode(ax_runtime::hal::irq::ShareMode::Shared)
.auto_enable(ax_runtime::hal::irq::AutoEnable::No);
match ax_runtime::hal::irq::request_irq(irq, request) {
Ok(handle) => {
self.irq_handle.call_once(|| handle);
ax_display::framebuffer_enable_irq();
if let Some(handle) = self.irq_handle.get().copied()
&& let Err(err) = ax_runtime::hal::irq::enable_irq(handle)
{
warn!("failed to enable display irq handler for irq {irq:?}: {err:?}");
ax_display::framebuffer_disable_irq();
}
}
Err(err) => {
warn!("failed to register display irq handler for irq {irq:?}: {err:?}");
ax_display::framebuffer_disable_irq();
}
}
}
fn ensure_in_formats_blob(&self) -> u32 {
let cur = self.in_formats_blob.load(Ordering::Acquire);
if cur != 0 {
return cur;
}
let _guard = self.system_blobs_init.lock();
let cur = self.in_formats_blob.load(Ordering::Acquire);
if cur != 0 {
return cur;
}
let bytes = build_in_formats_blob();
let id = self.next_blob_id.fetch_add(1, Ordering::Relaxed);
self.system_blobs.lock().insert(id, Arc::new(bytes));
self.in_formats_blob.store(id, Ordering::Release);
id
}
}
pub(crate) fn is_card0_device(inner: &dyn Any) -> bool {
inner.is::<Card0>()
}
pub(crate) fn open_card0_file(
inner: &dyn Any,
file: ax_fs_ng::File,
open_flags: u32,
) -> StarryResult<Arc<dyn FileLike>> {
let card = inner
.downcast_ref::<Card0>()
.ok_or(StarryError::NoSuchDevice)?;
let card = card.self_weak.upgrade().ok_or(StarryError::NoSuchDevice)?;
Ok(Arc::new(Card0File::new(
KernelFile::new(file, open_flags),
card,
)))
}
fn write_user_string(
current: &crate::task::UserTaskRef,
user_ptr: u64,
user_cap: usize,
src: &str,
) -> VfsResult<usize> {
let n = user_cap.min(src.len());
if n > 0 {
vm_write_slice(current, user_ptr as *mut u8, &src.as_bytes()[..n])
.map_err(|_| VfsError::BadAddress)?;
}
Ok(src.len())
}
fn report_user_array<T: bytemuck::NoUninit>(
current: &crate::task::UserTaskRef,
user_ptr: u64,
cap: u32,
src: &[T],
) -> VfsResult<u32> {
if user_ptr != 0 {
let to_write = (cap as usize).min(src.len());
vm_write_slice(current, user_ptr as *mut T, &src[..to_write])
.map_err(|_| VfsError::BadAddress)?;
}
Ok(src.len() as u32)
}
fn display_resolution() -> (u32, u32) {
if ax_display::has_display() {
let info = ax_display::framebuffer_info();
(info.width, info.height)
} else {
(640, 480)
}
}
const CVT_RB_HFRONT_PORCH: u16 = 48;
const CVT_RB_HSYNC_WIDTH: u16 = 32;
const CVT_RB_HBACK_PORCH: u16 = 80;
const CVT_RB_VFRONT_PORCH: u16 = 3;
const CVT_RB_VSYNC_WIDTH: u16 = 8;
const CVT_RB_VBACK_PORCH: u16 = 6;
const DEFAULT_VREFRESH: u32 = 60;
fn current_mode() -> DrmModeModeInfo {
let (w, h) = display_resolution();
let mut name = [0u8; 32];
let s = b"current";
name[..s.len()].copy_from_slice(s);
let hdisplay = w as u16;
let hsync_start = hdisplay + CVT_RB_HFRONT_PORCH;
let hsync_end = hsync_start + CVT_RB_HSYNC_WIDTH;
let htotal = hsync_end + CVT_RB_HBACK_PORCH;
let vdisplay = h as u16;
let vsync_start = vdisplay + CVT_RB_VFRONT_PORCH;
let vsync_end = vsync_start + CVT_RB_VSYNC_WIDTH;
let vtotal = vsync_end + CVT_RB_VBACK_PORCH;
let vrefresh: u32 = DEFAULT_VREFRESH;
let clock = ((htotal as u32) * (vtotal as u32) * vrefresh) / 1000;
DrmModeModeInfo {
clock,
hdisplay,
hsync_start,
hsync_end,
htotal,
hskew: 0,
vdisplay,
vsync_start,
vsync_end,
vtotal,
vscan: 0,
vrefresh,
flags: 0,
kind: 0,
name,
}
}
impl DeviceOps for Card0 {
fn read_at(&self, _buf: &mut [u8], _offset: u64) -> VfsResult<usize> {
Err(VfsError::BadFileDescriptor)
}
fn write_at(&self, _buf: &[u8], _offset: u64) -> VfsResult<usize> {
Err(VfsError::BadFileDescriptor)
}
fn ioctl(&self, _current: &UserTaskRef, _cmd: u32, _arg: usize) -> VfsResult<usize> {
Err(VfsError::NotATty)
}
fn mmap(&self, _offset: u64, _length: u64) -> DeviceMmap {
DeviceMmap::None
}
fn as_any(&self) -> &dyn Any {
self
}
fn flags(&self) -> NodeFlags {
NodeFlags::NON_CACHEABLE | NodeFlags::STREAM
}
}
impl Card0File {
fn new(base: KernelFile, card: Arc<Card0>) -> Self {
let file_id = card.next_file_id.fetch_add(1, Ordering::Relaxed);
Self {
base,
card,
file_id,
events: Mutex::new(VecDeque::with_capacity(MAX_EVENTS)),
poll_rx: PollSet::new(),
context: Mutex::new(None),
operation: Mutex::new(()),
}
}
fn create_context(&self, kind: CreateKind) -> VfsResult<u32> {
let (context_init, num_rings) = match kind {
CreateKind::Legacy => (0, 1),
CreateKind::Explicit {
capset_id,
num_rings,
} => (capset_id, num_rings),
};
if !ax_display::has_virgl() {
return Err(VfsError::Unsupported);
}
let ctx_id = self.card.next_ctx_id.fetch_add(1, Ordering::Relaxed);
let ctx_name = format!("starry-ctx-{ctx_id}");
ax_display::gpu3d_ctx_create(ctx_id, &ctx_name, context_init).map_err(map_gpu3d_err)?;
*self.context.lock() = Some(PerFdCtx {
capset_id: context_init,
num_rings,
ctx_id,
attached_resources: BTreeSet::new(),
});
Ok(ctx_id)
}
fn ensure_lazy_context(&self) -> VfsResult<u32> {
if let Some(context) = self.context.lock().as_ref() {
return Ok(context.ctx_id);
}
self.create_context(CreateKind::Legacy)
}
fn attach_resource_if_ready(&self, resource: &Arc<GpuResource>) -> VfsResult<bool> {
let mut context = self.context.lock();
let Some(context) = context.as_mut() else {
return Ok(false);
};
if context.attached_resources.contains(&resource.res_handle) {
return Ok(true);
}
ax_display::gpu3d_ctx_attach_resource(context.ctx_id, resource.res_handle)
.map_err(map_gpu3d_err)?;
context.attached_resources.insert(resource.res_handle);
Ok(true)
}
fn attach_resource(&self, resource: &Arc<GpuResource>) -> VfsResult<()> {
self.attach_resource_if_ready(resource)
.and_then(|attached| attached.then_some(()).ok_or(VfsError::InvalidInput))
}
fn detach_resource(&self, resource_id: u32) {
let mut context = self.context.lock();
let Some(context) = context.as_mut() else {
return;
};
if context.attached_resources.remove(&resource_id) {
let _ = ax_display::gpu3d_ctx_detach_resource(context.ctx_id, resource_id);
}
}
fn ioctl_inner(&self, current: &UserTaskRef, cmd: u32, arg: usize) -> VfsResult<usize> {
let card = &self.card;
match cmd {
DRM_IOCTL_VERSION => handle_version(current, arg),
DRM_IOCTL_GET_UNIQUE => handle_get_unique(current, arg),
DRM_IOCTL_SET_VERSION => handle_set_version(current, arg),
DRM_IOCTL_GET_CAP => handle_get_cap(current, arg),
DRM_IOCTL_SET_CLIENT_CAP => handle_set_client_cap(current, arg),
DRM_IOCTL_SET_MASTER | DRM_IOCTL_DROP_MASTER => Ok(0),
DRM_IOCTL_MODE_GETRESOURCES => handle_get_resources(current, arg),
DRM_IOCTL_MODE_GETCRTC => card.handle_get_crtc(current, arg),
DRM_IOCTL_MODE_SETCRTC => card.handle_set_crtc(current, arg),
DRM_IOCTL_MODE_GETENCODER => handle_get_encoder(current, arg),
DRM_IOCTL_MODE_GETCONNECTOR => handle_get_connector(current, arg),
DRM_IOCTL_MODE_ADDFB2 => card.handle_addfb2(self, current, arg),
DRM_IOCTL_MODE_RMFB => card.handle_rmfb(self, current, arg),
DRM_IOCTL_MODE_CREATE_DUMB => card.handle_create_dumb(self, current, arg),
DRM_IOCTL_MODE_MAP_DUMB => card.handle_map_dumb(self, current, arg),
DRM_IOCTL_MODE_DESTROY_DUMB => card.handle_destroy_dumb(self, current, arg),
DRM_IOCTL_GEM_CLOSE => card.handle_gem_close(self, current, arg),
DRM_IOCTL_MODE_GETPLANERESOURCES => handle_get_plane_resources(current, arg),
DRM_IOCTL_MODE_GETPLANE => card.handle_get_plane(current, arg),
DRM_IOCTL_MODE_OBJ_GETPROPERTIES => card.handle_obj_get_properties(current, arg),
DRM_IOCTL_MODE_GETPROPERTY => handle_get_property(current, arg),
DRM_IOCTL_MODE_PAGE_FLIP => card.handle_page_flip(self, current, arg),
DRM_IOCTL_WAIT_VBLANK => card.handle_wait_vblank(current, arg),
DRM_IOCTL_MODE_ATOMIC => card.handle_atomic(self, current, arg),
DRM_IOCTL_MODE_CREATEPROPBLOB => card.handle_create_blob(current, arg),
DRM_IOCTL_MODE_DESTROYPROPBLOB => card.handle_destroy_blob(current, arg),
DRM_IOCTL_MODE_GETPROPBLOB => card.handle_get_blob(current, arg),
DRM_IOCTL_GET_MAGIC => handle_get_magic(current, arg),
DRM_IOCTL_AUTH_MAGIC => handle_auth_magic(current, arg),
DRM_IOCTL_MODE_DIRTYFB => card.handle_dirty_fb(self, current, arg),
DRM_IOCTL_PRIME_HANDLE_TO_FD => card.handle_prime_handle_to_fd(self, current, arg),
DRM_IOCTL_PRIME_FD_TO_HANDLE => card.handle_prime_fd_to_handle(self, current, arg),
DRM_IOCTL_VIRTGPU_GETPARAM => card.handle_virtgpu_getparam(current, arg),
DRM_IOCTL_VIRTGPU_CONTEXT_INIT => card.handle_virtgpu_context_init(self, current, arg),
DRM_IOCTL_VIRTGPU_GET_CAPS => card.handle_virtgpu_get_caps(current, arg),
DRM_IOCTL_VIRTGPU_RESOURCE_CREATE => {
card.handle_virtgpu_resource_create(self, current, arg)
}
DRM_IOCTL_VIRTGPU_RESOURCE_INFO => {
card.handle_virtgpu_resource_info(self, current, arg)
}
DRM_IOCTL_VIRTGPU_MAP => card.handle_virtgpu_map(self, current, arg),
DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST => {
card.handle_virtgpu_transfer_to_host(self, current, arg)
}
DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST => {
card.handle_virtgpu_transfer_from_host(self, current, arg)
}
DRM_IOCTL_VIRTGPU_WAIT => card.handle_virtgpu_wait(self, current, arg),
DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB => {
card.handle_virtgpu_resource_create_blob(self, current, arg)
}
_ => {
warn!("[card0] unsupported ioctl cmd=0x{:08x}", cmd);
Err(VfsError::OperationNotSupported)
}
}
}
}
impl Pollable for Card0File {
fn poll(&self) -> IoEvents {
let mut events = IoEvents::empty();
events.set(IoEvents::IN, !self.events.lock().is_empty());
events
}
unsafe fn register_shared(
&self,
sink: &mut dyn axpoll::SharedRegistrationSink,
events: IoEvents,
) {
if events.contains(IoEvents::IN) {
unsafe { sink.register_shared(&self.poll_rx, IoEvents::IN) };
}
}
unsafe fn register_exclusive(
&self,
sink: &mut dyn axpoll::ExclusiveRegistrationSink,
events: IoEvents,
) {
if events.contains(IoEvents::IN) {
unsafe { sink.register_exclusive(&self.poll_rx, IoEvents::IN) };
}
}
}
impl FileLike for Card0File {
fn validate_write_access(&self) -> StarryResult {
self.base.validate_write_access()
}
fn read(&self, dst: &mut IoDst) -> StarryResult<usize> {
let event_size = core::mem::size_of::<DrmEventVblank>();
if dst.remaining_mut() < event_size {
return Err(StarryError::InvalidInput);
}
let task = current_user_task();
block_on_user(
&task,
poll_io(self, IoEvents::IN, self.nonblocking(), || {
let mut events = self.events.lock();
let Some(event) = events.pop_front() else {
return Err(StarryError::WouldBlock);
};
dst.write(bytes_of(&event))?;
Ok(event_size)
}),
)
.into_result()?
}
fn write(&self, _src: &mut IoSrc) -> StarryResult<usize> {
Err(StarryError::BadFileDescriptor)
}
fn stat(&self) -> StarryResult<Kstat> {
self.base.stat()
}
fn path(&self) -> Cow<'_, str> {
self.base.path()
}
fn ioctl(&self, current: &UserTaskRef, cmd: u32, arg: usize) -> StarryResult<usize> {
if arg == 0 && !matches!(cmd, DRM_IOCTL_SET_MASTER | DRM_IOCTL_DROP_MASTER) {
return Err(StarryError::BadAddress);
}
let _operation = self.operation.lock();
if cmd == DRM_IOCTL_VIRTGPU_EXECBUFFER {
return self.card.handle_virtgpu_execbuffer(self, current, arg);
}
Ok(self.ioctl_inner(current, cmd, arg)?)
}
fn device_mmap(&self, offset: u64, length: u64) -> StarryResult<DeviceMmap> {
let _operation = self.operation.lock();
let dumbs = self.card.dumbs.lock();
let buffer = dumbs
.values()
.find(|buffer| {
buffer.owner == self.file_id && buffer.mappable && buffer.offset == offset
})
.ok_or(StarryError::InvalidInput)?;
let range = PhysAddrRange::from_start_size(
virt_to_phys(buffer.pages.start_vaddr()),
length.min(buffer.pages.size() as u64) as usize,
);
let retain: Arc<dyn Any + Send + Sync> = buffer.pages.clone();
Ok(DeviceMmap::PhysicalResolved(range, Some(retain)))
}
fn open_flags(&self) -> u32 {
self.base.open_flags()
}
fn nonblocking(&self) -> bool {
self.base.nonblocking()
}
fn set_nonblocking(&self, nonblocking: bool) -> StarryResult {
self.base.set_nonblocking(nonblocking)
}
}
impl Drop for Card0File {
fn drop(&mut self) {
if let Some(context) = self.context.lock().take() {
for resource_id in context.attached_resources {
let _ = ax_display::gpu3d_ctx_detach_resource(context.ctx_id, resource_id);
}
let _ = ax_display::gpu3d_ctx_destroy(context.ctx_id);
}
let mut state = self.card.state.lock();
{
let mut framebuffers = self.card.fbs.lock();
let ids = framebuffers
.iter()
.filter_map(|(&id, framebuffer)| (framebuffer.owner == self.file_id).then_some(id))
.collect::<Vec<_>>();
if ids.contains(&state.plane_fb_id) {
let _ = self.card.clear_scanout();
*state = ModesetState::default();
}
for id in &ids {
framebuffers.remove(id);
}
}
drop(state);
let removed_dumbs = {
let mut dumbs = self.card.dumbs.lock();
let handles = dumbs
.iter()
.filter_map(|(&handle, buffer)| (buffer.owner == self.file_id).then_some(handle))
.collect::<Vec<_>>();
handles
.into_iter()
.filter_map(|handle| dumbs.remove(&handle))
.collect::<Vec<_>>()
};
let removed_aliases = {
let mut aliases = self.card.blob_aliases.lock();
let handles = aliases
.iter()
.filter_map(|(&handle, alias)| (alias.owner == self.file_id).then_some(handle))
.collect::<Vec<_>>();
handles
.into_iter()
.filter_map(|handle| aliases.remove(&handle))
.collect::<Vec<_>>()
};
let removed_resources = {
let mut resources = self.card.gpu_resources.lock();
let ids = resources
.iter()
.filter_map(|(&id, resource)| (resource.owner == self.file_id).then_some(id))
.collect::<Vec<_>>();
ids.into_iter()
.filter_map(|id| resources.remove(&id))
.collect::<Vec<_>>()
};
drop((removed_dumbs, removed_aliases, removed_resources));
}
}
impl Card0 {
fn clear_scanout(&self) -> VfsResult<()> {
if !ax_display::has_display() {
return Ok(());
}
let mut scanout = self.scanout_resource.lock();
ax_display::gpu3d_set_scanout(0, 0, 0, 0, 0, 0).map_err(map_gpu3d_err)?;
*scanout = None;
Ok(())
}
fn present_fb(&self, fb_id: u32) {
let fb = match self.fbs.lock().get(&fb_id) {
Some(fb) => Framebuffer {
owner: fb.owner,
size: fb.size,
stride: fb.stride,
width: fb.width,
height: fb.height,
kind: fb.kind.clone(),
},
None => return,
};
match &fb.kind {
FbBacking::Dumb { pages } => {
if !ax_display::has_display() {
return;
};
let mut scanout = self.scanout_resource.lock();
if scanout.is_some()
&& ax_display::gpu3d_set_scanout(0, 0, 0, 0, 0, 0).is_err()
{
return;
}
if ax_display::framebuffer_restore_scanout().is_err() {
return;
}
*scanout = None;
let src = pages.start_vaddr().as_usize() as *const u8;
let info = ax_display::framebuffer_info();
let dst = info.fb_base_vaddr as *mut u8;
if fb.stride != 0 && info.stride != 0 && fb.stride as usize != info.stride {
let dst_limit = info.fb_size / info.stride.max(1);
let rows = (fb.height as usize).min(dst_limit);
let bytes_per_row = (fb.stride as usize).min(info.stride);
for row in 0..rows {
unsafe {
core::ptr::copy_nonoverlapping(
src.add(row * fb.stride as usize),
dst.add(row * info.stride),
bytes_per_row,
);
}
}
} else {
let copy = (fb.size as usize).min(info.fb_size);
unsafe {
core::ptr::copy_nonoverlapping(src, dst, copy);
}
}
let _ = ax_display::framebuffer_flush();
}
FbBacking::Gpu3d { resource } => {
if !ax_display::has_display() {
return;
};
if resource.is_dumb_2d {
let _ = ax_display::gpu3d_transfer_to_host_2d(
resource.res_handle,
0,
0,
fb.width,
fb.height,
);
}
let mut scanout = self.scanout_resource.lock();
if ax_display::gpu3d_set_scanout(0, resource.res_handle, 0, 0, fb.width, fb.height).is_ok()
{
*scanout = Some(resource.clone());
}
let _ = ax_display::gpu3d_resource_flush(
resource.res_handle,
0,
0,
fb.width,
fb.height,
);
}
}
}
fn handle_create_dumb(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeCreateDumb;
let mut c: DrmModeCreateDumb = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if c.width == 0
|| c.height == 0
|| c.bpp == 0
|| c.bpp > 64
|| !c.bpp.is_multiple_of(8)
|| c.flags != 0
{
return Err(VfsError::InvalidInput);
}
if c.width > 16384 || c.height > 16384 {
return Err(VfsError::InvalidInput);
}
let bytes_per_pixel = c.bpp / 8;
let pitch = c
.width
.checked_mul(bytes_per_pixel)
.ok_or(VfsError::InvalidInput)?;
let size = (pitch as u64)
.checked_mul(c.height as u64)
.ok_or(VfsError::InvalidInput)?;
if size as usize > DUMB_BUFFER_MAX_SIZE {
return Err(VfsError::NoMemory);
}
c.pitch = pitch;
c.size = size;
let size_aligned = (size as usize).next_multiple_of(PAGE_SIZE_4K);
let pages = size_aligned / PAGE_SIZE_4K;
let mut backing =
GlobalPage::alloc_contiguous(pages, PAGE_SIZE_4K).map_err(|_| VfsError::NoMemory)?;
backing.zero();
let pages_arc = Arc::new(backing);
let offset = self
.next_offset
.fetch_add(DUMB_BUFFER_OFFSET_STRIDE, Ordering::Relaxed);
let handle = self.next_dumb_handle.fetch_add(1, Ordering::Relaxed);
let resource = if ax_display::has_display() {
let res_handle = self.next_res_handle.fetch_add(1, Ordering::Relaxed);
let paddr = virt_to_phys(pages_arc.start_vaddr());
ax_display::gpu3d_resource_create_2d(res_handle, c.width, c.height)
.map_err(map_gpu3d_err)?;
let resource = Arc::new(GpuResource {
owner: file.file_id,
res_handle,
bo_handle: handle,
width: c.width,
height: c.height,
stride: pitch,
size,
blob_mem: 0,
blob_flags: 0,
is_dumb_2d: true,
last_fence: AtomicU64::new(0),
});
ax_display::gpu3d_attach_backing(res_handle, paddr.as_usize() as u64, size as u32)
.map_err(map_gpu3d_err)?;
Some(resource)
} else {
None
};
let buffer = DumbBuffer {
owner: file.file_id,
width: c.width,
height: c.height,
bpp: c.bpp,
pitch: c.pitch,
size: c.size,
offset,
pages: pages_arc,
mappable: true,
resource: resource.clone(),
};
c.handle = handle;
ptr.vm_write(current, c).map_err(|_| VfsError::BadAddress)?;
self.dumbs.lock().insert(handle, buffer);
if let Some(resource) = resource {
self.gpu_resources
.lock()
.insert(resource.res_handle, resource);
}
Ok(0)
}
fn destroy_handle(&self, file: &Card0File, handle: u32) -> VfsResult<()> {
let removed_dumb = {
let mut dumbs = self.dumbs.lock();
dumbs
.get(&handle)
.is_some_and(|buffer| buffer.owner == file.file_id)
.then(|| dumbs.remove(&handle))
.flatten()
};
let removed_alias = {
let mut aliases = self.blob_aliases.lock();
aliases
.get(&handle)
.is_some_and(|alias| alias.owner == file.file_id)
.then(|| aliases.remove(&handle))
.flatten()
};
let removed_resources = {
let mut resources = self.gpu_resources.lock();
let ids = resources
.iter()
.filter_map(|(&id, resource)| {
(resource.owner == file.file_id && resource.bo_handle == handle).then_some(id)
})
.collect::<Vec<_>>();
let mut removed = Vec::with_capacity(ids.len());
for id in ids {
if let Some(resource) = resources.remove(&id) {
removed.push(resource);
}
}
removed
};
let found =
removed_dumb.is_some() || removed_alias.is_some() || !removed_resources.is_empty();
let mut detached_ids = BTreeSet::new();
if let Some(resource) = removed_dumb
.as_ref()
.and_then(|buffer| buffer.resource.as_ref())
{
detached_ids.insert(resource.res_handle);
}
if let Some(alias) = &removed_alias {
detached_ids.insert(alias.resource.res_handle);
}
for resource in &removed_resources {
detached_ids.insert(resource.res_handle);
}
for resource_id in detached_ids {
if !self.resource_is_referenced_by_file(file.file_id, resource_id) {
file.detach_resource(resource_id);
}
}
drop((removed_dumb, removed_alias, removed_resources));
if found {
Ok(())
} else {
Err(VfsError::InvalidInput)
}
}
fn resource_is_referenced_by_file(&self, file_id: u64, resource_id: u32) -> bool {
if self.dumbs.lock().values().any(|buffer| {
buffer.owner == file_id
&& buffer
.resource
.as_ref()
.is_some_and(|resource| resource.res_handle == resource_id)
}) {
return true;
}
if self
.blob_aliases
.lock()
.values()
.any(|alias| alias.owner == file_id && alias.resource.res_handle == resource_id)
{
return true;
}
self.gpu_resources
.lock()
.values()
.any(|resource| resource.owner == file_id && resource.res_handle == resource_id)
}
fn handle_destroy_dumb(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmModeDestroyDumb;
let d: DrmModeDestroyDumb = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
self.destroy_handle(file, d.handle)?;
Ok(0)
}
fn handle_gem_close(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmGemClose;
let c: DrmGemClose = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
self.destroy_handle(file, c.handle)?;
Ok(0)
}
fn handle_map_dumb(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeMapDumb;
let mut m: DrmModeMapDumb = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let offset = self
.dumbs
.lock()
.get(&m.handle)
.filter(|buffer| buffer.owner == file.file_id)
.map(|buffer| buffer.offset)
.ok_or(VfsError::InvalidInput)?;
m.offset = offset;
ptr.vm_write(current, m).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
}
fn handle_version(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmVersion;
let mut v: DrmVersion = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
v.version_major = DRIVER_VERSION_MAJOR;
v.version_minor = DRIVER_VERSION_MINOR;
v.version_patchlevel = DRIVER_VERSION_PATCHLEVEL;
v.name_len = write_user_string(current, v.name, v.name_len, DRIVER_NAME)?;
v.date_len = write_user_string(current, v.date, v.date_len, DRIVER_DATE)?;
v.desc_len = write_user_string(current, v.desc, v.desc_len, DRIVER_DESC)?;
ptr.vm_write(current, v).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_get_unique(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmUnique;
let mut u: DrmUnique = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let unique: String = format!("{}:0", DRIVER_NAME);
u.unique_len = write_user_string(current, u.unique, u.unique_len, &unique)?;
ptr.vm_write(current, u).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_set_version(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmSetVersion;
let mut sv: DrmSetVersion = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if sv.drm_di_major < 0 {
sv.drm_di_major = 1;
}
if sv.drm_di_minor < 0 {
sv.drm_di_minor = 4;
}
sv.drm_dd_major = DRIVER_VERSION_MAJOR;
sv.drm_dd_minor = DRIVER_VERSION_MINOR;
ptr.vm_write(current, sv)
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_get_cap(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmGetCap;
let mut cap: DrmGetCap = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
cap.value = match cap.capability {
DRM_CAP_DUMB_BUFFER => 1,
DRM_CAP_TIMESTAMP_MONOTONIC => 1,
DRM_CAP_CRTC_IN_VBLANK_EVENT => 1,
DRM_CAP_ADDFB2_MODIFIERS => 1,
DRM_CAP_PRIME => DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT,
_ => 0,
};
ptr.vm_write(current, cap)
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_set_client_cap(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *const DrmSetClientCap;
let _scc: DrmSetClientCap = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_get_magic(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmAuth;
let magic = DrmAuth { magic: 1 };
ptr.vm_write(current, magic)
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_auth_magic(_current: &crate::task::UserTaskRef, _arg: usize) -> VfsResult<usize> {
Ok(0)
}
impl Card0 {
fn handle_prime_handle_to_fd(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmPrimeHandle;
let mut req: DrmPrimeHandle = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let dma_buf: Arc<dyn FileLike> = {
let imported = self
.blob_aliases
.lock()
.get(&req.handle)
.filter(|alias| alias.owner == file.file_id)
.map(|alias| alias.resource.clone());
let host_res = imported.or_else(|| {
self.gpu_resources
.lock()
.values()
.find(|resource| {
resource.owner == file.file_id
&& resource.bo_handle == req.handle
&& !resource.is_dumb_2d
&& resource.blob_mem != VIRTGPU_BLOB_MEM_GUEST
})
.cloned()
});
if let Some(resource) = host_res {
Arc::new(HostResourceDmaBuf { resource })
} else {
let dumbs = self.dumbs.lock();
let buf = dumbs
.get(&req.handle)
.filter(|buffer| buffer.owner == file.file_id)
.ok_or(VfsError::InvalidInput)?;
let range = PhysAddrRange::from_start_size(
virt_to_phys(buf.pages.start_vaddr()),
buf.size as usize,
);
Arc::new(DmaBufGem {
range,
pages: buf.pages.clone(),
size: buf.size,
})
}
};
let cloexec = req.flags & O_CLOEXEC != 0;
let fd = add_file_like(dma_buf.clone(), cloexec).map_err(|_| VfsError::NoMemory)?;
req.fd = fd;
if ptr.vm_write(current, req).is_err() {
close_exported_fd(fd, &dma_buf);
return Err(VfsError::BadAddress);
}
Ok(0)
}
fn handle_prime_fd_to_handle(
&self,
card_file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmPrimeHandle;
let mut req: DrmPrimeHandle = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let file = crate::file::get_file_like(req.fd).map_err(|_| VfsError::BadFileDescriptor)?;
if let Some(dma) = file.as_any().downcast_ref::<HostResourceDmaBuf>() {
let handle = self.next_dumb_handle.fetch_add(1, Ordering::Relaxed);
if ax_display::has_virgl() && !ax_display::has_context_init() {
let _ctx_id = card_file.ensure_lazy_context()?;
}
let attached = card_file.attach_resource_if_ready(&dma.resource)?;
req.handle = handle;
if ptr.vm_write(current, req).is_err() {
if attached {
card_file.detach_resource(dma.resource.res_handle);
}
return Err(VfsError::BadAddress);
}
self.blob_aliases.lock().insert(
handle,
ImportedBlob {
owner: card_file.file_id,
resource: dma.resource.clone(),
},
);
return Ok(0);
}
let dma_buf: &DmaBufGem = file
.as_any()
.downcast_ref::<DmaBufGem>()
.ok_or(VfsError::InvalidInput)?;
let handle = self.next_dumb_handle.fetch_add(1, Ordering::Relaxed);
let offset = self
.next_offset
.fetch_add(DUMB_BUFFER_OFFSET_STRIDE, Ordering::Relaxed);
let buffer =
DumbBuffer {
owner: card_file.file_id,
width: 0,
height: 0,
bpp: 0,
pitch: 0,
size: dma_buf.size,
offset,
pages: dma_buf.pages.clone(),
mappable: true,
resource: None,
};
req.handle = handle;
ptr.vm_write(current, req)
.map_err(|_| VfsError::BadAddress)?;
self.dumbs.lock().insert(handle, buffer);
Ok(0)
}
}
fn close_exported_fd(fd: i32, expected: &Arc<dyn FileLike>) {
let removed = {
let table = current_fd_table();
let mut table = table.write();
let matches = table
.get(fd as usize)
.is_some_and(|descriptor| Arc::ptr_eq(&descriptor.inner, expected));
matches.then(|| table.remove(fd as usize)).flatten()
};
if let Some(descriptor) = removed {
release_locks_on_close(descriptor);
}
}
fn handle_get_resources(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeCardRes;
let mut r: DrmModeCardRes = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let (w, h) = display_resolution();
r.min_width = w;
r.max_width = w;
r.min_height = h;
r.max_height = h;
r.count_fbs = 0;
r.count_crtcs = report_user_array(current, r.crtc_id_ptr, r.count_crtcs, &[CRTC_ID])?;
r.count_encoders =
report_user_array(current, r.encoder_id_ptr, r.count_encoders, &[ENCODER_ID])?;
r.count_connectors = report_user_array(
current,
r.connector_id_ptr,
r.count_connectors,
&[CONNECTOR_ID],
)?;
ptr.vm_write(current, r).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
impl Card0 {
fn handle_get_crtc(&self, current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeCrtc;
let mut c: DrmModeCrtc = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if c.crtc_id != CRTC_ID {
return Err(VfsError::InvalidInput);
}
let state = self.state.lock().clone();
c.gamma_size = 0;
c.x = (state.plane_src_x >> 16) as u32;
c.y = (state.plane_src_y >> 16) as u32;
c.fb_id = state.plane_fb_id;
c.mode_valid = u32::from(state.mode.is_some());
c.mode = state
.mode
.as_ref()
.map_or_else(Default::default, |mode| mode.info);
let connectors = [CONNECTOR_ID];
c.count_connectors = report_user_array(
current,
c.set_connectors_ptr,
c.count_connectors,
if state.conn_crtc_id != 0 {
&connectors
} else {
&[]
},
)?;
ptr.vm_write(current, c).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_set_crtc(&self, current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeCrtc;
let c: DrmModeCrtc = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if c.crtc_id != CRTC_ID {
return Err(VfsError::InvalidInput);
}
if c.mode_valid == 0 {
if c.count_connectors != 0 {
return Err(VfsError::InvalidInput);
}
let mut state = self.state.lock();
self.clear_scanout()?;
*state = ModesetState::default();
return Ok(0);
}
if c.count_connectors == 0 || c.set_connectors_ptr == 0 {
return Err(VfsError::InvalidInput);
}
if c.count_connectors > 16 {
return Err(VfsError::InvalidInput);
}
let connectors: Vec<u32> = vm_load(
current,
c.set_connectors_ptr as *const u32,
c.count_connectors as usize,
)
.map_err(|_| VfsError::BadAddress)?;
for &id in &connectors {
if id != CONNECTOR_ID {
return Err(VfsError::InvalidInput);
}
}
let mut state = self.state.lock();
if c.fb_id == 0 || !self.fbs.lock().contains_key(&c.fb_id) {
return Err(VfsError::InvalidInput);
}
*state = ModesetState {
crtc_active: 1,
mode: Some(ModeBlob {
id: self.next_blob_id.fetch_add(1, Ordering::Relaxed),
info: c.mode,
bytes: Arc::new(bytes_of(&c.mode).to_vec()),
}),
conn_crtc_id: CRTC_ID,
plane_crtc_id: CRTC_ID,
plane_fb_id: c.fb_id,
plane_src_x: u64::from(c.x) << 16,
plane_src_y: u64::from(c.y) << 16,
plane_src_w: u64::from(c.mode.hdisplay) << 16,
plane_src_h: u64::from(c.mode.vdisplay) << 16,
plane_crtc_w: u64::from(c.mode.hdisplay),
plane_crtc_h: u64::from(c.mode.vdisplay),
..ModesetState::default()
};
self.present_fb(c.fb_id);
Ok(0)
}
}
fn handle_get_encoder(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetEncoder;
let mut e: DrmModeGetEncoder = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if e.encoder_id != ENCODER_ID {
return Err(VfsError::InvalidInput);
}
e.encoder_type = DRM_MODE_ENCODER_VIRTUAL;
e.crtc_id = CRTC_ID;
e.possible_crtcs = 1;
e.possible_clones = 0;
ptr.vm_write(current, e).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_get_connector(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetConnector;
let mut c: DrmModeGetConnector = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if c.connector_id != CONNECTOR_ID {
return Err(VfsError::InvalidInput);
}
c.encoder_id = ENCODER_ID;
c.connector_type = DRM_MODE_CONNECTOR_VIRTUAL;
c.connector_type_id = 1;
c.connection = DRM_MODE_CONNECTED;
let (w, h) = display_resolution();
c.mm_width = w;
c.mm_height = h;
c.subpixel = 0;
c.count_encoders = report_user_array(current, c.encoders_ptr, c.count_encoders, &[ENCODER_ID])?;
if c.modes_ptr != 0 && c.count_modes > 0 {
let p = c.modes_ptr as *mut DrmModeModeInfo;
p.vm_write(current, current_mode())
.map_err(|_| VfsError::BadAddress)?;
}
c.count_modes = 1;
c.count_props = 0;
ptr.vm_write(current, c).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
impl Card0 {
fn handle_addfb2(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeFbCmd2;
let mut f: DrmModeFbCmd2 = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let handle = f.handles[0];
let (kind, size) = {
let imported = self
.blob_aliases
.lock()
.get(&handle)
.filter(|alias| alias.owner == file.file_id)
.map(|alias| alias.resource.clone());
let owned = self
.gpu_resources
.lock()
.values()
.find(|resource| resource.owner == file.file_id && resource.bo_handle == handle)
.cloned();
if let Some(resource) = imported.or(owned) {
let size = resource.size;
(FbBacking::Gpu3d { resource }, size)
} else {
let dumbs = self.dumbs.lock();
let Some(buffer) = dumbs
.get(&handle)
.filter(|buffer| buffer.owner == file.file_id)
else {
return Err(VfsError::InvalidInput);
};
if let Some(resource) = &buffer.resource {
(
FbBacking::Gpu3d {
resource: resource.clone(),
},
buffer.size,
)
} else {
(
FbBacking::Dumb {
pages: buffer.pages.clone(),
},
buffer.size,
)
}
}
};
let fb_stride = f.pitches[0];
let fb_width = f.width;
let fb_height = f.height;
let fb_pixel_format = f.pixel_format;
let bpp = match fb_pixel_format {
DRM_FORMAT_XRGB8888 | DRM_FORMAT_ARGB8888 => 32u32,
_ => {
warn!("ADDFB2: unsupported pixel_format {:#x}", fb_pixel_format);
return Err(VfsError::InvalidInput);
}
};
let visible_bytes = fb_width * (bpp / 8);
if fb_stride < visible_bytes {
warn!(
"ADDFB2: stride {} < visible bytes {} ({}bpp, {}px)",
fb_stride, visible_bytes, bpp, fb_width
);
return Err(VfsError::InvalidInput);
}
let fb_total = fb_stride as u64 * fb_height as u64;
if matches!(&kind, FbBacking::Dumb { .. }) && size < fb_total {
warn!(
"ADDFB2: buffer size {} < fb_total {} ({}stride × {}height)",
size, fb_total, fb_stride, fb_height
);
return Err(VfsError::InvalidInput);
}
if f.flags & DRM_MODE_FB_MODIFIERS != 0 {
for i in 0..4 {
if f.handles[i] == 0 {
continue;
}
let m = f.modifier[i];
if m != DRM_FORMAT_MOD_LINEAR && m != DRM_FORMAT_MOD_INVALID {
return Err(VfsError::InvalidInput);
}
}
}
let fb_id = self.next_fb_id.fetch_add(1, Ordering::Relaxed);
let framebuffer = Framebuffer {
owner: file.file_id,
size,
stride: fb_stride,
width: fb_width,
height: fb_height,
kind,
};
f.fb_id = fb_id;
ptr.vm_write(current, f).map_err(|_| VfsError::BadAddress)?;
self.fbs.lock().insert(fb_id, framebuffer);
Ok(0)
}
fn handle_rmfb(&self, file: &Card0File, current: &UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *const u32;
let fb_id: u32 = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let mut state = self.state.lock();
let removed = {
let mut framebuffers = self.fbs.lock();
let owned = framebuffers
.get(&fb_id)
.is_some_and(|framebuffer| framebuffer.owner == file.file_id);
if owned && state.plane_fb_id == fb_id {
self.clear_scanout()?;
}
owned.then(|| framebuffers.remove(&fb_id)).flatten()
};
if removed.is_none() {
return Err(VfsError::InvalidInput);
}
if state.plane_fb_id == fb_id {
*state = ModesetState::default();
}
Ok(0)
}
}
fn handle_get_plane_resources(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetPlaneRes;
let mut r: DrmModeGetPlaneRes = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let planes: &[u32] = &[PLANE_ID];
r.count_planes = report_user_array(current, r.plane_id_ptr, r.count_planes, planes)?;
ptr.vm_write(current, r).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
impl Card0 {
fn handle_get_plane(&self, current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetPlane;
let mut p: DrmModeGetPlane = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if p.plane_id != PLANE_ID {
return Err(VfsError::InvalidInput);
}
let state = self.state.lock().clone();
p.crtc_id = state.plane_crtc_id;
p.fb_id = state.plane_fb_id;
p.possible_crtcs = 1;
p.gamma_size = 0;
p.count_format_types = report_user_array(
current,
p.format_type_ptr,
p.count_format_types,
SUPPORTED_FORMATS,
)?;
ptr.vm_write(current, p).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_obj_get_properties(
&self,
current: &crate::task::UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeObjGetProperties;
let mut q: DrmModeObjGetProperties =
ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let state = self.state.lock().clone();
let (prop_ids, prop_vals): (&[u32], Vec<u64>) = match (q.obj_type, q.obj_id) {
(DRM_MODE_OBJECT_PLANE, PLANE_ID) => {
let blob_id = self.ensure_in_formats_blob() as u64;
(PLANE_PROPS, plane_prop_values(&state, blob_id))
}
(DRM_MODE_OBJECT_CRTC, CRTC_ID) => (CRTC_PROPS, crtc_prop_values(&state)),
(DRM_MODE_OBJECT_CONNECTOR, CONNECTOR_ID) => (CONN_PROPS, conn_prop_values(&state)),
(DRM_MODE_OBJECT_FB, fb_id) => {
return Err(if self.fbs.lock().contains_key(&fb_id) {
VfsError::InvalidInput
} else {
VfsError::NotFound
});
}
_ => return Err(VfsError::NotFound),
};
report_user_array(current, q.props_ptr, q.count_props, prop_ids)?;
report_user_array(current, q.prop_values_ptr, q.count_props, &prop_vals)?;
q.count_props = prop_ids.len() as u32;
ptr.vm_write(current, q).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
}
fn plane_prop_values(s: &ModesetState, in_formats: u64) -> Vec<u64> {
vec![
DRM_PLANE_TYPE_PRIMARY,
s.plane_fb_id as u64,
s.plane_crtc_id as u64,
s.plane_src_x,
s.plane_src_y,
s.plane_src_w,
s.plane_src_h,
s.plane_crtc_x as u64,
s.plane_crtc_y as u64,
s.plane_crtc_w,
s.plane_crtc_h,
in_formats,
u64::MAX,
]
}
fn build_in_formats_blob() -> Vec<u8> {
#[repr(C)]
#[derive(Clone, Copy, bytemuck::NoUninit)]
struct Header {
version: u32,
flags: u32,
count_formats: u32,
formats_offset: u32,
count_modifiers: u32,
modifiers_offset: u32,
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::NoUninit)]
struct ModifierEntry {
formats: u64,
offset: u32,
_pad: u32,
modifier: u64,
}
let n_formats = SUPPORTED_FORMATS.len() as u32;
let formats_off = size_of::<Header>() as u32;
let modifiers_off = formats_off + n_formats * 4;
let hdr = Header {
version: 1,
flags: 0,
count_formats: n_formats,
formats_offset: formats_off,
count_modifiers: 1,
modifiers_offset: modifiers_off,
};
let format_mask = (1u64 << n_formats) - 1;
let me = ModifierEntry {
formats: format_mask,
offset: 0,
_pad: 0,
modifier: DRM_FORMAT_MOD_LINEAR,
};
let mut buf = Vec::with_capacity(
size_of::<Header>() + (n_formats as usize) * 4 + size_of::<ModifierEntry>(),
);
buf.extend_from_slice(bytes_of(&hdr));
for fmt in SUPPORTED_FORMATS {
buf.extend_from_slice(&fmt.to_le_bytes());
}
buf.extend_from_slice(bytes_of(&me));
buf
}
fn crtc_prop_values(s: &ModesetState) -> Vec<u64> {
vec![
s.crtc_active,
s.mode.as_ref().map_or(0, |mode| u64::from(mode.id)),
]
}
fn conn_prop_values(s: &ModesetState) -> Vec<u64> {
vec![s.conn_crtc_id as u64]
}
fn handle_get_property(current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetProperty;
let mut g: DrmModeGetProperty = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let meta = property_meta(g.prop_id).ok_or(VfsError::NotFound)?;
g.flags = meta.flags;
g.name = [0; DRM_PROP_NAME_LEN];
let nb = meta.name.as_bytes();
let n = nb.len().min(DRM_PROP_NAME_LEN - 1);
g.name[..n].copy_from_slice(&nb[..n]);
match meta.kind {
PropKind::Enum(enums) => {
g.count_values = enums.len() as u32;
g.count_enum_blobs =
report_user_array(current, g.enum_blob_ptr, g.count_enum_blobs, enums)?;
}
PropKind::RangeU64 { min, max } => {
let limits = [min, max];
g.count_values = report_user_array(current, g.values_ptr, g.count_values, &limits)?;
g.count_enum_blobs = 0;
}
PropKind::Object(object_type) => {
let values = [object_type as u64];
g.count_values = report_user_array(current, g.values_ptr, g.count_values, &values)?;
g.count_enum_blobs = 0;
}
PropKind::Blob => {
g.count_values = 0;
g.count_enum_blobs = 0;
}
}
ptr.vm_write(current, g).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
struct PropMeta {
name: &'static str,
flags: u32,
kind: PropKind,
}
enum PropKind {
Enum(&'static [DrmModePropertyEnum]),
RangeU64 { min: u64, max: u64 },
Object(u32),
Blob,
}
const fn enum_entry(value: u64, name: &[u8]) -> DrmModePropertyEnum {
let mut e = DrmModePropertyEnum {
value,
name: [0; DRM_PROP_NAME_LEN],
};
let n = if name.len() < DRM_PROP_NAME_LEN - 1 {
name.len()
} else {
DRM_PROP_NAME_LEN - 1
};
let mut i = 0;
while i < n {
e.name[i] = name[i];
i += 1;
}
e
}
const PLANE_TYPE_ENUMS: &[DrmModePropertyEnum] = &[
enum_entry(0, b"Overlay"),
enum_entry(1, b"Primary"),
enum_entry(2, b"Cursor"),
];
fn property_meta(id: u32) -> Option<PropMeta> {
let atomic = DRM_MODE_PROP_ATOMIC;
let meta = match id {
PROP_PLANE_TYPE => PropMeta {
name: "type",
flags: DRM_MODE_PROP_ENUM | DRM_MODE_PROP_IMMUTABLE,
kind: PropKind::Enum(PLANE_TYPE_ENUMS),
},
PROP_PLANE_FB_ID => PropMeta {
name: "FB_ID",
flags: DRM_MODE_PROP_OBJECT | atomic,
kind: PropKind::Object(DRM_MODE_OBJECT_FB),
},
PROP_PLANE_CRTC_ID => PropMeta {
name: "CRTC_ID",
flags: DRM_MODE_PROP_OBJECT | atomic,
kind: PropKind::Object(DRM_MODE_OBJECT_CRTC),
},
PROP_PLANE_SRC_X => range_u32("SRC_X", atomic),
PROP_PLANE_SRC_Y => range_u32("SRC_Y", atomic),
PROP_PLANE_SRC_W => range_u32("SRC_W", atomic),
PROP_PLANE_SRC_H => range_u32("SRC_H", atomic),
PROP_PLANE_CRTC_X => range_u32("CRTC_X", atomic),
PROP_PLANE_CRTC_Y => range_u32("CRTC_Y", atomic),
PROP_PLANE_CRTC_W => range_u32("CRTC_W", atomic),
PROP_PLANE_CRTC_H => range_u32("CRTC_H", atomic),
PROP_PLANE_IN_FORMATS => PropMeta {
name: "IN_FORMATS",
flags: DRM_MODE_PROP_BLOB | DRM_MODE_PROP_IMMUTABLE,
kind: PropKind::Blob,
},
PROP_PLANE_IN_FENCE_FD => PropMeta {
name: "IN_FENCE_FD",
flags: DRM_MODE_PROP_SIGNED_RANGE | atomic,
kind: PropKind::RangeU64 {
min: u64::MAX,
max: i32::MAX as u64,
},
},
PROP_CRTC_ACTIVE => PropMeta {
name: "ACTIVE",
flags: DRM_MODE_PROP_RANGE | atomic,
kind: PropKind::RangeU64 { min: 0, max: 1 },
},
PROP_CRTC_MODE_ID => PropMeta {
name: "MODE_ID",
flags: DRM_MODE_PROP_BLOB | atomic,
kind: PropKind::Blob,
},
PROP_CONN_CRTC_ID => PropMeta {
name: "CRTC_ID",
flags: DRM_MODE_PROP_OBJECT | atomic,
kind: PropKind::Object(DRM_MODE_OBJECT_CRTC),
},
_ => return None,
};
Some(meta)
}
fn range_u32(name: &'static str, atomic: u32) -> PropMeta {
PropMeta {
name,
flags: DRM_MODE_PROP_RANGE | atomic,
kind: PropKind::RangeU64 {
min: 0,
max: u32::MAX as u64,
},
}
}
impl Card0 {
fn handle_dirty_fb(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmModeDirtyFB;
let dirty: DrmModeDirtyFB = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if !self
.fbs
.lock()
.get(&dirty.fb_id)
.is_some_and(|framebuffer| framebuffer.owner == file.file_id)
{
return Err(VfsError::InvalidInput);
}
self.present_fb(dirty.fb_id);
Ok(0)
}
fn handle_page_flip(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmModeCrtcPageFlip;
let f: DrmModeCrtcPageFlip = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if f.crtc_id != CRTC_ID
|| !self
.fbs
.lock()
.get(&f.fb_id)
.is_some_and(|framebuffer| framebuffer.owner == file.file_id)
{
return Err(VfsError::InvalidInput);
}
let mut state = self.state.lock();
if state.plane_fb_id == 0 {
return Err(VfsError::ResourceBusy);
}
if state.crtc_active == 0 || !self.fbs.lock().contains_key(&f.fb_id) {
return Err(VfsError::InvalidInput);
}
state.plane_fb_id = f.fb_id;
self.present_fb(f.fb_id);
drop(state);
if f.flags & DRM_MODE_PAGE_FLIP_EVENT != 0 {
self.queue_flip_event(file, f.user_data);
}
Ok(0)
}
fn queue_flip_event(&self, file: &Card0File, user_data: u64) {
let seq = self
.sequence
.fetch_add(1, Ordering::Relaxed)
.wrapping_add(1);
let now = monotonic_time();
let ev = DrmEventVblank {
base: DrmEvent {
event_type: DRM_EVENT_FLIP_COMPLETE,
length: core::mem::size_of::<DrmEventVblank>() as u32,
},
user_data,
tv_sec: now.as_secs() as u32,
tv_usec: now.subsec_micros(),
sequence: seq,
crtc_id: CRTC_ID,
};
let enqueued = {
let mut queue = file.events.lock();
if queue.len() >= MAX_EVENTS {
false
} else {
queue.push_back(ev);
true
}
};
if enqueued {
unsafe { file.poll_rx.wake(IoEvents::IN) };
}
}
fn handle_wait_vblank(
&self,
current: &crate::task::UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmWaitVblank;
let request: DrmWaitVblank = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let is_relative = request.rep_type & crate::pseudofs::dev::drm::DRM_VBLANK_RELATIVE != 0;
let current_sequence = self.sequence.load(Ordering::Acquire);
let target = if is_relative {
current_sequence.wrapping_add(request.sequence)
} else {
request.sequence
};
let raw_wait = target.wrapping_sub(current_sequence);
let wait_count = if raw_wait == 0 || raw_wait >= i32::MAX as u32 {
1
} else {
raw_wait
};
const FRAME_PERIOD_NS: u64 = 1_000_000_000 / 60;
let delay =
core::time::Duration::from_nanos(FRAME_PERIOD_NS.saturating_mul(wait_count as u64));
crate::task::sleep(delay);
self.sequence.fetch_add(wait_count, Ordering::AcqRel);
let now = monotonic_time();
let reply = DrmWaitVblank {
rep_type: 0,
sequence: self.sequence.load(Ordering::Acquire),
tv_sec: now.as_secs() as i64,
tv_usec: now.subsec_micros() as i64,
};
ptr.vm_write(current, reply)
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_atomic(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmModeAtomic;
let a: DrmModeAtomic = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let known = DRM_MODE_ATOMIC_TEST_ONLY
| DRM_MODE_ATOMIC_NONBLOCK
| DRM_MODE_ATOMIC_ALLOW_MODESET
| DRM_MODE_PAGE_FLIP_EVENT;
if a.flags & !known != 0 {
return Err(VfsError::InvalidInput);
}
let n = a.count_objs as usize;
let objs: Vec<u32> =
vm_load(current, a.objs_ptr as *const u32, n).map_err(|_| VfsError::BadAddress)?;
let counts: Vec<u32> = vm_load(current, a.count_props_ptr as *const u32, n)
.map_err(|_| VfsError::BadAddress)?;
let total_props: usize = counts.iter().map(|c| *c as usize).sum();
let props: Vec<u32> = vm_load(current, a.props_ptr as *const u32, total_props)
.map_err(|_| VfsError::BadAddress)?;
let values: Vec<u64> = vm_load(current, a.prop_values_ptr as *const u64, total_props)
.map_err(|_| VfsError::BadAddress)?;
let mut state = self.state.lock();
let mut proposed = state.clone();
let mut idx = 0;
for (obj_i, &obj_id) in objs.iter().enumerate() {
let obj_type = object_type_of(obj_id).ok_or(VfsError::NotFound)?;
for _ in 0..counts[obj_i] {
let prop_id = props[idx];
let value = values[idx];
idx += 1;
if !self.apply_prop(obj_type, prop_id, value, &mut proposed)? {
return Err(VfsError::InvalidInput);
}
}
}
if a.flags & DRM_MODE_ATOMIC_TEST_ONLY != 0 {
return Ok(0);
}
let current_fb = proposed.plane_fb_id;
if (current_fb == 0 || proposed.crtc_active == 0) && state.plane_fb_id != 0 {
self.clear_scanout()?;
}
*state = proposed;
if current_fb != 0 && state.crtc_active != 0 {
self.present_fb(current_fb);
}
drop(state);
if a.flags & DRM_MODE_PAGE_FLIP_EVENT != 0 {
self.queue_flip_event(file, a.user_data);
}
Ok(0)
}
fn apply_prop(
&self,
obj_type: u32,
prop_id: u32,
value: u64,
s: &mut ModesetState,
) -> VfsResult<bool> {
match (obj_type, prop_id) {
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_TYPE) => {
if value != DRM_PLANE_TYPE_PRIMARY {
return Err(VfsError::InvalidInput);
}
}
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_FB_ID) => {
let fb = value as u32;
if fb != 0 && !self.fbs.lock().contains_key(&fb) {
return Err(VfsError::InvalidInput);
}
s.plane_fb_id = fb;
}
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_CRTC_ID) => {
let c = value as u32;
if c != 0 && c != CRTC_ID {
return Err(VfsError::InvalidInput);
}
s.plane_crtc_id = c;
}
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_SRC_X) => s.plane_src_x = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_SRC_Y) => s.plane_src_y = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_SRC_W) => s.plane_src_w = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_SRC_H) => s.plane_src_h = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_CRTC_X) => {
s.plane_crtc_x = checked_i32(value)? as i64;
}
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_CRTC_Y) => {
s.plane_crtc_y = checked_i32(value)? as i64;
}
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_CRTC_W) => s.plane_crtc_w = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_CRTC_H) => s.plane_crtc_h = value,
(DRM_MODE_OBJECT_PLANE, PROP_PLANE_IN_FENCE_FD) => {
if value != u64::MAX {
return Err(VfsError::InvalidInput);
}
}
(DRM_MODE_OBJECT_CRTC, PROP_CRTC_ACTIVE) => {
if value > 1 {
return Err(VfsError::InvalidInput);
}
s.crtc_active = value;
}
(DRM_MODE_OBJECT_CRTC, PROP_CRTC_MODE_ID) => {
let id = u32::try_from(value).map_err(|_| VfsError::InvalidInput)?;
s.mode = if id == 0 {
None
} else {
let bytes = self
.blobs
.lock()
.get(&id)
.cloned()
.or_else(|| {
s.mode
.as_ref()
.filter(|mode| mode.id == id)
.map(|mode| mode.bytes.clone())
})
.ok_or(VfsError::InvalidInput)?;
if bytes.len() != size_of::<DrmModeModeInfo>() {
return Err(VfsError::InvalidInput);
}
let info = bytemuck::try_pod_read_unaligned(&bytes)
.map_err(|_| VfsError::InvalidInput)?;
Some(ModeBlob { id, info, bytes })
};
}
(DRM_MODE_OBJECT_CONNECTOR, PROP_CONN_CRTC_ID) => {
let c = value as u32;
if c != 0 && c != CRTC_ID {
return Err(VfsError::InvalidInput);
}
s.conn_crtc_id = c;
}
_ => return Ok(false),
}
Ok(true)
}
fn handle_create_blob(
&self,
current: &crate::task::UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeCreateBlob;
let mut c: DrmModeCreateBlob = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if c.length == 0 || c.length as usize > MAX_BLOB_BYTES {
return Err(VfsError::InvalidInput);
}
let bytes: Vec<u8> = vm_load(current, c.data as *const u8, c.length as usize)
.map_err(|_| VfsError::BadAddress)?;
let id = self.next_blob_id.fetch_add(1, Ordering::Relaxed);
self.blobs.lock().insert(id, Arc::new(bytes));
c.blob_id = id;
ptr.vm_write(current, c).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_destroy_blob(
&self,
current: &crate::task::UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *const DrmModeDestroyBlob;
let d: DrmModeDestroyBlob = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if self.system_blobs.lock().contains_key(&d.blob_id) {
return Err(VfsError::PermissionDenied);
}
self.blobs
.lock()
.remove(&d.blob_id)
.ok_or(VfsError::NotFound)?;
Ok(0)
}
fn handle_get_blob(&self, current: &crate::task::UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmModeGetBlob;
let mut g: DrmModeGetBlob = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let published = self.blobs.lock().get(&g.blob_id).cloned();
let bytes = published
.or_else(|| {
self.state
.lock()
.mode
.as_ref()
.filter(|mode| mode.id == g.blob_id)
.map(|mode| mode.bytes.clone())
})
.or_else(|| self.system_blobs.lock().get(&g.blob_id).cloned())
.ok_or(VfsError::NotFound)?;
if g.data != 0 && g.length > 0 {
let n = (g.length as usize).min(bytes.len());
vm_write_slice(current, g.data as *mut u8, &bytes[..n])
.map_err(|_| VfsError::BadAddress)?;
}
g.length = bytes.len() as u32;
ptr.vm_write(current, g).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn resource_for_handle(&self, file: &Card0File, handle: u32) -> Option<Arc<GpuResource>> {
if let Some(resource) = self
.blob_aliases
.lock()
.get(&handle)
.filter(|alias| alias.owner == file.file_id)
.map(|alias| alias.resource.clone())
{
return Some(resource);
}
if let Some(resource) = self
.dumbs
.lock()
.get(&handle)
.filter(|buffer| buffer.owner == file.file_id)
.and_then(|buffer| buffer.resource.clone())
{
return Some(resource);
}
self.gpu_resources
.lock()
.values()
.find(|resource| resource.owner == file.file_id && resource.bo_handle == handle)
.cloned()
}
fn handle_virtgpu_getparam(&self, current: &UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuGetparam;
let g: DrmVirtgpuGetparam = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let has_virgl = ax_display::has_virgl();
let value = match g.param {
VIRTGPU_PARAM_3D_FEATURES => {
if has_virgl { 1 } else { 0 }
}
VIRTGPU_PARAM_CAPSET_QUERY_FIX => {
1
}
VIRTGPU_PARAM_RESOURCE_BLOB => {
if ax_display::has_resource_blob() {
1
} else {
0
}
}
VIRTGPU_PARAM_HOST_VISIBLE => {
0
}
VIRTGPU_PARAM_CROSS_DEVICE => {
0
}
VIRTGPU_PARAM_CONTEXT_INIT => {
if ax_display::has_context_init() { 1 } else { 0 }
}
VIRTGPU_PARAM_SUPPORTED_CAPSET_IDS => {
if has_virgl {
(1 << VIRTGPU_DRM_CAPSET_VIRGL) | (1 << VIRTGPU_DRM_CAPSET_VIRGL2)
} else {
0
}
}
_ => {
return Err(VfsError::InvalidInput);
}
};
if g.value == 0 {
return Err(VfsError::BadAddress);
}
vm_write_slice(current, g.value as *mut u64, &[value]).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_virtgpu_context_init(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let init: DrmVirtgpuContextInit = (arg as *const DrmVirtgpuContextInit)
.vm_read(current)
.map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_context_init() || !ax_display::has_virgl() {
return Err(VfsError::InvalidInput);
}
if file.context.lock().is_some() {
return Err(VfsError::AlreadyExists);
}
if init.num_params > 3 {
return Err(VfsError::InvalidInput);
}
if init.num_params > 0 && init.ctx_set_params == 0 {
return Err(VfsError::BadAddress);
}
let mut capset_id: u32 = 0;
let mut num_rings: u32 = 1;
if init.num_params > 0 {
let params_ptr = init.ctx_set_params as *const DrmVirtgpuContextSetParam;
for i in 0..init.num_params as usize {
let param: DrmVirtgpuContextSetParam = unsafe { params_ptr.add(i) }
.vm_read(current)
.map_err(|_| VfsError::BadAddress)?;
match param.param {
VIRTGPU_CONTEXT_PARAM_CAPSET_ID => {
capset_id = param.value as u32;
if capset_id > VIRTGPU_DRM_CAPSET_DRM {
return Err(VfsError::InvalidInput);
}
if capset_id != VIRTGPU_DRM_CAPSET_VIRGL
&& capset_id != VIRTGPU_DRM_CAPSET_VIRGL2
{
warn!("[card0] CONTEXT_INIT: unsupported capset_id={capset_id}");
return Err(VfsError::InvalidInput);
}
}
VIRTGPU_CONTEXT_PARAM_NUM_RINGS => {
num_rings = param.value as u32;
if num_rings == 0 || num_rings > 64 {
return Err(VfsError::InvalidInput);
}
}
VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK => {
let _ = param.value;
}
_ => {
return Err(VfsError::InvalidInput);
}
}
}
}
let ctx_id = file.create_context(CreateKind::Explicit {
capset_id,
num_rings,
})?;
info!(
"[card0] CONTEXT_INIT: ctx_id={ctx_id}, capset_id={capset_id}, num_rings={num_rings}"
);
Ok(0)
}
fn handle_virtgpu_get_caps(&self, current: &UserTaskRef, arg: usize) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuGetCaps;
let g: DrmVirtgpuGetCaps = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let user_size = g.size;
if !ax_display::has_virgl() {
return Err(VfsError::Unsupported);
}
let mut capsets = Vec::new();
for index in 0..MAX_CAPSET_ENUM {
match ax_display::gpu3d_capset_info(index) {
Ok(info) => capsets.push(info),
Err(_) => break,
}
}
if capsets.is_empty() {
return Err(VfsError::Unsupported);
}
if user_size == 0 {
return Err(VfsError::InvalidInput);
}
let matched = capsets
.iter()
.find(|info| info.capset_id == g.cap_set_id && info.max_version >= g.cap_set_ver)
.copied()
.ok_or(VfsError::InvalidInput)?;
let cache_key = (g.cap_set_id, g.cap_set_ver);
let cached = self.capset_cache.lock().get(&cache_key).cloned();
let cap_data = if let Some(data) = cached {
data
} else {
let data = ax_display::gpu3d_capset(g.cap_set_id, g.cap_set_ver, matched.max_size)
.map_err(map_gpu3d_err)?;
self.capset_cache.lock().insert(cache_key, data.clone());
data
};
let write_size = (user_size as usize).min(cap_data.len());
if write_size == 0 || g.addr == 0 {
return Err(VfsError::BadAddress);
}
vm_write_slice(current, g.addr as *mut u8, &cap_data[..write_size])
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_virtgpu_resource_create(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuResourceCreate;
let mut r: DrmVirtgpuResourceCreate =
ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_virgl() {
return Err(VfsError::Unsupported);
}
let ctx_id = file.ensure_lazy_context()?;
let res_handle = self.next_res_handle.fetch_add(1, Ordering::Relaxed);
let size = if r.size > 0 {
r.size as u64
} else {
PAGE_SIZE_4K as u64
};
if size > DUMB_BUFFER_MAX_SIZE as u64 {
return Err(VfsError::InvalidInput);
}
let mut pages =
GlobalPage::alloc_contiguous((size as usize).div_ceil(PAGE_SIZE_4K), PAGE_SIZE_4K)
.map_err(|_| VfsError::NoMemory)?;
pages.zero();
let bo_handle = self.next_dumb_handle.fetch_add(1, Ordering::Relaxed);
let offset = self
.next_offset
.fetch_add(DUMB_BUFFER_OFFSET_STRIDE, Ordering::Relaxed);
let backing_paddr = virt_to_phys(pages.start_vaddr());
let backing_size = pages.size();
let pages = Arc::new(pages);
ax_display::gpu3d_resource_create(ax_display::ResourceCreate3d {
ctx_id,
resource_id: res_handle,
target: r.target,
format: r.format,
bind: r.bind,
width: r.width,
height: r.height,
depth: r.depth,
array_size: r.array_size,
last_level: r.last_level,
nr_samples: r.nr_samples,
flags: r.flags,
})
.map_err(map_gpu3d_err)?;
let resource = Arc::new(GpuResource {
owner: file.file_id,
res_handle,
bo_handle,
width: r.width,
height: r.height,
stride: r.stride,
size,
blob_mem: 0,
blob_flags: 0,
is_dumb_2d: false,
last_fence: AtomicU64::new(0),
});
ax_display::gpu3d_attach_backing(
res_handle,
backing_paddr.as_usize() as u64,
backing_size as u32,
)
.map_err(map_gpu3d_err)?;
file.attach_resource(&resource)?;
let buffer = DumbBuffer {
owner: file.file_id,
width: r.width,
height: r.height,
bpp: 32,
pitch: r.stride,
size,
offset,
pages,
mappable: true,
resource: Some(resource.clone()),
};
r.bo_handle = bo_handle;
r.res_handle = res_handle;
r.size = size as u32;
if ptr.vm_write(current, r).is_err() {
file.detach_resource(res_handle);
return Err(VfsError::BadAddress);
}
self.dumbs.lock().insert(bo_handle, buffer);
self.gpu_resources.lock().insert(res_handle, resource);
Ok(0)
}
fn handle_virtgpu_resource_info(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuResourceInfo;
let mut info: DrmVirtgpuResourceInfo =
ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let resource = self
.resource_for_handle(file, info.bo_handle)
.ok_or(VfsError::NotFound)?;
info.res_handle = resource.res_handle;
info.size = resource.size as u32;
info.blob_mem = resource.blob_mem;
ptr.vm_write(current, info)
.map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_virtgpu_map(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuMap;
let mut m: DrmVirtgpuMap = ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
let dumbs = self.dumbs.lock();
let buf = dumbs
.get(&m.handle)
.filter(|buffer| buffer.owner == file.file_id && buffer.mappable)
.ok_or(VfsError::InvalidInput)?;
m.offset = buf.offset;
drop(dumbs);
ptr.vm_write(current, m).map_err(|_| VfsError::BadAddress)?;
Ok(0)
}
fn handle_virtgpu_execbuffer(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> StarryResult<usize> {
let ptr = arg as *mut DrmVirtgpuExecbuffer;
let mut eb: DrmVirtgpuExecbuffer =
ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_virgl() {
return Err(StarryError::Unsupported);
}
let known_fence_flags = VIRTGPU_EXECBUF_FENCE_FD_IN | VIRTGPU_EXECBUF_FENCE_FD_OUT;
if eb.flags & !known_fence_flags != 0
|| eb.ring_idx != 0
|| eb.syncobj_stride != 0
|| eb.num_in_syncobjs != 0
|| eb.num_out_syncobjs != 0
|| eb.in_syncobjs != 0
|| eb.out_syncobjs != 0
{
return Err(StarryError::InvalidInput);
}
let fence_in = eb.flags & VIRTGPU_EXECBUF_FENCE_FD_IN != 0;
let fence_out = eb.flags & VIRTGPU_EXECBUF_FENCE_FD_OUT != 0;
if eb.size == 0
|| !eb.size.is_multiple_of(4)
|| eb.size as usize > MAX_VIRGL_COMMAND_BYTES
|| eb.command == 0
{
return Err(StarryError::InvalidInput);
}
if eb.num_bo_handles > 256 || (eb.num_bo_handles > 0 && eb.bo_handles == 0) {
return Err(StarryError::InvalidInput);
}
if fence_in {
if eb.fence_fd < 0 {
return Err(StarryError::InvalidInput);
}
let file =
crate::file::get_file_like(eb.fence_fd).map_err(|_| VfsError::InvalidInput)?;
let fence = file
.downcast_arc::<SyncFile>()
.map_err(|_| VfsError::InvalidInput)?;
if !fence.is_signaled() {
return Err(StarryError::InvalidInput);
}
}
let out_fence = if fence_out {
let sync_file = Arc::new(SyncFile::new());
let created: Arc<dyn FileLike> = sync_file.clone();
let prepared = prepare_file_like(move || Ok(created), true)?;
Some((prepared, sync_file))
} else {
None
};
let cmd_buf = vm_load(current, eb.command as *const u8, eb.size as usize)
.map_err(|_| VfsError::BadAddress)?;
let handles = if eb.num_bo_handles == 0 {
Vec::new()
} else {
vm_load(
current,
eb.bo_handles as *const u32,
eb.num_bo_handles as usize,
)
.map_err(|_| VfsError::BadAddress)?
};
let mut resources = Vec::with_capacity(handles.len());
for handle in handles {
let resource = self
.resource_for_handle(file, handle)
.ok_or(VfsError::NotFound)?;
resources.push(resource);
}
let ctx_id = file.ensure_lazy_context()?;
for resource in &resources {
file.attach_resource(resource)?;
}
let fence_id = ax_display::gpu3d_submit_cmd(ctx_id, &cmd_buf).map_err(map_gpu3d_err)?;
for resource in resources {
resource.last_fence.store(fence_id, Ordering::Release);
}
if let Some((prepared, sync_file)) = out_fence {
sync_file.mark_signaled();
eb.fence_fd = prepared.fd();
ptr.vm_write(current, eb)
.map_err(|_| VfsError::BadAddress)?;
prepared.install();
} else {
ptr.vm_write(current, eb)
.map_err(|_| VfsError::BadAddress)?;
}
Ok(0)
}
fn handle_virtgpu_transfer_to_host(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let t: DrmVirtgpu3dTransferToHost = (arg as *const DrmVirtgpu3dTransferToHost)
.vm_read(current)
.map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_virgl() {
return Err(VfsError::Unsupported);
}
let ctx_id = file.ensure_lazy_context()?;
let resource = self
.resource_for_handle(file, t.bo_handle)
.ok_or(VfsError::NotFound)?;
file.attach_resource(&resource)?;
ax_display::gpu3d_transfer_to_host(ax_display::Transfer3d {
ctx_id,
resource_id: resource.res_handle,
box_: ax_display::TransferBox {
x: t.box_.x,
y: t.box_.y,
z: t.box_.z,
w: t.box_.w,
h: t.box_.h,
d: t.box_.d,
},
offset: t.offset as u64,
level: t.level,
stride: t.stride,
layer_stride: t.layer_stride,
})
.map_err(map_gpu3d_err)?;
Ok(0)
}
fn handle_virtgpu_transfer_from_host(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let t: DrmVirtgpu3dTransferFromHost = (arg as *const DrmVirtgpu3dTransferFromHost)
.vm_read(current)
.map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_virgl() {
return Err(VfsError::Unsupported);
}
let ctx_id = file.ensure_lazy_context()?;
let resource = self
.resource_for_handle(file, t.bo_handle)
.ok_or(VfsError::NotFound)?;
file.attach_resource(&resource)?;
ax_display::gpu3d_transfer_from_host(ax_display::Transfer3d {
ctx_id,
resource_id: resource.res_handle,
box_: ax_display::TransferBox {
x: t.box_.x,
y: t.box_.y,
z: t.box_.z,
w: t.box_.w,
h: t.box_.h,
d: t.box_.d,
},
offset: t.offset as u64,
level: t.level,
stride: t.stride,
layer_stride: t.layer_stride,
})
.map_err(map_gpu3d_err)?;
Ok(0)
}
fn handle_virtgpu_wait(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let w: DrmVirtgpu3dWait = (arg as *const DrmVirtgpu3dWait)
.vm_read(current)
.map_err(|_| VfsError::BadAddress)?;
if w.handle == 0 {
return Err(VfsError::InvalidInput);
}
let has_dumb = self
.dumbs
.lock()
.get(&w.handle)
.is_some_and(|buffer| buffer.owner == file.file_id);
let resource = self.resource_for_handle(file, w.handle);
if !has_dumb && resource.is_none() {
return Err(VfsError::NotFound);
}
let _last_fence = resource.map(|resource| resource.last_fence.load(Ordering::Acquire));
Ok(0)
}
fn handle_virtgpu_resource_create_blob(
&self,
file: &Card0File,
current: &UserTaskRef,
arg: usize,
) -> VfsResult<usize> {
let ptr = arg as *mut DrmVirtgpuResourceCreateBlob;
let mut b: DrmVirtgpuResourceCreateBlob =
ptr.vm_read(current).map_err(|_| VfsError::BadAddress)?;
if !ax_display::has_resource_blob() {
return Err(VfsError::InvalidInput);
}
if (b.blob_flags & !0x0007) != 0 {
return Err(VfsError::InvalidInput);
}
if (b.blob_flags & VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE) != 0 {
return Err(VfsError::InvalidInput);
}
let (guest_blob, host3d_blob) = match b.blob_mem {
VIRTGPU_BLOB_MEM_GUEST => (true, false),
VIRTGPU_BLOB_MEM_HOST3D_GUEST => (true, true),
VIRTGPU_BLOB_MEM_HOST3D => (false, true),
_ => {
return Err(VfsError::InvalidInput);
}
};
if host3d_blob {
if !ax_display::has_virgl() {
return Err(VfsError::InvalidInput);
}
if !b.cmd_size.is_multiple_of(4) {
return Err(VfsError::InvalidInput);
}
} else {
if b.blob_id != 0 || b.cmd_size != 0 {
return Err(VfsError::InvalidInput);
}
}
let ctx_id = if ax_display::has_virgl() {
let ctx_id = file.ensure_lazy_context()?;
if host3d_blob { ctx_id } else { 0 }
} else {
0
};
if b.cmd_size as usize > MAX_VIRGL_COMMAND_BYTES
|| (b.cmd_size > 0 && b.cmd == 0)
|| b.size == 0
|| b.size > DUMB_BUFFER_MAX_SIZE as u64
{
return Err(VfsError::InvalidInput);
}
let cmd_buf = if b.cmd_size == 0 {
Vec::new()
} else {
vm_load(current, b.cmd as *const u8, b.cmd_size as usize)
.map_err(|_| VfsError::BadAddress)?
};
let alloc_size = (b.size as usize).div_ceil(PAGE_SIZE_4K) * PAGE_SIZE_4K;
let pages = GlobalPage::alloc_contiguous(alloc_size / PAGE_SIZE_4K, PAGE_SIZE_4K)
.map_err(|_| VfsError::NoMemory)?;
unsafe {
core::ptr::write_bytes(pages.start_vaddr().as_ptr() as *mut u8, 0, alloc_size);
}
let backing = guest_blob.then(|| ax_display::BlobMemory {
paddr: virt_to_phys(pages.start_vaddr()).as_usize() as u64,
length: pages.size() as u32,
});
let pages = Arc::new(pages);
let bo_handle = self.next_dumb_handle.fetch_add(1, Ordering::Relaxed);
let offset = self
.next_offset
.fetch_add(DUMB_BUFFER_OFFSET_STRIDE, Ordering::Relaxed);
let res_handle = self.next_res_handle.fetch_add(1, Ordering::Relaxed);
ax_display::gpu3d_resource_create_blob(ax_display::ResourceCreateBlob {
ctx_id,
resource_id: res_handle,
blob_mem: b.blob_mem,
blob_flags: b.blob_flags,
size: b.size,
blob_id: b.blob_id,
backing,
cmd: &cmd_buf,
})
.map_err(map_gpu3d_err)?;
let resource = Arc::new(GpuResource {
owner: file.file_id,
res_handle,
bo_handle,
width: 0,
height: 0,
stride: 0,
size: b.size,
blob_mem: b.blob_mem,
blob_flags: b.blob_flags,
is_dumb_2d: false,
last_fence: AtomicU64::new(0),
});
if host3d_blob {
file.attach_resource(&resource)?;
}
let buffer = DumbBuffer {
owner: file.file_id,
width: 0,
height: 0,
bpp: 0,
pitch: 0,
size: b.size,
offset,
pages,
mappable: guest_blob,
resource: Some(resource.clone()),
};
b.bo_handle = bo_handle;
b.res_handle = res_handle;
if ptr.vm_write(current, b).is_err() {
if host3d_blob {
file.detach_resource(res_handle);
}
return Err(VfsError::BadAddress);
}
self.dumbs.lock().insert(bo_handle, buffer);
self.gpu_resources.lock().insert(res_handle, resource);
Ok(0)
}
}
fn object_type_of(id: u32) -> Option<u32> {
match id {
CRTC_ID => Some(DRM_MODE_OBJECT_CRTC),
CONNECTOR_ID => Some(DRM_MODE_OBJECT_CONNECTOR),
PLANE_ID => Some(DRM_MODE_OBJECT_PLANE),
_ => None,
}
}
fn map_gpu3d_err(err: ax_display::DisplayError) -> VfsError {
match err {
ax_display::DisplayError::NotSupported => VfsError::Unsupported,
ax_display::DisplayError::NotAvailable => VfsError::WouldBlock,
ax_display::DisplayError::Gpu3dError(kind) => match kind {
ax_display::Gpu3dErrorKind::InvalidParam => VfsError::InvalidInput,
ax_display::Gpu3dErrorKind::NotReady => VfsError::WouldBlock,
_ => VfsError::Io,
},
_ => VfsError::Io,
}
}
fn checked_i32(value: u64) -> VfsResult<i32> {
let v = value as i64;
if (i32::MIN as i64..=i32::MAX as i64).contains(&v) {
Ok(v as i32)
} else {
Err(VfsError::InvalidInput)
}
}
#[allow(dead_code)]
const _DUMB_BUFFER_FIELDS_USED: fn(&DumbBuffer) = |b| {
let _ = (b.width, b.height, b.bpp, b.pitch);
let _ = (b.size, b.offset, &b.pages);
};