christoph/lecture-operating-system-development
1
Fork 0
Code Activity

enable c++17 and use if constexpr for debug toggle

Browse Source
This commit is contained in:
churl
2022-05-23 12:31:10 +02:00
parent f6980edb3c
commit 60fe069650
6 changed files with 44 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
c_os/Makefile
View File

@ -71,7 +71,8 @@ ASM = nasm
CC ?= gcc CC ?= gcc
CXX ?= g++ CXX ?= g++
CFLAGS := $(CFLAGS) -m32 -march=i486 -Wall -fno-stack-protector -nostdlib -I. -g -ffreestanding -fno-pie -fno-pic -mpreferred-stack-boundary=2 -Wno-write-strings -mno-sse -mno-sse2 -mmanual-endbr CFLAGS := $(CFLAGS) -m32 -march=i486 -Wall -fno-stack-protector -nostdlib -I. -g -ffreestanding -fno-pie -fno-pic -mpreferred-stack-boundary=2 -Wno-write-strings -mno-sse -mno-sse2 -mmanual-endbr
CXXFLAGS := $(CFLAGS) -Wno-non-virtual-dtor -fno-threadsafe-statics -fno-use-cxa-atexit -fno-rtti -fno-exceptions CXXFLAGS := $(CFLAGS) -Wno-non-virtual-dtor -fno-threadsafe-statics -fno-use-cxa-atexit -fno-rtti -fno-exceptions -std=c++17
# I added -std=c++17 for if constexpr, but it isn't necessary for anything critical
# Needed for template concepts, but we don't have it available: -std=c++20 # Needed for template concepts, but we don't have it available: -std=c++20
BOOT = ../boot BOOT = ../boot

14
c_os/devices/BufferedCGA.cc
View File

@ -8,12 +8,12 @@ void BufferedCGA::init(unsigned int pages) {
this->screen_buffer = new CGA::cga_page_t; this->screen_buffer = new CGA::cga_page_t;
if (this->scrollback_buffer == NULL || this->screen_buffer == NULL) { if (this->scrollback_buffer == NULL || this->screen_buffer == NULL) {
if (DEBUG) kout << "Error initializing scrollback buffer" << endl; if constexpr (DEBUG) kout << "Error initializing scrollback buffer" << endl;
return; return;
} }
this->initialized = true; this->initialized = true;
if (DEBUG) kout << "Initialized scrollback buffer" << endl; if constexpr (DEBUG) kout << "Initialized scrollback buffer" << endl;
} }
void BufferedCGA::display_scrollback() { void BufferedCGA::display_scrollback() {
@ -26,7 +26,7 @@ void BufferedCGA::display_scrollback() {
this->scrollback_buffer->get((cga_line_t*)CGA_START, this->scrollback - 1); this->scrollback_buffer->get((cga_line_t*)CGA_START, this->scrollback - 1);
} }
} else { } else {
if (DEBUG) kout << "ScrollbackBuffer not initialized" << endl; if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
} }
} }
@ -45,7 +45,7 @@ void BufferedCGA::scrollup() {
if (this->initialized) { if (this->initialized) {
this->scrollback_buffer->put((cga_line_t*)CGA_START); this->scrollback_buffer->put((cga_line_t*)CGA_START);
} else { } else {
if (DEBUG) kout << "ScrollbackBuffer not initialized" << endl; if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
} }
CGA::scrollup(); CGA::scrollup();
@ -59,7 +59,7 @@ void BufferedCGA::clear() {
this->scrollback_buffer->clear(); this->scrollback_buffer->clear();
mmem::zero<CGA::cga_page_t>(this->screen_buffer); mmem::zero<CGA::cga_page_t>(this->screen_buffer);
} else { } else {
if (DEBUG) kout << "ScrollbackBuffer not initialized" << endl; if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
} }
} }
@ -78,7 +78,7 @@ void BufferedCGA::scroll_page_backward() {
} }
this->display_scrollback(); this->display_scrollback();
} else { } else {
if (DEBUG) kout << "ScrollbackBuffer not initialized" << endl; if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
} }
} }
@ -90,6 +90,6 @@ void BufferedCGA::scroll_page_forward() {
} }
this->display_scrollback(); this->display_scrollback();
} else { } else {
if (DEBUG) kout << "ScrollbackBuffer not initialized" << endl; if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
} }
} }

