process.cpp

Go to the documentation of this file.

 
#include <processes/process.h>
#include <common/logger.h>
#include <processes/scheduler.h> //@todo infinite recursion
 
using namespace MaxOS;
using namespace MaxOS::system;
using namespace MaxOS::memory;
using namespace MaxOS::processes;
using namespace MaxOS::common;
using namespace MaxOS::hardwarecommunication;
 
Thread::Thread(void (* _entry_point)(void*), void* args, int arg_amount, Process* parent)
{
 
    // Basic setup
    thread_state = ThreadState::NEW;
    wakeup_time = 0;
    ticks = 0;
 
    // Create the stack ()
    m_stack_pointer = (uintptr_t) parent->memory_manager->allocate(STACK_SIZE) + STACK_SIZE;
 
    // Use the kernel stack
    m_tss_stack_pointer = parent->is_kernel ? CPU::executing_core() -> tss.rsp0 : (uintptr_t) parent->memory_manager->kmalloc(STACK_SIZE) + STACK_SIZE;
 
    // Mak sure there is a stack
    ASSERT(m_stack_pointer != 0 && m_tss_stack_pointer != 0, "Failed to allocate stack for thread");
 
    // Set up the execution state
    execution_state = {};
    execution_state.rip = (uint64_t) _entry_point;
    execution_state.ss = parent->is_kernel ? 0x10 : 0x23;
    execution_state.cs = parent->is_kernel ? 0x8 : 0x1B;
    execution_state.rflags = 0x202;
    execution_state.interrupt_number = 0;
    execution_state.error_code = 0;
    execution_state.rsp = m_stack_pointer;
    execution_state.rbp = 0;
 
    // Copy the args into userspace
    uint64_t argc = arg_amount;
    size_t arg_size = argc * sizeof(void*);
    void* argv = parent->memory_manager->allocate(arg_size);
    for (int i = 0; i < argc; i++) {
 
        // Copy each argument
        size_t len = strlen(((char**)args)[i]) + 1;
        ((char**)argv)[i] = (char*) parent->memory_manager->allocate(len);
        memcpy(((char**)argv)[i], ((char**)args)[i], len);
    }
 
    execution_state.rdi = argc;
    execution_state.rsi = (uint64_t) argv;
    //execution_state->rdx = (uint64_t)env_args;
 
    // All ports denied by default
    memset(m_io_bitmap, 0xFF, sizeof(m_io_bitmap));
 
    parent_pid = parent->pid();
}
 
Thread::~Thread() = default;
 
void Thread::sleep(size_t milliseconds) {
 
    // Update the state
    thread_state = ThreadState::SLEEPING;
    wakeup_time  = milliseconds;
    yield();
}
 
void Thread::yield() {
 
    // Only update the state if the caller hasn't specified the resume condition state
    if (thread_state == ThreadState::RUNNING)
        thread_state = ThreadState::READY;
 
    // Save a checkpoint (resumed state is ret of the below function: execution after yield will be there)
    save_cpu_state();
 
    // Schedule the replacement thread, but guard against infinite loops where thread continusly pass execution to the
    // next thread after scheduler resumes it post yield)
    if(thread_state != ThreadState::RUNNING){
 
        // Yield to the next thread
        cpu_status_t* next = GlobalScheduler::core_scheduler()->schedule_next(&execution_state);
        InterruptManager::ForceInterruptReturn(next);
    }
}
 
void Thread::save_sse_state() {
 
    // Ensure the state saving is enabled
    if (!CPU::executing_core()->xsave_enabled)
        return;
 
    // Save the state
    asm volatile("fxsave %0" : "=m" (m_sse_save_region));
}
 
void Thread::restore_sse_state() {
 
    // Ensure the state saving is enabled
    if (!CPU::executing_core()->xsave_enabled)
        return;
 
    // Restore the state
    asm volatile("fxrstor %0" : : "m" (m_sse_save_region));
}
 
