Add pipewire cross domain channel type.

This adds a pipewire channel type, increases the maximum number
of fds that can be transferred in a single message, and adds support
for sharing eventfds between the guest and host.

Signed-off-by: Sasha Finkelstein <fnkl.kernel@gmail.com>
Signed-off-by: Dorinda Bassey <dbassey@redhat.com>

Author: Dorinda Bassey

ffi/src/include/rutabaga_gfx_ffi.h

@@ -92,6 +92,7 @@ extern "C" {
  * Rutabaga channel types
  */
 #define RUTABAGA_CHANNEL_TYPE_WAYLAND 1
+#define RUTABAGA_CHANNEL_TYPE_PIPEWIRE 0x10
 #define RUTABAGA_CHANNEL_TYPE_X11 0x11
 
 /**

ffi/src/tests/virtgpu_cross_domain_protocol.h

@@ -19,6 +19,7 @@
 // Channel types (must match rutabaga channel types)
 #define CROSS_DOMAIN_CHANNEL_TYPE_WAYLAND 0x0001
 #define CROSS_DOMAIN_CHANNEL_TYPE_CAMERA 0x0002
+#define CROSS_DOMAIN_CHANNEL_TYPE_PIPEWIRE 0x0010
 #define CROSS_DOMAIN_CHANNEL_TYPE_X11 0x0011
 
 // The maximum number of identifiers (value based on wp_linux_dmabuf)

src/cross_domain/cross_domain_protocol.rs

@@ -22,10 +22,12 @@ pub const CROSS_DOMAIN_CMD_WRITE: u8 = 7;
 pub const CROSS_DOMAIN_CMD_CREATE_ATOMIC_MEMORY_SENTINEL: u8 = 8;
 pub const CROSS_DOMAIN_CMD_SIGNAL_ATOMIC_MEMORY_SENTINEL: u8 = 9;
 pub const CROSS_DOMAIN_CMD_DESTROY_ATOMIC_MEMORY_SENTINEL: u8 = 10;
+pub const CROSS_DOMAIN_CMD_READ_CREATE_EVENT: u8 = 11;
 
 /// Channel types (must match rutabaga channel types)
 pub const CROSS_DOMAIN_CHANNEL_TYPE_WAYLAND: u32 = 0x0001;
 pub const CROSS_DOMAIN_CHANNEL_TYPE_CAMERA: u32 = 0x0002;
+pub const CROSS_DOMAIN_CHANNEL_TYPE_PIPEWIRE: u32 = 0x0010;
 pub const CROSS_DOMAIN_CHANNEL_TYPE_X11: u32 = 0x0011;
 
 /// The maximum number of identifiers
@@ -88,7 +90,7 @@ pub struct CrossDomainHeader {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug, Default, FromBytes, IntoBytes, Immutable)]
+#[derive(Copy, Clone, Default, FromBytes, IntoBytes, Immutable)]
 pub struct CrossDomainInit {
     pub hdr: CrossDomainHeader,
     pub query_ring_id: u32,
@@ -157,3 +159,11 @@ pub struct CrossDomainDestroyAtomicMemorySentinel {
     pub id: u32,
     pub pad: u32,
 }
+
+#[repr(C)]
+#[derive(Copy, Clone, Default, FromBytes, IntoBytes, Immutable)]
+pub struct CrossDomainCreateEvent {
+    pub hdr: CrossDomainHeader,
+    pub id: u32,
+    pub pad: u32,
+}

src/cross_domain/mod.rs

@@ -92,6 +92,7 @@ enum CrossDomainJob {
     AddReadPipe(u32),
     Finish,
     AddAtomicMemorySentinel(u32, Event),
+    AddReadEvent(u32),
 }
 
 enum RingWrite<'a, T> {
@@ -395,18 +396,18 @@ impl CrossDomainWorker {
                 _ => {
                     let mut items = self.item_state.lock().unwrap();
                     let mut cmd_read: CrossDomainReadWrite = Default::default();
-                    let pipe_id: u32 = event
+                    let item_id: u32 = event
                         .connection_id
                         .try_into()
                         .map_err(MesaError::TryFromIntError)?;
                     let bytes_read;
 
                     cmd_read.hdr.cmd = CROSS_DOMAIN_CMD_READ;
-                    cmd_read.identifier = pipe_id;
+                    cmd_read.identifier = item_id;
 
                     let item = items
                         .table
-                        .get_mut(&pipe_id)
+                        .get_mut(&item_id)
                         .ok_or(RutabagaError::InvalidCrossDomainItemId)?;
 
                     match item {
@@ -423,11 +424,18 @@ impl CrossDomainWorker {
                                 self.wait_ctx.delete(readpipe.as_borrowed_descriptor())?;
                             }
                         }
+                        CrossDomainItem::Event(ref evt) => {
+                            // For eventfd, we can use wait() to consume the event
+                            if event.readable {
+                                let _ = evt.wait();
+                            }
+                            bytes_read = 0; // eventfd doesn't have data to read like pipes
+                        }
                         _ => return Err(RutabagaError::InvalidCrossDomainItemType),
                     }
 
                     if event.hung_up && bytes_read == 0 {
-                        items.table.remove(&pipe_id);
+                        items.table.remove(&item_id);
                     }
 
                     self.fence_handler.call(fence);
@@ -547,6 +555,20 @@ impl CrossDomainWorker {
                         _ => return Err(RutabagaError::InvalidCrossDomainItemType),
                     }
                 }
+                CrossDomainJob::AddReadEvent(efd_id) => {
+                    let items = self.item_state.lock().unwrap();
+                    let item = items
+                        .table
+                        .get(&efd_id)
+                        .ok_or(RutabagaError::InvalidCrossDomainItemId)?;
+
+                    match item {
+                        CrossDomainItem::Event(event) => self
+                            .wait_ctx
+                            .add(efd_id as u64, event.as_borrowed_descriptor())?,
+                        _ => return Err(RutabagaError::InvalidCrossDomainItemType),
+                    }
+                }
                 CrossDomainJob::AddAtomicMemorySentinel(id, recv) => {
                     self.wait_ctx
                         .add(id as u64, recv.as_borrowed_descriptor())?;
@@ -720,29 +742,28 @@ impl CrossDomainContext {
 
     fn send(
         &mut self,
-        cmd_send: &CrossDomainSendReceive,
+        cmd_send: &mut CrossDomainSendReceive,
         opaque_data: &[u8],
     ) -> RutabagaResult<()> {
         let mut descriptors: Vec<OwnedDescriptor> = vec![];
         let mut write_pipe_opt: Option<WritePipe> = None;
         let mut read_pipe_id_opt: Option<u32> = None;
 
-        let num_identifiers = cmd_send
-            .num_identifiers
-            .try_into()
-            .map_err(MesaError::TryFromIntError)?;
+        let num_identifiers = cmd_send.num_identifiers as usize;
 
         if num_identifiers > CROSS_DOMAIN_MAX_IDENTIFIERS {
             return Err(MesaError::WithContext("max cross domain identifiers exceeded").into());
         }
 
         let iter = cmd_send
             .identifiers
-            .iter()
-            .zip(cmd_send.identifier_types.iter())
+            .iter_mut()
+            .zip(cmd_send.identifier_types.iter_mut())
+            .zip(cmd_send.identifier_sizes.iter_mut())
+            .map(|((i, it), is)| (i, it, is))
             .take(num_identifiers);
 
-        for (identifier, identifier_type) in iter {
+        for (identifier, identifier_type, _identifier_size) in iter {
             if *identifier_type == CROSS_DOMAIN_ID_TYPE_VIRTGPU_BLOB {
                 let context_resources = self.context_resources.lock().unwrap();
 
@@ -853,6 +874,25 @@ impl CrossDomainContext {
         Ok(())
     }
 
+    fn read_event_new(&mut self, cmd_event_new: &CrossDomainCreateEvent) -> RutabagaResult<()> {
+        let items = self.item_state.lock().unwrap();
+
+        if let Some(item) = items.table.get(&cmd_event_new.id) {
+            if let CrossDomainItem::Event(_) = item {
+                self.state
+                    .as_ref()
+                    .unwrap()
+                    .add_job(CrossDomainJob::AddReadEvent(cmd_event_new.id));
+                self.resample_evt.as_mut().unwrap().signal()?;
+                Ok(())
+            } else {
+                Err(RutabagaError::InvalidCrossDomainItemType)
+            }
+        } else {
+            Err(RutabagaError::InvalidCrossDomainItemId)
+        }
+    }
+
     fn write(&self, cmd_write: &CrossDomainReadWrite, opaque_data: &[u8]) -> RutabagaResult<()> {
         let mut items = self.item_state.lock().unwrap();
 
@@ -886,6 +926,21 @@ impl CrossDomainContext {
             _ => Err(RutabagaError::InvalidCrossDomainItemType),
         }
     }
+
+    fn process_cmd_send(&mut self, commands: &mut [u8]) -> RutabagaResult<()> {
+        let opaque_data_offset = size_of::<CrossDomainSendReceive>();
+        let (mut cmd_send, _) = CrossDomainSendReceive::read_from_prefix(commands.as_bytes())
+            .map_err(|_| RutabagaError::InvalidCommandBuffer)?;
+
+        let opaque_data = commands
+            .get_mut(opaque_data_offset..opaque_data_offset + cmd_send.opaque_data_size as usize)
+            .ok_or(RutabagaError::InvalidCommandSize(
+                cmd_send.opaque_data_size as usize,
+            ))?;
+
+        self.send(&mut cmd_send, opaque_data)?;
+        Ok(())
+    }
 }
 
 impl Drop for CrossDomainContext {
@@ -911,13 +966,24 @@ impl Drop for CrossDomainContext {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug, Default, FromBytes, IntoBytes, Immutable)]
+#[derive(Copy, Clone, Default, FromBytes, IntoBytes, Immutable)]
 struct CrossDomainInitLegacy {
     hdr: CrossDomainHeader,
     query_ring_id: u32,
     channel_type: u32,
 }
 
+impl CrossDomainInitLegacy {
+    pub(crate) fn upgrade(&self) -> CrossDomainInit {
+        CrossDomainInit {
+            hdr: self.hdr,
+            query_ring_id: self.query_ring_id,
+            channel_ring_id: self.query_ring_id,
+            channel_type: self.channel_type,
+        }
+    }
+}
+
 impl RutabagaContext for CrossDomainContext {
     fn context_create_blob(
         &mut self,
@@ -1025,24 +1091,13 @@ impl RutabagaContext for CrossDomainContext {
 
             match hdr.cmd {
                 CROSS_DOMAIN_CMD_INIT => {
-                    let cmd_init = match CrossDomainInit::read_from_prefix(commands) {
-                        Ok((cmd_init, _)) => cmd_init,
-                        _ => {
-                            if let Ok((cmd_init, _)) =
-                                CrossDomainInitLegacy::read_from_prefix(commands)
-                            {
-                                CrossDomainInit {
-                                    hdr: cmd_init.hdr,
-                                    query_ring_id: cmd_init.query_ring_id,
-                                    channel_ring_id: cmd_init.query_ring_id,
-                                    channel_type: cmd_init.channel_type,
-                                }
-                            } else {
-                                return Err(RutabagaError::InvalidCommandBuffer);
-                            }
-                        }
-                    };
-
+                    let cmd_init = CrossDomainInit::read_from_prefix(commands)
+                        .map(|(v, _)| v)
+                        .or_else(|_| {
+                            CrossDomainInitLegacy::read_from_prefix(commands)
+                                .map(|(v, _)| v.upgrade())
+                        })
+                        .map_err(|_| RutabagaError::InvalidCommandBuffer)?;
                     self.initialize(&cmd_init)?;
                 }
                 CROSS_DOMAIN_CMD_GET_IMAGE_REQUIREMENTS => {
@@ -1053,20 +1108,7 @@ impl RutabagaContext for CrossDomainContext {
                     self.get_image_requirements(&cmd_get_reqs)?;
                 }
                 CROSS_DOMAIN_CMD_SEND => {
-                    let opaque_data_offset = size_of::<CrossDomainSendReceive>();
-                    let (cmd_send, _) = CrossDomainSendReceive::read_from_prefix(commands)
-                        .map_err(|_e| RutabagaError::InvalidCommandBuffer)?;
-
-                    let opaque_data = commands
-                        .get_mut(
-                            opaque_data_offset
-                                ..opaque_data_offset + cmd_send.opaque_data_size as usize,
-                        )
-                        .ok_or(RutabagaError::InvalidCommandSize(
-                            cmd_send.opaque_data_size as usize,
-                        ))?;
-
-                    self.send(&cmd_send, opaque_data)?;
+                    self.process_cmd_send(commands)?;
                 }
                 CROSS_DOMAIN_CMD_POLL => {
                     // Actual polling is done in the subsequent when creating a fence.
@@ -1105,6 +1147,11 @@ impl RutabagaContext for CrossDomainContext {
                             .map_err(|_e| RutabagaError::InvalidCommandBuffer)?;
                     self.atomic_memory_sentinel_destroy(&cmd_atomic_memory_sentinel_destroy)?;
                 }
+                CROSS_DOMAIN_CMD_READ_CREATE_EVENT => {
+                    let (cmd_new_evt, _) = CrossDomainCreateEvent::read_from_prefix(commands)
+                        .map_err(|_| RutabagaError::InvalidCommandBuffer)?;
+                    self.read_event_new(&cmd_new_evt)?;
+                }
                 _ => return Err(MesaError::WithContext("invalid cross domain command").into()),
             }
 

src/rutabaga_utils.rs

@@ -608,6 +608,7 @@ impl Transfer3D {
 /// Rutabaga path types
 pub const RUTABAGA_PATH_TYPE_WAYLAND: u32 = 0x0001;
 pub const RUTABAGA_PATH_TYPE_GPU: u32 = 0x0002;
+pub const RUTABAGA_PATH_TYPE_PIPEWIRE: u32 = 0x0010;
 pub const RUTABAGA_PATH_TYPE_X11: u32 = 0x0011;
 
 pub type RutabagaPaths = Vec<RutabagaPath>;