A handler to manage resource commands over shared memory. More...

#include <resource_bridge.h>

Inheritance diagram for MaxOS::processes::resources::BridgeHandler:

Public Member Functions
	BridgeHandler (string const &shared_name, Process *owner_process)
	Constructs a handler to manage resource commands over shared memory.

size_t	allocate_id ()
	Allocates an ID to identify a resource on the bridge.

int64_t	send_to_bridge (size_t id, KPI::ServiceResourceCommand command, const void *buffer, size_t size, size_t flags)
	Send a command and its associated data to the endpoint associated with this resource.

Public Member Functions inherited from MaxOS::memory::allocator::BumpAllocator
	BumpAllocator ()
	Creates a new bump memory allocator.

virtual	~BumpAllocator ()
	Destructs a Bump memory allocator.

void	setup_region (uintptr_t address, size_t length) final
	Setup a region to be bump memory managed, creates a free chunk represent the whole region.

void *	allocate (size_t size) final
	Allocates a block of memory.

void	unallocate (void *pointer) final
	Frees a block of memory.

size_t	amount_used () final
	Returns the amount of memory used.

size_t	align (size_t size) final
	Aligns the size to the chunk alignment.

Public Member Functions inherited from MaxOS::memory::allocator::MemoryAllocator
	MemoryAllocator ()

virtual	~MemoryAllocator ()

Detailed Description

A handler to manage resource commands over shared memory.

Definition at line 32 of file resource_bridge.h.

Constructor & Destructor Documentation

◆ BridgeHandler()

BridgeHandler::BridgeHandler	(	string const &	shared_name,
		Process *	owner_process
	)

Constructs a handler to manage resource commands over shared memory.

Definition at line 21 of file resource_bridge.cpp.

: m_owner_process(owner_process)
{
 
    // Get the shared memory region
    auto shared_memory = (SharedMemory*)GlobalResourceRegistry::get_registry(resource_type_t::SHARED_MEMORY)->get_resource(shared_name);
    ASSERT(shared_memory != nullptr, "Shared memory resource not found\n");
 
    // Copy into the kernel
    ASSERT(shared_memory->size() == SERVICE_SHARED_MEM_SIZE, "Shared memory resource size mismatch\n");
    auto address = MemoryManager::s_kernel_memory_manager->vmm()->load_shared_memory(shared_memory->physical_address(), SERVICE_SHARED_MEM_SIZE);
 
    // Setup the message region
    m_message_ring = (service_message_ring_t*)address;
 
    // Setup the data region
    m_data_region = (uintptr_t)address + MESSAGE_SIZE;
    setup_region(m_data_region, DATA_SIZE);
}

References MaxOS::processes::resources::GlobalResourceRegistry::get_registry(), MaxOS::processes::resources::BaseResourceRegistry::get_resource(), MaxOS::memory::VirtualMemoryManager::load_shared_memory(), MaxOS::memory::MemoryManager::s_kernel_memory_manager, MaxOS::memory::allocator::BumpAllocator::setup_region(), and MaxOS::memory::BumpMemoryManager::vmm().

Member Function Documentation

◆ allocate_id()

size_t BridgeHandler::allocate_id ( )

Allocates an ID to identify a resource on the bridge.

Returns: The ID that the resource can use

Definition at line 122 of file resource_bridge.cpp.

                                  {
    return __atomic_fetch_add(&m_next_id, 1, __ATOMIC_RELAXED);
}

◆ send_to_bridge()

int64_t BridgeHandler::send_to_bridge	(	size_t	id,
		KPI::ServiceResourceCommand	command,
		const void *	buffer,
		size_t	size,
		size_t	flags
	)

Send a command and its associated data to the endpoint associated with this resource.

Parameters

id	The id of the resource
command	The command to execute
buffer	The data to pass along with the command
size	The size of the data buffer
flags	Flags associated with the command

Todo:: Get slot data before freeing

Definition at line 139 of file resource_bridge.cpp.

                                                                                                                              {
 
    // Copy data into shared region
    bool is_read = command == ServiceResourceCommand::R_READ; // || command == BridgeResourceCommand::R_READ_ATTR;
    bool is_page_mapped = size >= MAX_COPY_SIZE;
    size_t offset = store_data(buffer, size, is_read);
 
    // Construct the message
    auto slot = aquire_slot();
    __atomic_store_n(&slot->sending_pid,    GlobalScheduler::current_process()->pid(),  __ATOMIC_RELAXED);
    __atomic_store_n(&slot->resource_id,        id,                                         __ATOMIC_RELAXED);
    __atomic_store_n(&slot->flags,              flags,                                      __ATOMIC_RELAXED);
    __atomic_store_n(&slot->command,            (uint8_t)command,                           __ATOMIC_RELAXED);
    __atomic_store_n(&slot->data_size,          size,                                       __ATOMIC_RELAXED);
    __atomic_store_n(&slot->data_offset,        offset,                                     __ATOMIC_RELAXED);
    __atomic_store_n(&slot->data_page_mapped,   is_page_mapped,                             __ATOMIC_RELAXED);
    __atomic_store_n(&slot->response,       0,                                          __ATOMIC_RELAXED);
    __atomic_store_n(&slot->state,              (uint8_t)ServiceMessageSlotState::REQUEST,  __ATOMIC_RELEASE);
 
    // Wait for a response
    while (__atomic_load_n(&slot->state, __ATOMIC_ACQUIRE) == (uint8_t)ServiceMessageSlotState::REQUEST)
        GlobalScheduler::current_thread()->yield();
 
    // Read request
    if (is_read && !is_page_mapped)
        memcpy((void*)buffer, (void*)m_data_region + offset, size);
 
    // Free resources
    if (size != 0) {
        if (is_page_mapped) {
            MemoryManager* caller = GlobalScheduler::current_process()->memory_manager;
            MemoryManager::switch_active_memory_manager(m_owner_process->memory_manager);
            m_owner_process->memory_manager->vmm()->unload_range_from_process((void*)offset, size);
            MemoryManager::switch_active_memory_manager(caller);
        }
        else {
            m_lock.lock();
            unallocate((void*)m_data_region + offset);
            m_lock.unlock();
        }
    }
 
    // Get the response and then release the slot
    int64_t response = __atomic_load_n(&slot->response, __ATOMIC_RELAXED);
    __atomic_store_n(&slot->state, (uint8_t)ServiceMessageSlotState::FREE,__ATOMIC_RELEASE);
 
    return response;
}

References MaxOS::processes::GlobalScheduler::current_process(), MaxOS::processes::GlobalScheduler::current_thread(), MaxOS::processes::Process::memory_manager, MaxOS::processes::Process::pid(), MaxOS::memory::allocator::BumpAllocator::unallocate(), MaxOS::memory::VirtualMemoryManager::unload_range_from_process(), MaxOS::memory::BumpMemoryManager::vmm(), and MaxOS::processes::Thread::yield().

The documentation for this class was generated from the following files: