Merge branch 'process-classes'

include/asm/sys.h

@@ -14,9 +14,6 @@ pptr_t current_pd(void);
 
 // the limit should be set on the higher 16bit
 // e.g. (n * sizeof(segment_descriptor) - 1) << 16
-// the lower bit off the limit is either 0 or 1
-// indicating whether or not to enable interrupt
-// after loading gdt
 void asm_load_gdt(uint32_t limit, pptr_t addr);
 
 void asm_load_tr(uint16_t index);

include/kernel/process.hpp

@@ -4,6 +4,7 @@
 #include <kernel/interrupt.h>
 #include <kernel/mm.hpp>
 #include <kernel/task.h>
+#include <types/cplusplus.hpp>
 #include <types/hash_map.hpp>
 #include <types/list.hpp>
 #include <types/stdint.h>
@@ -93,7 +94,7 @@ public:
     process(const process& proc, const thread& main_thread);
 
     // only used for system initialization
-    explicit process(void);
+    explicit process(pid_t ppid);
     explicit process(void (*func_in_kernel_space)(void), pid_t ppid);
 
     ~process();
@@ -107,36 +108,143 @@ private:
     }
 };
 
-constexpr uint32_t push_stack(uint32_t** stack, uint32_t val)
-{
-    --*stack;
-    **stack = val;
-    return val;
-}
+class proclist final {
+public:
+    using list_type = types::list<process>;
+    using index_type = types::hash_map<pid_t, types::list<process>::iterator_type, types::linux_hasher<pid_t>>;
+    using child_index_type = types::hash_map<pid_t, types::list<pid_t>, types::linux_hasher<pid_t>>;
+    using iterator_type = list_type::iterator_type;
+    using const_iterator_type = list_type::const_iterator_type;
+
+private:
+    list_type m_procs;
+    index_type m_idx;
+    child_index_type m_child_idx;
+
+public:
+    template <typename... Args>
+    constexpr iterator_type emplace(Args&&... args)
+    {
+        auto iter = m_procs.emplace_back(types::forward<Args>(args)...);
+        m_idx.insert(iter->pid, iter);
+
+        auto children = m_child_idx.find(iter->ppid);
+        if (!children) {
+            m_child_idx.insert(iter->ppid, {});
+            children = m_child_idx.find(iter->ppid);
+        }
+
+        children->value.push_back(iter->pid);
+
+        return iter;
+    }
+
+    constexpr void remove(pid_t pid)
+    {
+        make_children_orphans(pid);
+
+        auto proc_iter = m_idx.find(pid);
+        auto ppid = proc_iter->value->ppid;
+
+        auto& parent_children = m_child_idx.find(ppid)->value;
+
+        auto i = parent_children.find(pid);
+        parent_children.erase(i);
+
+        m_procs.erase(proc_iter->value);
+        m_idx.remove(proc_iter);
+    }
+
+    constexpr process* find(pid_t pid)
+    {
+        return &m_idx.find(pid)->value;
+    }
+
+    constexpr bool has_child(pid_t pid)
+    {
+        auto children = m_child_idx.find(pid);
+        return children && !children->value.empty();
+    }
+
+    constexpr void make_children_orphans(pid_t pid)
+    {
+        auto children = m_child_idx.find(pid);
+        if (children) {
+            auto init_children = m_child_idx.find(1);
+            for (auto iter = children->value.begin(); iter != children->value.end(); ++iter) {
+                init_children->value.push_back(*iter);
+                this->find(*iter)->ppid = 1;
+            }
+            m_child_idx.remove(children);
+        }
+    }
+};
+
+class readyqueue final {
+public:
+    using list_type = types::list<thread*>;
+    using iterator_type = list_type::iterator_type;
+    using const_iterator_type = list_type::const_iterator_type;
+
+private:
+    list_type m_thds;
+
+private:
+    readyqueue(const readyqueue&) = delete;
+    readyqueue(readyqueue&&) = delete;
+    readyqueue& operator=(const readyqueue&) = delete;
+    readyqueue& operator=(readyqueue&&) = delete;
+
+    ~readyqueue() = delete;
+
+public:
+    constexpr explicit readyqueue(void) = default;
+
+    constexpr void push(thread* thd)
+    {
+        m_thds.push_back(thd);
+    }
+
+    constexpr thread* pop(void)
+    {
+        auto iter = m_thds.begin();
+        while (!((*iter)->attr.ready))
+            iter = m_thds.erase(iter);
+        auto* ptr = *iter;
+        m_thds.erase(iter);
+        return ptr;
+    }
+
+    constexpr thread* query(void)
+    {
+        auto* thd = this->pop();
+        this->push(thd);
+        return thd;
+    }
+
+    constexpr void remove_all(thread* thd)
+    {
+        auto iter = m_thds.find(thd);
+        while (iter != m_thds.end()) {
+            m_thds.erase(iter);
+            iter = m_thds.find(thd);
+        }
+    }
+};
 
 inline process* volatile current_process;
 inline thread* volatile current_thread;