extern "C" void save_cpu_state_naked(volatile void* location) __attribute__((naked));
extern "C" void save_cpu_state_naked(volatile void* location) {
    asm volatile(
 
        // Save registers
        "pushq %rax\n"
        "pushq %rbx\n"
        "pushq %rcx\n"
        "pushq %rdx\n"
        "pushq %rbp\n"
        "pushq %rsi\n"
        "pushq %rdi\n"
        "pushq %r8\n"
        "pushq %r9\n"
        "pushq %r10\n"
        "pushq %r11\n"
        "pushq %r12\n"
        "pushq %r13\n"
        "pushq %r14\n"
        "pushq %r15\n"
 
        // Store the save location
        "movq %rdi, %rsi\n"
 
        // Save general registers
        "movq   0(%rsp), %rax\n"   "movq %rax, 0x00(%rsi)\n"
        "movq   8(%rsp), %rax\n"   "movq %rax, 0x08(%rsi)\n"
        "movq  16(%rsp), %rax\n"   "movq %rax, 0x10(%rsi)\n"
        "movq  24(%rsp), %rax\n"   "movq %rax, 0x18(%rsi)\n"
        "movq  32(%rsp), %rax\n"   "movq %rax, 0x20(%rsi)\n"
        "movq  40(%rsp), %rax\n"   "movq %rax, 0x28(%rsi)\n"
        "movq  48(%rsp), %rax\n"   "movq %rax, 0x30(%rsi)\n"
        "movq  56(%rsp), %rax\n"   "movq %rax, 0x38(%rsi)\n"
        "movq  64(%rsp), %rax\n"   "movq %rax, 0x40(%rsi)\n"
        "movq  72(%rsp), %rax\n"   "movq %rax, 0x48(%rsi)\n"
        "movq  80(%rsp), %rax\n"   "movq %rax, 0x50(%rsi)\n"
        "movq  88(%rsp), %rax\n"   "movq %rax, 0x58(%rsi)\n"
        "movq  96(%rsp), %rax\n"   "movq %rax, 0x60(%rsi)\n"
        "movq 104(%rsp), %rax\n"   "movq %rax, 0x68(%rsi)\n"
        "movq 112(%rsp), %rax\n"   "movq %rax, 0x70(%rsi)\n"
 
        // Save the return address as the instruction pointer
        "movq 120(%rsp), %rax\n"
        "movq %rax, 0x88(%rsi)\n"
 
        // CS
        "xorq %rax, %rax\n"
        "movw %cs, %ax\n"
        "movq %rax, 0x90(%rsi)\n"
 
        // RFLAGS
        "pushfq\n"
        "popq %rax\n"
        "movq %rax, 0x98(%rsi)\n"
 
        // RSP
        "leaq 120(%rsp), %rax\n"
        "movq %rax, 0xA0(%rsi)\n"
 
        // SS
        "xorq %rax, %rax\n"
        "movw %ss, %ax\n"
        "movq %rax, 0xA8(%rsi)\n"
 
        // Restore registers
        "popq %r15\n"
        "popq %r14\n"
        "popq %r13\n"
        "popq %r12\n"
        "popq %r11\n"
        "popq %r10\n"
        "popq %r9\n"
        "popq %r8\n"
        "popq %rdi\n"
        "popq %rsi\n"
        "popq %rbp\n"
        "popq %rdx\n"
        "popq %rcx\n"
        "popq %rbx\n"
        "popq %rax\n"
        "ret\n"
    );
}
 
 
void Thread::save_cpu_state() {
    save_cpu_state_naked(&execution_state);
}
 
void Thread::enable_port(uint64_t port) {
 
    // Enable the port
    m_io_bitmap[port / 8] &= ~(1U << (port % 8));
    load_port_bitmap();
 
}
 
void Thread::disable_port(uint64_t port) {
 
    // Disable the port
    m_io_bitmap[port / 8] |= (1U << (port % 8));
    load_port_bitmap();
}
 
void Thread::load_port_bitmap() {
 
    memcpy(CPU::executing_core()->tss.io_bitmap, &m_io_bitmap, sizeof(m_io_bitmap));
 
}
 
Process::Process(const string& p_name, bool is_kernel)
: is_kernel(is_kernel),
  name(p_name)
{
    // If it is a kernel process then don't need a new memory manager
    memory_manager = is_kernel ? MemoryManager::s_kernel_memory_manager : new MemoryManager();
}
 
Process::Process(const string& p_name, void (* _entry_point)(void*), void* args, int arg_amount, bool is_kernel)
: Process(p_name, is_kernel)
{
 
    // Create the main thread
    auto* main_thread = new Thread(_entry_point, args, arg_amount, this);
 
    // Add the thread
    add_thread(main_thread);
}
 
Process::Process(const string& p_name, void* args, int arg_amount, ELF64* elf, bool is_kernel)
: Process(p_name, is_kernel)
{
 
    // Get the entry point
    elf->load_into_memory(memory_manager->vmm());
    auto* entry_point = (void (*)(void*)) elf->header()->entry;
 
    // Create the main thread
    auto* main_thread = new Thread(entry_point, args, arg_amount, this);
    add_thread(main_thread);
}
 
 
Process::~Process() {
 
    uint64_t pages = PhysicalMemoryManager::s_current_manager->memory_used();
 
    // Free the threads
    for (auto thread: m_threads)
        delete thread;
 
    // Free the memory manager (only if it was created)
    if (!is_kernel)
        delete memory_manager;
 
    // Log the cleanup
    Logger::DEBUG() << "Process " << name.c_str() << " cleaned up, memory before: " << (int)pages << " bytes, after cleanup: " << (int)PhysicalMemoryManager::s_current_manager->memory_used() << " bytes\n";
}
 
void Process::add_thread(Thread* thread) {
 
    m_lock.lock();
 
    // Store the thread
    m_threads.push_back(thread);
    thread->parent_pid = m_pid;
 
    m_lock.unlock();
}
 
void Process::remove_thread(uint64_t tid) {
 
    // Find the thread
    for (uint32_t i = 0; i < m_threads.size(); i++) {
 
        // Thread is not what is being removed
        if (m_threads[i]->tid != tid)
            continue;
 
        // Delete the thread
        Thread* thread = m_threads[i];
        delete thread;
 
        // Remove the thread from the list
        m_threads.erase(m_threads.begin() + i);
        return;
    }
}
 
void Process::set_pid(uint64_t pid) {
 
    // Check if the pid is already set
    if (m_pid != 0)
        return;
 
    // Set the pid
    m_pid = pid;
 
    // Assign the pid to the threads
    for (auto thread: m_threads)
        thread->parent_pid = pid;
 
}
 
Vector<Thread*> Process::threads() {
 
    return m_threads;
}
 
uint64_t Process::pid() const {
 
    return m_pid;
}
 
uint64_t Process::total_ticks() {
 
    uint64_t total_ticks = 0;
    for (auto thread: m_threads)
        total_ticks += thread->ticks;
 
    return total_ticks;
}