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

changed a lot of small clang-tidy warnings

Browse Source
This commit is contained in:
churl
2022-05-23 17:06:11 +02:00
parent b78faebdc5
commit 7927220247
30 changed files with 158 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
c_os/devices/BufferedCGA.cc
View File

@ -4,29 +4,29 @@
// Can't initialize in constructor as memory management already needs working CGA for output
// NOTE: This has to be called when memorymanagement is active
void BufferedCGA::init(unsigned int pages) {
this->scrollback_buffer = new ScrollbackBuffer(ROWS, pages); // No delete since it's only off when shutting the os down
this->screen_buffer = new CGA::cga_page_t;
this->scrollback_buffer = std::make_unique<ScrollbackBuffer>(ROWS, pages); // No delete since it's only off when shutting the os down
this->screen_buffer = std::make_unique<CGA::cga_page_t>();
if (this->scrollback_buffer == NULL || this->screen_buffer == NULL) {
if constexpr (DEBUG) kout << "Error initializing scrollback buffer" << endl;
if constexpr (DEBUG) { kout << "Error initializing scrollback buffer" << endl; }
return;
}
this->initialized = true;
if constexpr (DEBUG) kout << "Initialized scrollback buffer" << endl;
if constexpr (DEBUG) { kout << "Initialized scrollback buffer" << endl; }
}
void BufferedCGA::display_scrollback() {
if (this->initialized) {
if (this->scrollback == 0) {
// Use pagebuffer
mmem::memcpy<CGA::cga_page_t>((CGA::cga_page_t*)CGA_START, this->screen_buffer);
mmem::memcpy<CGA::cga_page_t>((CGA::cga_page_t*)CGA_START, this->screen_buffer.get());
} else {
// Use scrollback
this->scrollback_buffer->get((cga_line_t*)CGA_START, this->scrollback - 1);
this->scrollback_buffer->get((CGA::cga_line_t*)CGA_START, this->scrollback - 1);
}
} else {
if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
if constexpr (DEBUG) { kout << "ScrollbackBuffer not initialized" << endl; }
}
}
@ -43,9 +43,9 @@ void BufferedCGA::print(char* string, int n, unsigned char attrib) {
void BufferedCGA::scrollup() {
if (this->initialized) {
this->scrollback_buffer->put((cga_line_t*)CGA_START);
this->scrollback_buffer->put((CGA::cga_line_t*)CGA_START);
} else {
if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
if constexpr (DEBUG) { kout << "ScrollbackBuffer not initialized" << endl; }
}
CGA::scrollup();
@ -57,9 +57,9 @@ void BufferedCGA::clear() {
if (this->initialized) {
this->scrollback_buffer->clear();
mmem::zero<CGA::cga_page_t>(this->screen_buffer);
mmem::zero<CGA::cga_page_t>(this->screen_buffer.get());
} else {
if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
if constexpr (DEBUG) { kout << "ScrollbackBuffer not initialized" << endl; }
}
}
@ -68,7 +68,7 @@ void BufferedCGA::scroll_page_backward() {
// If this is the first scrollback we have to save the current screen content
if (this->scrollback == 0) {
mmem::memcpy<CGA::cga_page_t>(this->screen_buffer, (CGA::cga_page_t*)CGA_START);
mmem::memcpy<CGA::cga_page_t>(this->screen_buffer.get(), (CGA::cga_page_t*)CGA_START);
}
// current_page can be equal to scrollback_buffer->pages
@ -78,7 +78,7 @@ void BufferedCGA::scroll_page_backward() {
}
this->display_scrollback();
} else {
if constexpr (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();
} else {
if constexpr (DEBUG) kout << "ScrollbackBuffer not initialized" << endl;
if constexpr (DEBUG) { kout << "ScrollbackBuffer not initialized" << endl; }
}
}

15
c_os/devices/BufferedCGA.h
View File

@ -4,6 +4,7 @@
#include "devices/CGA.h"
#include "devices/Keyboard.h"
#include "lib/ScrollbackBuffer.h"
#include <memory>
// NOTE: I added this file, I don't know if it will be used till the end but right know it's nice to have
@ -12,20 +13,14 @@
// have to replace print with unbuffered_print or something, which I don't like.
class BufferedCGA : public CGA {
private:
ScrollbackBuffer* scrollback_buffer; // Contains previous pages
CGA::cga_page_t* screen_buffer; // Contains the current page separately from the scrollback.
bool initialized; // Don't do ScrollbackBuffer actions if not initialized
std::unique_ptr<ScrollbackBuffer> scrollback_buffer; // Contains previous pages
std::unique_ptr<CGA::cga_page_t> screen_buffer; // Contains the current page separately from the scrollback.
bool initialized; // Don't do ScrollbackBuffer actions if not initialized
BufferedCGA(const BufferedCGA&) = delete;
public:
BufferedCGA() : CGA(), initialized(false), scrollback(0) {};
~BufferedCGA() {
if (this->initialized) {
delete this->scrollback_buffer;
delete this->screen_buffer;
}
}
BufferedCGA() : initialized(false), scrollback(0) {}
unsigned char scrollback; // The page that is displayed, public to enable page display

16
c_os/devices/CGA.cc
View File

@ -41,7 +41,7 @@ void CGA::setpos(int x, int y) {
* *
* Rückgabewerte: x und y *
*****************************************************************************/
void CGA::getpos(int& x, int& y) {
void CGA::getpos(int& x, int& y) const {
/* Hier muess Code eingefuegt werden */
@ -78,7 +78,7 @@ void CGA::show(int x, int y, char character, unsigned char attrib) {
return;
}
cga_char_t* pos = (cga_char_t*)(CGA_START + 2 * (x + y * COLUMNS));
cga_char_t* pos = (cga_char_t*)CGA_START + x + y * COLUMNS;
pos->cga_char = character;
pos->cga_attribute = attrib;
}
@ -101,7 +101,7 @@ void CGA::print(char* string, int n, unsigned char attrib) {
int cursor_x, cursor_y; // Don't poll registers every stroke
this->getpos(cursor_x, cursor_y);
for (unsigned short byte = 0; byte < n; ++byte) {
for (int byte = 0; byte < n; ++byte) {
char current = *(string + byte);
if (current == '\n') {
cursor_x = 0;
@ -114,7 +114,9 @@ void CGA::print(char* string, int n, unsigned char attrib) {
}
continue;
} else if (current == '\0') {
}
if (current == '\0') {
// Don't need to run to end if null terminated
break;
}
@ -185,7 +187,7 @@ unsigned char CGA::attribute(CGA::color bg, CGA::color fg, bool blink) {
/* Hier muess Code eingefuegt werden */
return blink << 7 // B0000000
| (bg & 0x7) << 4 // 0HHH0000 (Hintergrund)
| (fg & 0xF); // 0000VVVV (Vordergrund)
return static_cast<int>(blink) << 7 // B0000000
| (bg & 0x7) << 4 // 0HHH0000 (Hintergrund)
| (fg & 0xF); // 0000VVVV (Vordergrund)
}

16
c_os/devices/CGA.h
View File

@ -16,23 +16,23 @@
#include "kernel/IOport.h"
#include "lib/MyStdLib.h"
#include <variant>
class CGA {
private:
IOport index_port; // Auswahl eines Register der Grafikkarte
IOport data_port; // Lese-/Schreib-Zugriff auf Register der Grafikk.
// Copy Konstrutkor unterbinden
CGA(const CGA& copy);
CGA(const CGA& copy) = delete;
public:
const char* CGA_START; // Startadresse des Buldschirmspeichers
// NOTE: I change CGA_START to this const because I think the address should be constant and macro-like,
// not the data at this address (we want that data to change).
static const unsigned int CGA_START = 0xb8000U;
// Konstruktur mit Initialisierung der Ports
CGA() : index_port(0x3d4), data_port(0x3d5) {
CGA_START = (const char*)0xb8000;
// NOTE: I added this
this->setpos(0, 0);
}
@ -67,7 +67,7 @@ public:
// NOTE: I added this
typedef struct {
char cga_char;
char cga_attribute;
unsigned char cga_attribute;
} cga_char_t;
typedef struct {
cga_char_t cga_line[COLUMNS];
@ -80,7 +80,7 @@ public:
void setpos(int x, int y);
// Abfragen der Cursorpostion
void getpos(int& x, int& y);
void getpos(int& x, int& y) const;
// Anzeige eines Zeichens mit Attribut an einer bestimmten Stelle
void show(int x, int y, char character, unsigned char attrib = STD_ATTR);
@ -96,7 +96,7 @@ public:
virtual void clear();
// Hilfsfunktion zur Erzeugung eines Attribut-Bytes
unsigned char attribute(CGA::color bg, CGA::color fg, bool blink);
static unsigned char attribute(CGA::color bg, CGA::color fg, bool blink);
};
#endif

2
c_os/devices/CGA_Stream.cc
View File

@ -24,7 +24,7 @@
* verwendet werden, um eine Ausgabe zu erzwingen. *
*****************************************************************************/
void CGA_Stream::flush() {
print(buffer, pos, attribute(this->color_bg, this->color_fg, this->blink));
print((char*)buffer, pos, attribute(this->color_bg, this->color_fg, this->blink));
// TODO: Should not be reset like this
// Flushing resets attributes

19
c_os/devices/CGA_Stream.h
View File

@ -21,35 +21,28 @@
// NOTE: I added this
class fgc {
public:
fgc() : fg(CGA::LIGHT_GREY) {};
fgc(CGA::color fg) : fg(fg) {};
fgc() : fg(CGA::LIGHT_GREY) {}
fgc(CGA::color fg) : fg(fg) {}
CGA::color fg;
};
class bgc {
public:
bgc() : bg(CGA::BLACK) {};
bgc(CGA::color bg) : bg(bg) {};
bgc() : bg(CGA::BLACK) {}
bgc(CGA::color bg) : bg(bg) {}
CGA::color bg;
};
// NOTE: I added this (changed this) to use BufferedCGA
class CGA_Stream : public OutStream, public BufferedCGA {
// class CGA_Stream : public OutStream, public CGA {
private:
CGA_Stream(CGA_Stream& copy); // Verhindere Kopieren
CGA_Stream(CGA_Stream& copy) = delete; // Verhindere Kopieren
public:
CGA::color color_fg;
CGA::color color_bg;
bool blink;
CGA_Stream() : OutStream(), BufferedCGA() {
// CGA_Stream() : OutStream(), CGA() {
color_fg = CGA::LIGHT_GREY;
color_bg = CGA::BLACK;
blink = false;
CGA_Stream() : color_fg(CGA::LIGHT_GREY), color_bg(CGA::BLACK), blink(false) {
flush();
}

8
c_os/kernel/Allocator.cc
View File

@ -44,16 +44,10 @@
/*****************************************************************************
* Konstruktor: Allocator::Allocator *
*****************************************************************************/
Allocator::Allocator() {
Allocator::Allocator() : heap_start(HEAP_START), heap_end(HEAP_START + HEAP_SIZE), heap_size(HEAP_SIZE), initialized(1) {
// Groesse des Hauptspeichers (kann über das BIOS abgefragt werden,
// aber sehr umstaendlich, daher hier fest eingetragen
total_mem = MEM_SIZE_DEF;
heap_start = HEAP_START;
heap_end = HEAP_START + HEAP_SIZE;
heap_size = HEAP_SIZE;
initialized = 1;
}
/*****************************************************************************

7
c_os/kernel/Allocator.h
View File

@ -33,10 +33,13 @@
#ifndef __Allocator_include__
#define __Allocator_include__
class Allocator {
// TODO: Is it 8 or 4?
constexpr unsigned int BASIC_ALIGN = 8;
constexpr unsigned int HEAP_MIN_FREE_BLOCK_SIZE = 64; // min. Groesse eines freien Blocks
class Allocator {
private:
Allocator(Allocator& copy); // Verhindere Kopieren
Allocator(Allocator& copy) = delete; // Verhindere Kopieren
public:
unsigned int heap_start;

2
c_os/kernel/Globals.cc
View File

@ -18,5 +18,5 @@ IntDispatcher intdis; // Unterbrechungsverteilung
PIC pic; // Interrupt-Controller
unsigned int total_mem; // RAM total
// BumpAllocator allocator;
// LinkedListAllocator allocator;
// LinkedListAllocator allocator;
TreeAllocator allocator;

2
c_os/kernel/Globals.h
View File

@ -28,7 +28,7 @@ extern IntDispatcher intdis; // Unterbrechungsverteilung
extern PIC pic; // Interrupt-Controller
extern unsigned int total_mem; // RAM total
// extern BumpAllocator allocator;
// extern LinkedListAllocator allocator;
// extern LinkedListAllocator allocator;
extern TreeAllocator allocator;
constexpr bool DEBUG = true;

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

@ -25,7 +25,7 @@ void BumpAllocator::init() {
this->allocations = 0;
this->next = (unsigned char*)heap_start;
if constexpr (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 */
if constexpr (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 constexpr (DEBUG) kout << " - More memory requested than available :(" << endl;
if constexpr (DEBUG) { kout << " - More memory requested than available :(" << endl; }
return NULL;
}
@ -62,7 +62,7 @@ void* BumpAllocator::alloc(unsigned int req_size) {
this->next = (unsigned char*)((unsigned int)this->next + req_size);
this->allocations = this->allocations + 1;
if constexpr (DEBUG) kout << " - Allocated " << hex << req_size << " Bytes." << endl;
if constexpr (DEBUG) { kout << " - Allocated " << hex << req_size << " Bytes." << endl; }
return allocated;
}
@ -73,5 +73,5 @@ void* BumpAllocator::alloc(unsigned int req_size) {
* Beschreibung: Nicht implementiert. *
*****************************************************************************/
void BumpAllocator::free(void* ptr) {
if constexpr (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; }
}

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

@ -20,15 +20,15 @@ private:
unsigned char* next;
unsigned int allocations;
BumpAllocator(Allocator& copy); // Verhindere Kopieren
BumpAllocator(Allocator& copy) = delete; // Verhindere Kopieren
public:
BumpAllocator() {}; // Allocator() called implicitely in C++
void init();
void dump_free_memory();
void* alloc(unsigned int req_size);
void free(void* ptr);
void init() override;
void dump_free_memory() override;
void* alloc(unsigned int req_size) override;
void free(void* ptr) override;
};
#endif

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

18
c_os/kernel/allocator/LinkedListAllocator.h
View File

@ -14,10 +14,6 @@
#include "kernel/Allocator.h"
// TODO: Is it 8 or 4?
#define BASIC_ALIGN 8
#define HEAP_MIN_FREE_BLOCK_SIZE 64 // min. Groesse eines freien Blocks
// Format eines freien Blocks, 4 + 4 + 4 Byte
typedef struct free_block {
bool allocated; // NOTE: I added this to allow easier merging of free blocks:
@ -37,21 +33,21 @@ private:
// freie Bloecke werden verkettet
struct free_block* free_start;
LinkedListAllocator(Allocator& copy); // Verhindere Kopieren
LinkedListAllocator(Allocator& copy) = delete; // Verhindere Kopieren
// NOTE: I added this
// Traverses the whole list forward till previous block is reached.
// This can only be called on free blocks as allocated blocks
// aren't reachable from the freelist.
struct free_block* find_previous_block(struct free_block*);
static struct free_block* find_previous_block(struct free_block*);
public:
LinkedListAllocator() {};
LinkedListAllocator() {}
void init();
void dump_free_memory();
void* alloc(unsigned int req_size);
void free(void* ptr);
void init() override;
void dump_free_memory() override;
void* alloc(unsigned int req_size) override;
void free(void* ptr) override;
};
#endif

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

@ -14,26 +14,22 @@ void TreeAllocator::init() {
this->free_start->next = (list_block_t*)this->free_start;
this->free_start->previous = (list_block_t*)this->free_start;
if constexpr (DEBUG) kout << "Initialized Tree Allocator" << endl;
if constexpr (DEBUG) { kout << "Initialized Tree Allocator" << endl; }
}
void TreeAllocator::dump_free_memory() {
kout << "Free Memory:" << endl;
this->dump_free_memory(this->free_start);
}
void TreeAllocator::dump_free_memory(tree_block_t* node) {
if (node == NULL) {
return;
}
this->dump_free_memory(node->left);
kout << " - Free Block at " << hex << (unsigned int)node << " (" << hex << this->get_size(node) << " Byte)" << endl;
this->dump_free_memory(node->right);
list_block_t* current = (list_block_t*)this->heap_start;
do {
if (!current->allocated) {
kout << " - Free Block at " << (unsigned int)current << ", Size: " << (unsigned int)current->next - (unsigned int)current << endl;
}
current = current->next;
} while ((unsigned int)current != this->heap_start);
}
void* TreeAllocator::alloc(unsigned int req_size) {
if constexpr (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
unsigned int rreq_size = req_size;
@ -41,35 +37,35 @@ void* TreeAllocator::alloc(unsigned int req_size) {
// the list_block_t is part of every block, but when freeing
// memory we need enough space to store the rbt metadata
rreq_size = sizeof(tree_block_t) - sizeof(list_block_t);
if constexpr (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;
rreq_size = rreq_size + req_size_diff;
if (req_size_diff > 0) {
if constexpr (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
tree_block_t* best_fit = this->rbt_search_bestfit(rreq_size);
if (best_fit == NULL) {
if constexpr (DEBUG) kout << " - No block found" << endl;
if constexpr (DEBUG) { kout << " - No block found" << endl; }
return NULL;
}
if (best_fit->allocated) {
// Something went really wrong
if constexpr (DEBUG) kout << " - Block already allocated :(" << endl;
if constexpr (DEBUG) { kout << " - Block already allocated :(" << endl; }
return NULL;
}
best_fit->allocated = true;
unsigned int size = this->get_size(best_fit);
if constexpr (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
// kout << " - Removing block from freelist" << endl;
this->rbt_remove(best_fit);
if (size > HEAP_MIN_FREE_BLOCK_SIZE + rreq_size + sizeof(list_block_t)) {
// Block can be cut
if constexpr (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]
tree_block_t* new_block = (tree_block_t*)((char*)best_fit + sizeof(list_block_t) + rreq_size);
@ -80,15 +76,15 @@ void* TreeAllocator::alloc(unsigned int req_size) {
// Don't cut block
// 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
if constexpr (DEBUG) kout << " - Allocating " << dec << rreq_size << " Bytes without cutting" << endl;
if constexpr (DEBUG) { kout << " - Allocating " << dec << rreq_size << " Bytes without cutting" << endl; }
}
if constexpr (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));
}
void TreeAllocator::free(void* ptr) {
if constexpr (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));
if (!block->allocated) {
@ -107,7 +103,7 @@ void TreeAllocator::free(void* ptr) {
if (!next->allocated) {
// Merge forward
if constexpr (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
this->dll_remove(next);
@ -120,7 +116,7 @@ void TreeAllocator::free(void* ptr) {
if (!previous->allocated) {
// Merge backward
if constexpr (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
// It doesn't have to be removed from rbt as it wasn't in there as it was allocated before

15
c_os/kernel/allocator/TreeAllocator.h
View File

@ -3,9 +3,6 @@
#include "kernel/Allocator.h"
#define HEAP_MIN_FREE_BLOCK_SIZE 64 // min. Groesse eines freien Blocks
#define BASIC_ALIGN 8
// NOTE: I added this file
// NOTE: I can't imagine that this is very fast with all the tree logic?
@ -40,7 +37,7 @@ private:
// Root of the rbt
tree_block_t* free_start;
TreeAllocator(Allocator& copy); // Verhindere Kopieren
TreeAllocator(Allocator& copy) = delete; // Verhindere Kopieren
// Returns the size of the usable memory of a block
unsigned int get_size(list_block_t* block) const;
@ -50,7 +47,7 @@ private:
// NOTE: Would be nice to have this stuff somewhere else for general use,
// but that would require different rbt_node/dll_node structures.
// If I need this again later I should look into it.
// If I need this again later I should move it.
void rbt_rot_l(tree_block_t* x);
void rbt_rot_r(tree_block_t* x);
void rbt_transplant(tree_block_t* a, tree_block_t* b);
@ -71,10 +68,10 @@ private:
public:
TreeAllocator() {};
void init();
void dump_free_memory();
void* alloc(unsigned int req_size);
void free(void* ptr);
void init() override;
void dump_free_memory() override;
void* alloc(unsigned int req_size) override;
void free(void* ptr) override;
};
#endif

9
c_os/kernel/allocator/TreeAllocatorOperations.cc
View File

@ -197,7 +197,7 @@ void TreeAllocator::rbt_remove(tree_block_t* z) {
// fix the rb tree modified by the delete operation
void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
tree_block_t* s;
while (x != this->free_start && x->red == false) {
while (x != this->free_start && !x->red) {
if (x == x->parent->left) {
s = x->parent->right;
if (s->red) {
@ -238,7 +238,7 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
s = x->parent->left;
}
if (!s->right->red && !s->right->red) {
if (!s->right->red) {
// case 3.2
s->red = true;
x = x->parent;
@ -264,6 +264,7 @@ void TreeAllocator::rbt_fix_remove(tree_block_t* x) {
}
// END copy from algorithmtutorprograms
// NOTE: This is recursive and depends on luck
tree_block_t* TreeAllocator::rbt_search_bestfit(tree_block_t* node, unsigned int req_size) {
if (node == NULL) {
return NULL;
@ -275,7 +276,9 @@ tree_block_t* TreeAllocator::rbt_search_bestfit(tree_block_t* node, unsigned int
}
return node;
} else if (req_size > this->get_size(node)) {
}
if (req_size > this->get_size(node)) {
if (node->right != NULL && this->get_size(node->right) >= req_size) {
return this->rbt_search_bestfit(node->right, req_size);
}

3
c_os/kernel/corouts/Coroutine.h
View File

@ -29,9 +29,8 @@
class Coroutine : public Chain {
private:
Coroutine(const Coroutine& copy); // Verhindere Kopieren
Coroutine(const Coroutine& copy) = delete; // Verhindere Kopieren
private:
struct CoroutineState regs;
public:

10
c_os/kernel/interrupts/ISR.h
View File

@ -13,15 +13,15 @@
#define __ISR_include__
class ISR {
private:
ISR (const ISR &copy); // Verhindere Kopieren
ISR(const ISR& copy) = delete; // Verhindere Kopieren
public:
ISR () {}
ISR() {}
// Unterbrechungsbehandlungsroutine
virtual void trigger () = 0;
virtual void trigger() = 0;
};
#endif

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

@ -94,7 +94,7 @@ int IntDispatcher::report(unsigned int vector) {
ISR* isr = this->map[vector];
if (isr == 0) {
if constexpr (DEBUG) kout << "No ISR registered for vector " << vector << endl;
if constexpr (DEBUG) { kout << "No ISR registered for vector " << vector << endl; }
return -1;
}

2
c_os/kernel/interrupts/IntDispatcher.h
View File

@ -18,7 +18,7 @@
class IntDispatcher {
private:
IntDispatcher(const IntDispatcher& copy); // Verhindere Kopieren
IntDispatcher(const IntDispatcher& copy) = delete; // Verhindere Kopieren
enum { size = 256 };
ISR* map[size];

3
c_os/kernel/interrupts/PIC.h
View File

@ -20,12 +20,11 @@
class PIC {
private:
PIC(const PIC& copy); // Verhindere Kopieren
PIC(const PIC& copy) = delete; // Verhindere Kopieren
public:
PIC() {}
public:
// IRQ-Nummern von Geraeten
enum {
timer = 0, // Programmable Interrupt Timer (PIT)

3
c_os/lib/Chain.h
View File

@ -13,9 +13,8 @@
#define __Chain_include__
class Chain {
private:
Chain(const Chain &copy); // Verhindere Kopieren
Chain(const Chain& copy) = delete; // Verhindere Kopieren
public:
Chain* next;

20
c_os/lib/OutStream.h
View File

@ -28,20 +28,20 @@
// NOTE: I added this
class fillw {
public:
fillw() : w(0) {};
fillw(unsigned char w) : w(w) {};
fillw() : w(0) {}
fillw(unsigned char w) : w(w) {}
unsigned char w;
};
class fillc {
public:
fillc() : c(' ') {};
fillc(char c) : c(c) {};
fillc() : c(' ') {}
fillc(char c) : c(c) {}
char c;
};
class OutStream : public StringBuffer {
private:
OutStream(const OutStream& copy); // Verhindere Kopieren
OutStream(const OutStream& copy) = delete; // Verhindere Kopieren
// NOTE: I added this
unsigned char fill_used; // indicates how many characters are already used by the text internally
@ -55,13 +55,7 @@ public:
unsigned char fill_width;
char fill_char; // fill character for fixed width
OutStream() : StringBuffer() {
base = 10; // initial Dezimalsystem
fill_width = 0; // no fixed width
fill_char = ' '; // fill with spaces
fill_used = 0;
}
OutStream() : fill_used(0), base(10), fill_width(0), fill_char(' ') {}
// Methode zur Ausgabe des Pufferinhalts der Basisklasse StringBuffer.
void flush() override;
@ -165,7 +159,7 @@ public:
// Bestimmung der groessten Potenz der gewaehlten Zahlenbasis, die
// noch kleiner als die darzustellende Zahl ist.
for (div = 1; ival / div >= (unsigned long)os.base; div *= os.base) {};
for (div = 1; ival / div >= (unsigned long)os.base; div *= os.base) {}
// ziffernweise Ausgabe der Zahl
for (; div > 0; div /= (unsigned long)os.base) {

6
c_os/lib/ScrollbackBuffer.cc
View File

@ -3,7 +3,7 @@
// NOTE: I added this file
void ScrollbackBuffer::put(CGA::cga_line_t* line) {
CGA::cga_line_t* destination = (CGA::cga_line_t*)this->buffer + this->pos;
CGA::cga_line_t* destination = (CGA::cga_line_t*)this->buffer.get() + this->pos;
mmem::memcpy<CGA::cga_line_t>(destination, line);
this->pos = (this->pos + 1) % this->rows;
@ -21,13 +21,13 @@ void ScrollbackBuffer::get(CGA::cga_line_t* destination, unsigned char page) con
unsigned int wrapline;
for (unsigned int line = 0; line < (this->rows / this->pages); ++line) {
wrapline = (this->pos + rpage * (this->rows / this->pages) + line) % this->rows;
mmem::memcpy<CGA::cga_line_t>(destination + line, (CGA::cga_line_t*)this->buffer + wrapline);
mmem::memcpy<CGA::cga_line_t>(destination + line, (CGA::cga_line_t*)this->buffer.get() + wrapline);
}
}
void ScrollbackBuffer::clear() {
for (unsigned char page = 0; page < this->pages; ++page) {
mmem::zero<CGA::cga_page_t>(this->buffer + page);
mmem::zero<CGA::cga_page_t>(this->buffer.get() + page);
}
this->pos = 0;
}

13
c_os/lib/ScrollbackBuffer.h
View File

@ -3,14 +3,15 @@
#include "devices/CGA.h"
#include "lib/MyStdLib.h"
#include <memory>
#include <stddef.h>
// NOTE: I added this file
class ScrollbackBuffer {
private:
CGA::cga_page_t* buffer; // Circular buffer to store lines that left the screen
unsigned int pos; // Buffer write position
std::unique_ptr<CGA::cga_page_t[]> buffer; // Circular buffer to store lines that left the screen
unsigned int pos; // Buffer write position
ScrollbackBuffer(const ScrollbackBuffer&) = delete;
@ -20,12 +21,8 @@ public:
ScrollbackBuffer(unsigned char rows, unsigned char pages)
: pos(0), pages(pages), rows(rows * pages) {
this->buffer = new CGA::cga_page_t[pages]; // Allocate with new because it's quite large (and I want to use the allocator)
this->clear(); // Null out the buffer so no crap gets displayed
}
~ScrollbackBuffer() {
delete[] this->buffer;
this->buffer = std::make_unique<CGA::cga_page_t[]>(pages); // Allocate with new because it's quite large (and I want to use the allocator)
this->clear(); // Null out the buffer so no crap gets displayed
}
void put(CGA::cga_line_t* line);

3
c_os/lib/StringBuffer.cc
View File

@ -31,6 +31,7 @@
void StringBuffer::put(char c) {
buffer[pos] = c;
pos++;
if (pos == sizeof(buffer))
if (pos == sizeof(buffer)) {
flush();
}
}

23
c_os/main.cc
View File

@ -13,7 +13,7 @@
#include "kernel/Globals.h"
#include "user/CoroutineDemo.h"
CoroutineDemo coroutineDemo;
const CoroutineDemo coroutineDemo;
int main() {
kout.clear();
@ -25,17 +25,18 @@ int main() {
kout.init(5);
// Startmeldung
if constexpr (!DEBUG)
kout << "HHUos 0.5" << endl
<< "=========" << endl
<< "Unterstuetzte Funktionen:" << endl
<< " - Bildschirmausgaben" << endl
<< " - Sound ueber den PC-Lautsprecher" << endl
<< " - Tastatureingaben per Abfrage" << endl
<< " - Einfache Heap verwaltung" << endl
<< " - Tastatureingaben per Interrupt" << endl
<< " - Koroutinen" << endl
if constexpr (!DEBUG) {
kout << "HHUos 0.5\n"
<< "=========\n"
<< "Unterstuetzte Funktionen:\n"
<< " - Bildschirmausgaben\n"
<< " - Sound ueber den PC-Lautsprecher\n"
<< " - Tastatureingaben per Abfrage\n"
<< " - Einfache Heap verwaltung\n"
<< " - Tastatureingaben per Interrupt\n"
<< " - Koroutinen\n"
<< endl;
}
// Tastatur-Unterbrechungsroutine 'einstoepseln'
/* hier muss Code eingefuegt werden */

2
c_os/user/CoroutineDemo.cc
View File

@ -17,7 +17,7 @@
*---------------------------------------------------------------------------*
* Beschreibung: main-Methode der Anwendung. *
*****************************************************************************/
void CoroutineDemo::main() {
void CoroutineDemo::main() const {
/*
* Hier muss Code eingefuegt werden

5
c_os/user/CoroutineDemo.h
View File

@ -11,15 +11,14 @@
#define __coroutinedemo_include__
class CoroutineDemo {
private:
CoroutineDemo(const CoroutineDemo& copy); // Verhindere Kopieren
CoroutineDemo(const CoroutineDemo& copy) = delete; // Verhindere Kopieren
public:
CoroutineDemo() {}
// Koroutine-Startmethode
void main();
void main() const;
};
#endif