// 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 fuchsia_zircon as zx;
use fuchsia_zircon::HandleBased;
use magma::*;
use std::collections::HashMap;
use std::sync::Arc;

use super::ffi::*;
use super::magma::*;
use crate::device::wayland::image_file::*;
use crate::fs::*;
use crate::lock::Mutex;
use crate::logging::impossible_error;
use crate::syscalls::*;
use crate::task::CurrentTask;
use crate::types::*;

#[derive(Clone)]
pub enum BufferInfo {
    Default,
    Image(ImageInfo),
}

/// A `MagmaConnection` is an internal representation of a `magma_connection_t`.
type MagmaConnection = u64;

/// A `BufferMap` stores all the magma buffers for a given connection.
type BufferMap = HashMap<magma_buffer_t, BufferInfo>;

/// A `ConnectionMap` stores the `BufferMap`s associated with each magma connection.
type ConnectionMap = HashMap<MagmaConnection, BufferMap>;
pub struct MagmaFile {
    // TODO(fxbug.dev/12731): The lifecycle of the device channels should be handled by magma.
    devices: Arc<Mutex<Vec<zx::Channel>>>,
    connections: Arc<Mutex<ConnectionMap>>,
}

impl MagmaFile {
    pub fn new() -> Result<Box<dyn FileOps>, Errno> {
        Ok(Box::new(Self {
            devices: Arc::new(Mutex::new(vec![])),
            connections: Arc::new(Mutex::new(HashMap::new())),
        }))
    }

    /// Returns a duplicate of the VMO associated with the file at `fd`, as well as a `BufferInfo`
    /// of the correct type for that file.
    ///
    /// Returns an error if the file does not contain a buffer.
    fn get_vmo_and_magma_buffer(
        current_task: &CurrentTask,
        fd: FdNumber,
    ) -> Result<(zx::Vmo, BufferInfo), Errno> {
        let file = current_task.files.get(fd)?;
        if let Some(file) = file.downcast_file::<ImageFile>() {
            let buffer = BufferInfo::Image(file.info.clone());
            Ok((
                file.vmo.duplicate_handle(zx::Rights::SAME_RIGHTS).map_err(impossible_error)?,
                buffer,
            ))
        } else if let Some(file) = file.downcast_file::<VmoFileObject>() {
            let buffer = BufferInfo::Default;
            Ok((
                file.vmo.duplicate_handle(zx::Rights::SAME_RIGHTS).map_err(impossible_error)?,
                buffer,
            ))
        } else {
            error!(EINVAL)
        }
    }

    /// Adds a `BufferInfo` for the given `magma_buffer_t`, associated with the specified
    /// connection.
    fn add_buffer_info(
        &self,
        connection: magma_connection_t,
        buffer: magma_buffer_t,
        buffer_info: BufferInfo,
    ) {
        self.connections
            .lock()
            .entry(connection as u64)
            .or_insert_with(HashMap::new)
            .insert(buffer, buffer_info);
    }

    /// Returns a `BufferInfo` for the given `magma_buffer_t`, if one exists for the given
    /// `connection`. Otherwise returns `None`.
    fn get_buffer_info(
        &self,
        connection: magma_connection_t,
        buffer: magma_buffer_t,
    ) -> Option<BufferInfo> {
        match self.connections.lock().get(&(connection as u64)) {
            Some(buffers) => buffers.get(&buffer).map(|buffer| buffer.clone()),
            _ => None,
        }
    }
}

impl FileOps for MagmaFile {
    fileops_impl_nonseekable!();
    fileops_impl_nonblocking!();

