| // Copyright 2018 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. |
| |
| #include "zircon_platform_connection.h" |
| |
| #include <mutex> |
| |
| #include "platform_connection_client.h" |
| #include <fuchsia/gpu/magma/c/fidl.h> |
| #include <fuchsia/gpu/magma/cpp/fidl.h> |
| #include <garnet/public/lib/fidl/cpp/vector.h> |
| #include <lib/fdio/io.h> |
| #include <lib/fdio/unsafe.h> |
| #include <lib/zx/channel.h> |
| |
| namespace { |
| // Convert zx channel status to magma status. |
| static magma_status_t MagmaChannelStatus(const zx_status_t status) |
| { |
| switch (status) { |
| case ZX_OK: |
| return MAGMA_STATUS_OK; |
| case ZX_ERR_PEER_CLOSED: |
| return MAGMA_STATUS_CONNECTION_LOST; |
| default: |
| return MAGMA_STATUS_INTERNAL_ERROR; |
| } |
| } |
| } // namespace |
| |
| namespace magma { |
| |
| #if MAGMA_FIDL |
| |
| /** |
| * ZirconPlatformConnectionClient with FIDL |
| */ |
| class ZirconPlatformConnectionClient : public PlatformConnectionClient { |
| public: |
| ZirconPlatformConnectionClient(zx::channel channel, zx::channel notification_channel) |
| : notification_channel_(std::move(notification_channel)) |
| { |
| magma_fidl_.Bind(std::move(channel)); |
| } |
| |
| // Imports a buffer for use in the system driver |
| magma_status_t ImportBuffer(PlatformBuffer* buffer) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ImportBuffer"); |
| if (!buffer) |
| return DRET_MSG(MAGMA_STATUS_INVALID_ARGS, "attempting to import null buffer"); |
| uint32_t duplicate_handle; |
| if (!buffer->duplicate_handle(&duplicate_handle)) |
| return DRET_MSG(MAGMA_STATUS_INVALID_ARGS, "failed to get duplicate_handle"); |
| |
| zx::vmo vmo(duplicate_handle); |
| magma_status_t result = MagmaChannelStatus(magma_fidl_->ImportBufferFIDL(std::move(vmo))); |
| if (result != MAGMA_STATUS_OK) { |
| return DRET_MSG(result, "failed to write to channel"); |
| } |
| return MAGMA_STATUS_OK; |
| } |
| |
| // Destroys the buffer with |buffer_id| within this connection |
| // returns false if the buffer with |buffer_id| has not been imported |
| magma_status_t ReleaseBuffer(uint64_t buffer_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ReleaseBuffer"); |
| magma_status_t result = MagmaChannelStatus(magma_fidl_->ReleaseBufferFIDL(buffer_id)); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t ImportObject(uint32_t handle, PlatformObject::Type object_type) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ImportObject"); |
| zx::handle duplicate_handle(handle); |
| magma_status_t result = MagmaChannelStatus( |
| magma_fidl_->ImportObjectFIDL(std::move(duplicate_handle), object_type)); |
| if (result != MAGMA_STATUS_OK) { |
| return DRET_MSG(result, "failed to write to channel"); |
| } |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t ReleaseObject(uint64_t object_id, PlatformObject::Type object_type) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ReleaseObject"); |
| magma_status_t result = |
| MagmaChannelStatus(magma_fidl_->ReleaseObjectFIDL(object_id, object_type)); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| // Creates a context and returns the context id |
| void CreateContext(uint32_t* context_id_out) override |
| { |
| DLOG("ZirconPlatformConnectionClient: CreateContext"); |
| auto context_id = next_context_id_++; |
| *context_id_out = context_id; |
| magma_status_t result = MagmaChannelStatus(magma_fidl_->CreateContextFIDL(context_id)); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| // Destroys a context for the given id |
| void DestroyContext(uint32_t context_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: DestroyContext"); |
| magma_status_t result = MagmaChannelStatus(magma_fidl_->DestroyContextFIDL(context_id)); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| void ExecuteCommandBuffer(uint32_t command_buffer_handle, uint32_t context_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ExecuteCommandBuffer"); |
| zx::handle duplicate_handle(command_buffer_handle); |
| magma_status_t result = MagmaChannelStatus( |
| magma_fidl_->ExecuteCommandBufferFIDL(std::move(duplicate_handle), context_id)); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| // Returns the number of commands that will fit within |max_bytes|. |
| static int FitCommands(const size_t max_bytes, const int num_buffers, |
| const magma_system_inline_command_buffer* buffers, |
| const int starting_index, uint64_t* command_bytes, |
| uint32_t* num_semaphores) |
| { |
| int buffer_count = 0; |
| uint64_t bytes_used = 0; |
| *command_bytes = 0; |
| *num_semaphores = 0; |
| while (starting_index + buffer_count < num_buffers && bytes_used < max_bytes) { |
| *command_bytes += buffers[starting_index + buffer_count].size; |
| *num_semaphores += buffers[starting_index + buffer_count].semaphore_count; |
| bytes_used = *command_bytes + *num_semaphores * sizeof(uint64_t); |
| buffer_count++; |
| } |
| if (bytes_used > max_bytes) |
| return (buffer_count - 1); |
| return buffer_count; |
| } |
| |
| void ExecuteImmediateCommands(uint32_t context_id, uint64_t num_buffers, |
| magma_system_inline_command_buffer* buffers) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ExecuteImmediateCommandsFIDL"); |
| uint64_t buffers_sent = 0; |
| while (buffers_sent < num_buffers) { |
| // Tally up the number of commands to send in this batch. |
| uint64_t command_bytes = 0; |
| uint32_t num_semaphores = 0; |
| int buffers_to_send = |
| FitCommands(fuchsia::gpu::magma::kReceiveBufferSize, num_buffers, buffers, |
| buffers_sent, &command_bytes, &num_semaphores); |
| |
| // TODO(MA-536): Figure out how to move command and semaphore bytes across the FIDL |
| // interface without copying. |
| std::vector<uint8_t> command_vec; |
| command_vec.reserve(command_bytes); |
| fidl::VectorPtr<uint64_t> semaphore_vec; |
| semaphore_vec->reserve(num_semaphores); |
| for (int i = 0; i < buffers_to_send; ++i) { |
| const auto& buffer = buffers[buffers_sent + i]; |
| const auto buffer_data = static_cast<uint8_t*>(buffer.data); |
| std::copy(buffer_data, buffer_data + buffer.size, std::back_inserter(command_vec)); |
| std::copy(buffer.semaphores, buffer.semaphores + buffer.semaphore_count, |
| std::back_inserter(*semaphore_vec)); |
| } |
| magma_status_t result = MagmaChannelStatus(magma_fidl_->ExecuteImmediateCommandsFIDL( |
| context_id, std::move(command_vec), std::move(semaphore_vec))); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| buffers_sent += buffers_to_send; |
| } |
| } |
| |
| magma_status_t GetError() override |
| { |
| // We need a lock around the channel write and read, because otherwise it's possible two |
| // threads will send the GetErrorOp, the first WaitError will get a response and read it, |
| // and the second WaitError will wake up because of the first response and error out because |
| // there's no message available to read yet. |
| std::lock_guard<std::mutex> lock(get_error_lock_); |
| magma_status_t error = error_; |
| error_ = 0; |
| if (error != MAGMA_STATUS_OK) |
| return error; |
| magma_status_t status = MagmaChannelStatus(magma_fidl_->GetErrorFIDL(&error)); |
| if (status != MAGMA_STATUS_OK) |
| return status; |
| return error; |
| } |
| |
| magma_status_t MapBufferGpu(uint64_t buffer_id, uint64_t gpu_va, uint64_t page_offset, |
| uint64_t page_count, uint64_t flags) override |
| { |
| DLOG("ZirconPlatformConnectionClient: MapBufferGpu"); |
| magma_status_t result = MagmaChannelStatus( |
| magma_fidl_->MapBufferGpuFIDL(buffer_id, gpu_va, page_offset, page_count, flags)); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t UnmapBufferGpu(uint64_t buffer_id, uint64_t gpu_va) override |
| { |
| DLOG("ZirconPlatformConnectionClient: UnmapBufferGpu"); |
| magma_status_t result = |
| MagmaChannelStatus(magma_fidl_->UnmapBufferGpuFIDL(buffer_id, gpu_va)); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t CommitBuffer(uint64_t buffer_id, uint64_t page_offset, |
| uint64_t page_count) override |
| { |
| DLOG("ZirconPlatformConnectionClient: CommitBuffer"); |
| magma_status_t result = |
| MagmaChannelStatus(magma_fidl_->CommitBufferFIDL(buffer_id, page_offset, page_count)); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| void SetError(magma_status_t error) |
| { |
| std::lock_guard<std::mutex> lock(get_error_lock_); |
| if (!error_) |
| error_ = DRET_MSG(error, "ZirconPlatformConnectionClient encountered dispatcher error"); |
| } |
| |
| int GetNotificationChannelFd() override |
| { |
| return fdio_handle_fd(notification_channel_.get(), |
| ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, 0, true); |
| } |
| |
| uint32_t GetNotificationChannelHandle() override { return notification_channel_.get(); } |
| |
| magma_status_t ReadNotificationChannel(void* buffer, size_t buffer_size, |
| size_t* buffer_size_out) override |
| { |
| uint32_t buffer_actual_size; |
| zx_status_t status = notification_channel_.read(0, buffer, buffer_size, &buffer_actual_size, |
| nullptr, 0, nullptr); |
| *buffer_size_out = buffer_actual_size; |
| if (status == ZX_ERR_SHOULD_WAIT) { |
| *buffer_size_out = 0; |
| return MAGMA_STATUS_OK; |
| } else if (status == ZX_OK) { |
| return MAGMA_STATUS_OK; |
| } else if (status == ZX_ERR_PEER_CLOSED) { |
| return DRET_MSG(MAGMA_STATUS_CONNECTION_LOST, "notification channel, closed"); |
| } else { |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, |
| "failed to wait on notification channel status %u", status); |
| } |
| } |
| |
| private: |
| fuchsia::gpu::magma::PrimarySyncPtr magma_fidl_; |
| zx::channel notification_channel_; |
| uint32_t next_context_id_ = 1; |
| std::mutex get_error_lock_; |
| MAGMA_GUARDED(get_error_lock_) magma_status_t error_{}; |
| }; // class ZirconPlatformConnectionClient |
| |
| #else // MAGMA_FIDL |
| |
| /** |
| * ZirconPlatformConnectionClient without FIDL |
| */ |
| class ZirconPlatformConnectionClient : public PlatformConnectionClient { |
| public: |
| ZirconPlatformConnectionClient(zx::channel channel, zx::channel notification_channel) |
| : channel_(std::move(channel)), notification_channel_(std::move(notification_channel)) |
| { |
| } |
| |
| // Imports a buffer for use in the system driver |
| magma_status_t ImportBuffer(PlatformBuffer* buffer) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ImportBuffer"); |
| if (!buffer) |
| return DRET_MSG(MAGMA_STATUS_INVALID_ARGS, "attempting to import null buffer"); |
| uint32_t duplicate_handle; |
| if (!buffer->duplicate_handle(&duplicate_handle)) |
| return DRET_MSG(MAGMA_STATUS_INVALID_ARGS, "failed to get duplicate_handle"); |
| |
| ImportBufferOp op; |
| zx_handle_t duplicate_handle_zx = duplicate_handle; |
| magma_status_t result = channel_write(&op, sizeof(op), &duplicate_handle_zx, 1); |
| if (result != MAGMA_STATUS_OK) { |
| DLOG("ZirconPlatformConnectionClient: ImportBuffer - failed to write to channel"); |
| return DRET_MSG(result, "failed to write to channel"); |
| } |
| return MAGMA_STATUS_OK; |
| } |
| |
| // Destroys the buffer with |buffer_id| within this connection |
| // returns false if the buffer with |buffer_id| has not been imported |
| magma_status_t ReleaseBuffer(uint64_t buffer_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ReleaseBuffer"); |
| ReleaseBufferOp op; |
| op.buffer_id = buffer_id; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t ImportObject(uint32_t handle, PlatformObject::Type object_type) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ImportObject"); |
| ImportObjectOp op; |
| op.object_type = object_type; |
| zx_handle_t duplicate_handle_zx = handle; |
| magma_status_t result = channel_write(&op, sizeof(op), &duplicate_handle_zx, 1); |
| if (result != MAGMA_STATUS_OK) { |
| return DRET_MSG(result, "failed to write to channel"); |
| } |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t ReleaseObject(uint64_t object_id, PlatformObject::Type object_type) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ReleaseObject"); |
| ReleaseObjectOp op; |
| op.object_id = object_id; |
| op.object_type = object_type; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| // Creates a context and returns the context id |
| void CreateContext(uint32_t* context_id_out) override |
| { |
| DLOG("ZirconPlatformConnectionClient: CreateContext"); |
| auto context_id = next_context_id_++; |
| *context_id_out = context_id; |
| CreateContextOp op; |
| op.context_id = context_id; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| // Destroys a context for the given id |
| void DestroyContext(uint32_t context_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: DestroyContext"); |
| DestroyContextOp op; |
| op.context_id = context_id; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| void ExecuteCommandBuffer(uint32_t command_buffer_handle, uint32_t context_id) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ExecuteCommandBuffer"); |
| ExecuteCommandBufferOp op; |
| op.context_id = context_id; |
| zx_handle_t duplicate_handle_zx = command_buffer_handle; |
| magma_status_t result = channel_write(&op, sizeof(op), &duplicate_handle_zx, 1); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| |
| void ExecuteImmediateCommands(uint32_t context_id, uint64_t command_count, |
| magma_system_inline_command_buffer* command_buffers) override |
| { |
| DLOG("ZirconPlatformConnectionClient: ExecuteImmediateCommands"); |
| uint8_t payload[fuchsia::gpu::magma::kReceiveBufferSize]; |
| uint64_t commands_sent = 0; |
| while (commands_sent < command_count) { |
| auto op = new (payload) ExecuteImmediateCommandsOp; |
| op->context_id = context_id; |
| |
| uint64_t space_used = sizeof(ExecuteImmediateCommandsOp); |
| uint64_t semaphores_used = 0; |
| uint64_t last_command; |
| for (last_command = commands_sent; last_command < command_count; last_command++) { |
| uint64_t command_space = |
| command_buffers[last_command].size + |
| command_buffers[last_command].semaphore_count * sizeof(uint64_t); |
| space_used += command_space; |
| if (space_used > sizeof(payload)) |
| break; |
| semaphores_used += command_buffers[last_command].semaphore_count; |
| } |
| op->semaphore_count = semaphores_used; |
| uint64_t* semaphore_data = op->semaphores; |
| uint8_t* command_data = op->command_data(); |
| uint64_t command_data_used = 0; |
| for (uint64_t i = commands_sent; i < last_command; i++) { |
| memcpy(semaphore_data, command_buffers[i].semaphores, |
| command_buffers[i].semaphore_count * sizeof(uint64_t)); |
| semaphore_data += command_buffers[i].semaphore_count; |
| memcpy(command_data, command_buffers[i].data, command_buffers[i].size); |
| command_data += command_buffers[i].size; |
| command_data_used += command_buffers[i].size; |
| } |
| op->commands_size = command_data_used; |
| commands_sent = last_command; |
| uint64_t payload_size = |
| ExecuteImmediateCommandsOp::size(op->semaphore_count, op->commands_size); |
| DASSERT(payload_size <= sizeof(payload)); |
| magma_status_t result = channel_write(payload, payload_size, nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| SetError(result); |
| } |
| } |
| |
| magma_status_t GetError() override |
| { |
| // We need a lock around the channel write and read, because otherwise it's possible two |
| // threads will send the GetErrorOp, the first WaitError will get a response and read it, |
| // and the second WaitError will wake up because of the first response and error out because |
| // there's no message available to read yet. |
| std::lock_guard<std::mutex> lock(get_error_lock_); |
| magma_status_t error = error_; |
| error_ = 0; |
| if (error != MAGMA_STATUS_OK) |
| return error; |
| GetErrorOp op; |
| magma_status_t status = channel_write(&op, sizeof(op), nullptr, 0); |
| if (status != MAGMA_STATUS_OK) |
| return DRET_MSG(status, "failed to write to channel"); |
| status = WaitError(&error); |
| if (status != MAGMA_STATUS_OK) |
| return status; |
| return error; |
| } |
| |
| magma_status_t MapBufferGpu(uint64_t buffer_id, uint64_t gpu_va, uint64_t page_offset, |
| uint64_t page_count, uint64_t flags) override |
| { |
| DLOG("ZirconPlatformConnectionClient: MapBufferGpu"); |
| MapBufferGpuOp op; |
| op.buffer_id = buffer_id; |
| op.gpu_va = gpu_va; |
| op.page_offset = page_offset; |
| op.page_count = page_count; |
| op.flags = flags; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t UnmapBufferGpu(uint64_t buffer_id, uint64_t gpu_va) override |
| { |
| DLOG("ZirconPlatformConnectionClient: UnmapBufferGpu"); |
| UnmapBufferGpuOp op; |
| op.buffer_id = buffer_id; |
| op.gpu_va = gpu_va; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| magma_status_t CommitBuffer(uint64_t buffer_id, uint64_t page_offset, |
| uint64_t page_count) override |
| { |
| DLOG("ZirconPlatformConnectionClient: CommitBuffer"); |
| CommitBufferOp op; |
| op.buffer_id = buffer_id; |
| op.page_offset = page_offset; |
| op.page_count = page_count; |
| magma_status_t result = channel_write(&op, sizeof(op), nullptr, 0); |
| if (result != MAGMA_STATUS_OK) |
| return DRET_MSG(result, "failed to write to channel"); |
| return MAGMA_STATUS_OK; |
| } |
| |
| void SetError(magma_status_t error) |
| { |
| std::lock_guard<std::mutex> lock(get_error_lock_); |
| if (!error_) |
| error_ = DRET_MSG(error, "ZirconPlatformConnectionClient encountered dispatcher error"); |
| } |
| |
| magma_status_t WaitError(magma_status_t* error_out) |
| { |
| return WaitMessage(reinterpret_cast<uint8_t*>(error_out), sizeof(*error_out), true); |
| } |
| |
| magma_status_t WaitMessage(uint8_t* msg_out, uint32_t msg_size, bool blocking) |
| { |
| zx_signals_t signals = ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED; |
| zx_signals_t pending = 0; |
| |
| zx_status_t status = |
| channel_.wait_one(signals, blocking ? zx::time::infinite() : zx::time(), &pending); |
| if (status == ZX_ERR_TIMED_OUT) { |
| return 0; |
| } else if (status == ZX_OK) { |
| DLOG("got ZX_OK, blocking: %s, readable: %s, closed %s", blocking ? "true" : "false", |
| pending & ZX_CHANNEL_READABLE ? "true" : "false", |
| pending & ZX_CHANNEL_PEER_CLOSED ? "true" : "false"); |
| if (pending & ZX_CHANNEL_READABLE) { |
| uint32_t actual_bytes; |
| zx_status_t status = |
| channel_.read(0, msg_out, msg_size, &actual_bytes, nullptr, 0, nullptr); |
| if (status != ZX_OK) |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, "failed to read from channel"); |
| if (actual_bytes != msg_size) |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, |
| "read wrong number of bytes from channel"); |
| } else if (pending & ZX_CHANNEL_PEER_CLOSED) { |
| return DRET_MSG(MAGMA_STATUS_CONNECTION_LOST, "channel, closed"); |
| } |
| return 0; |
| } else { |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, "failed to wait on channel"); |
| } |
| } |
| |
| int GetNotificationChannelFd() override |
| { |
| return fdio_handle_fd(notification_channel_.get(), |
| ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, 0, true); |
| } |
| |
| uint32_t GetNotificationChannelHandle() override { return notification_channel_.get(); } |
| |
| magma_status_t ReadNotificationChannel(void* buffer, size_t buffer_size, |
| size_t* buffer_size_out) override |
| { |
| uint32_t buffer_actual_size; |
| zx_status_t status = notification_channel_.read(0, buffer, buffer_size, &buffer_actual_size, |
| nullptr, 0, nullptr); |
| *buffer_size_out = buffer_actual_size; |
| if (status == ZX_ERR_SHOULD_WAIT) { |
| *buffer_size_out = 0; |
| return MAGMA_STATUS_OK; |
| } else if (status == ZX_OK) { |
| return MAGMA_STATUS_OK; |
| } else if (status == ZX_ERR_PEER_CLOSED) { |
| return DRET_MSG(MAGMA_STATUS_CONNECTION_LOST, "notification channel, closed"); |
| } else { |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, |
| "failed to wait on notification channel status %u", status); |
| } |
| } |
| |
| private: |
| magma_status_t channel_write(const void* bytes, uint32_t num_bytes, const zx_handle_t* handles, |
| uint32_t num_handles) |
| { |
| return MagmaChannelStatus(channel_.write(0, bytes, num_bytes, handles, num_handles)); |
| } |
| |
| zx::channel channel_; |
| zx::channel notification_channel_; |
| uint32_t next_context_id_ = 1; |
| std::mutex get_error_lock_; |
| MAGMA_GUARDED(get_error_lock_) magma_status_t error_{}; |
| }; // class ZirconPlatformConnectionClient |
| #endif // MAGMA_FIDL |
| |
| std::unique_ptr<PlatformConnectionClient> |
| PlatformConnectionClient::Create(uint32_t device_handle, uint32_t device_notification_handle) |
| { |
| return std::unique_ptr<ZirconPlatformConnectionClient>(new ZirconPlatformConnectionClient( |
| zx::channel(device_handle), zx::channel(device_notification_handle))); |
| } |
| |
| bool PlatformConnectionClient::Query(int fd, uint64_t query_id, uint64_t* result_out) |
| { |
| fdio_t* fdio = fdio_unsafe_fd_to_io(fd); |
| if (!fdio) |
| return DRETF(false, "invalid fd: %d", fd); |
| |
| zx_status_t status = |
| fuchsia_gpu_magma_DeviceQuery(fdio_unsafe_borrow_channel(fdio), query_id, result_out); |
| fdio_unsafe_release(fdio); |
| |
| if (status != ZX_OK) |
| return DRETF(false, "magma_DeviceQuery failed: %d", status); |
| |
| return true; |
| } |
| |
| bool PlatformConnectionClient::GetHandles(int fd, uint32_t* device_handle_out, |
| uint32_t* device_notification_handle_out) |
| { |
| fdio_t* fdio = fdio_unsafe_fd_to_io(fd); |
| if (!fdio) |
| return DRETF(false, "invalid fd: %d", fd); |
| |
| zx_status_t status = fuchsia_gpu_magma_DeviceConnect( |
| fdio_unsafe_borrow_channel(fdio), magma::PlatformThreadId().id(), device_handle_out, |
| device_notification_handle_out); |
| fdio_unsafe_release(fdio); |
| |
| if (status != ZX_OK) |
| return DRETF(false, "magma_DeviceConnect failed: %d", status); |
| |
| return true; |
| } |
| |
| } // namespace magma |
