| // Copyright 2016 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_buffer.h" |
| |
| #include "platform_trace.h" |
| #include "zircon_platform_handle.h" |
| #include <lib/zx/vmar.h> |
| #include <lib/zx/vmo.h> |
| #include <limits.h> // PAGE_SIZE |
| #include <map> |
| #include <vector> |
| |
| namespace magma { |
| |
| // static |
| uint64_t PlatformBuffer::MinimumMappableAddress() |
| { |
| zx_info_vmar_t root_info; |
| zx::vmar::root_self()->get_info(ZX_INFO_VMAR, &root_info, sizeof(root_info), nullptr, nullptr); |
| return root_info.base; |
| } |
| |
| bool ZirconPlatformBuffer::MapAtCpuAddr(uint64_t addr, uint64_t offset, uint64_t length) |
| { |
| if (!magma::is_page_aligned(addr)) |
| return DRETF(false, "addr %lx isn't page aligned", addr); |
| if (!magma::is_page_aligned(offset)) |
| return DRETF(false, "offset %lx isn't page aligned", offset); |
| if (!magma::is_page_aligned(length)) |
| return DRETF(false, "length %lx isn't page aligned", length); |
| if (offset + length > size()) |
| return DRETF(false, "offset %lx + length %lx > size %lx", offset, length, size()); |
| if (map_count_ > 0) |
| return DRETF(false, "buffer is already mapped"); |
| |
| uint64_t minimum_mappable = MinimumMappableAddress(); |
| if (addr < minimum_mappable) |
| return DRETF(false, "addr %lx below vmar base %lx", addr, minimum_mappable); |
| |
| uint64_t child_addr; |
| zx_status_t status = zx::vmar::root_self()->allocate( |
| addr - minimum_mappable, length, |
| ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_SPECIFIC, &vmar_, |
| &child_addr); |
| if (status != ZX_OK) |
| return DRETF(false, "Failed to create vmar, status %d", status); |
| DASSERT(child_addr == addr); |
| |
| uintptr_t ptr; |
| status = vmar_.map(0, vmo_, offset, length, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, |
| &ptr); |
| if (status != ZX_OK) |
| return DRETF(false, "failed to map vmo"); |
| DASSERT(ptr == addr); |
| virt_addr_ = reinterpret_cast<void*>(ptr); |
| |
| map_count_++; |
| |
| DLOG("mapped vmo %p got %p, map_count_ = %u", this, virt_addr_, map_count_); |
| return true; |
| } |
| |
| bool ZirconPlatformBuffer::MapCpu(void** addr_out, uint64_t alignment) |
| { |
| if (!magma::is_page_aligned(alignment)) |
| return DRETF(false, "alignment 0x%lx isn't page aligned", alignment); |
| if (alignment && !magma::is_pow2(alignment)) |
| return DRETF(false, "alignment 0x%lx isn't power of 2", alignment); |
| if (map_count_ == 0) { |
| DASSERT(!virt_addr_); |
| uintptr_t ptr; |
| uintptr_t child_addr; |
| // If alignment is needed, allocate a vmar that's large enough so that |
| // the buffer will fit at an aligned address inside it. |
| uintptr_t vmar_size = alignment ? size() + alignment : size(); |
| zx_status_t status = zx::vmar::root_self()->allocate( |
| 0, vmar_size, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, &vmar_, |
| &child_addr); |
| if (status != ZX_OK) |
| return DRETF(false, "failed to make vmar"); |
| uintptr_t offset = alignment ? magma::round_up(child_addr, alignment) - child_addr : 0; |
| status = vmar_.map(offset, vmo_, 0, size(), |
| ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, &ptr); |
| if (status != ZX_OK) |
| return DRETF(false, "failed to map vmo"); |
| |
| virt_addr_ = reinterpret_cast<void*>(ptr); |
| } |
| |
| DASSERT(!alignment || (reinterpret_cast<uintptr_t>(virt_addr_) & (alignment - 1)) == 0); |
| |
| *addr_out = virt_addr_; |
| map_count_++; |
| |
| DLOG("mapped vmo %p got %p, map_count_ = %u", this, virt_addr_, map_count_); |
| |
| return true; |
| } |
| |
| bool ZirconPlatformBuffer::UnmapCpu() |
| { |
| DLOG("UnmapCpu vmo %p, map_count_ %u", this, map_count_); |
| if (map_count_) { |
| map_count_--; |
| if (map_count_ == 0) { |
| DLOG("map_count 0 unmapping vmo %p", this); |
| zx_status_t status = vmar_unmap(); |
| if (status != ZX_OK) |
| DRETF(false, "failed to unmap vmo: %d", status); |
| } |
| return true; |
| } |
| return DRETF(false, "attempting to unmap buffer that isnt mapped"); |
| } |
| |
| bool ZirconPlatformBuffer::CommitPages(uint32_t start_page_index, uint32_t page_count) const |
| { |
| TRACE_DURATION("magma", "CommitPages"); |
| if (!page_count) |
| return true; |
| |
| if ((start_page_index + page_count) * PAGE_SIZE > size()) |
| return DRETF(false, "offset + length greater than buffer size"); |
| |
| zx_status_t status = vmo_.op_range(ZX_VMO_OP_COMMIT, start_page_index * PAGE_SIZE, |
| page_count * PAGE_SIZE, nullptr, 0); |
| |
| if (status == ZX_ERR_NO_MEMORY) |
| return DRETF(false, |
| "Kernel returned ZX_ERR_NO_MEMORY when attempting to commit %u vmo " |
| "pages (%u bytes).\nThis means the system has run out of physical memory and " |
| "things will now start going very badly.\nPlease stop using so much " |
| "physical memory or download more RAM at www.downloadmoreram.com :)", |
| page_count, PAGE_SIZE * page_count); |
| else if (status != ZX_OK) |
| return DRETF(false, "failed to commit vmo pages: %d", status); |
| |
| return true; |
| } |
| |
| bool ZirconPlatformBuffer::CleanCache(uint64_t offset, uint64_t length, bool invalidate) |
| { |
| #if defined(__aarch64__) |
| if (map_count_) { |
| uint32_t op = ZX_CACHE_FLUSH_DATA; |
| if (invalidate) |
| op |= ZX_CACHE_FLUSH_INVALIDATE; |
| if (offset + length > size()) |
| return DRETF(false, "size too large for buffer"); |
| zx_status_t status = zx_cache_flush(static_cast<uint8_t*>(virt_addr_) + offset, length, op); |
| if (status != ZX_OK) |
| return DRETF(false, "failed to clean cache: %d", status); |
| return true; |
| } |
| #endif |
| |
| uint32_t op = invalidate ? ZX_VMO_OP_CACHE_CLEAN_INVALIDATE : ZX_VMO_OP_CACHE_CLEAN; |
| zx_status_t status = vmo_.op_range(op, offset, length, nullptr, 0); |
| if (status != ZX_OK) |
| return DRETF(false, "failed to clean cache: %d", status); |
| return true; |
| } |
| |
| bool ZirconPlatformBuffer::SetCachePolicy(magma_cache_policy_t cache_policy) |
| { |
| uint32_t zx_cache_policy; |
| switch (cache_policy) { |
| case MAGMA_CACHE_POLICY_CACHED: |
| zx_cache_policy = ZX_CACHE_POLICY_CACHED; |
| break; |
| |
| case MAGMA_CACHE_POLICY_WRITE_COMBINING: |
| zx_cache_policy = ZX_CACHE_POLICY_WRITE_COMBINING; |
| break; |
| |
| case MAGMA_CACHE_POLICY_UNCACHED: |
| zx_cache_policy = ZX_CACHE_POLICY_UNCACHED; |
| break; |
| |
| default: |
| return DRETF(false, "Invalid cache policy %d", cache_policy); |
| } |
| |
| zx_status_t status = zx_vmo_set_cache_policy(vmo_.get(), zx_cache_policy); |
| return DRETF(status == ZX_OK, "zx_vmo_set_cache_policy failed with status %d", status); |
| } |
| |
| magma_status_t ZirconPlatformBuffer::GetCachePolicy(magma_cache_policy_t* cache_policy_out) |
| { |
| zx_info_vmo_t vmo_info; |
| zx_status_t status = vmo_.get_info(ZX_INFO_VMO, &vmo_info, sizeof(vmo_info), nullptr, 0); |
| if (status != ZX_OK) { |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, "ZX_INFO_VMO returned status: %d", status); |
| } |
| switch (vmo_info.cache_policy) { |
| case ZX_CACHE_POLICY_CACHED: |
| *cache_policy_out = MAGMA_CACHE_POLICY_CACHED; |
| return MAGMA_STATUS_OK; |
| |
| case ZX_CACHE_POLICY_UNCACHED: |
| *cache_policy_out = MAGMA_CACHE_POLICY_UNCACHED; |
| return MAGMA_STATUS_OK; |
| |
| case ZX_CACHE_POLICY_WRITE_COMBINING: |
| *cache_policy_out = MAGMA_CACHE_POLICY_WRITE_COMBINING; |
| return MAGMA_STATUS_OK; |
| |
| default: |
| return DRET_MSG(MAGMA_STATUS_INTERNAL_ERROR, "Unknown cache policy: %d", |
| vmo_info.cache_policy); |
| } |
| } |
| |
| std::unique_ptr<PlatformBuffer> PlatformBuffer::Create(uint64_t size, const char* name) |
| { |
| size = magma::round_up(size, PAGE_SIZE); |
| if (size == 0) |
| return DRETP(nullptr, "attempting to allocate 0 sized buffer"); |
| |
| zx::vmo vmo; |
| zx_status_t status = zx::vmo::create(size, 0, &vmo); |
| if (status != ZX_OK) |
| return DRETP(nullptr, "failed to allocate vmo size %" PRId64 ": %d", size, status); |
| vmo.set_property(ZX_PROP_NAME, name, strlen(name)); |
| |
| DLOG("allocated vmo size %ld handle 0x%x", size, vmo.get()); |
| return std::unique_ptr<PlatformBuffer>(new ZirconPlatformBuffer(std::move(vmo), size)); |
| } |
| |
| std::unique_ptr<PlatformBuffer> PlatformBuffer::Import(uint32_t handle) |
| { |
| uint64_t size; |
| // presumably this will fail if handle is invalid or not a vmo handle, so we perform no |
| // additional error checking |
| zx::vmo vmo(handle); |
| auto status = vmo.get_size(&size); |
| |
| if (status != ZX_OK) |
| return DRETP(nullptr, "zx_vmo_get_size failed"); |
| |
| if (!magma::is_page_aligned(size)) |
| return DRETP(nullptr, "attempting to import vmo with invalid size"); |
| |
| return std::unique_ptr<PlatformBuffer>(new ZirconPlatformBuffer(std::move(vmo), size)); |
| } |
| |
| } // namespace magma |
