christoph/churlos
1
Fork 0
Code Activity

Switch int to sized types

Browse Source
This commit is contained in:
Christoph Urlacher
2022-12-07 18:08:15 +01:00
parent d8fce00eed
commit ae98dc586e
32 changed files with 202 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/kernel/demo/PagingDemo.cc
View File

@ -8,7 +8,7 @@ void PagingDemo::writeprotect_page() {
// BlueScreen 2
log.info() << "Allocating page" << endl;
unsigned int* page = pg_alloc_page();
uint32_t* page = pg_alloc_page();
*page = 42;
log.info() << "Writeprotecting page..." << endl;
pg_write_protect_page(page);
@ -23,7 +23,7 @@ void PagingDemo::notpresent_page() {
kout << "Produces pagefault, if you can read this it didn't work" << endl;
log.info() << "Allocating page" << endl;
unsigned int* page = pg_alloc_page();
uint32_t* page = pg_alloc_page();
*page = 42;
log.info() << "Marking page notpresent..." << endl;

28
src/kernel/interrupt/Bluescreen.cc
View File

@ -56,8 +56,8 @@ void break_on_bluescreen() {
}
// Cursor-Position
int bs_xpos = 0;
int bs_ypos = 0;
uint8_t bs_xpos = 0;
uint8_t bs_ypos = 0;
/*****************************************************************************
* Funktion: bs_clear *
@ -65,13 +65,13 @@ int bs_ypos = 0;
* Beschreibung: Bildschirm loeschen. *
*****************************************************************************/
void bs_clear() {
unsigned int x;
unsigned int y;
unsigned short* ptr = reinterpret_cast<unsigned short*>(0xb8000);
uint8_t x;
uint8_t y;
auto* ptr = reinterpret_cast<uint16_t*>(0xb8000);
for (x = 0; x < 80; x++) {
for (y = 0; y < 25; y++) {
*(ptr + y * 80 + x) = static_cast<short>(0x1F00);
*(ptr + y * 80 + x) = static_cast<uint16_t>(0x1F00);
}
}
@ -155,11 +155,11 @@ void bs_printReg(char* str, unsigned int value) {
*---------------------------------------------------------------------------*
* Beschreibung: Hauptroutine des Bluescreens. *
*****************************************************************************/
void bs_dump(unsigned int exceptionNr) {
unsigned int* int_esp;
unsigned int* sptr;
unsigned int faultAdress;
unsigned int has_error_code = 0;
void bs_dump(uint8_t exceptionNr) {
uint32_t* int_esp;
uint32_t* sptr;
uint32_t faultAdress;
uint8_t has_error_code = 0;
bs_clear();
bs_print_string("HHUos crashed with Exception \0");
@ -210,7 +210,7 @@ void bs_dump(unsigned int exceptionNr) {
get_int_esp(&int_esp);
// wir müssen den Inhalt auslesen und das als Zeiger verwenden, um den Stack auszulesen
sptr = reinterpret_cast<unsigned int*>(*int_esp);
sptr = reinterpret_cast<uint32_t*>(*int_esp);
bs_lf();
@ -277,7 +277,7 @@ void bs_dump(unsigned int exceptionNr) {
bs_print_string("Calling Stack:\0");
bs_lf();
int x = 0;
unsigned int* ebp = reinterpret_cast<unsigned int*>(*(sptr + 2));
auto* ebp = reinterpret_cast<uint32_t*>(*(sptr + 2));
unsigned int raddr;
// solange eip > 1 MB && ebp < 128 MB, max. Aufruftiefe 10
@ -288,7 +288,7 @@ void bs_dump(unsigned int exceptionNr) {
bs_lf();
// dynamische Kette -> zum Aufrufer
ebp = reinterpret_cast<unsigned int*>(*ebp);
ebp = reinterpret_cast<uint32_t*>(*ebp);
x++;
}

2
src/kernel/interrupt/Bluescreen.h
View File

@ -14,6 +14,6 @@
#define Bluescreen_include__
// dump blue screen (will not return)
void bs_dump(unsigned int exceptionNr);
void bs_dump(uint8_t exceptionNr);
#endif

8
src/kernel/interrupt/IntDispatcher.cc
View File

@ -15,7 +15,7 @@
#include "kernel/system/Globals.h"
#include "kernel/interrupt/Bluescreen.h"
extern "C" void int_disp(unsigned int vector);
extern "C" void int_disp(uint8_t vector);
/*****************************************************************************
* Prozedur: int_disp *
@ -29,7 +29,7 @@ extern "C" void int_disp(unsigned int vector);
* Parameter: *
* vector: Vektor-Nummer der Unterbrechung *
*****************************************************************************/
void int_disp(unsigned int vector) {
void int_disp(uint8_t vector) {
/* hier muss Code eingefuegt werden */
@ -56,7 +56,7 @@ void int_disp(unsigned int vector) {
* *
* Rueckgabewert: 0 = Erfolg, -1 = Fehler *
*****************************************************************************/
int IntDispatcher::assign(unsigned int vector, ISR& isr) {
int IntDispatcher::assign(uint8_t vector, ISR& isr) {
/* hier muss Code eingefuegt werden */
@ -81,7 +81,7 @@ int IntDispatcher::assign(unsigned int vector, ISR& isr) {
* *
* Rueckgabewert: 0 = ISR wurde aufgerufen, -1 = unbekannte Vektor-Nummer *
*****************************************************************************/
int IntDispatcher::report(unsigned int vector) {
int IntDispatcher::report(uint8_t vector) {
/* hier muss Code eingefuegt werden */

4
src/kernel/interrupt/IntDispatcher.h
View File

@ -42,10 +42,10 @@ public:
}
// Registrierung einer ISR. (Rueckgabewert: 0 = Erfolg, -1 = Fehler)
int assign(unsigned int vector, ISR& isr);
int assign(uint8_t vector, ISR& isr);
// ISR fuer 'vector' ausfuehren
int report(unsigned int vector);
int report(uint8_t vector);
};
#endif

6
src/kernel/log/Logger.cc
View File

@ -19,7 +19,8 @@ void Logger::log(const bse::string_view message, CGA::color col) const {
if (Logger::kout_enabled) {
CGA::color old_col = kout.color_fg;
kout << fgc(col)
<< Logger::level_to_string(current_message_level) << "::"
<< "["
<< Logger::level_to_string(current_message_level) << "] "
<< message << fgc(old_col);
kout.flush(); // Don't add newline, Logger already does that
}
@ -40,8 +41,9 @@ void Logger::log(const bse::string_view message, CGA::color col) const {
default:
SerialOut::write(ansi_default);
}
SerialOut::write("[");
SerialOut::write(Logger::level_to_string(current_message_level));
SerialOut::write(":: ");
SerialOut::write("] ");
SerialOut::write(message);
SerialOut::write('\r');
// serial.write("\r\n");

30
src/kernel/log/Logger.h
View File

@ -8,6 +8,8 @@
#include "lib/util/StringView.h"
class Logger : public OutStream {
friend class NamedLogger; // Allow NamedLogger to lock/unlock
public:
static Logger& instance() {
static Logger log;
@ -20,9 +22,7 @@ private:
static bool kout_enabled;
static bool serial_enabled;
void log(const bse::string_view message, CGA::color col) const;
friend class NamedLogger; // Allow NamedLogger to lock/unlock
void log(bse::string_view message, CGA::color col) const;
SpinLock sem; // Semaphore would be a cyclic include
static void lock() { Logger::instance().sem.acquire(); }
@ -47,10 +47,10 @@ public:
void flush() override;
void trace(const bse::string_view message) const;
void debug(const bse::string_view message) const;
void error(const bse::string_view message) const;
void info(const bse::string_view message) const;
void trace(bse::string_view message) const;
void debug(bse::string_view message) const;
void error(bse::string_view message) const;
void info(bse::string_view message) const;
// TODO: Make lvl change accessible over menu
static void set_level(LogLevel lvl) {
@ -60,13 +60,13 @@ public:
static bse::string_view level_to_string(LogLevel lvl) {
switch (lvl) {
case Logger::TRACE:
return "TRACE";
return "TRC";
case Logger::DEBUG:
return "DEBUG";
return "DBG";
case Logger::ERROR:
return "ERROR";
return "ERR";
case Logger::INFO:
return "INFO";
return "INF";
}
}
@ -99,22 +99,22 @@ public:
Logger& trace() {
Logger::lock();
return Logger::instance() << TRACE << name << "::";
return Logger::instance() << TRACE << name << " :: ";
}
Logger& debug() {
Logger::lock();
return Logger::instance() << DEBUG << name << "::";
return Logger::instance() << DEBUG << name << " :: ";
}
Logger& error() {
Logger::lock();
return Logger::instance() << ERROR << name << "::";
return Logger::instance() << ERROR << name << " :: ";
}
Logger& info() {
Logger::lock();
return Logger::instance() << INFO << name << "::";
return Logger::instance() << INFO << name << " :: ";
}
};

44
src/kernel/memory/Paging.cc
View File

@ -74,20 +74,20 @@ constexpr const unsigned int LST_ALLOCABLE_PAGE = 0x2FF000;
* Beschreibung: Alloziert eine 4 KB Seite. Allozieren heisst hier *
* lediglich Setzen eines eigenen RESERVED-Bits. *
*****************************************************************************/
unsigned int* pg_alloc_page() {
unsigned int* p_page;
uint32_t* pg_alloc_page() {
uint32_t* p_page;
p_page = reinterpret_cast<unsigned int*>(PAGE_TABLE);
p_page = reinterpret_cast<uint32_t*>(PAGE_TABLE);
// 1. Eintrag ist fuer Null-Pointer-Exception reserviert
// ausserdem liegt an die Page-Table an Adresse PAGE_TABLE
// ausserdem liegt die Page-Table an Adresse PAGE_TABLE
// somit ist est PAGE_TABLE + 4 KB frei (bis max. 3 MB, da beginnt der Heap)
for (int i = 1; i < 1024; i++) {
for (uint32_t i = 1; i < 1024; i++) {
p_page++;
// pruefe ob Page frei
if (((*p_page) & PAGE_RESERVED) == 0) {
*p_page = (*p_page | PAGE_RESERVED);
return reinterpret_cast<unsigned int*>(i << 12); // Address without flags (Offset 0)
return reinterpret_cast<uint32_t*>(i << 12); // Address without flags (Offset 0)
}
}
return nullptr;
@ -99,13 +99,13 @@ unsigned int* pg_alloc_page() {
* Beschreibung: Schreibschutz fuer die uebergebene Seite aktivieren. *
* Dies fuer das Debugging nuetzlich. *
*****************************************************************************/
void pg_write_protect_page(const unsigned int* p_page) {
void pg_write_protect_page(const uint32_t* p_page) {
/* hier muss Code eingefügt werden */
unsigned int* page = reinterpret_cast<unsigned int*>(PAGE_TABLE) + (reinterpret_cast<unsigned int>(p_page) >> 12); // Pagetable entry
uint32_t* page = reinterpret_cast<uint32_t*>(PAGE_TABLE) + (reinterpret_cast<uint32_t>(p_page) >> 12); // Pagetable entry
unsigned int mask = PAGE_WRITEABLE; // fill to 32bit
uint32_t mask = PAGE_WRITEABLE; // fill to 32bit
*page = *page & ~mask; // set writable to 0
invalidate_tlb_entry(p_page);
@ -116,13 +116,13 @@ void pg_write_protect_page(const unsigned int* p_page) {
*---------------------------------------------------------------------------*
* Beschreibung: Seite als ausgelagert markieren. Nur fuer Testzwecke. *
*****************************************************************************/
void pg_notpresent_page(const unsigned int* p_page) {
void pg_notpresent_page(const uint32_t* p_page) {
/* hier muss Code eingefügt werden */
unsigned int* page = reinterpret_cast<unsigned int*>(PAGE_TABLE) + (reinterpret_cast<unsigned int>(p_page) >> 12); // Pagetable entry
uint32_t* page = reinterpret_cast<uint32_t*>(PAGE_TABLE) + (reinterpret_cast<uint32_t>(p_page) >> 12); // Pagetable entry
unsigned int mask = PAGE_PRESENT;
uint32_t mask = PAGE_PRESENT;
*page = *page & ~mask; // set present to 0
invalidate_tlb_entry(p_page);
@ -134,8 +134,8 @@ void pg_notpresent_page(const unsigned int* p_page) {
* Beschreibung: Gibt eine 4 KB Seite frei. Es wird hierbei das RESERVED- *
* Bit geloescht. *
*****************************************************************************/
void pg_free_page(unsigned int* p_page) {
unsigned int idx = reinterpret_cast<unsigned int>(p_page) >> 12;
void pg_free_page(uint32_t* p_page) {
uint32_t idx = reinterpret_cast<uint32_t>(p_page) >> 12;
// ausserhalb Page ?
if (idx < 1 || idx > 1023) {
@ -143,7 +143,7 @@ void pg_free_page(unsigned int* p_page) {
}
// Eintrag einlesen und aendern (PAGE_WRITEABLE loeschen)
p_page = reinterpret_cast<unsigned int*>(PAGE_TABLE);
p_page = reinterpret_cast<uint32_t*>(PAGE_TABLE);
p_page += idx;
*p_page = ((idx << 12) | PAGE_WRITEABLE | PAGE_PRESENT);
@ -156,10 +156,10 @@ void pg_free_page(unsigned int* p_page) {
* startup.asm aktivieren. *
*****************************************************************************/
void pg_init() {
unsigned int i;
unsigned int* p_pdir; // Zeiger auf Page-Directory
unsigned int* p_page; // Zeiger auf einzige Page-Table fuer 4 KB Pages
unsigned int num_pages; // Anzahl 4 MB Pages die phys. Adressraum umfassen
uint32_t i;
uint32_t* p_pdir; // Zeiger auf Page-Directory
uint32_t* p_page; // Zeiger auf einzige Page-Table fuer 4 KB Pages
uint32_t num_pages; // Anzahl 4 MB Pages die phys. Adressraum umfassen
// wie viele 4 MB Seiten sollen als 'Present' angelegt werden,
// sodass genau der physikalische Adressraum abgedeckt ist?
@ -174,7 +174,7 @@ void pg_init() {
//
// Eintrag 0: Zeiger auf 4 KB Page-Table
p_pdir = reinterpret_cast<unsigned int*>(PAGE_DIRECTORY);
p_pdir = reinterpret_cast<uint32_t*>(PAGE_DIRECTORY);
*p_pdir = PAGE_TABLE | PAGE_WRITEABLE | PAGE_PRESENT;
// Eintraege 1-1023: Direktes Mapping (1:1) auf 4 MB Pages (ohne Page-Table)
@ -190,7 +190,7 @@ void pg_init() {
//
// 1. Page-Table
//
p_page = reinterpret_cast<unsigned int*>(PAGE_TABLE);
p_page = reinterpret_cast<uint32_t*>(PAGE_TABLE);
// ersten Eintrag loeschen -> not present, write protected -> Null-Pointer abfangen
*p_page = 0;
@ -209,5 +209,5 @@ void pg_init() {
}
// Paging aktivieren (in startup.asm)
paging_on(reinterpret_cast<unsigned int*>(PAGE_DIRECTORY));
paging_on(reinterpret_cast<uint32_t*>(PAGE_DIRECTORY));
}

14
src/kernel/memory/Paging.h
View File

@ -53,24 +53,26 @@
#define Paging_include__
// Externe Funktionen in startup.asm
#include <cstdint>
extern "C" {
void paging_on(unsigned int* p_pdir); // Paging einschalten
void invalidate_tlb_entry(const unsigned int* ptr); // Page in TLB invalid.
void paging_on(uint32_t* p_pdir); // Paging einschalten
void invalidate_tlb_entry(const uint32_t* ptr); // Page in TLB invalid.
}
// ativiert paging
extern void pg_init();
// alloziert eine 4 KB Page
extern unsigned int* pg_alloc_page();
extern uint32_t* pg_alloc_page();
// Schreibschutz auf Seite setzen -> fuer debugging nuetzlich
extern void pg_write_protect_page(const unsigned int* p_page);
extern void pg_write_protect_page(const uint32_t* p_page);
// Present Bit loeschen
extern void pg_notpresent_page(const unsigned int* p_page);
extern void pg_notpresent_page(const uint32_t* p_page);
// gibt eine 4 KB Page frei
extern void pg_free_page(unsigned int* p_page);
extern void pg_free_page(uint32_t* p_page);
#endif

6
src/kernel/process/Thread.cc
View File

@ -26,11 +26,11 @@
// extern "C" deklariert werden, da sie nicht dem Name-Mangeling von C++
// entsprechen.
extern "C" {
void Thread_start(unsigned int esp);
void Thread_start(uint32_t esp);
// NOTE: Only when backing up the previous thread the esp gets updated,
// so only esp_pre is a pointer
void Thread_switch(unsigned int* esp_prev, unsigned int esp_next);
void Thread_switch(uint32_t* esp_prev, uint32_t esp_next);
}
unsigned int ThreadCnt = 1; // Skip tid 0 as the scheduler indicates no preemption with 0
@ -41,7 +41,7 @@ unsigned int ThreadCnt = 1; // Skip tid 0 as the scheduler indicates no preempt
* Beschreibung: Bereitet den Kontext der Koroutine fuer den ersten *
* Aufruf vor. *
*****************************************************************************/
void Thread_init(unsigned int* esp, unsigned int* stack, void (*kickoff)(Thread*), void* object) {
void Thread_init(uint32_t* esp, uint32_t* stack, void (*kickoff)(Thread*), void* object) {
// NOTE: c++17 doesn't allow register
// register unsigned int** sp = (unsigned int**)stack;

4
src/kernel/process/Thread.h
View File

@ -32,8 +32,8 @@
class Thread {
private:
unsigned int* stack;
unsigned int esp;
uint32_t* stack;
uint32_t esp;
protected:
Thread(char* name);