process.h

Go to the documentation of this file.

 
#ifndef MAXOS_PROCESSES_PROCESS_H
#define MAXOS_PROCESSES_PROCESS_H
 
#include <libcommon/vector.h>
#include <libcommon/string.h>
 
#include <system/cpu.h>
#include <memory/virtual.h>
#include <memory/memorymanagement.h>
#include <processes/elf.h>
#include <processes/resources/resource.h>
#include <hardwarecommunication/interrupts.h>
 
namespace MaxOS::processes {
    class Process;
 
    typedef enum class ThreadState {
        NEW,
        RUNNING,
        READY,
        SLEEPING,
        WAITING,
        STOPPED
    } thread_state_t;
 
    constexpr size_t STACK_SIZE = 0x10000;
 
    class Thread {
 
        private:
 
            uintptr_t m_stack_pointer;
            uintptr_t m_tss_stack_pointer;
 
            uint8_t m_io_bitmap[system::IO_BITMAP_SIZE];
 
            char m_sse_save_region[512] __attribute__((aligned(16)));
 
        public:
            Thread(void (* _entry_point)(void*), void* args, int arg_amount, Process* parent);
            ~Thread();
 
            void sleep(size_t milliseconds);
            void yield();
 
            uint64_t tid;                             
            uint64_t parent_pid;                      
 
            volatile system::cpu_status_t execution_state;      
            volatile thread_state_t thread_state;               
 
            volatile size_t ticks;                              
            volatile size_t wakeup_time;                        
 
            [[nodiscard]] uintptr_t tss_pointer() const { return m_tss_stack_pointer; }    
            void set_tss_pointer(uintptr_t new_tss_pointer) { m_tss_stack_pointer = new_tss_pointer; } 
 
            void save_sse_state();
            void restore_sse_state();
 
            void save_cpu_state();
 
            void enable_port(uint64_t port);
            void disable_port(uint64_t port);
            void load_port_bitmap();
    };
 
    class Process {
 
        private:
            common::Vector<Thread*> m_threads;
 
            uint64_t m_pid = 0;
            common::Spinlock m_lock;
 
        public:
            explicit Process(const string& name, bool is_kernel = false);
            Process(const string& name, void (* _entry_point)(void*), void* args, int arg_amount, bool is_kernel = false);
            Process(const string& name, void* args, int arg_amount, ELF64* elf, bool is_kernel = false);
            ~Process();
 
            common::Vector<Thread*> threads();
            void add_thread(Thread* thread);
            void remove_thread(uint64_t tid);
 
            void set_pid(uint64_t pid);
            [[nodiscard]] uint64_t pid() const;
            [[nodiscard]] uint64_t total_ticks();
 
            bool is_kernel;                                             
 
            string name;                                                
            string working_directory = "/";                             
 
            memory::MemoryManager* memory_manager = nullptr;            
            resources::ResourceManager resource_manager;                
    };
}
 
#endif // MAXOS_PROCESSES_PROCESS_H