10
c_os/kernel/allocator/BumpAllocator.cc
View File

@ -25,7 +25,7 @@ void BumpAllocator::init() {
this->allocations = 0; this->allocations = 0;
this->next = (unsigned char*)heap_start; this->next = (unsigned char*)heap_start;
if (DEBUG) kout << "Initialized Bump Allocator" << endl; if constexpr (DEBUG) kout << "Initialized Bump Allocator" << endl;
} }
/***************************************************************************** /*****************************************************************************
@ -51,10 +51,10 @@ void* BumpAllocator::alloc(unsigned int req_size) {
/* Hier muess Code eingefuegt werden */ /* Hier muess Code eingefuegt werden */
if (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl; if constexpr (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl;
if (req_size + (unsigned int)this->next > this->heap_end) { if (req_size + (unsigned int)this->next > this->heap_end) {
if (DEBUG) kout << " - More memory requested than available :(" << endl; if constexpr (DEBUG) kout << " - More memory requested than available :(" << endl;
return NULL; return NULL;
} }
@ -62,7 +62,7 @@ void* BumpAllocator::alloc(unsigned int req_size) {
this->next = (unsigned char*)((unsigned int)this->next + req_size); this->next = (unsigned char*)((unsigned int)this->next + req_size);
this->allocations = this->allocations + 1; this->allocations = this->allocations + 1;
if (DEBUG) kout << " - Allocated " << hex << req_size << " Bytes." << endl; if constexpr (DEBUG) kout << " - Allocated " << hex << req_size << " Bytes." << endl;
return allocated; return allocated;
} }
@ -73,5 +73,5 @@ void* BumpAllocator::alloc(unsigned int req_size) {
* Beschreibung: Nicht implementiert. * * Beschreibung: Nicht implementiert. *
*****************************************************************************/ *****************************************************************************/
void BumpAllocator::free(void* ptr) { void BumpAllocator::free(void* ptr) {
if (DEBUG) kout << " mm_free: ptr= " << hex << (unsigned int)ptr << ", not supported" << endl; if constexpr (DEBUG) kout << " mm_free: ptr= " << hex << (unsigned int)ptr << ", not supported" << endl;
} }

28
c_os/kernel/allocator/LinkedListAllocator.cc
View File

@ -37,7 +37,7 @@ void LinkedListAllocator::init() {
this->free_start->size = this->heap_size - sizeof(free_block_t); this->free_start->size = this->heap_size - sizeof(free_block_t);
this->free_start->next = this->free_start; // Only one block, points to itself this->free_start->next = this->free_start; // Only one block, points to itself
if (DEBUG) kout << "Initialized LinkedList Allocator" << endl; if constexpr (DEBUG) kout << "Initialized LinkedList Allocator" << endl;
} }
/***************************************************************************** /*****************************************************************************
@ -75,10 +75,10 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
/* Hier muess Code eingefuegt werden */ /* Hier muess Code eingefuegt werden */
// NOTE: next pointer zeigt auf headeranfang, returned wird zeiger auf anfang des nutzbaren freispeichers // NOTE: next pointer zeigt auf headeranfang, returned wird zeiger auf anfang des nutzbaren freispeichers
if (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl; if constexpr (DEBUG) kout << "Requested " << hex << req_size << " Bytes" << endl;
if (this->free_start == NULL) { if (this->free_start == NULL) {
if (DEBUG) kout << " - No free memory remaining :(" << endl; if constexpr (DEBUG) kout << " - No free memory remaining :(" << endl;
return NULL; return NULL;
} }
@ -86,7 +86,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
unsigned int req_size_diff = (BASIC_ALIGN - req_size % BASIC_ALIGN) % BASIC_ALIGN; unsigned int req_size_diff = (BASIC_ALIGN - req_size % BASIC_ALIGN) % BASIC_ALIGN;
unsigned int rreq_size = req_size + req_size_diff; unsigned int rreq_size = req_size + req_size_diff;
if (req_size_diff > 0) { if (req_size_diff > 0) {
if (DEBUG) kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl; if constexpr (DEBUG) kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl;
} }
free_block_t* current = this->free_start; free_block_t* current = this->free_start;
@ -117,7 +117,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
// Next-fit // Next-fit
this->free_start = new_next; this->free_start = new_next;
if (DEBUG) kout << " - Allocated " << hex << rreq_size << " Bytes with cutting" << endl; if constexpr (DEBUG) kout << " - Allocated " << hex << rreq_size << " Bytes with cutting" << endl;
} else { } else {
// Block too small to be cut, allocate whole block // Block too small to be cut, allocate whole block
@ -125,11 +125,11 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
this->free_start = current->next; // Pointer keeps pointing to current if last block this->free_start = current->next; // Pointer keeps pointing to current if last block
if (this->free_start == current) { if (this->free_start == current) {
// No free block remaining // No free block remaining
if (DEBUG) kout << " - Disabled freelist" << endl; if constexpr (DEBUG) kout << " - Disabled freelist" << endl;
this->free_start = NULL; this->free_start = NULL;
} }
if (DEBUG) kout << " - Allocated " << hex << current->size << " Bytes without cutting" << endl; if constexpr (DEBUG) kout << " - Allocated " << hex << current->size << " Bytes without cutting" << endl;
} }
// Block aushängen // Block aushängen
@ -146,7 +146,7 @@ void* LinkedListAllocator::alloc(unsigned int req_size) {
current = current->next; current = current->next;
} while (current != this->free_start); // Stop when arriving at the first block again } while (current != this->free_start); // Stop when arriving at the first block again
if (DEBUG) kout << " - More memory requested than available :(" << endl; if constexpr (DEBUG) kout << " - More memory requested than available :(" << endl;
return NULL; return NULL;
} }
@ -159,7 +159,7 @@ void LinkedListAllocator::free(void* ptr) {
/* Hier muess Code eingefuegt werden */ /* Hier muess Code eingefuegt werden */
if (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl; if constexpr (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl;
free_block_t* block_start = (free_block_t*)((unsigned int)ptr - sizeof(free_block_t)); free_block_t* block_start = (free_block_t*)((unsigned int)ptr - sizeof(free_block_t));
@ -170,7 +170,7 @@ void LinkedListAllocator::free(void* ptr) {
block_start->allocated = false; block_start->allocated = false;
block_start->next = block_start; block_start->next = block_start;
if (DEBUG) kout << " - Enabling freelist with one block" << endl; if constexpr (DEBUG) kout << " - Enabling freelist with one block" << endl;
return; return;
} }
@ -201,7 +201,7 @@ void LinkedListAllocator::free(void* ptr) {
// Try to merge forward ======================================================================== // Try to merge forward ========================================================================
if (next_block == next_free) { if (next_block == next_free) {
if (DEBUG) kout << " - Merging block forward" << endl; if constexpr (DEBUG) kout << " - Merging block forward" << endl;
// Current and next adjacent block can be merged // Current and next adjacent block can be merged
// [previous_free | previous_free_next | <> | block_start | next_free] // [previous_free | previous_free_next | <> | block_start | next_free]
@ -220,7 +220,7 @@ void LinkedListAllocator::free(void* ptr) {
if (this->free_start == next_free) { if (this->free_start == next_free) {
// next_free is now invalid after merge // next_free is now invalid after merge
if (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)block_start << endl; if constexpr (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)block_start << endl;
this->free_start = block_start; this->free_start = block_start;
} }
} else { } else {
@ -236,7 +236,7 @@ void LinkedListAllocator::free(void* ptr) {
// Try to merge backward ===================================================================== // Try to merge backward =====================================================================
if (previous_free_next == block_start) { if (previous_free_next == block_start) {
if (DEBUG) kout << " - Merging block backward" << endl; if constexpr (DEBUG) kout << " - Merging block backward" << endl;
// Current and previous adjacent block can be merged // Current and previous adjacent block can be merged
// [previous_free | block_start] // [previous_free | block_start]
@ -249,7 +249,7 @@ void LinkedListAllocator::free(void* ptr) {
if (this->free_start == block_start) { if (this->free_start == block_start) {
// block_start is now invalid after merge // block_start is now invalid after merge
if (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)previous_free << endl; if constexpr (DEBUG) kout << " - Moving freelist start to " << hex << (unsigned int)previous_free << endl;
this->free_start = previous_free; this->free_start = previous_free;
} }
} }

26
c_os/kernel/allocator/TreeAllocator.cc
View File

@ -14,7 +14,7 @@ void TreeAllocator::init() {
this->free_start->next = (list_block_t*)this->free_start; this->free_start->next = (list_block_t*)this->free_start;
this->free_start->previous = (list_block_t*)this->free_start; this->free_start->previous = (list_block_t*)this->free_start;
if (DEBUG) kout << "Initialized Tree Allocator" << endl; if constexpr (DEBUG) kout << "Initialized Tree Allocator" << endl;
} }
void TreeAllocator::dump_free_memory() { void TreeAllocator::dump_free_memory() {
@ -33,7 +33,7 @@ void TreeAllocator::dump_free_memory(tree_block_t* node) {
} }
void* TreeAllocator::alloc(unsigned int req_size) { void* TreeAllocator::alloc(unsigned int req_size) {
if (DEBUG) kout << "Requested " << dec << req_size << " Bytes" << endl; if constexpr (DEBUG) kout << "Requested " << dec << req_size << " Bytes" << endl;
// Round to word borders + tree_block size // Round to word borders + tree_block size
unsigned int rreq_size = req_size; unsigned int rreq_size = req_size;
@ -41,35 +41,35 @@ void* TreeAllocator::alloc(unsigned int req_size) {
// the list_block_t is part of every block, but when freeing // the list_block_t is part of every block, but when freeing
// memory we need enough space to store the rbt metadata // memory we need enough space to store the rbt metadata
rreq_size = sizeof(tree_block_t) - sizeof(list_block_t); rreq_size = sizeof(tree_block_t) - sizeof(list_block_t);
if (DEBUG) kout << " - Increased block size for rbt metadata" << endl; if constexpr (DEBUG) kout << " - Increased block size for rbt metadata" << endl;
} }
unsigned int req_size_diff = (BASIC_ALIGN - rreq_size % BASIC_ALIGN) % BASIC_ALIGN; unsigned int req_size_diff = (BASIC_ALIGN - rreq_size % BASIC_ALIGN) % BASIC_ALIGN;
rreq_size = rreq_size + req_size_diff; rreq_size = rreq_size + req_size_diff;
if (req_size_diff > 0) { if (req_size_diff > 0) {
if (DEBUG) kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl; if constexpr (DEBUG) kout << " - Rounded to word border (+" << dec << req_size_diff << " bytes)" << endl;
} }
// Finds smallest block that is large enough // Finds smallest block that is large enough
tree_block_t* best_fit = this->rbt_search_bestfit(rreq_size); tree_block_t* best_fit = this->rbt_search_bestfit(rreq_size);
if (best_fit == NULL) { if (best_fit == NULL) {
if (DEBUG) kout << " - No block found" << endl; if constexpr (DEBUG) kout << " - No block found" << endl;
return NULL; return NULL;
} }
if (best_fit->allocated) { if (best_fit->allocated) {
// Something went really wrong // Something went really wrong
if (DEBUG) kout << " - Block already allocated :(" << endl; if constexpr (DEBUG) kout << " - Block already allocated :(" << endl;
return NULL; return NULL;
} }
best_fit->allocated = true; best_fit->allocated = true;
unsigned int size = this->get_size(best_fit); unsigned int size = this->get_size(best_fit);
if (DEBUG) kout << " - Found best-fit: " << hex << (unsigned int)best_fit << endl; if constexpr (DEBUG) kout << " - Found best-fit: " << hex << (unsigned int)best_fit << endl;
// Remove the block first so we can insert correctly when cutting // Remove the block first so we can insert correctly when cutting
// kout << " - Removing block from freelist" << endl; // kout << " - Removing block from freelist" << endl;
this->rbt_remove(best_fit); this->rbt_remove(best_fit);
if (size > HEAP_MIN_FREE_BLOCK_SIZE + rreq_size + sizeof(list_block_t)) { if (size > HEAP_MIN_FREE_BLOCK_SIZE + rreq_size + sizeof(list_block_t)) {
// Block can be cut // Block can be cut
if (DEBUG) kout << " - Allocating " << dec << rreq_size << " Bytes with cutting" << endl; if constexpr (DEBUG) kout << " - Allocating " << dec << rreq_size << " Bytes with cutting" << endl;
// [best_fit_start | sizeof(list_block_t) | rreq_size | new_block_start] // [best_fit_start | sizeof(list_block_t) | rreq_size | new_block_start]
tree_block_t* new_block = (tree_block_t*)((char*)best_fit + sizeof(list_block_t) + rreq_size); tree_block_t* new_block = (tree_block_t*)((char*)best_fit + sizeof(list_block_t) + rreq_size);
@ -80,15 +80,15 @@ void* TreeAllocator::alloc(unsigned int req_size) {
// Don't cut block // Don't cut block
// The block is already correctly positioned in the linked list so we only // The block is already correctly positioned in the linked list so we only
// need to remove it from the freelist, which is done for both cases // need to remove it from the freelist, which is done for both cases
if (DEBUG) kout << " - Allocating " << dec << rreq_size << " Bytes without cutting" << endl; if constexpr (DEBUG) kout << " - Allocating " << dec << rreq_size << " Bytes without cutting" << endl;
} }
if (DEBUG) kout << " - Returned address " << hex << (unsigned int)((char*)best_fit + sizeof(list_block_t)) << endl; if constexpr (DEBUG) kout << " - Returned address " << hex << (unsigned int)((char*)best_fit + sizeof(list_block_t)) << endl;
return (void*)((char*)best_fit + sizeof(list_block_t)); return (void*)((char*)best_fit + sizeof(list_block_t));
} }
void TreeAllocator::free(void* ptr) { void TreeAllocator::free(void* ptr) {
if (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl; if constexpr (DEBUG) kout << "Freeing " << hex << (unsigned int)ptr << endl;
list_block_t* block = (list_block_t*)((char*)ptr - sizeof(list_block_t)); list_block_t* block = (list_block_t*)((char*)ptr - sizeof(list_block_t));
if (!block->allocated) { if (!block->allocated) {
@ -107,7 +107,7 @@ void TreeAllocator::free(void* ptr) {
if (!next->allocated) { if (!next->allocated) {
// Merge forward // Merge forward
if (DEBUG) kout << " - Merging forward" << endl; if constexpr (DEBUG) kout << " - Merging forward" << endl;
// Remove the next block from all lists as it is now part of our freed block // Remove the next block from all lists as it is now part of our freed block
this->dll_remove(next); this->dll_remove(next);
@ -120,7 +120,7 @@ void TreeAllocator::free(void* ptr) {
if (!previous->allocated) { if (!previous->allocated) {
// Merge backward // Merge backward
if (DEBUG) kout << " - Merging backward" << endl; if constexpr (DEBUG) kout << " - Merging backward" << endl;
// Remove the current block from all lists as it is now part of the previous block // Remove the current block from all lists as it is now part of the previous block
// It doesn't have to be removed from rbt as it wasn't in there as it was allocated before // It doesn't have to be removed from rbt as it wasn't in there as it was allocated before

6
c_os/kernel/interrupts/IntDispatcher.cc
View File

@ -63,12 +63,12 @@ int IntDispatcher::assign(unsigned int vector, ISR& isr) {
/* hier muss Code eingefuegt werden */ /* hier muss Code eingefuegt werden */
if (vector >= this->size) { if (vector >= this->size) {
if (DEBUG) kout << "Invalid vector number when assigning" << endl; if constexpr (DEBUG) kout << "Invalid vector number when assigning" << endl;
return -1; return -1;
} }
this->map[vector] = &isr; this->map[vector] = &isr;
if (DEBUG) kout << "Registered ISR for vector " << dec << vector << endl; if constexpr (DEBUG) kout << "Registered ISR for vector " << dec << vector << endl;
return 0; return 0;
} }
@ -94,7 +94,7 @@ int IntDispatcher::report(unsigned int vector) {
ISR* isr = this->map[vector]; ISR* isr = this->map[vector];
if (isr == 0) { if (isr == 0) {
if (DEBUG) kout << "No ISR registered for vector " << vector << endl; if constexpr (DEBUG) kout << "No ISR registered for vector " << vector << endl;
return -1; return -1;
} }