ipc.cpp

Go to the documentation of this file.

 
#include <processes/ipc.h>
 
using namespace MaxOS;
using namespace MaxOS::processes;
using namespace MaxOS::processes::resources;
using namespace MaxOS::common;
using namespace MaxOS::memory;
 
#include <common/logger.h>
#include <processes/scheduler.h>
 
SharedMemory::SharedMemory(const string& name, size_t size, resource_type_t type)
: Resource(name, size, MaxOS::KPI::ResourceType::SHARED_MEMORY),
  m_size(size)
{
    m_physical_address = (uintptr_t) PhysicalMemoryManager::s_current_manager->allocate_area(0, size);
}
 
SharedMemory::~SharedMemory() = default;
 
int SharedMemory::read(void* buffer, size_t size, size_t flags) {
 
    // Process hasn't opened the resource
    auto it = m_mappings.find(GlobalScheduler::current_process()->pid());
    if(it == m_mappings.end())
        return 0;
 
    return it->second;
}
 
uintptr_t SharedMemory::physical_address() const {
 
    return m_physical_address;
}
 
size_t SharedMemory::size() const {
 
    return m_size;
}
 
void SharedMemory::open(size_t flags) {
 
    // Process has already opened this memory
    auto it = m_mappings.find(GlobalScheduler::current_process()->pid());
    if(it != m_mappings.end())
        return;
 
    auto virtual_address = (uintptr_t)GlobalScheduler::current_process()->memory_manager->vmm()->load_shared_memory(m_physical_address, m_size);
    m_mappings.insert(GlobalScheduler::current_process()->pid(), virtual_address);
 
}
 
void SharedMemory::close(size_t flags) {
 
    PhysicalMemoryManager::s_current_manager->free_area(m_physical_address, m_size);
 
}
 
SharedMessageEndpoint::SharedMessageEndpoint(const string& name, size_t size, resource_type_t type)
: Resource(name, size, type)
{
 
}
 
SharedMessageEndpoint::~SharedMessageEndpoint() {
 
    // Free the messages
    for(auto& message : m_queue)
        delete message;
}
 
void SharedMessageEndpoint::send(const ipc_iovec_t *vec, size_t count) {
 
    m_message_lock.lock();
 
    // Parse the message parts
    size_t size = 0;
    for (size_t i = 0; i < count; ++i)
        size += vec[i].length;
 
    // Create the message
    auto* new_message = new buffer_t(size);
    for (size_t i = 0; i < count; ++i)
        new_message->copy_from(vec[i].address, vec[i].length);
 
    // Send the message
    m_queue.push_back(new_message);
    m_message_lock.unlock();
 
}
 
int SharedMessageEndpoint::read(void* buffer, size_t size, size_t flags) {
 
    // Wait for a message
    while(m_queue.empty()) {
        if (flags)
            return 0;
 
        // Block
        GlobalScheduler::current_thread()->yield();
    }
 
    // Read the message into the buffer
    buffer_t* message = m_queue.pop_front();
    size_t readable = size > message->capacity() ? message->capacity() : size;
    memcpy(buffer, message -> raw(), readable);
 
    //@todo free the message mem here now aswell?
 
    return readable;
}
 
int SharedMessageEndpoint::write(void const* buffer, size_t size, size_t flags) {
 
    // Send the buffer as the entire message
    ipc_iovec_t message = {buffer, size};
    send(&message, 1);
 
    return size;
}