src/proc/bin/starnix/device/magma/magma.rs - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #![allow(non_upper_case_globals)]

 use fidl_fuchsia_sysmem as fsysmem;
 use fidl_fuchsia_ui_composition as fuicomp;
 use fuchsia_component::client::connect_channel_to_protocol;
 use fuchsia_image_format::*;
 use fuchsia_zircon as zx;
 use magma::*;
 use vk_sys as vk;
 use zerocopy::{AsBytes, FromBytes};

 use crate::device::wayland::vulkan::*;
 use crate::task::CurrentTask;
 use crate::types::*;

 /// Reads a magma command and its type from user space.
 ///
 /// # Parameters
 /// - `current_task`: The task to which the command memory belongs.
 /// - `command_address`: The address of the `virtmagma_ioctl_args_magma_command`.
 pub fn read_magma_command_and_type(
     current_task: &CurrentTask,
     command_address: UserAddress,
 ) -> Result<(virtmagma_ioctl_args_magma_command, virtio_magma_ctrl_type), Errno> {
     let command_ref = UserRef::new(command_address);
     let mut command = virtmagma_ioctl_args_magma_command::default();
     current_task.mm.read_object(command_ref, &mut command)?;

     let request_address = UserAddress::from(command.request_address);
     let mut header = virtio_magma_ctrl_hdr_t::default();
     current_task.mm.read_object(UserRef::new(request_address), &mut header)?;

     Ok((command, header.type_ as u16))
 }

 /// Reads the control and response structs from the given magma command struct.
 ///
 /// # Parameters
 /// - `current_task`: The task to which the memory belongs.
 /// - `command`: The command struct that contains the pointers to the control and response structs.
 pub fn read_control_and_response<C: Default + AsBytes + FromBytes, R: Default>(
     current_task: &CurrentTask,
     command: &virtmagma_ioctl_args_magma_command,
 ) -> Result<(C, R), Errno> {
     let request_address = UserAddress::from(command.request_address);
     let mut ctrl = C::default();
     current_task.mm.read_object(UserRef::new(request_address), &mut ctrl)?;

     Ok((ctrl, R::default()))
 }

 /// Creates an image in a buffer collection.
 ///
 /// # Parameters
 /// - `physical_device_index`: The index of the physical device to use when initializing the Vulkan
 ///                            loader.
 /// - `create_info`: The magma info used to create the image.
 ///
 /// Returns the image vmo, an import token for the collection, and the image info for the created
 /// image.
 pub fn create_drm_image(
     physical_device_index: u32,
     create_info: &magma_image_create_info_t,
 ) -> Result<(zx::Vmo, fuicomp::BufferCollectionImportToken, magma_image_info_t), magma_status_t> {
     let flags = create_info.flags as u32;
     if flags & !MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE != 0 {
         return Err(MAGMA_STATUS_INVALID_ARGS);
     }

     let vk_format = drm_format_to_vulkan_format(create_info.drm_format as u32)
         .map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     let sysmem_format = drm_format_to_sysmem_format(create_info.drm_format as u32)
         .map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     let mut sysmem_modifiers = vec![];
     let mut terminator_found = false;
     for modifier in create_info.drm_format_modifiers {
         if modifier == DRM_FORMAT_MOD_INVALID {
             terminator_found = true;
             break;
         }

         let modifier =
             drm_modifier_to_sysmem_modifier(modifier).map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

         sysmem_modifiers.push(modifier);
     }

     if !terminator_found {
         return Err(MAGMA_STATUS_INVALID_ARGS);
     }

     let loader = Loader::new(physical_device_index).map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     // TODO: verify physical device limits
     // TODO: Handle the case when MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE is not set and the scenic
     //       allocator is not intended to be used.
     let scenic_allocator = init_scenic().map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     let image_create_info = vk::ImageCreateInfo {
         sType: vk::STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         pNext: std::ptr::null(),
         flags: 0,
         imageType: vk::IMAGE_TYPE_2D,
         format: vk_format,
         extent: vk::Extent3D { width: create_info.width, height: create_info.height, depth: 1 },
         mipLevels: 1,
         arrayLayers: 1,
         samples: vk::SAMPLE_COUNT_1_BIT,
         tiling: vk::IMAGE_TILING_OPTIMAL,
         usage: vk::IMAGE_USAGE_TRANSFER_SRC_BIT
             | vk::IMAGE_USAGE_TRANSFER_DST_BIT
             | vk::IMAGE_USAGE_SAMPLED_BIT
             | vk::IMAGE_USAGE_STORAGE_BIT
             | vk::IMAGE_USAGE_COLOR_ATTACHMENT_BIT
             | vk::IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
         sharingMode: vk::SHARING_MODE_EXCLUSIVE,
         queueFamilyIndexCount: 0,
         pQueueFamilyIndices: std::ptr::null(),
         initialLayout: vk::IMAGE_LAYOUT_UNDEFINED,
     };

     let (tokens, sysmem_allocator) = init_sysmem().map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;
     let (scenic_import_token, buffer_collection) = loader
         .create_collection(
             &image_create_info,
             sysmem_format,
             &sysmem_modifiers,
             tokens,
             &scenic_allocator,
             &sysmem_allocator,
         )
         .map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     let (vmo, image_info) =
         get_image_info(buffer_collection, create_info.width, create_info.height)
             .map_err(|_| MAGMA_STATUS_INVALID_ARGS)?;

     Ok((vmo, scenic_import_token, image_info))
 }

 /// Initializes and returns Scenic allocator proxy.
 pub fn init_scenic() -> Result<fuicomp::AllocatorSynchronousProxy, Errno> {
     let (server_end, client_end) = zx::Channel::create().map_err(|_| errno!(ENOENT))?;
     connect_channel_to_protocol::<fuicomp::AllocatorMarker>(server_end)
         .map_err(|_| errno!(ENOENT))?;
     let composition_proxy = fuicomp::AllocatorSynchronousProxy::new(client_end);
     Ok(composition_proxy)
 }

 /// Allocates a shared sysmem collection.
 ///
 /// The returned `BufferCollectionTokens` contains a proxy to the shared collection, as well as a
 /// duplicate token to use for both Scenic and Vulkan.
 pub fn init_sysmem() -> Result<(BufferCollectionTokens, fsysmem::AllocatorSynchronousProxy), Errno>
 {
     let (server_end, client_end) = zx::Channel::create().map_err(|_| errno!(ENOENT))?;
     connect_channel_to_protocol::<fsysmem::AllocatorMarker>(server_end)
         .map_err(|_| errno!(ENOENT))?;
     let sysmem_allocator = fsysmem::AllocatorSynchronousProxy::new(client_end);

     let (client, remote) =
         fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
             .map_err(|_| errno!(EINVAL))?;

     sysmem_allocator.allocate_shared_collection(remote).map_err(|_| errno!(EINVAL))?;

     let buffer_token_proxy =
         fsysmem::BufferCollectionTokenSynchronousProxy::new(client.into_channel());

     let (scenic_token, remote) =
         fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
             .map_err(|_| errno!(EINVAL))?;

     buffer_token_proxy.duplicate(!0, remote).map_err(|_| errno!(EINVAL))?;

     let (vulkan_token, remote) =
         fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
             .map_err(|_| errno!(EINVAL))?;

     buffer_token_proxy.duplicate(!0, remote).map_err(|_| errno!(EINVAL))?;

     buffer_token_proxy.sync(zx::Time::INFINITE).map_err(|_| errno!(EINVAL))?;

     Ok((
         BufferCollectionTokens { buffer_token_proxy, scenic_token, vulkan_token },
         sysmem_allocator,
     ))
 }

 /// Waits for buffers to be allocated in the provided buffer collection and returns the first buffer
 /// in the collection, as well as the image info for the buffer.
 ///
 /// # Parameters
 /// - `buffer_collection`: The collection to fetch the image and info from.
 /// - `width`: The width to use when creating the image format.
 /// - `height`: The height to use when creating the image format.
 pub fn get_image_info(
     buffer_collection: fsysmem::BufferCollectionSynchronousProxy,
     width: u32,
     height: u32,
 ) -> Result<(zx::Vmo, magma_image_info_t), Errno> {
     let (_, mut collection_info) = buffer_collection
         .wait_for_buffers_allocated(zx::Time::INFINITE)
         .map_err(|_| errno!(EINVAL))?;
     let _ = buffer_collection.close();

     let image_format =
         constraints_to_format(&collection_info.settings.image_format_constraints, width, height)
             .map_err(|_| errno!(EINVAL))?;

     let mut image_info = magma_image_info_t::default();
     for plane in 0..MAGMA_MAX_IMAGE_PLANES {
         image_info.plane_offsets[plane as usize] =
             image_format_plane_byte_offset(&image_format, plane).unwrap_or(0);
         image_info.plane_strides[plane as usize] =
             get_plane_row_bytes(&image_format, plane).unwrap_or(0) as u64;
     }

     image_info.drm_format_modifier =
         sysmem_modifier_to_drm_modifier(image_format.pixel_format.format_modifier.value)
             .unwrap_or(0);
     image_info.coherency_domain = match collection_info.settings.buffer_settings.coherency_domain {
         fsysmem::CoherencyDomain::Cpu => MAGMA_COHERENCY_DOMAIN_CPU,
         fsysmem::CoherencyDomain::Ram => MAGMA_COHERENCY_DOMAIN_RAM,
         fsysmem::CoherencyDomain::Inaccessible => MAGMA_COHERENCY_DOMAIN_INACCESSIBLE,
     };

     let vmo = collection_info.buffers[0].vmo.take().ok_or(errno!(EINVAL))?;
     Ok((vmo, image_info))
 }

 #[repr(C)]
 #[derive(AsBytes, FromBytes, Copy, Clone, Default, Debug)]
 /// `StarnixPollItem` exists to be able to `AsBytes` and `FromBytes` the union that exists in
 /// `magma_poll_item_t`.
 pub struct StarnixPollItem {
     pub semaphore_or_handle: u64,
     pub type_: u32,
     pub condition: u32,
     pub result: u32,
     pub unused: [u8; 4usize],
 }

 impl StarnixPollItem {
     pub fn new(poll_item: &magma_poll_item_t) -> StarnixPollItem {
         let semaphore_or_handle = unsafe {
             if poll_item.type_ == MAGMA_POLL_TYPE_SEMAPHORE {
                 poll_item.__bindgen_anon_1.semaphore as u64
             } else {
                 poll_item.__bindgen_anon_1.handle as u64
             }
         };
         StarnixPollItem {
             semaphore_or_handle,
             type_: poll_item.type_,
             condition: poll_item.condition,
             result: poll_item.result,
             unused: [0; 4],
         }
     }

     pub fn into_poll_item(&self) -> magma_poll_item_t {
         let handle = if self.type_ == MAGMA_POLL_TYPE_SEMAPHORE {
             magma_poll_item__bindgen_ty_1 {
                 semaphore: self.semaphore_or_handle as magma_semaphore_t,
             }
         } else {
             magma_poll_item__bindgen_ty_1 { handle: self.semaphore_or_handle as magma_handle_t }
         };
         magma_poll_item_t {
             __bindgen_anon_1: handle,
             type_: self.type_,
             condition: self.condition,
             result: self.result,
             unused: 0,
         }
     }
 }
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#![allow(non_upper_case_globals)]

	use fidl_fuchsia_sysmem as fsysmem;
	use fidl_fuchsia_ui_composition as fuicomp;
	use fuchsia_component::client::connect_channel_to_protocol;
	use fuchsia_image_format::*;
	use fuchsia_zircon as zx;
	use magma::*;
	use vk_sys as vk;
	use zerocopy::{AsBytes, FromBytes};

	use crate::device::wayland::vulkan::*;
	use crate::task::CurrentTask;
	use crate::types::*;

	/// Reads a magma command and its type from user space.
	///
	/// # Parameters
	/// - `current_task`: The task to which the command memory belongs.
	/// - `command_address`: The address of the `virtmagma_ioctl_args_magma_command`.
	pub fn read_magma_command_and_type(
	current_task: &CurrentTask,
	command_address: UserAddress,
	) -> Result<(virtmagma_ioctl_args_magma_command, virtio_magma_ctrl_type), Errno> {
	let command_ref = UserRef::new(command_address);
	let mut command = virtmagma_ioctl_args_magma_command::default();
	current_task.mm.read_object(command_ref, &mut command)?;

	let request_address = UserAddress::from(command.request_address);
	let mut header = virtio_magma_ctrl_hdr_t::default();
	current_task.mm.read_object(UserRef::new(request_address), &mut header)?;

	Ok((command, header.type_ as u16))
	}

	/// Reads the control and response structs from the given magma command struct.
	///
	/// # Parameters
	/// - `current_task`: The task to which the memory belongs.
	/// - `command`: The command struct that contains the pointers to the control and response structs.
	pub fn read_control_and_response<C: Default + AsBytes + FromBytes, R: Default>(
	current_task: &CurrentTask,
	command: &virtmagma_ioctl_args_magma_command,
	) -> Result<(C, R), Errno> {
	let request_address = UserAddress::from(command.request_address);
	let mut ctrl = C::default();
	current_task.mm.read_object(UserRef::new(request_address), &mut ctrl)?;

	Ok((ctrl, R::default()))
	}

	/// Creates an image in a buffer collection.
	///
	/// # Parameters
	/// - `physical_device_index`: The index of the physical device to use when initializing the Vulkan
	/// loader.
	/// - `create_info`: The magma info used to create the image.
	///
	/// Returns the image vmo, an import token for the collection, and the image info for the created
	/// image.
	pub fn create_drm_image(
	physical_device_index: u32,
	create_info: &magma_image_create_info_t,
	) -> Result<(zx::Vmo, fuicomp::BufferCollectionImportToken, magma_image_info_t), magma_status_t> {
	let flags = create_info.flags as u32;
	if flags & !MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE != 0 {
	return Err(MAGMA_STATUS_INVALID_ARGS);
	}

	let vk_format = drm_format_to_vulkan_format(create_info.drm_format as u32)
	.map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	let sysmem_format = drm_format_to_sysmem_format(create_info.drm_format as u32)
	.map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	let mut sysmem_modifiers = vec![];
	let mut terminator_found = false;
	for modifier in create_info.drm_format_modifiers {
	if modifier == DRM_FORMAT_MOD_INVALID {
	terminator_found = true;
	break;
	}

	let modifier =
	drm_modifier_to_sysmem_modifier(modifier).map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	sysmem_modifiers.push(modifier);
	}

	if !terminator_found {
	return Err(MAGMA_STATUS_INVALID_ARGS);
	}

	let loader = Loader::new(physical_device_index).map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	// TODO: verify physical device limits
	// TODO: Handle the case when MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE is not set and the scenic
	// allocator is not intended to be used.
	let scenic_allocator = init_scenic().map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	let image_create_info = vk::ImageCreateInfo {
	sType: vk::STRUCTURE_TYPE_IMAGE_CREATE_INFO,
	pNext: std::ptr::null(),
	flags: 0,
	imageType: vk::IMAGE_TYPE_2D,
	format: vk_format,
	extent: vk::Extent3D { width: create_info.width, height: create_info.height, depth: 1 },
	mipLevels: 1,
	arrayLayers: 1,
	samples: vk::SAMPLE_COUNT_1_BIT,
	tiling: vk::IMAGE_TILING_OPTIMAL,
	usage: vk::IMAGE_USAGE_TRANSFER_SRC_BIT
	\| vk::IMAGE_USAGE_TRANSFER_DST_BIT
	\| vk::IMAGE_USAGE_SAMPLED_BIT
	\| vk::IMAGE_USAGE_STORAGE_BIT
	\| vk::IMAGE_USAGE_COLOR_ATTACHMENT_BIT
	\| vk::IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
	sharingMode: vk::SHARING_MODE_EXCLUSIVE,
	queueFamilyIndexCount: 0,
	pQueueFamilyIndices: std::ptr::null(),
	initialLayout: vk::IMAGE_LAYOUT_UNDEFINED,
	};

	let (tokens, sysmem_allocator) = init_sysmem().map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;
	let (scenic_import_token, buffer_collection) = loader
	.create_collection(
	&image_create_info,
	sysmem_format,
	&sysmem_modifiers,
	tokens,
	&scenic_allocator,
	&sysmem_allocator,
	)
	.map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	let (vmo, image_info) =
	get_image_info(buffer_collection, create_info.width, create_info.height)
	.map_err(\|_\| MAGMA_STATUS_INVALID_ARGS)?;

	Ok((vmo, scenic_import_token, image_info))
	}

	/// Initializes and returns Scenic allocator proxy.
	pub fn init_scenic() -> Result<fuicomp::AllocatorSynchronousProxy, Errno> {
	let (server_end, client_end) = zx::Channel::create().map_err(\|_\| errno!(ENOENT))?;
	connect_channel_to_protocol::<fuicomp::AllocatorMarker>(server_end)
	.map_err(\|_\| errno!(ENOENT))?;
	let composition_proxy = fuicomp::AllocatorSynchronousProxy::new(client_end);
	Ok(composition_proxy)
	}

	/// Allocates a shared sysmem collection.
	///
	/// The returned `BufferCollectionTokens` contains a proxy to the shared collection, as well as a
	/// duplicate token to use for both Scenic and Vulkan.
	pub fn init_sysmem() -> Result<(BufferCollectionTokens, fsysmem::AllocatorSynchronousProxy), Errno>
	{
	let (server_end, client_end) = zx::Channel::create().map_err(\|_\| errno!(ENOENT))?;
	connect_channel_to_protocol::<fsysmem::AllocatorMarker>(server_end)
	.map_err(\|_\| errno!(ENOENT))?;
	let sysmem_allocator = fsysmem::AllocatorSynchronousProxy::new(client_end);

	let (client, remote) =
	fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
	.map_err(\|_\| errno!(EINVAL))?;

	sysmem_allocator.allocate_shared_collection(remote).map_err(\|_\| errno!(EINVAL))?;

	let buffer_token_proxy =
	fsysmem::BufferCollectionTokenSynchronousProxy::new(client.into_channel());

	let (scenic_token, remote) =
	fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
	.map_err(\|_\| errno!(EINVAL))?;

	buffer_token_proxy.duplicate(!0, remote).map_err(\|_\| errno!(EINVAL))?;

	let (vulkan_token, remote) =
	fidl::endpoints::create_endpoints::<fsysmem::BufferCollectionTokenMarker>()
	.map_err(\|_\| errno!(EINVAL))?;

	buffer_token_proxy.duplicate(!0, remote).map_err(\|_\| errno!(EINVAL))?;

	buffer_token_proxy.sync(zx::Time::INFINITE).map_err(\|_\| errno!(EINVAL))?;

	Ok((
	BufferCollectionTokens { buffer_token_proxy, scenic_token, vulkan_token },
	sysmem_allocator,
	))
	}

	/// Waits for buffers to be allocated in the provided buffer collection and returns the first buffer
	/// in the collection, as well as the image info for the buffer.
	///
	/// # Parameters
	/// - `buffer_collection`: The collection to fetch the image and info from.
	/// - `width`: The width to use when creating the image format.
	/// - `height`: The height to use when creating the image format.
	pub fn get_image_info(
	buffer_collection: fsysmem::BufferCollectionSynchronousProxy,
	width: u32,
	height: u32,
	) -> Result<(zx::Vmo, magma_image_info_t), Errno> {
	let (_, mut collection_info) = buffer_collection
	.wait_for_buffers_allocated(zx::Time::INFINITE)
	.map_err(\|_\| errno!(EINVAL))?;
	let _ = buffer_collection.close();

	let image_format =
	constraints_to_format(&collection_info.settings.image_format_constraints, width, height)
	.map_err(\|_\| errno!(EINVAL))?;

	let mut image_info = magma_image_info_t::default();
	for plane in 0..MAGMA_MAX_IMAGE_PLANES {
	image_info.plane_offsets[plane as usize] =
	image_format_plane_byte_offset(&image_format, plane).unwrap_or(0);
	image_info.plane_strides[plane as usize] =
	get_plane_row_bytes(&image_format, plane).unwrap_or(0) as u64;
	}

	image_info.drm_format_modifier =
	sysmem_modifier_to_drm_modifier(image_format.pixel_format.format_modifier.value)
	.unwrap_or(0);
	image_info.coherency_domain = match collection_info.settings.buffer_settings.coherency_domain {
	fsysmem::CoherencyDomain::Cpu => MAGMA_COHERENCY_DOMAIN_CPU,
	fsysmem::CoherencyDomain::Ram => MAGMA_COHERENCY_DOMAIN_RAM,
	fsysmem::CoherencyDomain::Inaccessible => MAGMA_COHERENCY_DOMAIN_INACCESSIBLE,
	};

	let vmo = collection_info.buffers[0].vmo.take().ok_or(errno!(EINVAL))?;
	Ok((vmo, image_info))
	}

	#[repr(C)]
	#[derive(AsBytes, FromBytes, Copy, Clone, Default, Debug)]
	/// `StarnixPollItem` exists to be able to `AsBytes` and `FromBytes` the union that exists in
	/// `magma_poll_item_t`.
	pub struct StarnixPollItem {
	pub semaphore_or_handle: u64,
	pub type_: u32,
	pub condition: u32,
	pub result: u32,
	pub unused: [u8; 4usize],
	}

	impl StarnixPollItem {
	pub fn new(poll_item: &magma_poll_item_t) -> StarnixPollItem {
	let semaphore_or_handle = unsafe {
	if poll_item.type_ == MAGMA_POLL_TYPE_SEMAPHORE {
	poll_item.__bindgen_anon_1.semaphore as u64
	} else {
	poll_item.__bindgen_anon_1.handle as u64
	}
	};
	StarnixPollItem {
	semaphore_or_handle,
	type_: poll_item.type_,
	condition: poll_item.condition,
	result: poll_item.result,
	unused: [0; 4],
	}
	}

	pub fn into_poll_item(&self) -> magma_poll_item_t {
	let handle = if self.type_ == MAGMA_POLL_TYPE_SEMAPHORE {
	magma_poll_item__bindgen_ty_1 {
	semaphore: self.semaphore_or_handle as magma_semaphore_t,
	}
	} else {
	magma_poll_item__bindgen_ty_1 { handle: self.semaphore_or_handle as magma_handle_t }
	};
	magma_poll_item_t {
	__bindgen_anon_1: handle,
	type_: self.type_,
	condition: self.condition,
	result: self.result,
	unused: 0,
	}
	}
	}