blob: 15ffdd9cb9c82c581479e0bcff11a7be581a6e08 [file] [log] [blame]
// 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/listnode.h> // for containerof
#include <region-alloc/region-alloc.h>
extern "C" {
zx_status_t ralloc_create_pool(size_t max_memory, ralloc_pool_t** out_pool) {
if (out_pool == nullptr)
return ZX_ERR_INVALID_ARGS;
auto pool = RegionAllocator::RegionPool::Create(max_memory);
if (pool == nullptr)
return ZX_ERR_NO_MEMORY;
// Everything looks good. Deliberately leak our reference out into the cold
// cruel world of C. I sure hope that it comes back some day...
*out_pool = reinterpret_cast<ralloc_pool_t*>(fbl::ExportToRawPtr(&pool));
return ZX_OK;
}
void ralloc_release_pool(ralloc_pool_t* pool) {
ZX_DEBUG_ASSERT(pool != nullptr);
// Reclaim our reference back from the land of C by turning the pointer
// back into a RefPtr, then deliberately let it go out of scope, dropping
// its reference and destructing the RegionPool if need be.
auto release_me = fbl::ImportFromRawPtr(reinterpret_cast<RegionAllocator::RegionPool*>(pool));
}
zx_status_t ralloc_create_allocator(ralloc_allocator_t** out_allocator) {
if (!out_allocator)
return ZX_ERR_INVALID_ARGS;
void* mem = ::malloc(sizeof(RegionAllocator));
if (!mem)
return ZX_ERR_NO_MEMORY;
*out_allocator = reinterpret_cast<ralloc_allocator_t*>(new (mem) RegionAllocator());
return ZX_OK;
}
zx_status_t ralloc_set_region_pool(ralloc_allocator_t* allocator, ralloc_pool* pool) {
if (!allocator || !pool)
return ZX_ERR_INVALID_ARGS;
RegionAllocator& alloc = *(reinterpret_cast<RegionAllocator*>(allocator));
// Turn our C-style pointer back into a RefPtr<> without adding a reference,
// then use it to call the RegionAllocator::SetRegionPool method. Finally,
// deliberately leak the reference again so we are not accidentally removing
// the unmanaged reference held by our C user.
auto pool_ref = fbl::ImportFromRawPtr(reinterpret_cast<RegionAllocator::RegionPool*>(pool));
zx_status_t ret = alloc.SetRegionPool(pool_ref);
__UNUSED auto leak = fbl::ExportToRawPtr(&pool_ref);
return ret;
}
void ralloc_reset_allocator(ralloc_allocator_t* allocator) {
ZX_DEBUG_ASSERT(allocator);
reinterpret_cast<RegionAllocator*>(allocator)->Reset();
}
void ralloc_destroy_allocator(ralloc_allocator_t* allocator) {
ZX_DEBUG_ASSERT(allocator);
RegionAllocator* alloc = reinterpret_cast<RegionAllocator*>(allocator);
alloc->~RegionAllocator();
::free(alloc);
}
zx_status_t ralloc_add_region(ralloc_allocator_t* allocator, const ralloc_region_t* region,
region_allocator_allow_overlap_t allow_overlap) {
if (!allocator || !region)
return ZX_ERR_INVALID_ARGS;
return reinterpret_cast<RegionAllocator*>(allocator)->AddRegion(
*region, static_cast<RegionAllocator::AllowOverlap>(allow_overlap));
}
zx_status_t ralloc_sub_region(ralloc_allocator_t* allocator, const ralloc_region_t* region,
region_allocator_allow_incomplete_t allow_incomplete) {
if (!allocator || !region)
return ZX_ERR_INVALID_ARGS;
return reinterpret_cast<RegionAllocator*>(allocator)->SubtractRegion(
*region, static_cast<RegionAllocator::AllowIncomplete>(allow_incomplete));
}
zx_status_t ralloc_get_sized_region_ex(ralloc_allocator_t* allocator, uint64_t size,
uint64_t alignment, const ralloc_region_t** out_region) {
if (!allocator || !out_region)
return ZX_ERR_INVALID_ARGS;
RegionAllocator::Region::UPtr managed_region;
RegionAllocator& alloc = *(reinterpret_cast<RegionAllocator*>(allocator));
zx_status_t result = alloc.GetRegion(size, alignment, managed_region);
if (result == ZX_OK) {
// Everything looks good. Detach the managed_region our unique_ptr<>
// and send the unmanaged pointer to the inner ralloc_region_t back
// to the caller.
ZX_DEBUG_ASSERT(managed_region != nullptr);
const RegionAllocator::Region* raw_region = managed_region.release();
*out_region = static_cast<const ralloc_region_t*>(raw_region);
} else {
ZX_DEBUG_ASSERT(managed_region == nullptr);
*out_region = nullptr;
}
return result;
}
zx_status_t ralloc_get_specific_region_ex(ralloc_allocator_t* allocator,
const ralloc_region_t* requested_region,
const ralloc_region_t** out_region) {
if (!allocator || !requested_region || !out_region)
return ZX_ERR_INVALID_ARGS;
RegionAllocator::Region::UPtr managed_region;
RegionAllocator& alloc = *(reinterpret_cast<RegionAllocator*>(allocator));
zx_status_t result = alloc.GetRegion(*requested_region, managed_region);
if (result == ZX_OK) {
// Everything looks good. Detach the managed_region our unique_ptr<>
// and send the unmanaged pointer to the inner ralloc_region_t back
// to the caller.
ZX_DEBUG_ASSERT(managed_region != nullptr);
const RegionAllocator::Region* raw_region = managed_region.release();
*out_region = static_cast<const ralloc_region_t*>(raw_region);
} else {
ZX_DEBUG_ASSERT(managed_region == nullptr);
*out_region = nullptr;
}
return result;
}
size_t ralloc_get_allocated_region_count(const ralloc_allocator_t* allocator) {
ZX_DEBUG_ASSERT(allocator != nullptr);
const RegionAllocator& alloc = *(reinterpret_cast<const RegionAllocator*>(allocator));
return alloc.AllocatedRegionCount();
}
size_t ralloc_get_available_region_count(const ralloc_allocator_t* allocator) {
ZX_DEBUG_ASSERT(allocator != nullptr);
const RegionAllocator& alloc = *(reinterpret_cast<const RegionAllocator*>(allocator));
return alloc.AvailableRegionCount();
}
void ralloc_put_region(const ralloc_region_t* region) {
ZX_DEBUG_ASSERT(region);
// Reclaim our reference back from the land of C by turning the pointer
// back into a unique_ptr, then deliberately let it go out of scope, destroying the
// RegionAllocator::Region in the process..
auto raw_region = static_cast<const RegionAllocator::Region*>(region);
RegionAllocator::Region::UPtr release_me(raw_region);
}
zx_status_t ralloc_walk_allocated_regions(const ralloc_allocator_t* allocator, region_walk_cb cb,
void* ctx) {
ZX_DEBUG_ASSERT(allocator != nullptr);
if (cb == NULL) {
return ZX_ERR_INVALID_ARGS;
}
const RegionAllocator& alloc = *(reinterpret_cast<const RegionAllocator*>(allocator));
alloc.WalkAllocatedRegions([cb, ctx](const ralloc_region_t* r) -> bool { return cb(r, ctx); });
return ZX_OK;
}
} // extern "C"