    fn ioctl(
        &self,
        _file: &FileObject,
        current_task: &CurrentTask,
        _request: u32,
        user_addr: UserAddress,
    ) -> Result<SyscallResult, Errno> {
        let (command, command_type) = read_magma_command_and_type(current_task, user_addr)?;
        let response_address = UserAddress::from(command.response_address);

        match command_type {
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_IMPORT => {
                let (control, mut response) = read_control_and_response(current_task, &command)?;
                (*self.devices.lock()).push(device_import(control, &mut response)?);

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_IMPORT as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CREATE_CONNECTION2 => {
                let (control, mut response): (
                    virtio_magma_create_connection2_ctrl,
                    virtio_magma_create_connection2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut connection_out: magma_connection_t = 0;
                response.result_return =
                    unsafe { magma_create_connection2(control.device, &mut connection_out) as u64 };

                response.connection_out = connection_out;
                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CREATE_CONNECTION2 as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_RELEASE_CONNECTION => {
                let (control, mut response): (
                    virtio_magma_release_connection_ctrl_t,
                    virtio_magma_release_connection_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let connection = control.connection as magma_connection_t;
                let mut connections = self.connections.lock();
                if connections.contains_key(&connection) {
                    unsafe { magma_release_connection(connection) };
                    connections.remove(&connection);
                }

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_RELEASE_CONNECTION as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_RELEASE => {
                let (control, mut response): (
                    virtio_magma_device_release_ctrl_t,
                    virtio_magma_device_release_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                unsafe { magma_device_release(control.device) };

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_RELEASE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_VIRT_CREATE_IMAGE => {
                let (control, mut response): (
                    virtio_magma_virt_create_image_ctrl_t,
                    virtio_magma_virt_create_image_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut create_info_ptr: u64 = 0;
                let create_info_address = UserAddress::from(control.create_info);
                current_task
                    .mm
                    .read_object(UserRef::new(create_info_address), &mut create_info_ptr)?;

                let mut create_info = magma_image_create_info_t::default();
                let create_info_address = UserAddress::from(create_info_ptr);
                current_task.mm.read_object(UserRef::new(create_info_address), &mut create_info)?;

                let (vmo, token, info) = create_drm_image(0, &create_info).map_err(|e| {
                    tracing::warn!("Error creating drm image: {:?}", e);
                    errno!(EINVAL)
                })?;

                let mut buffer_out = magma_buffer_t::default();
                response.result_return = unsafe {
                    magma_import(
                        control.connection as magma_connection_t,
                        vmo.into_raw(),
                        &mut buffer_out,
                    ) as u64
                };

                self.add_buffer_info(
                    control.connection as magma_connection_t,
                    buffer_out,
                    BufferInfo::Image(ImageInfo { info, token }),
                );

                response.image_out = buffer_out;
                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_VIRT_CREATE_IMAGE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_VIRT_GET_IMAGE_INFO => {
                let (control, mut response): (
                    virtio_magma_virt_get_image_info_ctrl_t,
                    virtio_magma_virt_get_image_info_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let image_info_address_ref =
                    UserRef::new(UserAddress::from(control.image_info_out));
                let mut image_info_ptr = UserAddress::default();
                current_task.mm.read_object(image_info_address_ref, &mut image_info_ptr)?;

                match self.get_buffer_info(
                    control.connection as magma_connection_t,
                    control.image as magma_buffer_t,
                ) {
                    Some(BufferInfo::Image(image_info)) => {
                        let image_info_ref = UserRef::new(image_info_ptr);
                        current_task.mm.write_object(image_info_ref, &image_info.info)?;
                        response.result_return = MAGMA_STATUS_OK as u64;
                    }
                    _ => {
                        tracing::error!("No image info was found for buffer: {:?}", {
                            control.image
                        });
                        response.result_return = MAGMA_STATUS_INVALID_ARGS as u64;
                    }
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_VIRT_GET_IMAGE_INFO as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE => {
                let (control, mut response): (
                    virtio_magma_get_buffer_size_ctrl_t,
                    virtio_magma_get_buffer_size_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return = unsafe { magma_get_buffer_size(control.buffer) };
                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_FLUSH => {
                let (control, mut response): (
                    virtio_magma_flush_ctrl_t,
                    virtio_magma_flush_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return =
                    unsafe { magma_flush(control.connection as magma_connection_t) as u64 };

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_FLUSH as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL2 => {
                let (control, mut response): (
                    virtio_magma_read_notification_channel2_ctrl_t,
                    virtio_magma_read_notification_channel2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                // Buffer has a min length of 1 to make sure the call to
                // `magma_read_notification_channel2` uses a valid reference.
                let mut buffer = vec![0; std::cmp::max(control.buffer_size as usize, 1)];
                let mut buffer_size_out = 0;
                let mut more_data_out: u8 = 0;

                response.result_return = unsafe {
                    magma_read_notification_channel2(
                        control.connection as magma_connection_t,
                        &mut buffer[0] as *mut u8 as *mut std::ffi::c_void,
                        control.buffer_size,
                        &mut buffer_size_out,
                        &mut more_data_out as *mut u8,
                    ) as u64
                };

                response.more_data_out = more_data_out as u64;
                response.buffer_size_out = buffer_size_out;
                current_task.mm.write_memory(UserAddress::from(control.buffer), &mut buffer)?;

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL2 as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_BUFFER_HANDLE2 => {
                let (control, mut response): (
                    virtio_magma_get_buffer_handle2_ctrl_t,
                    virtio_magma_get_buffer_handle2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut buffer_handle_out = 0;
                let status = unsafe {
                    magma_get_buffer_handle2(
                        control.buffer as magma_buffer_t,
                        &mut buffer_handle_out as *mut magma_handle_t,
                    )
                };
                if status != MAGMA_STATUS_OK as i32 {
                    response.result_return = status as u64;
                } else {
                    let vmo = unsafe { zx::Vmo::from(zx::Handle::from_raw(buffer_handle_out)) };
                    let file = Anon::new_file(
                        anon_fs(current_task.kernel()),
                        Box::new(VmoFileObject::new(Arc::new(vmo))),
                        OpenFlags::RDWR,
                    );
                    let fd = current_task.files.add_with_flags(file, FdFlags::empty())?;
                    response.handle_out = fd.raw() as u64;
                    response.result_return = MAGMA_STATUS_OK as u64;
                }

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_BUFFER_HANDLE2 as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_RELEASE_BUFFER => {
                let (control, mut response): (
                    virtio_magma_release_buffer_ctrl_t,
                    virtio_magma_release_buffer_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                self.connections.lock().get_mut(&{ control.connection }).map(
                    |buffers| match buffers.remove(&(control.buffer as u64)) {
                        Some(_) => unsafe {
                            magma_release_buffer(
                                control.connection as magma_connection_t,
                                control.buffer as magma_buffer_t,
                            );
                        },
                        _ => {
                            tracing::error!("Calling magma_release_buffer with an invalid buffer.");
                        }
                    },
                );

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_RELEASE_BUFFER as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_EXPORT => {
                let (control, mut response): (
                    virtio_magma_export_ctrl_t,
                    virtio_magma_export_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut buffer_handle_out = 0;
                let status = unsafe {
                    magma_export(
                        control.connection as magma_connection_t,
                        control.buffer as magma_buffer_t,
                        &mut buffer_handle_out as *mut magma_handle_t,
                    )
                };

                if status as u32 == MAGMA_STATUS_OK {
                    let vmo = unsafe { zx::Vmo::from(zx::Handle::from_raw(buffer_handle_out)) };
                    let file = match self
                        .connections
                        .lock()
                        .get(&{ control.connection })
                        .and_then(|buffers| buffers.get(&(control.buffer as magma_buffer_t)))
                    {
                        Some(BufferInfo::Image(image_info)) => {
                            ImageFile::new(current_task.kernel(), image_info.clone(), vmo)
                        }
                        _ => Anon::new_file(
                            anon_fs(current_task.kernel()),
                            Box::new(VmoFileObject::new(Arc::new(vmo))),
                            OpenFlags::RDWR,
                        ),
                    };
                    let fd = current_task.files.add_with_flags(file, FdFlags::empty())?;
                    response.buffer_handle_out = fd.raw() as u64;
                }

                response.result_return = status as u64;
                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_EXPORT as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_IMPORT => {
                let (control, mut response): (
                    virtio_magma_import_ctrl_t,
                    virtio_magma_import_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let buffer_fd = FdNumber::from_raw(control.buffer_handle as i32);
                let (vmo, buffer) = MagmaFile::get_vmo_and_magma_buffer(current_task, buffer_fd)?;

                let mut buffer_out = magma_buffer_t::default();
                response.result_return = unsafe {
                    magma_import(
                        control.connection as magma_connection_t,
                        vmo.into_raw(),
                        &mut buffer_out,
                    ) as u64
                };

                // Store the information for the newly imported buffer.
                self.add_buffer_info(control.connection as magma_connection_t, buffer_out, buffer);
                // Import is expected to close the file that was imported.
                let _ = current_task.files.close(buffer_fd);

                response.buffer_out = buffer_out;
                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_IMPORT as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_QUERY2 => {
                let (control, mut response): (
                    virtio_magma_query2_ctrl_t,
                    virtio_magma_query2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut value_out = 0;
                response.result_return =
                    unsafe { magma_query2(control.device, control.id, &mut value_out) as u64 };
                response.value_out = value_out;

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_QUERY2 as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE => {
                let (control, mut response): (
                    virtio_magma_get_notification_channel_handle_ctrl_t,
                    virtio_magma_get_notification_channel_handle_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return = unsafe {
                    magma_get_notification_channel_handle(control.connection as magma_connection_t)
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_NOTIFICATION_CHANNEL_HANDLE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CREATE_CONTEXT => {
                let (control, mut response): (
                    virtio_magma_create_context_ctrl_t,
                    virtio_magma_create_context_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut context_id_out = 0;
                response.result_return = unsafe {
                    magma_create_context(
                        control.connection as magma_connection_t,
                        &mut context_id_out,
                    ) as u64
                };
                response.context_id_out = context_id_out as u64;

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CREATE_CONTEXT as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_RELEASE_CONTEXT => {
                let (control, mut response): (
                    virtio_magma_release_context_ctrl_t,
                    virtio_magma_release_context_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                unsafe {
                    magma_release_context(
                        control.connection as magma_connection_t,
                        control.context_id as u32,
                    );
                }

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_RELEASE_CONTEXT as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CREATE_BUFFER => {
                let (control, mut response): (
                    virtio_magma_create_buffer_ctrl_t,
                    virtio_magma_create_buffer_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut size_out = 0;
                let mut buffer_out = 0;
                response.result_return = unsafe {
                    magma_create_buffer(
                        control.connection as magma_connection_t,
                        control.size,
                        &mut size_out,
                        &mut buffer_out,
                    ) as u64
                };
                response.size_out = size_out;
                response.buffer_out = buffer_out;
                self.add_buffer_info(
                    control.connection as magma_connection_t,
                    buffer_out,
                    BufferInfo::Default,
                );

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CREATE_BUFFER as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_BUFFER_ID => {
                let (control, mut response): (
                    virtio_magma_get_buffer_id_ctrl_t,
                    virtio_magma_get_buffer_id_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return =
                    unsafe { magma_get_buffer_id(control.buffer as magma_buffer_t) };

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_BUFFER_ID as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_create_semaphore_ctrl_t,
                    virtio_magma_create_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut semaphore_out = 0;
                response.result_return = unsafe {
                    magma_create_semaphore(
                        control.connection as magma_connection_t,
                        &mut semaphore_out,
                    ) as u64
                };

                response.semaphore_out = semaphore_out;
                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_QUERY_RETURNS_BUFFER2 => {
                let (control, mut response): (
                    virtio_magma_query_returns_buffer2_ctrl_t,
                    virtio_magma_query_returns_buffer2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut handle_out = 0;
                response.result_return = unsafe {
                    magma_query_returns_buffer2(
                        control.device as magma_device_t,
                        control.id,
                        &mut handle_out,
                    ) as u64
                };
                let vmo = unsafe { zx::Vmo::from(zx::Handle::from_raw(handle_out)) };
                let file = Anon::new_file(
                    anon_fs(current_task.kernel()),
                    Box::new(VmoFileObject::new(Arc::new(vmo))),
                    OpenFlags::RDWR,
                );
                let fd = current_task.files.add_with_flags(file, FdFlags::empty())?;

                response.handle_out = fd.raw() as u64;
                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_QUERY_RETURNS_BUFFER2 as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_ERROR => {
                let (control, mut response): (
                    virtio_magma_get_error_ctrl_t,
                    virtio_magma_get_error_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return =
                    unsafe { magma_get_error(control.connection as magma_connection_t) as u64 };

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_ERROR as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_import_semaphore_ctrl_t,
                    virtio_magma_import_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut semaphore_out = 0;
                response.result_return = unsafe {
                    magma_import_semaphore(
                        control.connection as magma_connection_t,
                        control.semaphore_handle,
                        &mut semaphore_out,
                    ) as u64
                };
                response.semaphore_out = semaphore_out;

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID => {
                let (control, mut response): (
                    virtio_magma_get_semaphore_id_ctrl_t,
                    virtio_magma_get_semaphore_id_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return = unsafe {
                    magma_get_semaphore_id(control.semaphore as magma_semaphore_t) as u64
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_release_semaphore_ctrl_t,
                    virtio_magma_release_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                unsafe {
                    magma_release_semaphore(
                        control.connection as magma_connection_t,
                        control.semaphore as magma_semaphore_t,
                    );
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_export_semaphore_ctrl_t,
                    virtio_magma_export_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                let mut semaphore_handle_out = 0;
                response.result_return = unsafe {
                    magma_export_semaphore(
                        control.connection as magma_connection_t,
                        control.semaphore as magma_semaphore_t,
                        &mut semaphore_handle_out,
                    ) as u64
                };
                response.semaphore_handle_out = semaphore_handle_out as u64;

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_RESET_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_reset_semaphore_ctrl_t,
                    virtio_magma_reset_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                unsafe {
                    magma_reset_semaphore(control.semaphore as magma_semaphore_t);
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_RESET_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE => {
                let (control, mut response): (
                    virtio_magma_signal_semaphore_ctrl_t,
                    virtio_magma_signal_semaphore_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                unsafe {
                    magma_signal_semaphore(control.semaphore as magma_semaphore_t);
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU => {
                let (control, mut response): (
                    virtio_magma_map_buffer_gpu_ctrl_t,
                    virtio_magma_map_buffer_gpu_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                response.result_return = unsafe {
                    magma_map_buffer_gpu(
                        control.connection as magma_connection_t,
                        control.buffer,
                        control.page_offset,
                        control.page_count,
                        control.gpu_va,
                        control.map_flags,
                    ) as u64
                };

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_POLL => {
                let (control, mut response): (virtio_magma_poll_ctrl_t, virtio_magma_poll_resp_t) =
                    read_control_and_response(current_task, &command)?;

                let num_items = control.count as usize / std::mem::size_of::<StarnixPollItem>();
                let items_ref = UserRef::new(UserAddress::from(control.items));
                // Read the poll items as `StarnixPollItem`, since they contain a union. Also note
                // that the minimum length of the vector is 1, to always have a valid reference for
                // `magma_poll`.
                let mut starnix_items =
                    vec![StarnixPollItem::default(); std::cmp::max(num_items, 1)];
                current_task.mm.read_objects(items_ref, &mut starnix_items)?;
                // Then convert each item "manually" into `magma_poll_item_t`.
                let mut magma_items: Vec<magma_poll_item_t> =
                    starnix_items.iter().map(|item| item.into_poll_item()).collect();

                response.result_return = unsafe {
                    magma_poll(
                        &mut magma_items[0] as *mut magma_poll_item,
                        num_items as u32,
                        control.timeout_ns,
                    ) as u64
                };

                // Convert the poll items back to a serializable version after the `magma_poll`
                // call.
                let starnix_items: Vec<StarnixPollItem> =
                    magma_items.iter().map(StarnixPollItem::new).collect();
                current_task.mm.write_objects(items_ref, &starnix_items)?;

                response.hdr.type_ = virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_POLL as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_EXECUTE_COMMAND_BUFFER_WITH_RESOURCES2 => {
                let (control, mut response): (
                    virtio_magma_execute_command_buffer_with_resources2_ctrl_t,
                    virtio_magma_execute_command_buffer_with_resources2_resp_t,
                ) = read_control_and_response(current_task, &command)?;

                // First read the `virtmagma_command_buffer`, this contains pointers to all the
                // remaining structures needed by `magma_execute_command_buffer_with_resources2`.
                let virt_command_buffer_ref =
                    UserRef::new(UserAddress::from(control.command_buffer as u64));
                let mut virt_command_buffer = virtmagma_command_buffer::default();
                current_task.mm.read_object(virt_command_buffer_ref, &mut virt_command_buffer)?;

                let command_buffer_ref = UserRef::<magma_command_buffer>::new(UserAddress::from(
                    virt_command_buffer.command_buffer,
                ));
                let mut command_buffer = magma_command_buffer::default();
                current_task.mm.read_object(command_buffer_ref, &mut command_buffer)?;

                let resources_ref = UserRef::<magma_exec_resource>::new(UserAddress::from(
                    virt_command_buffer.resources as u64,
                ));
                let mut resources = vec![
                    magma_exec_resource::default();
                    std::cmp::max(1, command_buffer.resource_count as usize)
                ];
                // The resources vector is of length >= 1, since we need a valid reference to pass
                // to the magma function even when there is no data. This check is here to prevent
                // us from reading objects when the length is really 0.
                if command_buffer.resource_count > 0 {
                    current_task.mm.read_objects(resources_ref, &mut resources)?;
                }

                let semaphore_ids_ref =
                    UserRef::<u64>::new(UserAddress::from(virt_command_buffer.semaphores as u64));
                let semaphore_count = (command_buffer.wait_semaphore_count
                    + command_buffer.signal_semaphore_count)
                    as usize;
                let mut semaphore_ids = vec![0; std::cmp::max(1, semaphore_count)];
                // This check exists for the same reason as the command_buffer.resource_count check
                // above (to avoid reading when the actual count is 0).
                if semaphore_count > 0 {
                    current_task.mm.read_objects(semaphore_ids_ref, &mut semaphore_ids)?;
                }
                response.result_return = unsafe {
                    magma_execute_command_buffer_with_resources2(
                        control.connection as magma_connection_t,
                        control.context_id,
                        &mut command_buffer,
                        &mut resources[0] as *mut magma_exec_resource,
                        &mut semaphore_ids[0] as *mut u64,
                    ) as u64
                };

                response.hdr.type_ =
                    virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_EXECUTE_COMMAND_BUFFER_WITH_RESOURCES2
                        as u32;
                current_task.mm.write_object(UserRef::new(response_address), &response)
            }
            t => {
                tracing::warn!("Got unknown request: {:?}", t);
                error!(ENOSYS)
            }
        }?;

        Ok(SUCCESS)
    }

    fn read(
        &self,
        _file: &FileObject,
        _current_task: &CurrentTask,
        _data: &[UserBuffer],
    ) -> Result<usize, Errno> {
        error!(EINVAL)
    }

    fn write(
        &self,
        _file: &FileObject,
        _current_task: &CurrentTask,
        _data: &[UserBuffer],
    ) -> Result<usize, Errno> {
        error!(EINVAL)
    }
}