Add preprocessor directives to supress logs per file.

Makes the output much cleaner by default but allows for getting more
infor if debugging in the future.

lib/mammoth/src/process.cpp

@@ -6,6 +6,8 @@
 #include "mammoth/channel.h"
 #include "mammoth/debug.h"
 
+#define MAM_PROC_DEBUG 0
+
 namespace {
 
 typedef struct {
@@ -63,19 +65,27 @@ uint64_t LoadElfProgram(uint64_t base, uint64_t as_cap) {
       reinterpret_cast<Elf64ProgramHeader*>(base + header->phoff);
   for (uint64_t i = 0; i < header->phnum; i++) {
     Elf64ProgramHeader& program = programs[i];
+#if MAM_PROC_DEBUG
     dbgln("Create mem object");
+#endif
     uint64_t mem_cap;
     uint64_t size = program.filesz;
     check(ZMemoryObjectCreate(size, &mem_cap));
 
+#if MAM_PROC_DEBUG
     dbgln("Map Local");
+#endif
     uint64_t vaddr;
     check(ZAddressSpaceMap(Z_INIT_VMAS_SELF, 0, mem_cap, &vaddr));
 
+#if MAM_PROC_DEBUG
     dbgln("Copy");
+#endif
     memcpy(base + program.offset, program.filesz, vaddr);
 
+#if MAM_PROC_DEBUG
     dbgln("Map Foreign");
+#endif
     check(ZAddressSpaceMap(as_cap, program.vaddr, mem_cap, &vaddr));
   }
   return header->entry;
@@ -87,7 +97,9 @@ uint64_t SpawnProcessFromElfRegion(uint64_t program) {
   Channel local, foreign;
   check(CreateChannels(local, foreign));
 
+#if MAM_PROC_DEBUG
   dbgln("Spawn");
+#endif
   uint64_t proc_cap;
   uint64_t as_cap;
   uint64_t foreign_chan_id;
@@ -95,11 +107,15 @@ uint64_t SpawnProcessFromElfRegion(uint64_t program) {
                       &as_cap, &foreign_chan_id));
 
   uint64_t entry_point = LoadElfProgram(program, as_cap);
+#if MAM_PROC_DEBUG
   dbgln("Thread Create");
+#endif
   uint64_t thread_cap;
   check(ZThreadCreate(proc_cap, &thread_cap));
 
+#if MAM_PROC_DEBUG
   dbgln("Thread start");
+#endif
   check(ZThreadStart(thread_cap, entry_point, foreign_chan_id, 0));
 
   local.WriteStr("Hello!");

zion/interrupt/interrupt.cpp

@@ -90,15 +90,13 @@ extern "C" void interrupt_protection_fault(InterruptFrame* frame) {
 
 extern "C" void isr_page_fault();
 extern "C" void interrupt_page_fault(InterruptFrame* frame) {
-  dbgln("Page Fault - trying to resolve");
   uint64_t cr2;
   asm volatile("mov %%cr2, %0" : "=r"(cr2));
 
   if (gScheduler->CurrentProcess().vmas()->HandlePageFault(cr2)) {
-    dbgln("Handled");
     return;
   }
-  dbgln("Unable to handle:");
+  dbgln("Unhandled Page Fault:");
   uint64_t err = frame->error_code;
   if (err & 0x1) {
     dbgln("Page Protection");

zion/loader/init_loader.cpp

@@ -9,6 +9,8 @@
 #include "object/thread.h"
 #include "scheduler/process_manager.h"
 
+#define K_INIT_DEBUG 0
+
 namespace {
 
 typedef struct {
@@ -54,16 +56,20 @@ typedef struct {
 
 uint64_t LoadElfProgram(Process& dest_proc, uint64_t base, uint64_t offset) {
   Elf64Header* header = reinterpret_cast<Elf64Header*>(base);
+#if K_INIT_DEBUG
   dbgln("phoff: %u phnum: %u", header->phoff, header->phnum);
+#endif
   Elf64ProgramHeader* programs =
       reinterpret_cast<Elf64ProgramHeader*>(base + header->phoff);
   for (uint64_t i = 0; i < header->phnum; i++) {
     Elf64ProgramHeader& program = programs[i];
+#if K_INIT_DEBUG
     dbgln(
         "prog: type: %u, flags: %u, offset: %u\n  vaddr: %m, paddr: %m\n  "
         "filesz: %x, memsz: %x, align: %x",
         program.type, program.flags, program.offset, program.vaddr,
         program.paddr, program.filesz, program.memsz, program.align);
+#endif
     auto mem_obj = MakeRefCounted<MemoryObject>(program.filesz);
     mem_obj->CopyBytesToObject(base + program.offset, program.filesz);
     dest_proc.vmas()->MapInMemoryObject(program.vaddr, mem_obj);
@@ -86,12 +92,14 @@ bool streq(const char* a, const char* b) {
 }
 
 void DumpModules() {
+#if K_INIT_DEBUG
   const limine_module_response& resp = boot::GetModules();
   dbgln("[boot] Dumping bootloader modules.");
   for (uint64_t i = 0; i < resp.module_count; i++) {
     const limine_file& file = *resp.modules[i];
     dbgln("    %s,%m,%x", file.path, file.address, file.size);
   }
+#endif
 }
 
 const limine_file& GetInitProgram(const char* path) {

zion/memory/physical_memory.cpp

@@ -3,6 +3,8 @@
 #include "boot/boot_info.h"
 #include "debug/debug.h"
 
+#define K_PHYS_DEBUG 0
+
 namespace phys_mem {
 namespace {
 
@@ -29,7 +31,9 @@ class PhysicalMemoryManager {
         if (base == gBootstrap.init_page) {
           base = gBootstrap.next_page;
           uint64_t bootstrap_used = gBootstrap.next_page - gBootstrap.init_page;
+#if K_PHYS_DEBUG
           dbgln("[PMM] Taking over from bootstrap, used: %x", bootstrap_used);
+#endif
           size -= bootstrap_used;
         }
         AddMemoryRegion(base, size);
@@ -109,7 +113,9 @@ uint64_t AllocatePage() {
     panic("No Bootstrap Memory Manager");
   }
 
+#if K_PHYS_DEBUG
   dbgln("[PMM] Boostrap Alloc!");
+#endif
 
   uint64_t page = gBootstrap.next_page;
   if (page == gBootstrap.max_page) {

zion/object/address_space.cpp

@@ -4,6 +4,8 @@
 #include "memory/paging_util.h"
 #include "memory/physical_memory.h"
 
+#define K_VMAS_DEBUG 0
+
 extern KernelStackManager* gKernelStackManager;
 
 RefPtr<AddressSpace> AddressSpace::ForRoot() {
@@ -50,6 +52,9 @@ uint64_t* AddressSpace::AllocateKernelStack() {
 }
 
 bool AddressSpace::HandlePageFault(uint64_t vaddr) {
+#if K_VMAS_DEBUG
+  dbgln("[VMAS] Page Fault!");
+#endif
   MemoryMapping* mapping = GetMemoryMappingForAddr(vaddr);
   if (mapping == nullptr) {
     return false;
@@ -60,7 +65,9 @@ bool AddressSpace::HandlePageFault(uint64_t vaddr) {
     dbgln("WARN: Memory object returned invalid physical addr.");
     return false;
   }
-  dbgln("Mapping P(%m) at V(%m)", physical_addr, vaddr);
+#if K_VMAS_DEBUG
+  dbgln("[VMAS] Mapping P(%m) at V(%m)", physical_addr, vaddr);
+#endif
   MapPage(cr3_, vaddr, physical_addr);
   return true;
 }

zion/object/memory_object.cpp

@@ -4,10 +4,14 @@
 #include "debug/debug.h"
 #include "memory/physical_memory.h"
 
+#define K_MEM_DEBUG 0
+
 MemoryObject::MemoryObject(uint64_t size) : size_(size) {
   if ((size & 0xFFF) != 0) {
     size_ = (size & ~0xFFF) + 0x1000;
+#if K_MEM_DEBUG
     dbgln("MemoryObject: aligned %x to %x", size, size_);
+#endif
   }
   // FIXME: Do this lazily.
   uint64_t num_pages = size_ / 0x1000;
@@ -56,7 +60,9 @@ uint64_t MemoryObject::PageNumberToPhysAddr(uint64_t page_num) {
   }
 
   if (*iter == 0) {
+#if K_MEM_DEBUG
     dbgln("Allocating page num %u for mem object", page_num);
+#endif
     *iter = phys_mem::AllocatePage();
   }
   return *iter;

zion/object/thread.cpp

@@ -6,6 +6,8 @@
 #include "object/process.h"
 #include "scheduler/scheduler.h"
 
+#define K_THREAD_DEBUG 0
+
 namespace {
 
 extern "C" void jump_user_space(uint64_t rip, uint64_t rsp, uint64_t arg1,
@@ -53,14 +55,18 @@ void Thread::Start(uint64_t entry, uint64_t arg1, uint64_t arg2) {
 }
 
 void Thread::Init() {
+#if K_THREAD_DEBUG
   dbgln("Thread start.", pid(), id_);
+#endif
   uint64_t rsp = process_.vmas()->AllocateUserStack();
   SetRsp0(rsp0_start_);
   jump_user_space(rip_, rsp, arg1_, arg2_);
 }
 
 void Thread::Exit() {
-  dbgln("Exiting", pid(), id_);
+#if K_THREAD_DEBUG
+  dbgln("Exiting");
+#endif
   state_ = FINISHED;
   process_.CheckState();
   gScheduler->Yield();