[PROJ] TODO and log cleanup

Author: Diego Ferrari

kernel/console/kconsole/terminal.cpp

@@ -104,8 +104,6 @@ void Terminal::run_command(){
     command_running = true;
 }
 
-//TODO: implement the full state machine explained at https://vt100.net/emu/dec_ansi_parser & https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
-//The current implementation is not standard compliant and uses hex colors as [FF0000;
 void Terminal::TMP_test(int argc, const char* args[]){
     // const char *term = seek_to(args, '\033');
     // if (*term == 0) return;

kernel/filesystem/filesystem.cpp

@@ -93,7 +93,6 @@ file_offset shared_seek(file *fd, file_offset offset){
 }
 
 sizedptr shared_readdir(const char* path){
-    kprintf("Here?");
     //TODO: Need to pass a buffer and write to that, returning size
     return p9Driver->list_contents(path);
 }
@@ -176,7 +175,6 @@ size_t write_file(file *descriptor, const char* buf, size_t size){
 
 sizedptr list_directory_contents(const char *path){
     const char *search_path = path;
-    kprintf("Searching in %s",search_path);
     driver_module *mod = get_module(&search_path);
     if (!mod){
         kprintf("No module for path");

kernel/graph/drivers/virtio_gpu_pci/virtio_gpu_pci.cpp

@@ -32,7 +32,6 @@
 
 #define VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM 1
 
-//TODO: format logs
 VirtioGPUDriver* VirtioGPUDriver::try_init(gpu_size preferred_screen_size){
     VirtioGPUDriver* driver = new VirtioGPUDriver();
     if (driver->init(preferred_screen_size))
@@ -483,7 +482,6 @@ void VirtioGPUDriver::set_cursor_pressed(bool pressed){
 }
 
 void VirtioGPUDriver::create_window(uint32_t x, uint32_t y, uint32_t width, uint32_t height, draw_ctx *new_ctx){
-    // TODO: use separate resources for windows. Will probably make rendering a lot faster. Do before DOOM
     new_ctx->fb = (uint32_t*)palloc(width * height * BPP, MEM_PRIV_SHARED, MEM_RW, true);
     new_ctx->width = width;
     new_ctx->height = height;

kernel/input/input_dispatch.cpp

@@ -170,8 +170,6 @@ bool sys_shortcut_triggered(uint16_t pid, uint16_t sid){
     return false;
 }
 
-// TODO: discard input before DOOM
-
 bool input_init(){
     for (int i = 0; i < 16; i++) shortcuts[i] = {};
     if (BOARD_TYPE == 2 && RPI_BOARD != 5){

kernel/input/usb_types.h

@@ -68,7 +68,6 @@ typedef struct __attribute__((packed)) {
         uint8_t  bDescriptorType;
         uint8_t wDescriptorLength;
     }__attribute__((packed)) descriptors[1];
-//TODO: wDescriptorLength is supposed to be 16, but for some reason the descriptor from usb-kbd is 8. Will need to fix this once we do a real device
 } usb_hid_descriptor;
 
 typedef struct __attribute__((packed)) {
@@ -77,7 +76,6 @@ typedef struct __attribute__((packed)) {
     uint8_t bmAttributes;
     uint8_t wMaxPacketSize;
     uint8_t bInterval;
-//TODO: wMaxPacketSize is supposed to be 16, but for some reason the descriptor from usb-kbd is 8. Will need to fix this once we do a real device
 } usb_endpoint_descriptor;
 
 typedef struct __attribute__((packed)) {

kernel/memory/mmu.c

@@ -172,7 +172,6 @@ void mmu_unmap(uint64_t va, uint64_t pa){
 
 void mmu_alloc(){
     page_table_l0 = (uint64_t*)talloc(PAGE_SIZE);
-    //TODO: use palloc, but consider it won't be able to add sections to MMU during that init
 }
 
 extern uint64_t shared_start;
@@ -195,13 +194,13 @@ void mmu_init() {
         mmu_map_4kb(addr, addr, MAIR_IDX_DEVICE, MEM_RW, MEM_PRIV_KERNEL);
 
     for (uint64_t addr = (uintptr_t)&shared_start; addr < (uintptr_t)&shared_code_end; addr += GRANULE_4KB)
-        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_EXEC | MEM_RO, MEM_PRIV_SHARED);//TODO: separate into sections and mark as shared
+        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_EXEC | MEM_RO, MEM_PRIV_SHARED);
 
     for (uint64_t addr = (uintptr_t)&shared_code_end; addr < (uintptr_t)&shared_ro_end; addr += GRANULE_4KB)
-        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_RO, MEM_PRIV_SHARED);//TODO: separate into sections and mark as share
+        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_RO, MEM_PRIV_SHARED);
 
     for (uint64_t addr = (uintptr_t)&shared_ro_end; addr < (uintptr_t)&shared_end; addr += GRANULE_4KB)
-        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_RW, MEM_PRIV_SHARED);//TODO: separate into sections and mark as shared
+        mmu_map_4kb(addr, addr, MAIR_IDX_NORMAL, MEM_RW, MEM_PRIV_SHARED);
 
     if (XHCI_BASE)
     for (uint64_t addr = XHCI_BASE; addr <= XHCI_BASE + 0x1000; addr += GRANULE_4KB)

kernel/memory/page_allocator.c

@@ -5,6 +5,7 @@
 #include "exceptions/exception_handler.h"
 #include "std/memory.h"
 #include "math/math.h"
+#include "console/kio.h"
 
 #define PD_TABLE 0b11
 #define PD_BLOCK 0b01
@@ -55,8 +56,6 @@ void pfree(void* ptr, uint64_t size) {
 uint64_t start;
 uint64_t end;
 
-#include "console/kio.h"
-
 void* palloc(uint64_t size, uint8_t level, uint8_t attributes, bool full) {
     if (!start) start = count_pages(get_user_ram_start(),PAGE_SIZE);
     if (!end) end = count_pages(get_user_ram_end(),PAGE_SIZE);
@@ -169,7 +168,7 @@ bool page_used(uintptr_t ptr){
 void mark_used(uintptr_t address, size_t pages)
 {
     if ((address & (PAGE_SIZE - 1)) != 0) {
-        // kprintf("[mark_used error] address %x not aligned", address);
+        kprintf("[mark_used error] address %x not aligned", address);
         return;
     }
     if (pages == 0) return;
@@ -193,7 +192,7 @@ void* kalloc(void *page, uint64_t size, uint16_t alignment, uint8_t level){
 
     size = (size + alignment - 1) & ~(alignment - 1);
 
-    // kprintfv("[in_page_alloc] Requested size: %x", size);
+    kprintfv("[in_page_alloc] Requested size: %x", size);
 
     mem_page *info = (mem_page*)page;
 
@@ -206,43 +205,43 @@ void* kalloc(void *page, uint64_t size, uint16_t alignment, uint8_t level){
     FreeBlock** curr = &info->free_list;
     while (*curr) {
         if ((*curr)->size >= size) {
-            // kprintfv("[in_page_alloc] Reusing free block at %x",(uintptr_t)*curr);
+            kprintfv("[in_page_alloc] Reusing free block at %x",(uintptr_t)*curr);
 
             uint64_t result = (uint64_t)*curr;
             *curr = (*curr)->next;
             memset((void*)result, 0, size);
             info->size += size;
             return (void*)result;
         }
-        // kprintfv("-> %x",(uintptr_t)&(*curr)->next);
+        kprintfv("-> %x",(uintptr_t)&(*curr)->next);
         curr = &(*curr)->next;
     }
 
-    // kprintfv("[in_page_alloc] Current next pointer %x",info->next_free_mem_ptr);
+    kprintfv("[in_page_alloc] Current next pointer %x",info->next_free_mem_ptr);
 
     info->next_free_mem_ptr = (info->next_free_mem_ptr + alignment - 1) & ~(alignment - 1);
 
-    // kprintfv("[in_page_alloc] Aligned next pointer %x",info->next_free_mem_ptr);
+    kprintfv("[in_page_alloc] Aligned next pointer %x",info->next_free_mem_ptr);
 
     if (info->next_free_mem_ptr + size > (((uintptr_t)page) + PAGE_SIZE)) {
         if (!info->next)
             info->next = palloc(PAGE_SIZE, level, info->attributes, false);
-        // kprintfv("[in_page_alloc] Page full. Moving to %x",(uintptr_t)info->next);
+        kprintfv("[in_page_alloc] Page full. Moving to %x",(uintptr_t)info->next);
         return kalloc(info->next, size, alignment, level);
     }
 
     uint64_t result = info->next_free_mem_ptr;
     info->next_free_mem_ptr += size;
 
-    // kprintfv("[in_page_alloc] Allocated address %x",result);
+    kprintfv("[in_page_alloc] Allocated address %x",result);
 
     memset((void*)result, 0, size);
     info->size += size;
     return (void*)result;
 }
 
 void kfree(void* ptr, uint64_t size) {
-    // kprintfv("[page_alloc_free] Freeing block at %x size %x",(uintptr_t)ptr, size);
+    kprintfv("[page_alloc_free] Freeing block at %x size %x",(uintptr_t)ptr, size);
 
     memset((void*)ptr,0,size);