resource_bridge.cpp

Go to the documentation of this file.

 
#include <processes/resources/resource_bridge.h>
 
using namespace MaxOS;
using namespace MaxOS::processes;
using namespace MaxOS::processes::resources;
using namespace MaxOS::common;
using namespace MaxOS::memory;
using namespace MaxOS::KPI;
 
BridgeHandler::BridgeHandler(string const& shared_name, Process* owner_process)
: 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);
}
 
 
BridgeHandler::~BridgeHandler() = default;
 
size_t BridgeHandler::store_data(const void *buffer, size_t size, bool reserve_only) {
 
    // Nothing to store
    if (!size)
        return 0;
 
    bool is_mapped = size >= MAX_COPY_SIZE;
 
    // Set up the storage
    void* data;
    if (is_mapped) {
        MemoryManager* caller = GlobalScheduler::current_process()->memory_manager;
        MemoryManager::switch_active_memory_manager(m_owner_process->memory_manager);
        data = m_owner_process->memory_manager->vmm()->load_range_from_process(caller->vmm(), buffer, size);
        MemoryManager::switch_active_memory_manager(caller);
    } else {
        m_lock.lock();
        data = allocate(size);
        m_lock.unlock();
    }
    ASSERT(data != nullptr, "Could not allocate memory for bridge\n");
 
    // Copy the data
    if (!reserve_only && !is_mapped)
        memcpy(data, buffer, size);
 
    // If not mapped then its an offset into the process's own virtual address for the shared mem
    return (size_t)data - (is_mapped ? 0 : m_data_region);
 
}
 
service_resource_message_t* BridgeHandler::aquire_slot() {
 
    // Find a spot
    while (true) {
 
        // Get the data
        size_t head = __atomic_load_n(&m_message_ring->head, __ATOMIC_RELAXED);
        size_t tail = __atomic_load_n(&m_message_ring->tail, __ATOMIC_ACQUIRE);
 
        ASSERT((head < MESSAGE_SLOTS && tail < MESSAGE_SLOTS), "invalid queue indexes for resource bridge");
 
        // No available spots to claim
        size_t next = (head + 1) % MESSAGE_SLOTS;
        if (next == tail) {
            GlobalScheduler::current_thread()->yield();
            continue;
        }
 
        // Try to claim a spot
        if(!__atomic_compare_exchange_n(&m_message_ring->head, &head, next,true,__ATOMIC_ACQ_REL,__ATOMIC_RELAXED))
            continue;
 
        // Claim slot
        size_t slot = head;
        return &m_message_ring->ring_buffer[slot];
    }
}
 
size_t BridgeHandler::allocate_id() {
    return __atomic_fetch_add(&m_next_id, 1, __ATOMIC_RELAXED);
}
 
 
 
int64_t BridgeHandler::send_to_bridge(size_t id, ServiceResourceCommand command, const void *buffer, size_t size, size_t flags) {
 
    // 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;
}
 
 
BridgeResource::BridgeResource(const string &name, size_t flags, resource_type_t type)
: Resource(name, flags, type)
{
}
 
BridgeResource::~BridgeResource() = default;
 
void BridgeResource::open(size_t flags) {
     m_handler -> send_to_bridge(m_id, ServiceResourceCommand::R_OPEN, 0,0, flags);
}
 
void BridgeResource::close(size_t flags) {
     m_handler -> send_to_bridge(m_id, ServiceResourceCommand::R_CLOSE, 0,0, flags);
}
 
int BridgeResource::read(void *buffer, size_t size, size_t flags) {
    return m_handler -> send_to_bridge(m_id, ServiceResourceCommand::R_READ, buffer, size, flags);
}
 
int BridgeResource::write(const void *buffer, size_t size, size_t flags) {
    return m_handler -> send_to_bridge(m_id, ServiceResourceCommand::R_WRITE, buffer, size, flags);
}
 
void BridgeResource::attach_wrapper(BridgeHandler *wrapper) {
 
    m_handler = wrapper;
    m_id = wrapper->allocate_id();
 
}
 
bool BridgeResource::get_on_bridge() {
 
   // Let the bridge get the object on its end
   return m_handler -> send_to_bridge(m_id, ServiceResourceCommand::S_GET, name().c_str(),name().length() + 1, 0) > 0;
 
 
}
 
void BridgeResource::create_on_bridge() {
 
    // Let the bridge construct the object on its end
    m_handler -> send_to_bridge(m_id, ServiceResourceCommand::S_CREATE, name().c_str(),name().length() + 1, 0);
 
}
 
 
BridgeResourceRegistry::BridgeResourceRegistry(const string &shared_name, size_t resource_id)
: ResourceRegistry((resource_type_t)resource_id),
  m_handler(shared_name, GlobalScheduler::current_process())
{
 
}
 
BridgeResourceRegistry::~BridgeResourceRegistry() = default;
 
Resource* BridgeResourceRegistry::get_resource(const string &name) {
 
    // Resource already opened
    auto resource = BaseResourceRegistry::get_resource(name);
    if(resource != nullptr)
        return resource;
 
    // Setup a temporary resource
    auto attempt_resource = new BridgeResource(name, 0, m_type);
    attempt_resource->attach_wrapper(&m_handler);
 
    // Try open on the server
    if (attempt_resource->get_on_bridge()) {
        register_resource(attempt_resource);
        return attempt_resource;
    }
 
    // Must have failed to get on server
    delete attempt_resource;
    return nullptr;
}
 
Resource* BridgeResourceRegistry::create_resource(const string &name, size_t flags, uintptr_t data) {
 
    // Create the resource
    auto resource = new BridgeResource(name, flags, m_type);
 
    // Creation failed
    if(!register_resource(resource)) {
        delete resource;
        return nullptr;
    }
 
    // Handoff setup to bridge
    resource->attach_wrapper(&m_handler);
    resource->create_on_bridge();
    return resource;
}