RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-10-31 19:32:45 +00:00
Code Issues Activity Actions

Kernel: Simplify KBuffer by removing KBufferImpl

Browse source 
This patch moves everything from KBufferImpl into KBuffer instead.
One layer of indirection is removed, and the whole thing is massively
simplified. :^)
This commit is contained in:
Andreas Kling 2021-09-07 16:19:47 +02:00
parent 60b892772f
commit 8ded4ad88c
1 changed files with 16 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

97
Kernel/KBuffer.h
View file

@ -1,14 +1,13 @@
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
// KBuffer: Statically sized kernel-only memory buffer.
// KBuffer: Memory buffer backed by a kernel region.
//
// A KBuffer is a value-type convenience class that wraps a NonnullRefPtr<KBufferImpl>.
// The memory is allocated via the global kernel-only page allocator, rather than via
// kmalloc() which is what ByteBuffer/Vector/etc will use.
//
@ -17,51 +16,34 @@
// severely limited kmalloc heap.
#include <AK/Assertions.h>
#include <AK/ByteBuffer.h>
#include <AK/Memory.h>
#include <AK/StringView.h>
#include <Kernel/Memory/MemoryManager.h>
#include <Kernel/Memory/Region.h>
namespace Kernel {
class KBufferImpl : public RefCounted<KBufferImpl> {
class [[nodiscard]] KBuffer {
public:
static RefPtr<KBufferImpl> try_create_with_size(size_t size, Memory::Region::Access access, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
{
auto region_or_error = MM.allocate_kernel_region(Memory::page_round_up(size), name, access, strategy);
if (region_or_error.is_error())
return nullptr;
return adopt_ref_if_nonnull(new (nothrow) KBufferImpl(region_or_error.release_value(), size, strategy));
auto region = TRY(MM.allocate_kernel_region(Memory::page_round_up(size), name, access, strategy));
return TRY(adopt_nonnull_own_or_enomem(new (nothrow) KBuffer { size, move(region) }));
}
static RefPtr<KBufferImpl> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
{
auto region_or_error = MM.allocate_kernel_region(Memory::page_round_up(bytes.size()), name, access, strategy);
if (region_or_error.is_error())
return nullptr;
auto region = region_or_error.release_value();
memcpy(region->vaddr().as_ptr(), bytes.data(), bytes.size());
return adopt_ref_if_nonnull(new (nothrow) KBufferImpl(move(region), bytes.size(), strategy));
}
static RefPtr<KBufferImpl> create_with_size(size_t size, Memory::Region::Access access, StringView name, AllocationStrategy strategy = AllocationStrategy::Reserve)
{
return try_create_with_size(size, access, name, strategy);
}
static RefPtr<KBufferImpl> copy(const void* data, size_t size, Memory::Region::Access access, StringView name)
{
auto buffer = create_with_size(size, access, name, AllocationStrategy::AllocateNow);
if (!buffer)
return {};
memcpy(buffer->data(), data, size);
auto buffer = TRY(try_create_with_size(bytes.size(), access, name, strategy));
memcpy(buffer->data(), bytes.data(), bytes.size());
return buffer;
}
static KResultOr<NonnullOwnPtr<KBuffer>> try_copy(const void* data, size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer")
{
return try_create_with_bytes(ReadonlyBytes { data, size }, access, name);
}
[[nodiscard]] u8* data() { return m_region->vaddr().as_ptr(); }
[[nodiscard]] const u8* data() const { return m_region->vaddr().as_ptr(); }
[[nodiscard]] u8 const* data() const { return m_region->vaddr().as_ptr(); }
[[nodiscard]] size_t size() const { return m_size; }
[[nodiscard]] size_t capacity() const { return m_region->size(); }
@ -71,62 +53,15 @@ public:
m_size = size;
}
[[nodiscard]] Memory::Region const& region() const { return *m_region; }
[[nodiscard]] Memory::Region& region() { return *m_region; }
private:
explicit KBufferImpl(NonnullOwnPtr<Memory::Region>&& region, size_t size, AllocationStrategy strategy)
explicit KBuffer(size_t size, NonnullOwnPtr<Memory::Region> region)
: m_size(size)
, m_allocation_strategy(strategy)
, m_region(move(region))
{
}
size_t m_size { 0 };
AllocationStrategy m_allocation_strategy { AllocationStrategy::Reserve };
NonnullOwnPtr<Memory::Region> m_region;
};
class [[nodiscard]] KBuffer {
public:
static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
{
auto impl = KBufferImpl::try_create_with_size(size, access, name, strategy);
if (!impl)
return ENOMEM;
return adopt_nonnull_own_or_enomem(new (nothrow) KBuffer(impl.release_nonnull()));
}
static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
{
auto impl = KBufferImpl::try_create_with_bytes(bytes, access, name, strategy);
if (!impl)
return ENOMEM;
return adopt_nonnull_own_or_enomem(new (nothrow) KBuffer(impl.release_nonnull()));
}
static KResultOr<NonnullOwnPtr<KBuffer>> try_copy(const void* data, size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer")
{
auto impl = KBufferImpl::copy(data, size, access, name);
if (!impl)
return ENOMEM;
return adopt_nonnull_own_or_enomem(new (nothrow) KBuffer(impl.release_nonnull()));
}
[[nodiscard]] u8* data() { return m_impl->data(); }
[[nodiscard]] const u8* data() const { return m_impl->data(); }
[[nodiscard]] size_t size() const { return m_impl->size(); }
[[nodiscard]] size_t capacity() const { return m_impl->capacity(); }
void set_size(size_t size) { m_impl->set_size(size); }
private:
explicit KBuffer(NonnullRefPtr<KBufferImpl> impl)
: m_impl(move(impl))
{
}
NonnullRefPtr<KBufferImpl> m_impl;
};
}