mirror of
https://github.com/wichtounet/thor-os.git
synced 2025-09-18 01:01:57 -04:00
Improve compiling
Use cross compiler instead of normal G++ Improve compiler options
This commit is contained in:
Baptiste Wicht
parent
cfb38cc330
commit
a3e6d6aab6
@ -1,5 +1,9 @@
|
||||
KERNEL_FLAGS=-masm=intel -Iinclude/ -O1 -std=c++11 -Wall -Wextra -pedantic -Wold-style-cast -Wshadow -fno-exceptions -fno-rtti -ffreestanding -fno-builtin
|
||||
KERNEL_LINK_FLAGS=-std=c++11 -T linker.ld -ffreestanding -O1 -nostdlib
|
||||
CC=x86_64-elf-g++
|
||||
|
||||
WARNING_FLAGS=-Wall -Wextra -pedantic -Wold-style-cast -Wshadow
|
||||
CPP_FLAGS=-masm=intel -Iinclude/ -nostdlib -O1 -std=c++11 -fno-exceptions -fno-rtti -ffreestanding -lgcc -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-3dnow $(WARNING_FLAGS)
|
||||
KERNEL_FLAGS=$(CPP_FLAGS)
|
||||
KERNEL_LINK_FLAGS=-T linker.ld $(CPP_FLAGS)
|
||||
|
||||
KERNEL_O_FILES=kernel.o keyboard.o console.o kernel_utils.o timer.o shell.o utils.o memory.o ata.o thor.o
|
||||
|
||||
@ -8,39 +12,40 @@ CRTEND_OBJ:=$(shell $(CC) $(CFLAGS) -print-file-name=crtend.o)
|
||||
|
||||
LINK_O_FILES=$(KERNEL_O_FILES)
|
||||
|
||||
|
||||
kernel.bin: $(LINK_O_FILES)
|
||||
g++ $(KERNEL_LINK_FLAGS) -o kernel.bin.o $(LINK_O_FILES)
|
||||
$(CC) $(KERNEL_LINK_FLAGS) -o kernel.bin.o $(LINK_O_FILES)
|
||||
objcopy -R .note -R .comment -S -O binary kernel.bin.o kernel.bin
|
||||
|
||||
kernel.o: src/kernel.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/kernel.cpp -o kernel.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/kernel.cpp -o kernel.o
|
||||
|
||||
keyboard.o: src/keyboard.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/keyboard.cpp -o keyboard.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/keyboard.cpp -o keyboard.o
|
||||
|
||||
console.o: src/console.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/console.cpp -o console.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/console.cpp -o console.o
|
||||
|
||||
kernel_utils.o: src/kernel_utils.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/kernel_utils.cpp -o kernel_utils.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/kernel_utils.cpp -o kernel_utils.o
|
||||
|
||||
timer.o: src/timer.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/timer.cpp -o timer.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/timer.cpp -o timer.o
|
||||
|
||||
shell.o: src/shell.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/shell.cpp -o shell.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/shell.cpp -o shell.o
|
||||
|
||||
utils.o: src/utils.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/utils.cpp -o utils.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/utils.cpp -o utils.o
|
||||
|
||||
memory.o: src/memory.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/memory.cpp -o memory.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/memory.cpp -o memory.o
|
||||
|
||||
ata.o: src/ata.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/ata.cpp -o ata.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/ata.cpp -o ata.o
|
||||
|
||||
thor.o: src/thor.cpp
|
||||
g++ $(KERNEL_FLAGS) -c src/thor.cpp -o thor.o
|
||||
$(CC) $(KERNEL_FLAGS) -c src/thor.cpp -o thor.o
|
||||
|
||||
clean:
|
||||
rm -f *.o
|
||||
|
||||
@ -14,6 +14,6 @@ void detect_disks();
|
||||
uint8_t number_of_disks();
|
||||
drive_descriptor& drive(uint8_t disk);
|
||||
|
||||
bool ata_read_sectors(drive_descriptor& drive, std::size_t start, uint8_t count, void* destination);
|
||||
bool ata_read_sectors(drive_descriptor& drive, uint64_t start, uint8_t count, void* destination);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#ifndef CONSOLE_H
|
||||
#define CONSOLE_H
|
||||
|
||||
#include <cstddef>
|
||||
#include "types.hpp"
|
||||
|
||||
void set_column(long column);
|
||||
long get_column();
|
||||
@ -12,7 +12,7 @@ long get_line();
|
||||
void wipeout();
|
||||
void k_print(char key);
|
||||
void k_print(const char* string);
|
||||
void k_print(std::size_t number);
|
||||
void k_print(uint64_t number);
|
||||
void k_print_line();
|
||||
void k_print_line(const char* string);
|
||||
void k_printf(const char* fmt, ...);
|
||||
|
||||
@ -4,29 +4,29 @@
|
||||
#include "types.hpp"
|
||||
|
||||
struct mmapentry {
|
||||
std::size_t base;
|
||||
std::size_t size;
|
||||
std::size_t type;
|
||||
uint64_t base;
|
||||
uint64_t size;
|
||||
uint64_t type;
|
||||
};
|
||||
|
||||
void load_memory_map();
|
||||
bool mmap_failed();
|
||||
std::size_t mmap_entry_count();
|
||||
const mmapentry& mmap_entry(std::size_t i);
|
||||
const char* str_e820_type(std::size_t type);
|
||||
uint64_t mmap_entry_count();
|
||||
const mmapentry& mmap_entry(uint64_t i);
|
||||
const char* str_e820_type(uint64_t type);
|
||||
|
||||
void init_memory_manager();
|
||||
|
||||
std::size_t* k_malloc(std::size_t bytes);
|
||||
void k_free(std::size_t* block);
|
||||
uint64_t* k_malloc(uint64_t bytes);
|
||||
void k_free(uint64_t* block);
|
||||
|
||||
template<typename T>
|
||||
T* k_malloc(){
|
||||
return reinterpret_cast<T*>(k_malloc(sizeof(T)));
|
||||
}
|
||||
|
||||
std::size_t available_memory();
|
||||
std::size_t free_memory();
|
||||
std::size_t used_memory();
|
||||
uint64_t available_memory();
|
||||
uint64_t free_memory();
|
||||
uint64_t used_memory();
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,11 +1,9 @@
|
||||
#ifndef THOR_H
|
||||
#define THOR_H
|
||||
|
||||
#include <new>
|
||||
|
||||
#include "memory.hpp"
|
||||
|
||||
void* operator new (size_t size);
|
||||
void* operator new (uint64_t size);
|
||||
void operator delete (void *p);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
#ifndef TIMER_H
|
||||
#define TIMER_H
|
||||
|
||||
#include <cstddef>
|
||||
#include "types.hpp"
|
||||
|
||||
void install_timer();
|
||||
void sleep_ms(std::size_t delay);
|
||||
void sleep_ms(uint64_t delay);
|
||||
|
||||
std::size_t timer_ticks();
|
||||
std::size_t timer_seconds();
|
||||
uint64_t timer_ticks();
|
||||
uint64_t timer_seconds();
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,17 +1,18 @@
|
||||
#ifndef TYPES_H
|
||||
#define TYPES_H
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
typedef unsigned int uint8_t __attribute__((__mode__(__QI__)));
|
||||
typedef unsigned int uint16_t __attribute__ ((__mode__ (__HI__)));
|
||||
typedef unsigned int uint32_t __attribute__ ((__mode__ (__SI__)));
|
||||
typedef unsigned int uint32_t __attribute__ ((__mode__ (__SI__)));
|
||||
typedef unsigned int uint64_t __attribute__ ((__mode__ (__DI__)));
|
||||
|
||||
typedef std::size_t uintptr_t;
|
||||
typedef uint64_t uintptr_t;
|
||||
|
||||
static_assert(sizeof(uint8_t) == 1, "uint32_t must be 1 byte long");
|
||||
static_assert(sizeof(uint16_t) == 2, "uint32_t must be 2 bytes long");
|
||||
static_assert(sizeof(uint32_t) == 4, "uint32_t must be 4 bytes long");
|
||||
static_assert(sizeof(uintptr_t) == sizeof(std::size_t*), "uintptr_t must have the same size as a pointer");
|
||||
static_assert(sizeof(uint64_t) == 8, "uint64_t must be 8 bytes long");
|
||||
static_assert(sizeof(uintptr_t) == sizeof(uint64_t*), "uintptr_t must have the same size as a pointer");
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
#ifndef UTILS_H
|
||||
#define UTILS_H
|
||||
|
||||
#include <cstddef>
|
||||
#include "types.hpp"
|
||||
|
||||
std::size_t parse(const char* str);
|
||||
uint64_t parse(const char* str);
|
||||
|
||||
bool str_equals(const char* a, const char* b);
|
||||
bool str_contains(const char* a, char c);
|
||||
|
||||
@ -147,7 +147,7 @@ drive_descriptor& drive(uint8_t disk){
|
||||
return drives[disk];
|
||||
}
|
||||
|
||||
bool ata_read_sectors(drive_descriptor& drive, std::size_t start, uint8_t count, void* destination){
|
||||
bool ata_read_sectors(drive_descriptor& drive, uint64_t start, uint8_t count, void* destination){
|
||||
//Select the device
|
||||
if(!select_device(drive)){
|
||||
return false;
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
#include <cstddef>
|
||||
#include <cstdarg>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "console.hpp"
|
||||
#include "types.hpp"
|
||||
@ -68,7 +67,7 @@ void k_print_line(const char* string){
|
||||
++current_line;
|
||||
}
|
||||
|
||||
std::size_t digits(std::size_t number){
|
||||
uint64_t digits(uint64_t number){
|
||||
if(number < 10){
|
||||
return 1;
|
||||
}
|
||||
@ -83,7 +82,7 @@ std::size_t digits(std::size_t number){
|
||||
return i;
|
||||
}
|
||||
|
||||
void k_print(std::size_t number){
|
||||
void k_print(uint64_t number){
|
||||
if(number == 0){
|
||||
k_print('0');
|
||||
return;
|
||||
@ -130,7 +129,7 @@ void wipeout(){
|
||||
current_column = 0;
|
||||
|
||||
for(int line = 0; line < 25; ++line){
|
||||
for(std::size_t column = 0; column < 80; ++column){
|
||||
for(uint64_t column = 0; column < 80; ++column){
|
||||
k_print(' ');
|
||||
}
|
||||
}
|
||||
@ -151,13 +150,13 @@ void k_printf(const char* fmt, ...){
|
||||
} else {
|
||||
ch = *(fmt++);
|
||||
|
||||
std::size_t min_width = 0;
|
||||
uint64_t min_width = 0;
|
||||
while(ch >= '0' && ch <= '9'){
|
||||
min_width = 10 * min_width + (ch - '0');
|
||||
ch = *(fmt++);
|
||||
}
|
||||
|
||||
std::size_t min_digits = 0;
|
||||
uint64_t min_digits = 0;
|
||||
if(ch == '.'){
|
||||
ch = *(fmt++);
|
||||
|
||||
@ -171,7 +170,7 @@ void k_printf(const char* fmt, ...){
|
||||
|
||||
//Decimal
|
||||
if(ch == 'd'){
|
||||
auto arg = va_arg(va, std::size_t);
|
||||
auto arg = va_arg(va, uint64_t);
|
||||
|
||||
if(min_digits > 0){
|
||||
auto d = digits(arg);
|
||||
@ -194,7 +193,7 @@ void k_printf(const char* fmt, ...){
|
||||
|
||||
uint8_t buffer[20];
|
||||
|
||||
auto arg = va_arg(va, std::size_t);
|
||||
auto arg = va_arg(va, uint64_t);
|
||||
int i = 0;
|
||||
|
||||
while(arg / 16 != 0){
|
||||
@ -245,7 +244,7 @@ void k_printf(const char* fmt, ...){
|
||||
}
|
||||
//Memory
|
||||
else if(ch == 'm'){
|
||||
auto memory= va_arg(va, std::size_t);
|
||||
auto memory= va_arg(va, uint64_t);
|
||||
|
||||
if(memory > 1024 * 1024 * 1024){
|
||||
k_print(memory / (1024 * 1024 * 1024));
|
||||
|
||||
@ -12,63 +12,63 @@ struct bios_mmap_entry {
|
||||
uint32_t damn_padding;
|
||||
} __attribute__((packed));
|
||||
|
||||
std::size_t e820_failed = 0;
|
||||
std::size_t entry_count = 0;
|
||||
uint64_t e820_failed = 0;
|
||||
uint64_t entry_count = 0;
|
||||
bios_mmap_entry* e820_address = 0;
|
||||
|
||||
mmapentry e820_mmap[32];
|
||||
|
||||
void mmap_query(std::size_t cmd, std::size_t* result){
|
||||
std::size_t tmp;
|
||||
void mmap_query(uint64_t cmd, uint64_t* result){
|
||||
uint64_t tmp;
|
||||
__asm__ __volatile__ ("mov r8, %0; int 62; mov %1, rax" : : "dN" (cmd), "a" (tmp));
|
||||
*result = tmp;
|
||||
}
|
||||
|
||||
std::size_t _available_memory;
|
||||
std::size_t _used_memory;
|
||||
uint64_t _available_memory;
|
||||
uint64_t _used_memory;
|
||||
|
||||
struct malloc_header_chunk {
|
||||
std::size_t size;
|
||||
uint64_t size;
|
||||
malloc_header_chunk* next;
|
||||
malloc_header_chunk* prev;
|
||||
};
|
||||
|
||||
struct malloc_footer_chunk {
|
||||
std::size_t size;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
struct fake_head {
|
||||
std::size_t size;
|
||||
uint64_t size;
|
||||
malloc_header_chunk* next;
|
||||
malloc_header_chunk* prev;
|
||||
std::size_t size_2;
|
||||
uint64_t size_2;
|
||||
};
|
||||
|
||||
const std::size_t META_SIZE = sizeof(malloc_header_chunk) + sizeof(malloc_footer_chunk);
|
||||
const std::size_t MIN_SPLIT = 32;
|
||||
const std::size_t BLOCK_SIZE = 4096;
|
||||
const std::size_t MIN_BLOCKS = 4;
|
||||
const uint64_t META_SIZE = sizeof(malloc_header_chunk) + sizeof(malloc_footer_chunk);
|
||||
const uint64_t MIN_SPLIT = 32;
|
||||
const uint64_t BLOCK_SIZE = 4096;
|
||||
const uint64_t MIN_BLOCKS = 4;
|
||||
|
||||
fake_head head;
|
||||
malloc_header_chunk* malloc_head = 0;
|
||||
|
||||
typedef std::size_t* page_entry;
|
||||
typedef uint64_t* page_entry;
|
||||
typedef page_entry* pt_t;
|
||||
typedef pt_t* pdt_t;
|
||||
typedef pdt_t* pdpt_t;
|
||||
typedef pdpt_t* pml4t_t;
|
||||
|
||||
mmapentry* current_mmap_entry = nullptr;
|
||||
std::size_t current_mmap_entry_position;
|
||||
uint64_t current_mmap_entry_position;
|
||||
|
||||
std::size_t pml4t_index = 0;
|
||||
std::size_t pdpt_index = 0;
|
||||
std::size_t pdt_index = 0;
|
||||
std::size_t pt_index = 256;
|
||||
uint64_t pml4t_index = 0;
|
||||
uint64_t pdpt_index = 0;
|
||||
uint64_t pdt_index = 0;
|
||||
uint64_t pt_index = 256;
|
||||
|
||||
std::size_t* allocate_block(std::size_t blocks){
|
||||
uint64_t* allocate_block(uint64_t blocks){
|
||||
if(!current_mmap_entry){
|
||||
for(std::size_t i = 0; i < entry_count; ++i){
|
||||
for(uint64_t i = 0; i < entry_count; ++i){
|
||||
auto& entry = e820_mmap[i];
|
||||
|
||||
if(entry.type == 1 && entry.base >= 0x100000 && entry.size >= 16384){
|
||||
@ -92,11 +92,11 @@ std::size_t* allocate_block(std::size_t blocks){
|
||||
//TODO Go to a new page table
|
||||
}
|
||||
|
||||
for(std::size_t i = 0; i < blocks; ++i){
|
||||
for(uint64_t i = 0; i < blocks; ++i){
|
||||
pt[pt_index + i] = reinterpret_cast<page_entry>((current_mmap_entry_position + i * BLOCK_SIZE) | 0x3);
|
||||
}
|
||||
|
||||
auto block = reinterpret_cast<std::size_t*>(current_mmap_entry_position);
|
||||
auto block = reinterpret_cast<uint64_t*>(current_mmap_entry_position);
|
||||
|
||||
pt_index += blocks;
|
||||
current_mmap_entry_position += blocks * BLOCK_SIZE;
|
||||
@ -130,14 +130,14 @@ void init_memory_manager(){
|
||||
malloc_head->prev = header;
|
||||
}
|
||||
|
||||
std::size_t* k_malloc(std::size_t bytes){
|
||||
uint64_t* k_malloc(uint64_t bytes){
|
||||
auto current = malloc_head->next;
|
||||
|
||||
while(true){
|
||||
if(current == malloc_head){
|
||||
//There are no blocks big enough to hold this request
|
||||
|
||||
std::size_t* block = allocate_block(MIN_BLOCKS);
|
||||
uint64_t* block = allocate_block(MIN_BLOCKS);
|
||||
auto header = reinterpret_cast<malloc_header_chunk*>(block);
|
||||
header->size = MIN_BLOCKS * BLOCK_SIZE - META_SIZE;
|
||||
|
||||
@ -196,11 +196,11 @@ std::size_t* k_malloc(std::size_t bytes){
|
||||
current->prev = nullptr;
|
||||
current->next = nullptr;
|
||||
|
||||
return reinterpret_cast<std::size_t*>(
|
||||
return reinterpret_cast<uint64_t*>(
|
||||
reinterpret_cast<uintptr_t>(current) + sizeof(malloc_header_chunk));
|
||||
}
|
||||
|
||||
void k_free(std::size_t* block){
|
||||
void k_free(uint64_t* block){
|
||||
auto free_header = reinterpret_cast<malloc_header_chunk*>(
|
||||
reinterpret_cast<uintptr_t>(block) - sizeof(malloc_header_chunk));
|
||||
|
||||
@ -218,15 +218,15 @@ void k_free(std::size_t* block){
|
||||
void load_memory_map(){
|
||||
mmap_query(0, &e820_failed);
|
||||
mmap_query(1, &entry_count);
|
||||
mmap_query(2, reinterpret_cast<std::size_t*>(&e820_address));
|
||||
mmap_query(2, reinterpret_cast<uint64_t*>(&e820_address));
|
||||
|
||||
if(!e820_failed && e820_address){
|
||||
for(std::size_t i = 0; i < entry_count; ++i){
|
||||
for(uint64_t i = 0; i < entry_count; ++i){
|
||||
auto& bios_entry = e820_address[i];
|
||||
auto& os_entry = e820_mmap[i];
|
||||
|
||||
std::size_t base = bios_entry.base_low + (static_cast<std::size_t>(bios_entry.base_high) << 32);
|
||||
std::size_t length = bios_entry.length_low + (static_cast<std::size_t>(bios_entry.length_high) << 32);
|
||||
uint64_t base = bios_entry.base_low + (static_cast<uint64_t>(bios_entry.base_high) << 32);
|
||||
uint64_t length = bios_entry.length_low + (static_cast<uint64_t>(bios_entry.length_high) << 32);
|
||||
|
||||
os_entry.base = base;
|
||||
os_entry.size = length;
|
||||
@ -243,7 +243,7 @@ void load_memory_map(){
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t mmap_entry_count(){
|
||||
uint64_t mmap_entry_count(){
|
||||
return entry_count;
|
||||
}
|
||||
|
||||
@ -251,11 +251,11 @@ bool mmap_failed(){
|
||||
return e820_failed;
|
||||
}
|
||||
|
||||
const mmapentry& mmap_entry(std::size_t i){
|
||||
const mmapentry& mmap_entry(uint64_t i){
|
||||
return e820_mmap[i];
|
||||
}
|
||||
|
||||
const char* str_e820_type(std::size_t type){
|
||||
const char* str_e820_type(uint64_t type){
|
||||
switch(type){
|
||||
case 1:
|
||||
return "Free";
|
||||
@ -275,14 +275,14 @@ const char* str_e820_type(std::size_t type){
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t available_memory(){
|
||||
uint64_t available_memory(){
|
||||
return _available_memory;
|
||||
}
|
||||
|
||||
std::size_t used_memory(){
|
||||
uint64_t used_memory(){
|
||||
return _used_memory;
|
||||
}
|
||||
|
||||
std::size_t free_memory(){
|
||||
uint64_t free_memory(){
|
||||
return _available_memory - _used_memory;
|
||||
}
|
||||
|
||||
@ -1,6 +1,3 @@
|
||||
#include <cstddef>
|
||||
#include <array>
|
||||
|
||||
#include "types.hpp"
|
||||
#include "keyboard.hpp"
|
||||
#include "kernel_utils.hpp"
|
||||
@ -31,7 +28,7 @@ struct command_definition {
|
||||
void (*function)(const char*);
|
||||
};
|
||||
|
||||
std::array<command_definition, 10> commands = {{
|
||||
command_definition commands[10] = {
|
||||
{"reboot", reboot_command},
|
||||
{"help", help_command},
|
||||
{"uptime", uptime_command},
|
||||
@ -42,9 +39,9 @@ std::array<command_definition, 10> commands = {{
|
||||
{"mmap", mmap_command},
|
||||
{"memory", memory_command},
|
||||
{"disks", disks_command},
|
||||
}};
|
||||
};
|
||||
|
||||
std::size_t current_input_length = 0;
|
||||
uint64_t current_input_length = 0;
|
||||
char current_input[50];
|
||||
|
||||
void exec_command();
|
||||
@ -148,20 +145,20 @@ uint8_t get_RTC_register(int reg) {
|
||||
}
|
||||
|
||||
void date_command(const char*){
|
||||
std::size_t second;
|
||||
std::size_t minute;
|
||||
std::size_t hour;
|
||||
std::size_t day;
|
||||
std::size_t month;
|
||||
std::size_t year;
|
||||
uint64_t second;
|
||||
uint64_t minute;
|
||||
uint64_t hour;
|
||||
uint64_t day;
|
||||
uint64_t month;
|
||||
uint64_t year;
|
||||
|
||||
std::size_t last_second;
|
||||
std::size_t last_minute;
|
||||
std::size_t last_hour;
|
||||
std::size_t last_day;
|
||||
std::size_t last_month;
|
||||
std::size_t last_year;
|
||||
std::size_t registerB;
|
||||
uint64_t last_second;
|
||||
uint64_t last_minute;
|
||||
uint64_t last_hour;
|
||||
uint64_t last_day;
|
||||
uint64_t last_month;
|
||||
uint64_t last_year;
|
||||
uint64_t registerB;
|
||||
|
||||
//TODO When ACPI gets supported, get the address
|
||||
//of the century register and use it to make
|
||||
@ -242,7 +239,7 @@ void mmap_command(const char*){
|
||||
k_printf("There are %d mmap entry\n", mmap_entry_count());
|
||||
|
||||
k_print_line("Base End Size Type");
|
||||
for(std::size_t i = 0; i < mmap_entry_count(); ++i){
|
||||
for(uint64_t i = 0; i < mmap_entry_count(); ++i){
|
||||
auto& entry = mmap_entry(i);
|
||||
|
||||
k_printf("%.10h %.10h %.10h %8m %s\n",
|
||||
@ -267,18 +264,18 @@ void memory_command(const char*){
|
||||
} else {
|
||||
for(int i = 0; i < 80; i += 8){
|
||||
k_printf("%.4h %.4h %.4h %.4h %.4h %.4h %.4h %.4h\n",
|
||||
(std::size_t) buffer[i+0], (std::size_t) buffer[i+1], (std::size_t) buffer[i+2], (std::size_t) buffer[i+3],
|
||||
(std::size_t) buffer[i+4], (std::size_t) buffer[i+5], (std::size_t) buffer[i+6], (std::size_t) buffer[i+7]);
|
||||
(uint64_t) buffer[i+0], (uint64_t) buffer[i+1], (uint64_t) buffer[i+2], (uint64_t) buffer[i+3],
|
||||
(uint64_t) buffer[i+4], (uint64_t) buffer[i+5], (uint64_t) buffer[i+6], (uint64_t) buffer[i+7]);
|
||||
}
|
||||
|
||||
k_free(reinterpret_cast<std::size_t*>(buffer));
|
||||
k_free(reinterpret_cast<uint64_t*>(buffer));
|
||||
}
|
||||
}
|
||||
|
||||
void disks_command(const char*){
|
||||
k_print_line("Controller Drive Present");
|
||||
|
||||
for(std::size_t i = 0; i < number_of_disks(); ++i){
|
||||
for(uint64_t i = 0; i < number_of_disks(); ++i){
|
||||
auto& descriptor = drive(i);
|
||||
|
||||
k_printf("%12h %8h %s\n", descriptor.controller, descriptor.drive, descriptor.present ? "Yes" : "No");
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
#include "thor.hpp"
|
||||
#include "memory.hpp"
|
||||
|
||||
void* operator new (size_t size){
|
||||
void* operator new (uint64_t size){
|
||||
return k_malloc(size);
|
||||
}
|
||||
|
||||
void operator delete (void* p){
|
||||
k_free(reinterpret_cast<std::size_t*>(p));
|
||||
k_free(reinterpret_cast<uint64_t*>(p));
|
||||
}
|
||||
|
||||
@ -4,10 +4,10 @@
|
||||
|
||||
namespace {
|
||||
|
||||
std::size_t _timer_ticks = 0;
|
||||
std::size_t _timer_seconds = 0;
|
||||
uint64_t _timer_ticks = 0;
|
||||
uint64_t _timer_seconds = 0;
|
||||
|
||||
volatile std::size_t _timer_countdown = 0;
|
||||
volatile uint64_t _timer_countdown = 0;
|
||||
|
||||
void timer_handler(){
|
||||
++_timer_ticks;
|
||||
@ -24,7 +24,7 @@ void timer_handler(){
|
||||
}
|
||||
|
||||
void install_timer(){
|
||||
std::size_t divisor = 1193180 / 1000;
|
||||
uint64_t divisor = 1193180 / 1000;
|
||||
|
||||
out_byte(0x43, 0x36);
|
||||
out_byte(0x40, static_cast<uint8_t>(divisor));
|
||||
@ -33,7 +33,7 @@ void install_timer(){
|
||||
register_irq_handler<0>(timer_handler);
|
||||
}
|
||||
|
||||
void sleep_ms(std::size_t delay){
|
||||
void sleep_ms(uint64_t delay){
|
||||
_timer_countdown = delay;
|
||||
|
||||
while(true){
|
||||
@ -54,10 +54,10 @@ void sleep_ms(std::size_t delay){
|
||||
__asm__ __volatile__ ("sti");
|
||||
}
|
||||
|
||||
std::size_t timer_ticks(){
|
||||
uint64_t timer_ticks(){
|
||||
return _timer_ticks;
|
||||
}
|
||||
|
||||
std::size_t timer_seconds(){
|
||||
uint64_t timer_seconds(){
|
||||
return _timer_seconds;
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@ bool str_equals(const char* a, const char* b){
|
||||
return *a == *b;
|
||||
}
|
||||
|
||||
std::size_t parse(const char* str){
|
||||
uint64_t parse(const char* str){
|
||||
int i = 0;
|
||||
|
||||
const char* it = str;
|
||||
@ -17,8 +17,8 @@ std::size_t parse(const char* str){
|
||||
++i;
|
||||
}
|
||||
|
||||
std::size_t factor = 1;
|
||||
std::size_t acc = 0;
|
||||
uint64_t factor = 1;
|
||||
uint64_t acc = 0;
|
||||
|
||||
for(; i >= 0; --i){
|
||||
acc += (str[i] - '0') * factor;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user