monolith

public

Star0

Fork 0

Watch0

10 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7de49c2aa70b`

tarball

atagen <boss@atagen.co>2026-10-16 09:33 UTC

11 files changed+949-105

render-vk: import, render into and allocate dmabufs

Dmabuf images are acquired from the foreign queue family before each use and released after, so other devices and processes see coherent contents without implicit sync. Exporting a fence as a sync_file resets the Vulkan fence, so completion is tracked through the file afterwards. The renderer doubles as a smithay Allocator, which the nested backend uses for its swapchain.

Modified file: Cargo.lock+1

@@ -428,6 +428,7 @@ dependencies = [

428428 "ash",

429429 "glam",

430430 "gpu-allocator",

431+ "rustix",

431432 "smithay",

432433 "thiserror 2.0.21",

433434 ]

Modified file: crates/render-vk/Cargo.toml+1

@@ -11,6 +11,7 @@ workspace = true

1111 [dependencies]

1212 ash = "0.38"

1313 glam = { version = "0.33", default-features = false, features = ["std"] }

14+rustix = { version = "1", features = ["event"] }

1415 gpu-allocator = { version = "0.27", default-features = false, features = ["vulkan"] }

1516 smithay.workspace = true

1617 thiserror = "2"

Modified file: crates/render-vk/src/device.rs+35 additions−5 deletions@@ -11,18 +11,31 @@ pub(crate) struct Shared {
     pub device: Device,
 }
 
+/// Loaders for the extensions that dmabuf import, export and fence export
+/// need. Absent when the device lacks any of them.
+pub(crate) struct DmabufExt {
+    pub memory_fd: ash::khr::external_memory_fd::Device,
+    pub fence_fd: ash::khr::external_fence_fd::Device,
+    pub modifier: ash::ext::image_drm_format_modifier::Device,
+}
+
+const DMABUF_EXTENSIONS: [&std::ffi::CStr; 5] = [
+    ash::khr::external_memory_fd::NAME,
+    ash::ext::external_memory_dma_buf::NAME,
+    ash::ext::image_drm_format_modifier::NAME,
+    ash::ext::queue_family_foreign::NAME,
+    ash::khr::external_fence_fd::NAME,
+];
+
 pub(crate) struct Device {
     pub _entry: ash::Entry,
     pub instance: ash::Instance,
-    #[expect(
-        dead_code,
-        reason = "dmabuf import queries format properties through it"
-    )]
     pub physical: vk::PhysicalDevice,
     pub device: ash::Device,
     pub queue: Mutex<vk::Queue>,
     pub queue_family: u32,
     pub push_descriptor: ash::khr::push_descriptor::Device,
+    pub dmabuf: Option<DmabufExt>,
     pub name: String,
 }
 
@@ -61,7 +74,18 @@ impl Shared {
         let queues = [vk::DeviceQueueCreateInfo::default()
             .queue_family_index(queue_family)
             .queue_priorities(&priorities)];
-        let extensions = [ash::khr::push_descriptor::NAME.as_ptr()];
+        let available: Vec<_> = unsafe { instance.enumerate_device_extension_properties(physical) }
+            .unwrap_or_default()
+            .iter()
+            .filter_map(|e| e.extension_name_as_c_str().ok().map(ToOwned::to_owned))
+            .collect();
+        let has_dmabuf = DMABUF_EXTENSIONS
+            .iter()
+            .all(|n| available.iter().any(|a| a.as_c_str() == *n));
+        let mut extensions = vec![ash::khr::push_descriptor::NAME.as_ptr()];
+        if has_dmabuf {
+            extensions.extend(DMABUF_EXTENSIONS.iter().map(|n| n.as_ptr()));
+        }
         let mut features13 = vk::PhysicalDeviceVulkan13Features::default()
             .dynamic_rendering(true)
             .synchronization2(true);
@@ -78,6 +102,11 @@ impl Shared {
         };
         let queue = unsafe { device.get_device_queue(queue_family, 0) };
         let push_descriptor = ash::khr::push_descriptor::Device::new(&instance, &device);
+        let dmabuf = has_dmabuf.then(|| DmabufExt {
+            memory_fd: ash::khr::external_memory_fd::Device::new(&instance, &device),
+            fence_fd: ash::khr::external_fence_fd::Device::new(&instance, &device),
+            modifier: ash::ext::image_drm_format_modifier::Device::new(&instance, &device),
+        });
         let allocator = Allocator::new(&AllocatorCreateDesc {
             instance: instance.clone(),
             device: device.clone(),
@@ -94,6 +123,7 @@ impl Shared {
             queue: Mutex::new(queue),
             queue_family,
             push_descriptor,
+            dmabuf,
             name,
         };
         Ok(Self {

Added file: crates/render-vk/src/dmabuf.rs+392 additions@@ -0,0 +1,392 @@
+use crate::Error;
+use crate::device::Shared;
+use crate::format::{SUPPORTED, vk_format};
+use crate::image::{ImageInner, Memory};
+use ash::vk;
+use smithay::backend::allocator::dmabuf::{Dmabuf, DmabufFlags};
+use smithay::backend::allocator::format::FormatSet;
+use smithay::backend::allocator::{Allocator, Buffer, Format, Fourcc, Modifier};
+use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd};
+use std::sync::Arc;
+
+/// Which (format, modifier) pairs the device can import for sampling and
+/// render into, queried once at startup.
+#[derive(Debug, Default)]
+pub(crate) struct DmabufCaps {
+    pub sample: FormatSet,
+    pub render: FormatSet,
+}
+
+pub(crate) const RENDER_USAGE: vk::ImageUsageFlags = vk::ImageUsageFlags::from_raw(
+    vk::ImageUsageFlags::COLOR_ATTACHMENT.as_raw()
+        | vk::ImageUsageFlags::SAMPLED.as_raw()
+        | vk::ImageUsageFlags::TRANSFER_SRC.as_raw(),
+);
+pub(crate) const SAMPLE_USAGE: vk::ImageUsageFlags = vk::ImageUsageFlags::SAMPLED;
+
+impl DmabufCaps {
+    pub fn query(shared: &Shared) -> Self {
+        if shared.device.dmabuf.is_none() {
+            return Self::default();
+        }
+        let (mut sample, mut render) = (Vec::new(), Vec::new());
+        for fourcc in SUPPORTED {
+            let Some(fmt) = vk_format(fourcc) else {
+                continue;
+            };
+            for props in modifier_properties(shared, fmt.format) {
+                if props.drm_format_modifier_plane_count != 1 {
+                    continue;
+                }
+                let features = props.drm_format_modifier_tiling_features;
+                let format = Format {
+                    code: fourcc,
+                    modifier: Modifier::from(props.drm_format_modifier),
+                };
+                let supports =
+                    |usage| external_support(shared, fmt.format, props.drm_format_modifier, usage);
+                if features.contains(vk::FormatFeatureFlags::SAMPLED_IMAGE)
+                    && supports(SAMPLE_USAGE).importable
+                {
+                    sample.push(format);
+                }
+                let renderable = vk::FormatFeatureFlags::COLOR_ATTACHMENT
+                    | vk::FormatFeatureFlags::COLOR_ATTACHMENT_BLEND;
+                let s = supports(RENDER_USAGE);
+                if features.contains(renderable) && s.importable && s.exportable {
+                    render.push(format);
+                }
+            }
+        }
+        Self {
+            sample: sample.into_iter().collect(),
+            render: render.into_iter().collect(),
+        }
+    }
+}
+
+fn modifier_properties(
+    shared: &Shared,
+    format: vk::Format,
+) -> Vec<vk::DrmFormatModifierPropertiesEXT> {
+    let dev = &shared.device;
+    let mut list = vk::DrmFormatModifierPropertiesListEXT::default();
+    let mut props = vk::FormatProperties2::default().push_next(&mut list);
+    unsafe {
+        dev.instance
+            .get_physical_device_format_properties2(dev.physical, format, &mut props)
+    };
+    let count = list.drm_format_modifier_count as usize;
+    let mut out = vec![vk::DrmFormatModifierPropertiesEXT::default(); count];
+    let mut list =
+        vk::DrmFormatModifierPropertiesListEXT::default().drm_format_modifier_properties(&mut out);
+    let mut props = vk::FormatProperties2::default().push_next(&mut list);
+    unsafe {
+        dev.instance
+            .get_physical_device_format_properties2(dev.physical, format, &mut props)
+    };
+    out
+}
+
+struct External {
+    importable: bool,
+    exportable: bool,
+}
+
+fn external_support(
+    shared: &Shared,
+    format: vk::Format,
+    modifier: u64,
+    usage: vk::ImageUsageFlags,
+) -> External {
+    let dev = &shared.device;
+    let mut modifier_info = vk::PhysicalDeviceImageDrmFormatModifierInfoEXT::default()
+        .drm_format_modifier(modifier)
+        .sharing_mode(vk::SharingMode::EXCLUSIVE);
+    let mut external_info = vk::PhysicalDeviceExternalImageFormatInfo::default()
+        .handle_type(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
+    let info = vk::PhysicalDeviceImageFormatInfo2::default()
+        .format(format)
+        .ty(vk::ImageType::TYPE_2D)
+        .tiling(vk::ImageTiling::DRM_FORMAT_MODIFIER_EXT)
+        .usage(usage)
+        .push_next(&mut external_info)
+        .push_next(&mut modifier_info);
+    let mut external_props = vk::ExternalImageFormatProperties::default();
+    let mut props = vk::ImageFormatProperties2::default().push_next(&mut external_props);
+    let ok = unsafe {
+        dev.instance
+            .get_physical_device_image_format_properties2(dev.physical, &info, &mut props)
+    }
+    .is_ok();
+    let features = external_props
+        .external_memory_properties
+        .external_memory_features;
+    External {
+        importable: ok && features.contains(vk::ExternalMemoryFeatureFlags::IMPORTABLE),
+        exportable: ok && features.contains(vk::ExternalMemoryFeatureFlags::EXPORTABLE),
+    }
+}
+
+fn memory_type(shared: &Shared, bits: u32, prefer: vk::MemoryPropertyFlags) -> Option<u32> {
+    let props = unsafe {
+        shared
+            .device
+            .instance
+            .get_physical_device_memory_properties(shared.device.physical)
+    };
+    let types = &props.memory_types[..props.memory_type_count as usize];
+    let allowed = |i: usize| bits & (1 << i) != 0;
+    (0..types.len())
+        .find(|&i| allowed(i) && types[i].property_flags.contains(prefer))
+        .or_else(|| (0..types.len()).find(|&i| allowed(i)))
+        .map(|i| i as u32)
+}
+
+fn image_info<'a>(
+    fourcc: Fourcc,
+    size: (u32, u32),
+    usage: vk::ImageUsageFlags,
+) -> Result<vk::ImageCreateInfo<'a>, Error> {
+    let fmt = vk_format(fourcc).ok_or(Error::UnsupportedFormat(fourcc))?;
+    Ok(vk::ImageCreateInfo::default()
+        .image_type(vk::ImageType::TYPE_2D)
+        .format(fmt.format)
+        .extent(vk::Extent3D {
+            width: size.0,
+            height: size.1,
+            depth: 1,
+        })
+        .mip_levels(1)
+        .array_layers(1)
+        .samples(vk::SampleCountFlags::TYPE_1)
+        .tiling(vk::ImageTiling::DRM_FORMAT_MODIFIER_EXT)
+        .usage(usage)
+        .sharing_mode(vk::SharingMode::EXCLUSIVE)
+        .initial_layout(vk::ImageLayout::UNDEFINED))
+}
+
+/// Imports a single-plane dmabuf as an image, without copying.
+pub(crate) fn import(
+    shared: &Arc<Shared>,
+    caps: &DmabufCaps,
+    dmabuf: &Dmabuf,
+    usage: vk::ImageUsageFlags,
+) -> Result<Arc<ImageInner>, Error> {
+    let ext = shared
+        .device
+        .dmabuf
+        .as_ref()
+        .ok_or(Error::DmabufUnsupported)?;
+    let format = dmabuf.format();
+    let set = if usage.contains(vk::ImageUsageFlags::COLOR_ATTACHMENT) {
+        &caps.render
+    } else {
+        &caps.sample
+    };
+    if dmabuf.num_planes() != 1 || !set.contains(&format) {
+        return Err(Error::UnsupportedDmabuf(format));
+    }
+    let (Some(fd), Some(offset), Some(stride)) = (
+        dmabuf.handles().next(),
+        dmabuf.offsets().next(),
+        dmabuf.strides().next(),
+    ) else {
+        return Err(Error::UnsupportedDmabuf(format));
+    };
+    let size = (dmabuf.width(), dmabuf.height());
+    let d = &shared.device.device;
+    let layouts = [vk::SubresourceLayout {
+        offset: u64::from(offset),
+        size: 0,
+        row_pitch: u64::from(stride),
+        array_pitch: 0,
+        depth_pitch: 0,
+    }];
+    let mut explicit = vk::ImageDrmFormatModifierExplicitCreateInfoEXT::default()
+        .drm_format_modifier(u64::from(format.modifier))
+        .plane_layouts(&layouts);
+    let mut external = vk::ExternalMemoryImageCreateInfo::default()
+        .handle_types(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
+    let info = image_info(format.code, size, usage)?
+        .push_next(&mut external)
+        .push_next(&mut explicit);
+    let image = unsafe { d.create_image(&info, None)? };
+    let destroy = || unsafe { d.destroy_image(image, None) };
+    let owned = match fd.try_clone_to_owned() {
+        Ok(o) => o,
+        Err(_) => {
+            destroy();
+            return Err(Error::UnsupportedDmabuf(format));
+        }
+    };
+    let mut fd_props = vk::MemoryFdPropertiesKHR::default();
+    if let Err(e) = unsafe {
+        ext.memory_fd.get_memory_fd_properties(
+            vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT,
+            owned.as_raw_fd(),
+            &mut fd_props,
+        )
+    } {
+        destroy();
+        return Err(e.into());
+    }
+    let requirements = unsafe { d.get_image_memory_requirements(image) };
+    let Some(type_index) = memory_type(
+        shared,
+        requirements.memory_type_bits & fd_props.memory_type_bits,
+        vk::MemoryPropertyFlags::empty(),
+    ) else {
+        destroy();
+        return Err(Error::UnsupportedDmabuf(format));
+    };
+    let raw = owned.into_raw_fd();
+    let mut import = vk::ImportMemoryFdInfoKHR::default()
+        .handle_type(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT)
+        .fd(raw);
+    let mut dedicated = vk::MemoryDedicatedAllocateInfo::default().image(image);
+    let alloc = vk::MemoryAllocateInfo::default()
+        .allocation_size(requirements.size)
+        .memory_type_index(type_index)
+        .push_next(&mut import)
+        .push_next(&mut dedicated);
+    let memory = match unsafe { d.allocate_memory(&alloc, None) } {
+        Ok(m) => m,
+        Err(e) => {
+            drop(unsafe { OwnedFd::from_raw_fd(raw) });
+            destroy();
+            return Err(e.into());
+        }
+    };
+    ImageInner::finish(
+        shared,
+        image,
+        Memory::Imported(memory),
+        memory,
+        0,
+        format.code,
+        size.0,
+        size.1,
+        true,
+    )
+}
+
+/// Allocates a dmabuf the device can render into, picking among `modifiers`.
+pub(crate) fn export(
+    shared: &Arc<Shared>,
+    caps: &DmabufCaps,
+    fourcc: Fourcc,
+    size: (u32, u32),
+    modifiers: &[Modifier],
+) -> Result<Dmabuf, Error> {
+    let ext = shared
+        .device
+        .dmabuf
+        .as_ref()
+        .ok_or(Error::DmabufUnsupported)?;
+    let allowed: Vec<u64> = modifiers
+        .iter()
+        .filter(|&&modifier| {
+            caps.render.contains(&Format {
+                code: fourcc,
+                modifier,
+            })
+        })
+        .map(|&m| u64::from(m))
+        .collect();
+    if allowed.is_empty() {
+        return Err(Error::UnsupportedFormat(fourcc));
+    }
+    let d = &shared.device.device;
+    let mut list =
+        vk::ImageDrmFormatModifierListCreateInfoEXT::default().drm_format_modifiers(&allowed);
+    let mut external = vk::ExternalMemoryImageCreateInfo::default()
+        .handle_types(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
+    let info = image_info(fourcc, size, RENDER_USAGE)?
+        .push_next(&mut external)
+        .push_next(&mut list);
+    let image = unsafe { d.create_image(&info, None)? };
+    let result = (|| -> Result<Dmabuf, Error> {
+        let requirements = unsafe { d.get_image_memory_requirements(image) };
+        let type_index = memory_type(
+            shared,
+            requirements.memory_type_bits,
+            vk::MemoryPropertyFlags::DEVICE_LOCAL,
+        )
+        .ok_or(Error::UnsupportedFormat(fourcc))?;
+        let mut export = vk::ExportMemoryAllocateInfo::default()
+            .handle_types(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT);
+        let mut dedicated = vk::MemoryDedicatedAllocateInfo::default().image(image);
+        let alloc = vk::MemoryAllocateInfo::default()
+            .allocation_size(requirements.size)
+            .memory_type_index(type_index)
+            .push_next(&mut export)
+            .push_next(&mut dedicated);
+        let memory = unsafe { d.allocate_memory(&alloc, None)? };
+        let exported = (|| -> Result<Dmabuf, Error> {
+            unsafe { d.bind_image_memory(image, memory, 0)? };
+            let raw = unsafe {
+                ext.memory_fd.get_memory_fd(
+                    &vk::MemoryGetFdInfoKHR::default()
+                        .memory(memory)
+                        .handle_type(vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT),
+                )?
+            };
+            let fd = unsafe { OwnedFd::from_raw_fd(raw) };
+            let mut props = vk::ImageDrmFormatModifierPropertiesEXT::default();
+            unsafe {
+                ext.modifier
+                    .get_image_drm_format_modifier_properties(image, &mut props)?
+            };
+            let layout = unsafe {
+                d.get_image_subresource_layout(
+                    image,
+                    vk::ImageSubresource::default()
+                        .aspect_mask(vk::ImageAspectFlags::MEMORY_PLANE_0_EXT),
+                )
+            };
+            let mut builder = Dmabuf::builder(
+                (size.0 as i32, size.1 as i32),
+                fourcc,
+                Modifier::from(props.drm_format_modifier),
+                DmabufFlags::empty(),
+            );
+            builder.add_plane(fd, layout.offset as u32, layout.row_pitch as u32);
+            builder.build().ok_or(Error::UnsupportedFormat(fourcc))
+        })();
+        unsafe { d.free_memory(memory, None) };
+        exported
+    })();
+    unsafe { d.destroy_image(image, None) };
+    result
+}
+
+/// Allocates render-capable dmabufs, for swapchains.
+#[derive(Clone, Debug)]
+pub struct VulkanAllocator {
+    pub(crate) shared: Arc<Shared>,
+    pub(crate) caps: Arc<DmabufCaps>,
+}
+
+impl Allocator for VulkanAllocator {
+    type Buffer = Dmabuf;
+    type Error = Error;
+
+    fn create_buffer(
+        &mut self,
+        width: u32,
+        height: u32,
+        fourcc: Fourcc,
+        modifiers: &[Modifier],
+    ) -> Result<Dmabuf, Error> {
+        export(&self.shared, &self.caps, fourcc, (width, height), modifiers)
+    }
+}
+
+impl std::fmt::Debug for Shared {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Shared")
+            .field("device", &self.device.name)
+            .finish()
+    }
+}

Modified file: crates/render-vk/src/error.rs+4 additions@@ -17,6 +17,10 @@ pub enum Error {
     BufferTooSmall { needed: usize, got: usize },
     #[error("texture belongs to a different renderer")]
     ForeignTexture,
+    #[error("the device cannot share memory through dmabufs")]
+    DmabufUnsupported,
+    #[error("cannot import dmabuf with format {0:?}")]
+    UnsupportedDmabuf(smithay::backend::allocator::Format),
     #[error("interrupted while waiting for a sync point")]
     Interrupted,
     #[error("invalid size {0}x{1}")]

Modified file: crates/render-vk/src/frame.rs+1−1

@@ -159,7 +159,7 @@ impl Frame for VulkanFrame<'_, '_> {

159159 if !Arc::ptr_eq(&texture.0.shared, self.renderer.shared()) {

160160 return Err(Error::ForeignTexture);

161161 }

162- if dst.size.w <= 0 || dst.size.h <= 0 || Arc::ptr_eq(&texture.0, &self.target.0.0) {

162+ if dst.size.w <= 0 || dst.size.h <= 0 || Arc::ptr_eq(&texture.0, &self.target.0) {

163163 return Ok(());

164164 }

165165 let scissors = self.scissors(dst, damage);

Modified file: crates/render-vk/src/image.rs+74 additions−29 deletions@@ -7,18 +7,28 @@ use gpu_allocator::vulkan::{Allocation, AllocationCreateDesc, AllocationScheme};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::{Texture, TextureMapping};
 use std::fmt;
+use std::marker::PhantomData;
 use std::sync::{Arc, Mutex};
 
+pub(crate) enum Memory {
+    Allocated(Allocation),
+    /// Memory imported from a dmabuf, owned directly.
+    Imported(vk::DeviceMemory),
+}
+
 pub(crate) struct ImageInner {
     pub shared: Arc<Shared>,
     pub image: vk::Image,
     pub view: vk::ImageView,
-    pub allocation: Mutex<Option<Allocation>>,
+    pub memory: Mutex<Option<Memory>>,
     pub fourcc: Fourcc,
     pub format: vk::Format,
     pub width: u32,
     pub height: u32,
     pub layout: Mutex<vk::ImageLayout>,
+    /// Shared with other devices or processes through a dmabuf. Every use
+    /// acquires the image from the foreign queue family and releases it after.
+    pub external: bool,
 }
 
 impl fmt::Debug for ImageInner {
@@ -27,6 +37,7 @@ impl fmt::Debug for ImageInner {
             .field("image", &self.image)
             .field("fourcc", &self.fourcc)
             .field("size", &(self.width, self.height))
+            .field("external", &self.external)
             .finish()
     }
 }
@@ -38,18 +49,17 @@ impl Drop for ImageInner {
             d.destroy_image_view(self.view, None);
             d.destroy_image(self.image, None);
         }
-        if let Some(a) = self
-            .allocation
-            .lock()
-            .unwrap_or_else(|e| e.into_inner())
-            .take()
-        {
-            let _ = self
-                .shared
-                .allocator
-                .lock()
-                .unwrap_or_else(|e| e.into_inner())
-                .free(a);
+        match self.memory.lock().unwrap_or_else(|e| e.into_inner()).take() {
+            Some(Memory::Allocated(a)) => {
+                let _ = self
+                    .shared
+                    .allocator
+                    .lock()
+                    .unwrap_or_else(|e| e.into_inner())
+                    .free(a);
+            }
+            Some(Memory::Imported(m)) => unsafe { d.free_memory(m, None) },
+            None => {}
         }
     }
 }
@@ -101,25 +111,57 @@ impl ImageInner {
                 return Err(e.into());
             }
         };
-        unsafe { d.bind_image_memory(image, allocation.memory(), allocation.offset())? };
-        let view_info = vk::ImageViewCreateInfo::default()
-            .image(image)
-            .view_type(vk::ImageViewType::TYPE_2D)
-            .format(fmt.format)
-            .components(components(fmt.opaque))
-            .subresource_range(color_range());
-        let view = unsafe { d.create_image_view(&view_info, None)? };
-        Ok(Arc::new(Self {
+        let memory = Memory::Allocated(allocation);
+        let (mem, offset) = match &memory {
+            Memory::Allocated(a) => (unsafe { a.memory() }, a.offset()),
+            Memory::Imported(m) => (*m, 0),
+        };
+        Self::finish(
+            shared, image, memory, mem, offset, fourcc, width, height, false,
+        )
+    }
+
+    /// Binds memory, creates the view and wraps everything up. Takes
+    /// ownership of `image` and `memory`, releasing both on failure.
+    #[expect(clippy::too_many_arguments)]
+    pub fn finish(
+        shared: &Arc<Shared>,
+        image: vk::Image,
+        memory: Memory,
+        mem: vk::DeviceMemory,
+        offset: u64,
+        fourcc: Fourcc,
+        width: u32,
+        height: u32,
+        external: bool,
+    ) -> Result<Arc<Self>, Error> {
+        let fmt = vk_format(fourcc).ok_or(Error::UnsupportedFormat(fourcc))?;
+        let d = &shared.device.device;
+        let mut inner = Self {
             shared: shared.clone(),
             image,
-            view,
-            allocation: Mutex::new(Some(allocation)),
+            view: vk::ImageView::null(),
+            memory: Mutex::new(Some(memory)),
             fourcc,
             format: fmt.format,
             width,
             height,
-            layout: Mutex::new(vk::ImageLayout::UNDEFINED),
-        }))
+            layout: Mutex::new(if external {
+                vk::ImageLayout::GENERAL
+            } else {
+                vk::ImageLayout::UNDEFINED
+            }),
+            external,
+        };
+        unsafe { d.bind_image_memory(image, mem, offset)? };
+        let view_info = vk::ImageViewCreateInfo::default()
+            .image(image)
+            .view_type(vk::ImageViewType::TYPE_2D)
+            .format(fmt.format)
+            .components(components(fmt.opaque))
+            .subresource_range(color_range());
+        inner.view = unsafe { d.create_image_view(&view_info, None)? };
+        Ok(Arc::new(inner))
     }
 
     pub fn layout(&self) -> vk::ImageLayout {
@@ -232,9 +274,12 @@ impl VulkanImage {
     }
 }
 
-/// A bound render target.
+/// A bound render target, borrowing whatever it was bound from.
 #[derive(Debug)]
-pub struct VulkanTarget<'a>(pub(crate) &'a mut VulkanImage);
+pub struct VulkanTarget<'a>(
+    pub(crate) Arc<ImageInner>,
+    pub(crate) PhantomData<&'a mut ()>,
+);
 
 /// Pixels read back from the GPU.
 #[derive(Debug)]
@@ -266,7 +311,7 @@ macro_rules! texture_impl {
 
 texture_impl!(VulkanTexture, |s| s.0);
 texture_impl!(VulkanImage, |s| s.0);
-texture_impl!(VulkanTarget<'_>, |s| s.0.0);
+texture_impl!(VulkanTarget<'_>, |s| s.0);
 texture_impl!(VulkanMapping, |s| s);
 
 impl TextureMapping for VulkanMapping {

Modified file: crates/render-vk/src/lib.rs+2 additions@@ -4,6 +4,7 @@
 //! command buffer when it finishes, returning a fence as its sync point.
 
 mod device;
+mod dmabuf;
 mod error;
 mod format;
 mod frame;
@@ -13,6 +14,7 @@ mod renderer;
 mod sync;
 mod transform;
 
+pub use dmabuf::VulkanAllocator;
 pub use error::Error;
 pub use frame::VulkanFrame;
 pub use image::{VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};

Modified file: crates/render-vk/src/renderer.rs+229 additions−52 deletions@@ -1,5 +1,6 @@
 use crate::Error;
 use crate::device::Shared;
+use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};
 use crate::format::{BYTES_PER_PIXEL, SUPPORTED};
 use crate::frame::{Op, VulkanFrame};
 use crate::image::{
@@ -10,23 +11,29 @@ use crate::sync::{FenceInner, VkFence};
 use ash::vk;
 use gpu_allocator::MemoryLocation;
 use smithay::backend::allocator::Fourcc;
+use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
+use smithay::backend::allocator::format::FormatSet;
 use smithay::backend::renderer::sync::SyncPoint;
 use smithay::backend::renderer::{
-    Bind, ContextId, DebugFlags, ExportMem, ImportMem, Offscreen, Renderer, RendererSuper, Texture,
-    TextureFilter,
+    Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,
+    RendererSuper, Texture, TextureFilter,
 };
 use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};
+use std::collections::HashMap;
 use std::fmt;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 struct Pending {
     fence: Arc<FenceInner>,
     cmd: vk::CommandBuffer,
-    _keep: Vec<VulkanTexture>,
+    _keep: Vec<Arc<ImageInner>>,
 }
 
 pub struct VulkanRenderer {
     pending: Vec<Pending>,
+    dmabuf_textures: HashMap<WeakDmabuf, VulkanTexture>,
+    dmabuf_targets: HashMap<WeakDmabuf, Arc<ImageInner>>,
     pipelines: Pipelines,
     pool: vk::CommandPool,
     samplers: [vk::Sampler; 4],
@@ -34,6 +41,7 @@ pub struct VulkanRenderer {
     mag_filter: TextureFilter,
     debug: DebugFlags,
     context: ContextId<VulkanTexture>,
+    caps: Arc<DmabufCaps>,
     shared: Arc<Shared>,
 }
 
@@ -78,6 +86,8 @@ impl VulkanRenderer {
         }
         Ok(Self {
             pending: Vec::new(),
+            dmabuf_textures: HashMap::new(),
+            dmabuf_targets: HashMap::new(),
             pipelines: Pipelines::new(&shared)?,
             pool,
             samplers,
@@ -85,6 +95,7 @@ impl VulkanRenderer {
             mag_filter: TextureFilter::Linear,
             debug: DebugFlags::empty(),
             context: ContextId::new(),
+            caps: Arc::new(DmabufCaps::query(&shared)),
             shared,
         })
     }
@@ -94,6 +105,24 @@ impl VulkanRenderer {
         &self.shared.device.name
     }
 
+    /// Whether dmabufs can be imported, rendered into and allocated.
+    pub fn supports_dmabuf(&self) -> bool {
+        self.caps.render.iter().next().is_some()
+    }
+
+    /// Formats and modifiers this renderer can render into as dmabufs.
+    pub fn render_formats(&self) -> FormatSet {
+        self.caps.render.clone()
+    }
+
+    /// An allocator for render-capable dmabufs on this device.
+    pub fn allocator(&self) -> VulkanAllocator {
+        VulkanAllocator {
+            shared: self.shared.clone(),
+            caps: self.caps.clone(),
+        }
+    }
+
     pub(crate) fn shared(&self) -> &Arc<Shared> {
         &self.shared
     }
@@ -117,6 +146,8 @@ impl VulkanRenderer {
             unsafe { d.free_command_buffers(pool, &[p.cmd]) };
             false
         });
+        self.dmabuf_textures.retain(|k, _| !k.is_gone());
+        self.dmabuf_targets.retain(|k, _| !k.is_gone());
     }
 
     fn begin(&self) -> Result<vk::CommandBuffer, Error> {
@@ -151,17 +182,21 @@ impl VulkanRenderer {
             .queue
             .lock()
             .unwrap_or_else(|e| e.into_inner());
-        unsafe { d.queue_submit2(*queue, &[submit], fence.fence)? };
+        unsafe { d.queue_submit2(*queue, &[submit], fence.fence())? };
         Ok(fence)
     }
 
     /// Records, submits and waits for a short command buffer.
     fn one_shot(
         &mut self,
-        record: impl FnOnce(&ash::Device, vk::CommandBuffer),
+        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),
     ) -> Result<(), Error> {
         let cmd = self.begin()?;
-        record(&self.shared.device.device, cmd);
+        record(
+            &self.shared.device.device,
+            cmd,
+            self.shared.device.queue_family,
+        );
         let fence = self.end_and_submit(cmd)?;
         let res = fence.wait();
         unsafe {
@@ -179,18 +214,15 @@ impl VulkanRenderer {
         ops: Vec<Op>,
     ) -> Result<SyncPoint, Error> {
         self.reap();
-        let image = target.0.0.clone();
-        let mut keep = vec![VulkanTexture(image.clone())];
-        let mut transitions = Vec::new();
+        let image = target.0.clone();
+        let mut sampled: Vec<Arc<ImageInner>> = Vec::new();
         for op in &ops {
             if let Op::Draw {
                 texture: Some(t), ..
             } = op
+                && !sampled.iter().any(|s| Arc::ptr_eq(s, &t.0))
             {
-                if t.0.layout() != vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL {
-                    transitions.push(t.clone());
-                }
-                keep.push(t.clone());
+                sampled.push(t.0.clone());
             }
         }
         let mut pipelines = Vec::with_capacity(ops.len());
@@ -202,25 +234,19 @@ impl VulkanRenderer {
         }
         let cmd = self.begin()?;
         let d = &self.shared.device.device;
+        let family = self.shared.device.queue_family;
         let push = &self.shared.device.push_descriptor;
         let (w, h) = (image.width, image.height);
         let sampler = self.sampler();
         unsafe {
-            for t in &transitions {
-                barrier(
-                    d,
-                    cmd,
-                    t.0.image,
-                    t.0.layout(),
-                    vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
-                );
-                t.0.set_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
+            for t in &sampled {
+                acquire(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
             }
-            barrier(
+            acquire(
                 d,
                 cmd,
-                image.image,
-                image.layout(),
+                family,
+                &image,
                 vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
             );
             let attachments = [vk::RenderingAttachmentInfo::default()
@@ -318,13 +344,23 @@ impl VulkanRenderer {
                 }
             }
             d.cmd_end_rendering(cmd);
+            release(
+                d,
+                cmd,
+                family,
+                &image,
+                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
+            );
+            for t in &sampled {
+                release(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
+            }
         }
-        image.set_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
         let fence = self.end_and_submit(cmd)?;
+        sampled.push(image);
         self.pending.push(Pending {
             fence: fence.clone(),
             cmd,
-            _keep: keep,
+            _keep: sampled,
         });
         Ok(SyncPoint::from(VkFence(fence)))
     }
@@ -336,6 +372,9 @@ impl VulkanRenderer {
         region: Rectangle<i32, Buffer>,
         flipped: bool,
     ) -> Result<(), Error> {
+        if image.external {
+            return Err(Error::ForeignTexture);
+        }
         let width = image.width as usize;
         let needed = width * image.height as usize * BYTES_PER_PIXEL;
         if data.len() < needed {
@@ -357,7 +396,6 @@ impl VulkanRenderer {
             let from = if flipped { rows - 1 - y } else { y };
             dst[y * row..(y + 1) * row].copy_from_slice(&data[from * row..(from + 1) * row]);
         }
-        let old = image.layout();
         let copy = vk::BufferImageCopy::default()
             .buffer_offset(
                 ((region.loc.y as usize * width + region.loc.x as usize) * BYTES_PER_PIXEL) as u64,
@@ -378,26 +416,31 @@ impl VulkanRenderer {
                 height: region.size.h as u32,
                 depth: 1,
             });
-        let (img, buffer) = (image.image, staging.buffer);
-        self.one_shot(|d, cmd| unsafe {
-            barrier(d, cmd, img, old, vk::ImageLayout::TRANSFER_DST_OPTIMAL);
+        let buffer = staging.buffer;
+        let target = image.clone();
+        self.one_shot(|d, cmd, family| unsafe {
+            acquire(
+                d,
+                cmd,
+                family,
+                &target,
+                vk::ImageLayout::TRANSFER_DST_OPTIMAL,
+            );
             d.cmd_copy_buffer_to_image(
                 cmd,
                 buffer,
-                img,
+                target.image,
                 vk::ImageLayout::TRANSFER_DST_OPTIMAL,
                 &[copy],
             );
-            barrier(
+            acquire(
                 d,
                 cmd,
-                img,
-                vk::ImageLayout::TRANSFER_DST_OPTIMAL,
+                family,
+                &target,
                 vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
             );
-        })?;
-        image.set_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
-        Ok(())
+        })
     }
 
     fn read_back(
@@ -421,7 +464,6 @@ impl VulkanRenderer {
             MemoryLocation::GpuToCpu,
         )?;
         if w > 0 && h > 0 {
-            let old = image.layout();
             let copy = vk::BufferImageCopy::default()
                 .image_subresource(
                     vk::ImageSubresourceLayers::default()
@@ -438,18 +480,31 @@ impl VulkanRenderer {
                     height: h,
                     depth: 1,
                 });
-            let (img, buffer) = (image.image, staging.buffer);
-            self.one_shot(|d, cmd| unsafe {
-                barrier(d, cmd, img, old, vk::ImageLayout::TRANSFER_SRC_OPTIMAL);
+            let buffer = staging.buffer;
+            let source = image.clone();
+            self.one_shot(|d, cmd, family| unsafe {
+                acquire(
+                    d,
+                    cmd,
+                    family,
+                    &source,
+                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                );
                 d.cmd_copy_image_to_buffer(
                     cmd,
-                    img,
+                    source.image,
                     vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
                     buffer,
                     &[copy],
                 );
+                release(
+                    d,
+                    cmd,
+                    family,
+                    &source,
+                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
+                );
             })?;
-            image.set_layout(vk::ImageLayout::TRANSFER_SRC_OPTIMAL);
         }
         let mut data = staging.bytes()[..w as usize * h as usize * BYTES_PER_PIXEL].to_vec();
         if swap {
@@ -498,14 +553,17 @@ fn sampler_filter(bit: usize) -> TextureFilter {
     }
 }
 
-/// A full barrier between all earlier and later work on the image. Coarse,
-/// but correct for every transition the renderer makes.
+/// A full barrier between all earlier and later work on the image, optionally
+/// transferring ownership between queue families. Coarse, but correct for
+/// every transition the renderer makes.
 unsafe fn barrier(
     d: &ash::Device,
     cmd: vk::CommandBuffer,
     image: vk::Image,
     old: vk::ImageLayout,
     new: vk::ImageLayout,
+    src_family: u32,
+    dst_family: u32,
 ) {
     let b = [vk::ImageMemoryBarrier2::default()
         .src_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)
@@ -514,6 +572,8 @@ unsafe fn barrier(
         .dst_access_mask(vk::AccessFlags2::MEMORY_READ | vk::AccessFlags2::MEMORY_WRITE)
         .old_layout(old)
         .new_layout(new)
+        .src_queue_family_index(src_family)
+        .dst_queue_family_index(dst_family)
         .image(image)
         .subresource_range(color_range())];
     unsafe {
@@ -524,6 +584,70 @@ unsafe fn barrier(
     };
 }
 
+/// Moves an image into `layout` for use on this queue. Dmabuf images come
+/// from the foreign queue family in the general layout, others continue from
+/// their tracked layout.
+unsafe fn acquire(
+    d: &ash::Device,
+    cmd: vk::CommandBuffer,
+    family: u32,
+    image: &ImageInner,
+    layout: vk::ImageLayout,
+) {
+    if image.external {
+        unsafe {
+            barrier(
+                d,
+                cmd,
+                image.image,
+                vk::ImageLayout::GENERAL,
+                layout,
+                vk::QUEUE_FAMILY_FOREIGN_EXT,
+                family,
+            )
+        };
+    } else {
+        let old = image.layout();
+        if old != layout {
+            unsafe {
+                barrier(
+                    d,
+                    cmd,
+                    image.image,
+                    old,
+                    layout,
+                    vk::QUEUE_FAMILY_IGNORED,
+                    vk::QUEUE_FAMILY_IGNORED,
+                )
+            };
+            image.set_layout(layout);
+        }
+    }
+}
+
+/// Hands a dmabuf image back to the foreign queue family after use.
+unsafe fn release(
+    d: &ash::Device,
+    cmd: vk::CommandBuffer,
+    family: u32,
+    image: &ImageInner,
+    layout: vk::ImageLayout,
+) {
+    if image.external {
+        unsafe {
+            barrier(
+                d,
+                cmd,
+                image.image,
+                layout,
+                vk::ImageLayout::GENERAL,
+                family,
+                vk::QUEUE_FAMILY_FOREIGN_EXT,
+            )
+        };
+    }
+}
+
 /// Whether reading `from` as `to` needs red and blue swapped.
 fn needs_swizzle(from: Fourcc, to: Fourcc) -> Result<bool, Error> {
     let bgr = |f: Fourcc| match f {
@@ -577,7 +701,7 @@ impl Renderer for VulkanRenderer {
     where
         'buffer: 'frame,
     {
-        self.own(&framebuffer.0.0)?;
+        self.own(&framebuffer.0)?;
         self.reap();
         Ok(VulkanFrame::new(
             self,
@@ -595,12 +719,38 @@ impl Renderer for VulkanRenderer {
         self.reap();
         Ok(())
     }
+
+    fn invalidate_caches(&mut self) -> Result<(), Error> {
+        self.reap();
+        self.dmabuf_textures.clear();
+        self.dmabuf_targets.clear();
+        Ok(())
+    }
 }
 
 impl Bind<VulkanImage> for VulkanRenderer {
     fn bind<'a>(&mut self, target: &'a mut VulkanImage) -> Result<VulkanTarget<'a>, Error> {
         self.own(&target.0)?;
-        Ok(VulkanTarget(target))
+        Ok(VulkanTarget(target.0.clone(), PhantomData))
+    }
+}
+
+impl Bind<Dmabuf> for VulkanRenderer {
+    fn bind<'a>(&mut self, target: &'a mut Dmabuf) -> Result<VulkanTarget<'a>, Error> {
+        let key = target.weak();
+        let image = match self.dmabuf_targets.get(&key) {
+            Some(image) => image.clone(),
+            None => {
+                let image = dmabuf::import(&self.shared, &self.caps, target, RENDER_USAGE)?;
+                self.dmabuf_targets.insert(key, image.clone());
+                image
+            }
+        };
+        Ok(VulkanTarget(image, PhantomData))
+    }
+
+    fn supported_formats(&self) -> Option<FormatSet> {
+        Some(self.caps.render.clone())
     }
 }
 
@@ -664,6 +814,33 @@ impl ImportMem for VulkanRenderer {
     }
 }
 
+impl ImportDma for VulkanRenderer {
+    fn dmabuf_formats(&self) -> FormatSet {
+        self.caps.sample.clone()
+    }
+
+    fn import_dmabuf(
+        &mut self,
+        buffer: &Dmabuf,
+        _damage: Option<&[Rectangle<i32, Buffer>]>,
+    ) -> Result<VulkanTexture, Error> {
+        let key = buffer.weak();
+        if let Some(t) = self.dmabuf_textures.get(&key) {
+            return Ok(t.clone());
+        }
+        let texture = VulkanTexture(dmabuf::import(
+            &self.shared,
+            &self.caps,
+            buffer,
+            SAMPLE_USAGE,
+        )?);
+        self.dmabuf_textures.insert(key, texture.clone());
+        Ok(texture)
+    }
+}
+
+impl ImportDmaWl for VulkanRenderer {}
+
 impl ExportMem for VulkanRenderer {
     type TextureMapping = VulkanMapping;
 
@@ -673,8 +850,8 @@ impl ExportMem for VulkanRenderer {
         region: Rectangle<i32, Buffer>,
         format: Fourcc,
     ) -> Result<VulkanMapping, Error> {
-        self.own(&target.0.0)?;
-        let image = target.0.0.clone();
+        self.own(&target.0)?;
+        let image = target.0.clone();
         self.read_back(&image, region, format)
     }
 
@@ -688,8 +865,8 @@ impl ExportMem for VulkanRenderer {
         self.read_back(&texture.0, region, format)
     }
 
-    fn can_read_texture(&mut self, _texture: &VulkanTexture) -> Result<bool, Error> {
-        Ok(true)
+    fn can_read_texture(&mut self, texture: &VulkanTexture) -> Result<bool, Error> {
+        Ok(texture.0.external || texture.0.layout() != vk::ImageLayout::UNDEFINED)
     }
 
     fn map_texture<'a>(&mut self, mapping: &'a VulkanMapping) -> Result<&'a [u8], Error> {

Modified file: crates/render-vk/src/sync.rs+81 additions−18 deletions@@ -1,38 +1,101 @@
 use crate::device::Shared;
 use ash::vk;
+use rustix::event::{PollFd, PollFlags, poll};
 use smithay::backend::renderer::sync::{Fence, Interrupted};
 use std::fmt;
-use std::sync::Arc;
+use std::os::fd::{FromRawFd, OwnedFd};
+use std::sync::{Arc, Mutex};
+
+enum State {
+    Pending,
+    /// Exporting a sync_file resets the Vulkan fence, so from then on the
+    /// file is the only record of completion. `None` means it had already
+    /// signalled when exported.
+    Exported(Option<OwnedFd>),
+}
 
 pub(crate) struct FenceInner {
-    pub shared: Arc<Shared>,
-    pub fence: vk::Fence,
+    shared: Arc<Shared>,
+    fence: vk::Fence,
+    exportable: bool,
+    state: Mutex<State>,
 }
 
 impl FenceInner {
     pub fn new(shared: &Arc<Shared>) -> Result<Arc<Self>, vk::Result> {
-        let fence = unsafe {
-            shared
-                .device
-                .device
-                .create_fence(&vk::FenceCreateInfo::default(), None)?
-        };
+        let exportable = shared.device.dmabuf.is_some();
+        let mut export = vk::ExportFenceCreateInfo::default()
+            .handle_types(vk::ExternalFenceHandleTypeFlags::SYNC_FD);
+        let mut info = vk::FenceCreateInfo::default();
+        if exportable {
+            info = info.push_next(&mut export);
+        }
+        let fence = unsafe { shared.device.device.create_fence(&info, None)? };
         Ok(Arc::new(Self {
             shared: shared.clone(),
             fence,
+            exportable,
+            state: Mutex::new(State::Pending),
         }))
     }
 
+    pub fn fence(&self) -> vk::Fence {
+        self.fence
+    }
+
     pub fn signaled(&self) -> bool {
-        unsafe { self.shared.device.device.get_fence_status(self.fence) }.unwrap_or(true)
+        match &*self.state.lock().unwrap_or_else(|e| e.into_inner()) {
+            State::Pending => {
+                unsafe { self.shared.device.device.get_fence_status(self.fence) }.unwrap_or(true)
+            }
+            State::Exported(None) => true,
+            State::Exported(Some(fd)) => readable(fd, Some(&Default::default())),
+        }
     }
 
     pub fn wait(&self) -> Result<(), vk::Result> {
-        unsafe {
-            self.shared
-                .device
-                .device
-                .wait_for_fences(&[self.fence], true, u64::MAX)
+        match &*self.state.lock().unwrap_or_else(|e| e.into_inner()) {
+            State::Pending => unsafe {
+                self.shared
+                    .device
+                    .device
+                    .wait_for_fences(&[self.fence], true, u64::MAX)
+            },
+            State::Exported(None) => Ok(()),
+            State::Exported(Some(fd)) => {
+                readable(fd, None);
+                Ok(())
+            }
+        }
+    }
+
+    fn export(&self) -> Option<OwnedFd> {
+        if !self.exportable {
+            return None;
+        }
+        let ext = self.shared.device.dmabuf.as_ref()?;
+        let mut state = self.state.lock().unwrap_or_else(|e| e.into_inner());
+        if let State::Pending = *state {
+            let info = vk::FenceGetFdInfoKHR::default()
+                .fence(self.fence)
+                .handle_type(vk::ExternalFenceHandleTypeFlags::SYNC_FD);
+            let raw = unsafe { ext.fence_fd.get_fence_fd(&info) }.ok()?;
+            *state = State::Exported((raw >= 0).then(|| unsafe { OwnedFd::from_raw_fd(raw) }));
+        }
+        match &*state {
+            State::Exported(Some(fd)) => fd.try_clone().ok(),
+            _ => None,
+        }
+    }
+}
+
+fn readable(fd: &OwnedFd, timeout: Option<&rustix::event::Timespec>) -> bool {
+    let mut fds = [PollFd::new(fd, PollFlags::IN)];
+    loop {
+        match poll(&mut fds, timeout) {
+            Ok(n) => return n > 0,
+            Err(rustix::io::Errno::INTR) => continue,
+            Err(_) => return true,
         }
     }
 }
@@ -62,10 +125,10 @@ impl Fence for VkFence {
     }
 
     fn is_exportable(&self) -> bool {
-        false
+        self.0.exportable
     }
 
-    fn export(&self) -> Option<std::os::fd::OwnedFd> {
-        None
+    fn export(&self) -> Option<OwnedFd> {
+        self.0.export()
     }
 }

Added file: crates/render-vk/tests/dmabuf.rs+129 additions@@ -0,0 +1,129 @@
+//! Dmabuf allocation, rendering, import and fence export. Skips on devices
+//! without dmabuf support, such as lavapipe inside the nix sandbox.
+
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::allocator::{Allocator, Fourcc, Modifier};
+use smithay::backend::renderer::{
+    Bind, Color32F, ExportMem, Frame, ImportDma, Offscreen, Renderer,
+};
+use smithay::utils::{Rectangle, Transform};
+
+const SIZE: i32 = 32;
+
+fn renderer() -> Option<VulkanRenderer> {
+    let r = VulkanRenderer::new().expect("no usable Vulkan device");
+    if !r.supports_dmabuf() {
+        eprintln!("skipping, {} cannot share dmabufs", r.device_name());
+        return None;
+    }
+    Some(r)
+}
+
+fn dmabuf(r: &VulkanRenderer) -> Dmabuf {
+    let modifiers: Vec<Modifier> = r
+        .render_formats()
+        .iter()
+        .filter(|f| f.code == Fourcc::Argb8888)
+        .map(|f| f.modifier)
+        .collect();
+    r.allocator()
+        .create_buffer(SIZE as u32, SIZE as u32, Fourcc::Argb8888, &modifiers)
+        .unwrap()
+}
+
+fn fill(
+    r: &mut VulkanRenderer,
+    buf: &mut Dmabuf,
+    colour: [f32; 4],
+) -> smithay::backend::renderer::sync::SyncPoint {
+    let mut target = r.bind(buf).unwrap();
+    let mut frame = r
+        .render(&mut target, (SIZE, SIZE).into(), Transform::Normal)
+        .unwrap();
+    frame
+        .clear(
+            Color32F::from(colour),
+            &[Rectangle::from_size((SIZE, SIZE).into())],
+        )
+        .unwrap();
+    frame.finish().unwrap()
+}
+
+fn all_rgba(bytes: &[u8], want: [u8; 4]) -> bool {
+    bytes.as_chunks::<4>().0.iter().all(|p| *p == want)
+}
+
+#[test]
+fn renders_into_an_allocated_dmabuf_and_reads_it_back() {
+    let Some(mut r) = renderer() else { return };
+    let mut buf = dmabuf(&r);
+    fill(&mut r, &mut buf, [1.0, 0.0, 0.0, 1.0]).wait().unwrap();
+    let target = r.bind(&mut buf).unwrap();
+    let mapping = r
+        .copy_framebuffer(
+            &target,
+            Rectangle::from_size((SIZE, SIZE).into()),
+            Fourcc::Abgr8888,
+        )
+        .unwrap();
+    assert!(all_rgba(r.map_texture(&mapping).unwrap(), [255, 0, 0, 255]));
+}
+
+#[test]
+fn samples_an_imported_dmabuf() {
+    let Some(mut r) = renderer() else { return };
+    let mut buf = dmabuf(&r);
+    fill(&mut r, &mut buf, [0.0, 0.0, 1.0, 1.0]).wait().unwrap();
+    let texture = r.import_dmabuf(&buf, None).unwrap();
+    let mut out = r
+        .create_buffer(Fourcc::Argb8888, (SIZE, SIZE).into())
+        .unwrap();
+    let mut target = r.bind(&mut out).unwrap();
+    {
+        let full = Rectangle::from_size((SIZE, SIZE).into());
+        let mut frame = r
+            .render(&mut target, (SIZE, SIZE).into(), Transform::Normal)
+            .unwrap();
+        frame
+            .render_texture_from_to(
+                &texture,
+                Rectangle::from_size((SIZE as f64, SIZE as f64).into()),
+                full,
+                &[full],
+                &[],
+                Transform::Normal,
+                1.0,
+            )
+            .unwrap();
+        frame.finish().unwrap().wait().unwrap();
+    }
+    let mapping = r
+        .copy_framebuffer(
+            &target,
+            Rectangle::from_size((SIZE, SIZE).into()),
+            Fourcc::Abgr8888,
+        )
+        .unwrap();
+    assert!(all_rgba(r.map_texture(&mapping).unwrap(), [0, 0, 255, 255]));
+}
+
+#[test]
+fn imports_are_cached_per_buffer() {
+    let Some(mut r) = renderer() else { return };
+    let buf = dmabuf(&r);
+    let a = r.import_dmabuf(&buf, None).unwrap();
+    let b = r.import_dmabuf(&buf, None).unwrap();
+    assert_eq!(format!("{a:?}"), format!("{b:?}"));
+}
+
+#[test]
+fn frame_fences_export_as_sync_files() {
+    let Some(mut r) = renderer() else { return };
+    let mut buf = dmabuf(&r);
+    let sync = fill(&mut r, &mut buf, [0.0, 1.0, 0.0, 1.0]);
+    assert!(sync.is_exportable());
+    let _fd = sync.export();
+    sync.wait().unwrap();
+    assert!(sync.is_reached());
+}

monolith

Commit 7de49c2aa70b

Commit `7de49c2aa70b`