-inline typename types::hash_map<pid_t, types::list<pid_t>, types::linux_hasher<pid_t>>* idx_child_processes;
+inline proclist* procs;
+inline readyqueue* readythds;
 
 extern "C" void NORETURN init_scheduler();
 void schedule(void);
 
-pid_t add_to_process_list(process&& proc);
-void remove_from_process_list(pid_t pid);
-
-void add_to_ready_list(thread* thd);
-void remove_from_ready_list(thread* thd);
-types::list<thread*>::iterator_type query_next_thread(void);
-
-// the function call INVALIDATES iterator
-inline void next_task(types::list<thread*>::iterator_type target)
+constexpr uint32_t push_stack(uint32_t** stack, uint32_t val)
 {
-    auto* ptr = *target;
-    remove_from_ready_list(ptr);
-    if (ptr->attr.ready)
-        add_to_ready_list(ptr);
+    --*stack;
+    **stack = val;
+    return val;
 }
 
-process* findproc(pid_t pid);
-
 void k_new_thread(void (*func)(void*), void* data);

include/types/cplusplus.hpp

@@ -15,40 +15,27 @@ using false_type = constant_value<bool, false>;
 
 };
 
-namespace types::traits::inner {
+namespace types::traits {
 
-template <typename Tp, typename>
+template <typename T>
 struct remove_pointer {
-    using type = Tp;
+    using type = T;
 };
-
-template <typename Tp, typename T>
-struct remove_pointer<Tp, T*> {
+template <typename T>
+struct remove_pointer<T*> {
     using type = T;
 };
-
-template <typename Tr, typename>
+template <typename T>
 struct remove_reference {
-    using type = Tr;
-};
-
-template <typename Tr, typename T>
-struct remove_reference<Tr, T&> {
     using type = T;
 };
-
-} // namespace types::traits::inner
-
-namespace types::traits {
-
-template <typename Tp>
-struct remove_pointer
-    : inner::remove_pointer<Tp, Tp> {
+template <typename T>
+struct remove_reference<T&> {
+    using type = T;
 };
-
-template <typename Tr>
-struct remove_reference
-    : inner::remove_reference<Tr, Tr> {
+template <typename T>
+struct remove_reference<T&&> {
+    using type = T;
 };
 
 template <typename T>
@@ -99,15 +86,20 @@ public:
 
 namespace types {
 template <typename T>
-constexpr T&& move(T& val)
+constexpr typename traits::remove_reference<T>::type&& move(T&& val)
 {
-    return static_cast<T&&>(val);
+    return static_cast<typename traits::remove_reference<T>::type&&>(val);
 }
 template <typename T>
 constexpr T&& forward(typename traits::remove_reference<T>::type& val)
 {
     return static_cast<T&&>(val);
 }
+template <typename T>
+constexpr T&& forward(typename traits::remove_reference<T>::type&& val)
+{
+    return static_cast<T&&>(val);
+}
 
 template <typename>
 struct template_true_type : public true_type {

include/types/hash_map.hpp

@@ -164,16 +164,16 @@ public:
             return !(*this == iter);
         }
 
-        constexpr operator bool()
+        constexpr operator bool(void)
         {
             return p != nullptr;
         }
 
-        constexpr Reference operator*() const noexcept
+        constexpr Reference operator*(void) const noexcept
         {
             return *p;
         }
-        constexpr Pointer operator->() const noexcept
+        constexpr Pointer operator->(void) const noexcept
         {
             return p;
         }

include/types/list.hpp

@@ -66,6 +66,8 @@ public:
         using Value = typename types::traits::remove_pointer<Pointer>::type;
         using Reference = typename types::traits::add_reference<Value>::type;
 
+        friend class list;
+
     public:
         constexpr iterator(const iterator& iter) noexcept
             : n(iter.n)
@@ -99,7 +101,7 @@ public:
             return !(*this == iter);
         }
 
-        constexpr iterator& operator++() noexcept
+        constexpr iterator& operator++(void) noexcept
         {
             n = n->next;
             return *this;
@@ -112,7 +114,7 @@ public:
             return iter;
         }
 
-        constexpr iterator& operator--() noexcept
+        constexpr iterator& operator--(void) noexcept
         {
             n = n->prev;
             return *this;
@@ -125,21 +127,22 @@ public:
             return iter;
         }
 
-        constexpr Reference operator*() const noexcept
+        constexpr Reference operator*(void) const noexcept
         {
             return n->value;
         }
 
-        constexpr Pointer operator->() const noexcept
+        constexpr Pointer operator&(void) const noexcept
         {
             return &n->value;
         }
 
-        constexpr Pointer ptr(void) const noexcept
+        constexpr Pointer operator->(void) const noexcept
         {
             return &n->value;
         }
 
+    protected:
         constexpr node_base_type* _node(void) const noexcept
         {
             return n;

include/types/vector.hpp

@@ -62,7 +62,7 @@ public:
             return !(*this == iter);
         }
 
-        constexpr iterator& operator++() noexcept
+        constexpr iterator& operator++(void) noexcept
         {
             ++p;
             return *this;
@@ -75,7 +75,7 @@ public:
             return iter;
         }
 
-        constexpr iterator& operator--() noexcept
+        constexpr iterator& operator--(void) noexcept
         {
             --p;
             return *this;
@@ -100,12 +100,17 @@ public:
             return iter;
         }
 
-        constexpr Reference operator*() const noexcept
+        constexpr Reference operator*(void) const noexcept
         {
             return *p;
         }
 
-        constexpr Pointer operator->() const noexcept
+        constexpr Pointer operator&(void) const noexcept
+        {
+            return p;
+        }
+
+        constexpr Pointer operator->(void) const noexcept
         {
             return p;
         }

src/asm/sys.s

@@ -38,10 +38,6 @@ asm_load_gdt:
     lgdt (%eax)
     ljmp $0x08, $_asm_load_gdt_fin
 _asm_load_gdt_fin:
-	movw 4(%esp), %ax
-	cmpw $0, %ax
-	je _asm_load_gdt_fin_ret
-_asm_load_gdt_fin_ret:
     ret
 
 .global asm_load_tr

src/kernel/event/event.cpp

@@ -72,7 +72,7 @@ kernel::evt kernel::evtqueue::front()
 
 const kernel::evt* kernel::evtqueue::peek(void) const
 {
-    return m_evts.begin().ptr();
+    return &m_evts.begin();
 }
 
 bool kernel::evtqueue::empty(void) const
@@ -85,7 +85,7 @@ void kernel::evtqueue::notify(void)
     for (auto* sub : m_subscribers) {
         sub->attr.ready = 1;
         sub->attr.wait = 0;
-        add_to_ready_list(sub);
+        readythds->push(sub);
     }
 }
 

src/kernel/hw/ata.cpp

@@ -6,6 +6,7 @@
 #include <kernel/tty.h>
 #include <kernel/vfs.hpp>
 #include <types/allocator.hpp>
+#include <types/assert.h>
 #include <types/status.h>
 #include <types/stdint.h>
 
@@ -136,7 +137,8 @@ constexpr hw::ata** p_ata_sec = &ata_sec;
 template <hw::ata** ata_bus>
 size_t _ata_read(fs::special_node* sn, char* buf, size_t buf_size, size_t offset, size_t n)
 {
-    // TODO: check buf_size
+    assert_likely(buf_size >= n);
+
     char b[512] {};
     char* orig_buf = buf;
     size_t start = sn->data1 + offset / 512;

src/kernel/interrupt.cpp

@@ -81,8 +81,6 @@ void init_pic(void)
     SET_UP_IRQ(13, 0x08);
     SET_UP_IRQ(14, 0x08);
     SET_UP_IRQ(15, 0x08);
-
-    asm_sti();
 }
 
 extern "C" void int6_handler(
@@ -175,7 +173,7 @@ extern "C" void int14_handler(int14_data* d)
         _int14_panic(d->v_eip, d->l_addr, d->error_code);
 
     pte_t* pte = to_pte(mms->m_pd, d->l_addr);
-    page* page = lto_page(mm_area.ptr(), d->l_addr);
+    page* page = lto_page(&mm_area, d->l_addr);
 
     if (unlikely(d->error_code.present == 0 && !mm_area->mapped_file))
         _int14_panic(d->v_eip, d->l_addr, d->error_code);

src/kernel/process.cpp

@@ -21,10 +21,6 @@
 #include <types/stdint.h>
 #include <types/types.h>
 
-static bool is_scheduler_ready;
-static types::list<process>* processes;
-static typename types::hash_map<pid_t, types::list<process>::iterator_type, types::linux_hasher<pid_t>>* idx_processes;
-static types::list<thread*>* ready_thds;
 static void (*volatile kthreadd_new_thd_func)(void*);
 static void* volatile kthreadd_new_thd_data;
 static types::mutex kthreadd_mtx;
@@ -72,8 +68,8 @@ process::process(const process& val, const thread& main_thd)
     , pid { process::alloc_pid() }
     , ppid { val.pid }
 {
-    auto iter_thd = thds.emplace_back(main_thd);
-    iter_thd->owner = this;
+    auto* thd = &thds.emplace_back(main_thd);
+    thd->owner = this;
 
     for (auto& area : val.mms) {
         if (area.is_ident())
@@ -81,30 +77,24 @@ process::process(const process& val, const thread& main_thd)
 
         mms.mirror_area(area);
     }
+
+    readythds->push(thd);
 }
 
-process::process(void)
+process::process(pid_t _ppid)
     : mms(*kernel_mms)
     , attr { .system = 1 }
     , pid { process::alloc_pid() }
-    , ppid { 1 }
+    , ppid { _ppid }
 {
     auto thd = thds.emplace_back(this, true);
-
-    add_to_ready_list(thd.ptr());
+    readythds->push(&thd);
 }
 
 process::process(void (*func)(void), pid_t _ppid)
-    : mms(*kernel_mms)
-    , attr { .system = 1 }
-    , pid { process::alloc_pid() }
-    , ppid { _ppid }
+    : process { _ppid }
 {
-    auto thd = thds.emplace_back(this, true);
-
-    add_to_ready_list(thd.ptr());
-
-    auto* esp = &thd->esp;
+    auto* esp = &thds.begin()->esp;
 
     // return(start) address
     push_stack(esp, (uint32_t)func);
@@ -123,7 +113,7 @@ process::process(void (*func)(void), pid_t _ppid)
 process::~process()
 {
     for (auto iter = thds.begin(); iter != thds.end(); ++iter)
-        remove_from_ready_list(iter.ptr());
+        readythds->remove_all(&iter);
 }
 
 inline void NORETURN _noreturn_crash(void)
@@ -171,11 +161,10 @@ void kernel_threadd_main(void)
 
 void NORETURN _kernel_init(void)
 {
-    {
-        kernel::no_irq_guard grd;
+    procs->emplace(kernel_threadd_main, 1);
+
+    asm_sti();
 
-        add_to_process_list(process { kernel_threadd_main, 1 });
-    }
     hw::init_ata();
 
     // TODO: parse kernel parameters
@@ -195,9 +184,7 @@ void NORETURN _kernel_init(void)
 
     assert(types::elf::elf32_load(&d) == GB_OK);
 
-    is_scheduler_ready = true;
-
-    asm volatile (
+    asm volatile(
         "movw $0x23, %%ax\n"
         "movw %%ax, %%ds\n"
         "movw %%ax, %%es\n"
@@ -213,11 +200,9 @@ void NORETURN _kernel_init(void)
         "iret\n"
         :
         : "c"(d.sp), "d"(d.eip)
-        : "eax", "memory"
-    );
+        : "eax", "memory");
 
-    for (;;)
-        assert(false);
+    _noreturn_crash();
 }
 
 void k_new_thread(void (*func)(void*), void* data)
@@ -229,20 +214,17 @@ void k_new_thread(void (*func)(void*), void* data)
 
 void NORETURN init_scheduler()
 {
-    processes = types::kernel_allocator_pnew(processes);
-    ready_thds = types::kernel_allocator_pnew(ready_thds);
-    idx_processes = types::kernel_allocator_pnew(idx_processes);
-    idx_child_processes = types::kernel_allocator_pnew(idx_child_processes);
+    procs = types::kernel_allocator_pnew(procs);
+    readythds = types::kernel_ident_allocator_pnew(readythds);
 
-    auto pid = add_to_process_list(process {});
-    auto init = findproc(pid);
+    auto* init = &procs->emplace(1);
 
     // we need interrupts enabled for cow mapping so now we disable it
     // in case timer interrupt mess things up
     asm_cli();
 
     current_process = init;
-    current_thread = init->thds.begin().ptr();
+    current_thread = &init->thds.begin();
 
     tss.ss0 = KERNEL_DATA_SEGMENT;
     tss.esp0 = current_thread->kstack;
@@ -264,7 +246,7 @@ void NORETURN init_scheduler()
         "xorl %%ebp, %%ebp\n"
         "xorl %%edx, %%edx\n"
 
-        "pushl $0x200\n"
+        "pushl $0x0\n"
         "popfl\n"
 
         "ret\n"
@@ -273,83 +255,18 @@ void NORETURN init_scheduler()
         "ud2"
         :
         : "a"(current_thread->esp), "c"(_kernel_init)
-        : "memory"
-    );
+        : "memory");
 
-    for (;;)
-        assert(false);
-}
-
-pid_t add_to_process_list(process&& proc)
-{
-    auto iter = processes->emplace_back(types::move(proc));
-    idx_processes->insert(iter->pid, iter);
-
-    auto children = idx_child_processes->find(iter->ppid);
-    if (!children) {
-        idx_child_processes->insert(iter->ppid, {});
-        children = idx_child_processes->find(iter->ppid);
-    }
-
-    children->value.push_back(iter->pid);
-
-    return iter->pid;
-}
-
-void remove_from_process_list(pid_t pid)
-{
-    auto proc_iter = idx_processes->find(pid);
-    auto ppid = proc_iter->value->ppid;
-
-    auto& parent_children = idx_child_processes->find(ppid)->value;
-
-    auto i = parent_children.find(pid);
-    parent_children.erase(i);
-
-    processes->erase(proc_iter->value);
-    idx_processes->remove(proc_iter);
-}
-
-void add_to_ready_list(thread* thd)
-{
-    ready_thds->push_back(thd);
-}
-
-void remove_from_ready_list(thread* thd)
-{
-    auto iter = ready_thds->find(thd);
-    while (iter != ready_thds->end()) {
-        ready_thds->erase(iter);
-        iter = ready_thds->find(thd);
-    }
-}
-
-types::list<thread*>::iterator_type query_next_thread(void)
-{
-    auto iter_thd = ready_thds->begin();
-    while (!((*iter_thd)->attr.ready))
-        iter_thd = ready_thds->erase(iter_thd);
-    return iter_thd;
-}
-
-process* findproc(pid_t pid)
-{
-    return idx_processes->find(pid)->value.ptr();
+    _noreturn_crash();
 }
 
 extern "C" void asm_ctx_switch(uint32_t** curr_esp, uint32_t* next_esp);
 void schedule()
 {
-    if (unlikely(!is_scheduler_ready))
-        return;
-
-    auto iter_thd = query_next_thread();
-    auto thd = *iter_thd;
+    auto thd = readythds->query();
 
-    if (current_thread == thd) {
-        next_task(iter_thd);
+    if (current_thread == thd)
         return;
-    }
 
     process* proc = thd->owner;
     if (current_process != proc) {
@@ -361,7 +278,6 @@ void schedule()
 
     current_thread = thd;
     tss.esp0 = current_thread->kstack;
-    next_task(iter_thd);
 
     asm_ctx_switch(&curr_thd->esp, thd->esp);
 }

src/kernel/syscall.cpp

@@ -34,10 +34,8 @@ void _syscall_not_impl(interrupt_stack* data)
 extern "C" void _syscall_stub_fork_return(void);
 void _syscall_fork(interrupt_stack* data)
 {
-    auto newpid = add_to_process_list(process { *current_process, *current_thread });
-    auto* newproc = findproc(newpid);
-    thread* newthd = newproc->thds.begin().ptr();
-    add_to_ready_list(newthd);
+    auto* newproc = &procs->emplace(*current_process, *current_thread);
+    thread* newthd = &newproc->thds.begin();
 
     // create fake interrupt stack
     push_stack(&newthd->esp, data->ss);
@@ -71,7 +69,7 @@ void _syscall_fork(interrupt_stack* data)
     // eflags
     push_stack(&newthd->esp, 0);
 
-    SYSCALL_SET_RETURN_VAL(newpid, 0);
+    SYSCALL_SET_RETURN_VAL(newproc->pid, 0);
 }
 
 void _syscall_write(interrupt_stack* data)
@@ -135,7 +133,7 @@ void _syscall_exit(interrupt_stack* data)
 
     // remove this thread from ready list
     current_thread->attr.ready = 0;
-    remove_from_ready_list(current_thread);
+    readythds->remove_all(current_thread);
 
     // TODO: write back mmap'ped files and close them
 
@@ -143,22 +141,14 @@ void _syscall_exit(interrupt_stack* data)
     current_process->mms.clear_user();
 
     // make child processes orphans (children of init)
-    auto children = idx_child_processes->find(pid);
-    if (children) {
-        auto init_children = idx_child_processes->find(1);
-        for (auto iter = children->value.begin(); iter != children->value.end(); ++iter) {
-            init_children->value.push_back(*iter);
-            findproc(*iter)->ppid = 1;
-        }
-        idx_child_processes->remove(children);
-    }
+    procs->make_children_orphans(pid);
 
     current_process->attr.zombie = 1;
 
     // notify parent process and init
-    auto* proc = findproc(pid);
-    auto* parent = findproc(ppid);
-    auto* init = findproc(1);
+    auto* proc = procs->find(pid);
+    auto* parent = procs->find(ppid);
+    auto* init = procs->find(1);
     while (!proc->wait_lst.empty()) {
         init->wait_lst.push(proc->wait_lst.front());
     }
@@ -183,7 +173,7 @@ void _syscall_wait(interrupt_stack* data)
     }
 
     auto& waitlst = current_process->wait_lst;
-    if (waitlst.empty() && !idx_child_processes->find(current_process->pid)) {
+    if (waitlst.empty() && !procs->has_child(current_process->pid)) {
         SYSCALL_SET_RETURN_VAL(-1, ECHILD);
         return;
     }
@@ -207,7 +197,7 @@ void _syscall_wait(interrupt_stack* data)
     // TODO: copy_to_user check privilege
     *arg1 = (int)evt.data2;
 
-    remove_from_process_list(pid);
+    procs->remove(pid);
     SYSCALL_SET_RETURN_VAL(pid, 0);
 }
 

src/kernel/vfs.cpp

@@ -49,14 +49,14 @@ fs::vfs::dentry::dentry(dentry&& val)
 fs::vfs::dentry* fs::vfs::dentry::append(inode* ind, const name_type& name)
 {
     auto iter = children.emplace_back(this, ind, name);
-    idx_children.insert(iter->name, iter.ptr());
-    return iter.ptr();
+    idx_children.insert(iter->name, &iter);
+    return &iter;
 }
 fs::vfs::dentry* fs::vfs::dentry::append(inode* ind, name_type&& name)
 {
     auto iter = children.emplace_back(this, ind, types::move(name));
-    idx_children.insert(iter->name, iter.ptr());
-    return iter.ptr();
+    idx_children.insert(iter->name, &iter);
+    return &iter;
 }
 fs::vfs::dentry* fs::vfs::dentry::find(const name_type& name)
 {
@@ -97,8 +97,8 @@ fs::ino_t fs::vfs::_assign_inode_id(void)
 fs::inode* fs::vfs::cache_inode(inode_flags flags, uint32_t perm, size_t size, void* impl_data)
 {
     auto iter = _inodes.emplace_back(inode { flags, perm, impl_data, _assign_inode_id(), this, size });
-    _idx_inodes.insert(iter->ino, iter.ptr());
-    return iter.ptr();
+    _idx_inodes.insert(iter->ino, &iter);
+    return &iter;
 }
 fs::inode* fs::vfs::get_inode(ino_t ino)
 {