From f5f62b145d472a2a2c388c385be9d1c4e5b5d84c Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Tue, 13 May 2025 08:46:49 +0200 Subject: feat(kernel): see below for the commit's details. what? - UserProcessScheduler and CoreProcessScheduler have been extended for FILE_TREE and also HEAP_TREE structures. - DDK device's API will use dk_ calls instead of sk_ calls. - SIGTRAP and Interrupt handlers have been fixed to handle when no process is being run, and the kernel is instead raising the interrupt. - Add file for HeFS formating in DiskImage.fwrk - Replace generic handler with breakpoint handler in int 3. why? - These changes are bug fixes and improvements. Signed-off-by: Amlal El Mahrouss --- dev/kernel/src/UserProcessScheduler.cc | 83 ++++++++++++++++------------------ 1 file changed, 40 insertions(+), 43 deletions(-) (limited to 'dev/kernel/src') diff --git a/dev/kernel/src/UserProcessScheduler.cc b/dev/kernel/src/UserProcessScheduler.cc index 2082642c..f868a810 100644 --- a/dev/kernel/src/UserProcessScheduler.cc +++ b/dev/kernel/src/UserProcessScheduler.cc @@ -101,16 +101,15 @@ Void USER_PROCESS::Wake(Bool should_wakeup) { /** @param tree The tree to calibrate */ /***********************************************************************************/ -STATIC USER_PROCESS::USER_HEAP_TREE* sched_try_go_upper_heap_tree( - USER_PROCESS::USER_HEAP_TREE* tree) { +STATIC PROCESS_HEAP_TREE* sched_try_go_upper_heap_tree(PROCESS_HEAP_TREE* tree) { if (!tree) { return nullptr; } - tree = tree->MemoryParent; + tree = tree->Parent; if (tree) { - auto tree_tmp = tree->MemoryNext; + auto tree_tmp = tree->Next; if (!tree_tmp) { return tree; @@ -141,65 +140,63 @@ ErrorOr USER_PROCESS::New(SizeT sz, SizeT pad_amount) { #endif if (!this->HeapTree) { - this->HeapTree = new USER_HEAP_TREE(); + this->HeapTree = new PROCESS_HEAP_TREE(); - this->HeapTree->MemoryEntryPad = pad_amount; - this->HeapTree->MemoryEntrySize = sz; + this->HeapTree->EntryPad = pad_amount; + this->HeapTree->EntrySize = sz; - this->HeapTree->MemoryEntry = ptr; + this->HeapTree->Entry = ptr; - this->HeapTree->MemoryColor = USER_HEAP_TREE::kBlackMemory; + this->HeapTree->Color = kBlackTreeKind; - this->HeapTree->MemoryPrev = nullptr; - this->HeapTree->MemoryNext = nullptr; - this->HeapTree->MemoryParent = nullptr; - this->HeapTree->MemoryChild = nullptr; + this->HeapTree->Prev = nullptr; + this->HeapTree->Next = nullptr; + this->HeapTree->Parent = nullptr; + this->HeapTree->Child = nullptr; } else { - USER_HEAP_TREE* entry = this->HeapTree; - USER_HEAP_TREE* prev_entry = entry; + PROCESS_HEAP_TREE* entry = this->HeapTree; + PROCESS_HEAP_TREE* prev_entry = entry; BOOL is_parent = NO; while (entry) { - if (entry->MemoryEntrySize < 1) break; + if (entry->EntrySize < 1) break; prev_entry = entry; - if (entry->MemoryColor == USER_HEAP_TREE::kBlackMemory) break; + if (entry->Color == kBlackTreeKind) break; - if (entry->MemoryChild && entry->MemoryChild->MemoryEntrySize > 0 && - entry->MemoryChild->MemoryEntrySize == sz) { - entry = entry->MemoryChild; + if (entry->Child && entry->Child->EntrySize > 0 && entry->Child->EntrySize == sz) { + entry = entry->Child; is_parent = YES; - } else if (entry->MemoryNext && entry->MemoryChild->MemoryEntrySize > 0 && - entry->MemoryNext->MemoryEntrySize == sz) { + } else if (entry->Next && entry->Child->EntrySize > 0 && entry->Next->EntrySize == sz) { is_parent = NO; - entry = entry->MemoryNext; + entry = entry->Next; } else { entry = sched_try_go_upper_heap_tree(entry); - if (entry && entry->MemoryColor == USER_HEAP_TREE::kBlackMemory) break; + if (entry && entry->Color == kBlackTreeKind) break; } } - auto new_entry = new USER_HEAP_TREE(); + auto new_entry = new PROCESS_HEAP_TREE(); - new_entry->MemoryEntry = ptr; - new_entry->MemoryEntrySize = sz; - new_entry->MemoryEntryPad = pad_amount; - new_entry->MemoryParent = entry; - new_entry->MemoryChild = nullptr; - new_entry->MemoryNext = nullptr; - new_entry->MemoryPrev = nullptr; + new_entry->Entry = ptr; + new_entry->EntrySize = sz; + new_entry->EntryPad = pad_amount; + new_entry->Parent = entry; + new_entry->Child = nullptr; + new_entry->Next = nullptr; + new_entry->Prev = nullptr; - new_entry->MemoryColor = USER_HEAP_TREE::kBlackMemory; - prev_entry->MemoryColor = USER_HEAP_TREE::kRedMemory; + new_entry->Color = kBlackTreeKind; + prev_entry->Color = kRedTreeKind; if (is_parent) { - prev_entry->MemoryChild = new_entry; - new_entry->MemoryParent = prev_entry; + prev_entry->Child = new_entry; + new_entry->Parent = prev_entry; } else { - prev_entry->MemoryNext = new_entry; - new_entry->MemoryPrev = prev_entry; + prev_entry->Next = new_entry; + new_entry->Prev = prev_entry; } } @@ -243,18 +240,18 @@ const AffinityKind& USER_PROCESS::GetAffinity() noexcept { /** @brief Free heap tree. */ /***********************************************************************************/ -STATIC Void sched_free_heap_tree(USER_PROCESS::USER_HEAP_TREE* memory_heap_list) { +STATIC Void sched_free_heap_tree(PROCESS_HEAP_TREE* memory_heap_list) { // Deleting memory lists. Make sure to free all of them. while (memory_heap_list) { - if (memory_heap_list->MemoryEntry) { - MUST_PASS(mm_delete_heap(memory_heap_list->MemoryEntry)); + if (memory_heap_list->Entry) { + MUST_PASS(mm_delete_heap(memory_heap_list->Entry)); } - auto next = memory_heap_list->MemoryNext; + auto next = memory_heap_list->Next; mm_delete_heap(memory_heap_list); - if (memory_heap_list->MemoryChild) sched_free_heap_tree(memory_heap_list->MemoryChild); + if (memory_heap_list->Child) sched_free_heap_tree(memory_heap_list->Child); memory_heap_list = next; } -- cgit v1.2.3