ipc.cpp

Go to the documentation of this file.

 
#include <processes/ipc.h>
 
using namespace MaxOS;
using namespace MaxOS::processes;
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, syscore::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;
}
 
int SharedMessageEndpoint::read(void* buffer, size_t size, size_t flags) {
 
    // Wait for a message
    if(m_queue.empty())
        return -1 * (int)resource_error_base_t::SHOULD_BLOCK;
 
    // 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);
 
    return readable;
}
 
int SharedMessageEndpoint::write(void const* buffer, size_t size, size_t flags) {
 
    m_message_lock.lock();
 
    // Create the message
    auto* new_message = new buffer_t(size);
    new_message->copy_from(buffer, size);
    m_queue.push_back(new_message);
 
    m_message_lock.unlock();
    return size;
}