gwdev/Chroma
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implement proper PS2 Keyboard driver

Browse Source
This commit is contained in:
Curle 2022-07-10 01:01:49 +01:00
parent f066462f29
commit e09f1790a0
48 changed files with 560 additions and 675 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -36,7 +36,7 @@ SET(src_files
${CMAKE_SOURCE_DIR}/src/system/extern/extern_defs.cpp ${CMAKE_SOURCE_DIR}/src/system/extern/extern_defs.cpp
${CMAKE_SOURCE_DIR}/src/drivers/elf.cpp ${CMAKE_SOURCE_DIR}/src/drivers/elf.cpp
${CMAKE_SOURCE_DIR}/src/drivers/devices/devices.cpp ${CMAKE_SOURCE_DIR}/src/drivers/devices/devices.cpp
${CMAKE_SOURCE_DIR}/src/drivers/devices/input/keyboard.cpp ${CMAKE_SOURCE_DIR}/src/drivers/devices/io/ps2_keyboard.cpp
${CMAKE_SOURCE_DIR}/src/drivers/devices/io/apic.cpp ${CMAKE_SOURCE_DIR}/src/drivers/devices/io/apic.cpp
${CMAKE_SOURCE_DIR}/src/drivers/devices/storage/ata.cpp ${CMAKE_SOURCE_DIR}/src/drivers/devices/storage/ata.cpp
) )
@ -46,7 +46,7 @@ SET(lib_files
${CMAKE_SOURCE_DIR}/src/lainlib/mutex/ticketlock.cpp ${CMAKE_SOURCE_DIR}/src/lainlib/mutex/ticketlock.cpp
${CMAKE_SOURCE_DIR}/src/lainlib/compression/lzgmini.c ${CMAKE_SOURCE_DIR}/src/lainlib/compression/lzgmini.c
${CMAKE_SOURCE_DIR}/src/lainlib/string/str.cpp ${CMAKE_SOURCE_DIR}/src/lainlib/string/str.cpp
${CMAKE_SOURCE_DIR}/src/editor/EditorMain.cpp ${CMAKE_SOURCE_DIR}/src/lainlib/vector/vector.cpp
) )
include_directories("inc" "D:/mingw/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++" "D:/mingw/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32") include_directories("inc" "D:/mingw/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++" "D:/mingw/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32")
@ -79,5 +79,5 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
add_executable(kernel) add_executable(kernel)
target_sources(kernel PUBLIC ${src_preamble} PUBLIC ${src_files} PUBLIC ${src_no_sse} PUBLIC ${lib_files} PUBLIC ${src_epilogue}) target_sources(kernel PUBLIC ${src_preamble} PUBLIC ${src_files} PUBLIC ${src_no_sse} PUBLIC ${lib_files} PUBLIC ${src_epilogue})
target_compile_options(kernel PRIVATE -ffreestanding -O0 -Wall -Wextra -Wall -Werror -fPIC -fno-exceptions -fno-omit-frame-pointer -mno-red-zone -fno-stack-protector $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti> -ggdb3) target_compile_options(kernel PRIVATE -ffreestanding -O0 -Wall -Wextra -Wall -Werror -fPIC -fno-exceptions -fno-omit-frame-pointer -mno-red-zone -fno-stack-protector -fno-strict-aliasing $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti> -ggdb3)
target_link_options(kernel PRIVATE -T ${CMAKE_SOURCE_DIR}/linker.ld -ffreestanding -O2 -nostdlib -nostartfiles -lgcc) target_link_options(kernel PRIVATE -T ${CMAKE_SOURCE_DIR}/linker.ld -ffreestanding -O2 -nostdlib -nostartfiles -lgcc)

46
inc/driver/generic/device.h
View File

@ -2,6 +2,7 @@
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
#include "lainlib/vector/vector.h"
/************************ /************************
*** Team Kitty, 2021 *** *** Team Kitty, 2021 ***
@ -50,7 +51,50 @@ namespace Device {
}; };
}; };
// TODO: GenericKeyboard class GenericKeyboard : public GenericDevice {
public:
struct KeyboardData {
char Char;
char Scancode;
bool Pressed;
};
// This is an input device.
DeviceType GetType() const final {
return DeviceType::INTERFACE;
};
// Provided for utility checks.
static DeviceType GetRootType() {
return DeviceType::INTERFACE;
};
virtual bool isPressed(uint8_t) const = 0;
virtual uint8_t getLastPress() const = 0;
size_t readBuffer(void* dest, size_t index, size_t len) {
size_t lengthRead = len;
if (index > buffer.size()) {
return 0;
} else if (index + len > buffer.size()) {
lengthRead = sizeof(KeyboardData) - index; // TODO: wat?
}
memcpy((uint8_t*) dest, ((uint8_t*)buffer.data) + index, lengthRead);
return lengthRead;
}
size_t getBufferSize() {
return buffer.size();
}
protected:
lainlib::vector<KeyboardData> buffer;
};
// TODO: GenericDebugger // TODO: GenericDebugger
// TODO: GenericNetwork // TODO: GenericNetwork

39
inc/driver/io/ps2_keyboard.h Normal file
View File

@ -0,0 +1,39 @@
#pragma once
#include <driver/generic/device.h>
/************************
*** Team Kitty, 2022 ***
*** Chroma ***
***********************/
extern char keys[128];
namespace Device {
class PS2Keyboard : public GenericKeyboard {
bool keyStates[128];
uint8_t lastPress = 0;
uint8_t* callback;
public:
PS2Keyboard();
// The instance of this singleton class.
static PS2Keyboard* driver;
const char* GetName() const {
return "PS2 Keyboard";
};
void Init();
void InterruptHandler();
void setState(bool state, uint8_t key);
bool isPressed(uint8_t key) const;
uint8_t getLastPress() const {
return keys[lastPress];
}
void SetCallback(uint32_t*);
};
}

28
inc/driver/keyboard.h
View File

@ -1,28 +0,0 @@
#include <kernel/chroma.h>
/************************
*** Team Kitty, 2020 ***
*** Chroma ***
***********************/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
char Char;
char Scancode;
bool Pressed;
} KeyboardData;
typedef void (*KeyboardCallback)(KeyboardData Frame);
extern KeyboardCallback KeyboardCallbacks[16];
int SetupKBCallback(void (*Handler)(KeyboardData Frame));
void UninstallKBCallback(int Index);
#ifdef __cplusplus
}
#endif

10
inc/kernel/boot/boot.h
View File

@ -6,10 +6,6 @@
#include <stdint.h> #include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* /*
;* Memory map ;* Memory map
;* 0h - 600h reserved for the system ;* 0h - 600h reserved for the system
@ -156,9 +152,3 @@ typedef struct {
* MMapEnt *mmap_ent = &bootboot.mmap; mmap_ent++; * MMapEnt *mmap_ent = &bootboot.mmap; mmap_ent++;
* until you reach bootboot->size */ * until you reach bootboot->size */
} __attribute__((packed)) bootinfo; } __attribute__((packed)) bootinfo;
#ifdef __cplusplus
}
#endif

23
inc/kernel/chroma.h
View File

@ -9,10 +9,6 @@
* It also provides the symbols for the framebuffer and configuration file, which are both equually important. * It also provides the symbols for the framebuffer and configuration file, which are both equually important.
*/ */
#ifdef __cplusplus
extern "C" {
#endif
#define UNUSED(x) (void)x #define UNUSED(x) (void)x
#include <stdint.h> #include <stdint.h>
@ -73,7 +69,6 @@ void WriteChar(const char character);
void WriteStringWithFont(const char* string); void WriteStringWithFont(const char* string);
void InitInterrupts();
void InitSerial(); void InitSerial();
void InitPrint(); void InitPrint();
@ -82,12 +77,14 @@ void SetupIDT();
int ParseKernelHeader(size_t InitrdPtr); int ParseKernelHeader(size_t InitrdPtr);
int Main();
void Exit(int code);
void SomethingWentWrong(const char* Message);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" extern "C" {
#endif #endif
void InitInterrupts();
int Main();
void Exit(int code);
void SomethingWentWrong(const char* Message);
#ifdef __cplusplus
}
#endif

11
inc/kernel/system/core.hpp
View File

@ -63,17 +63,6 @@ class Core {
private: private:
static Core* Processors[]; static Core* Processors[];
// Initialization vectors for all new cores.
// Numbers derived from boot.h space.
// Specifically, the bootloader ROM.
enum Initialization {
PAGETABLES = 0x600,
STARTUP = 0x620,
STACK = 0x670,
GDT = 0x680,
IDT = 0x690
};
void Bootstrap(); void Bootstrap();
void SetupData(size_t ID); void SetupData(size_t ID);

8
inc/kernel/system/descriptors.h
View File

@ -8,10 +8,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct __attribute__((packed)) { typedef struct __attribute__((packed)) {
uint16_t LowLimit; uint16_t LowLimit;
uint16_t BaseLow; uint16_t BaseLow;
@ -86,7 +82,3 @@ typedef struct __attribute__((packed)) {
uint16_t Length; uint16_t Length;
size_t Address; size_t Address;
} IDT; } IDT;
#ifdef __cplusplus
} // extern "C"
#endif

16
inc/kernel/system/interrupts.h
View File

@ -6,13 +6,12 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
extern const char* ExceptionStrings[]; extern const char* ExceptionStrings[];
typedef struct __attribute__((packed)) { typedef struct __attribute__((packed)) {
size_t rip; size_t rip;
size_t cs; size_t cs;
@ -30,12 +29,17 @@ typedef struct __attribute__((packed)) {
size_t ss; size_t ss;
} EXCEPTION_FRAME; } EXCEPTION_FRAME;
typedef void (*IRQHandler)(INTERRUPT_FRAME* Frame); typedef void (*IRQHandler)(INTERRUPT_FRAME* Frame);
extern IRQHandler IRQ_Handlers[16]; typedef struct {
IRQHandler handlers[8];
size_t numHandlers;
} IRQHandlerData;
void InstallIRQ(int IRQ, void (*Handler)(INTERRUPT_FRAME* Frame)); extern IRQHandlerData IRQHandlers[32];
size_t InstallIRQ(int IRQ, IRQHandler handler);
void UninstallIRQHandler(int IRQ, size_t ID);
__attribute__((no_caller_saved_registers)) void IRQ_Common(INTERRUPT_FRAME* Frame, size_t Interupt); __attribute__((no_caller_saved_registers)) void IRQ_Common(INTERRUPT_FRAME* Frame, size_t Interupt);
__attribute__((no_caller_saved_registers)) void ISR_Common(INTERRUPT_FRAME* Frame, size_t Interrupt); __attribute__((no_caller_saved_registers)) void ISR_Common(INTERRUPT_FRAME* Frame, size_t Interrupt);
@ -95,5 +99,5 @@ void IRQ14Handler(INTERRUPT_FRAME* Frame);
void IRQ15Handler(INTERRUPT_FRAME* Frame); void IRQ15Handler(INTERRUPT_FRAME* Frame);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" }
#endif #endif

23
inc/kernel/system/io.h
View File

@ -8,11 +8,7 @@
#define PAUSE __asm__ __volatile__("pause") #define PAUSE __asm__ __volatile__("pause")
#ifdef __cplusplus typedef struct {
extern "C" {
#endif
typedef struct {
uint8_t ACK; uint8_t ACK;
uint8_t SelfTest; uint8_t SelfTest;
uint8_t Echo; uint8_t Echo;
@ -22,7 +18,6 @@ typedef struct {
extern KBD_FLAGS KbdFlags; extern KBD_FLAGS KbdFlags;
DESC_TBL ReadGDT(void); DESC_TBL ReadGDT(void);
void WriteGDT(DESC_TBL GDTData); void WriteGDT(DESC_TBL GDTData);
@ -69,12 +64,14 @@ void Send8042(size_t);
void WriteSerialChar(const char); void WriteSerialChar(const char);
void WriteSerialString(const char*, size_t); void WriteSerialString(const char*, size_t);
int SerialPrintf(const char* format, ...);
int Printf(const char* Format, ...);
void* memcpy(void* dest, void const* src, size_t len); #ifdef __cplusplus
void* memset(void* dst, int src, size_t len); extern "C" {
#endif
#ifdef __cplusplus int SerialPrintf(const char* format, ...);
int Printf(const char* Format, ...);
void* memcpy(void* dest, void const* src, size_t len);
void* memset(void* dst, int src, size_t len);
#ifdef __cplusplus
} }
#endif #endif

27
inc/kernel/system/memory.h
View File

@ -1,13 +1,10 @@
#pragma once #pragma once
#ifdef __cplusplus #include <lainlib/lainlib.h>
extern "C" {
#endif
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <kernel/system/interrupts.h> #include <kernel/system/interrupts.h>
#include <lainlib/lainlib.h>
/************************ /************************
*** Team Kitty, 2020 *** *** Team Kitty, 2020 ***
@ -41,10 +38,18 @@ extern "C" {
#define CONCAT(x, y) x ## y #define CONCAT(x, y) x ## y
#define CONCAT2(x, y) CONCAT(x, y) #define CONCAT2(x, y) CONCAT(x, y)
#ifdef __cplusplus
extern "C" {
#endif
#define ASSERT(exp, error) \ #define ASSERT(exp, error) \
if(!(exp)) SomethingWentWrong(error); if(!(exp)) SomethingWentWrong(error);
// typedef char CONCAT2(static_assert, __LINE__) [(exp) ? 1 : -1] // typedef char CONCAT2(static_assert, __LINE__) [(exp) ? 1 : -1]
#ifdef __cplusplus
}
#endif
#define CLZ(num) (num ? __builtin_clzll(num) : 64) #define CLZ(num) (num ? __builtin_clzll(num) : 64)
#define IS_ALIGNED(addr) (((size_t) addr | 0xFFFFFFFFFFFFF000) == 0) #define IS_ALIGNED(addr) (((size_t) addr | 0xFFFFFFFFFFFFF000) == 0)
@ -223,10 +228,15 @@ size_t AllocatorMaxBlockSize(void);
size_t AllocatorPoolOverhead(void); size_t AllocatorPoolOverhead(void);
size_t AllocatorAllocateOverhead(void); size_t AllocatorAllocateOverhead(void);
#ifdef __cplusplus
extern "C" {
#endif
size_t AlignUpwards(size_t Pointer, size_t Alignment); size_t AlignUpwards(size_t Pointer, size_t Alignment);
size_t AlignDownwards(size_t Pointer, size_t Alignment); size_t AlignDownwards(size_t Pointer, size_t Alignment);
void* AlignPointer(const void* Pointer, size_t Alignment); void* AlignPointer(const void* Pointer, size_t Alignment);
#ifdef __cplusplus
}
#endif
/************************************************************ /************************************************************
@ -237,6 +247,10 @@ extern size_t memstart;
extern size_t end; extern size_t end;
#ifdef __cplusplus
extern "C" {
#endif
void ListMemoryMap(); void ListMemoryMap();
void InitMemoryManager(); void InitMemoryManager();
@ -270,6 +284,7 @@ void TraversePageTables();
void* memcpy(void* dest, void const* src, size_t len); void* memcpy(void* dest, void const* src, size_t len);
/********************************************* /*********************************************
* C h r o m a A l l o c a t o r * C h r o m a A l l o c a t o r
**********************************************/ **********************************************/
@ -300,6 +315,6 @@ extern void *PREFIX(realloc)(void *, size_t); ///< The standard function.
extern void *PREFIX(calloc)(size_t, size_t); ///< The standard function. extern void *PREFIX(calloc)(size_t, size_t); ///< The standard function.
extern void PREFIX(free)(void *); ///< The standard function. extern void PREFIX(free)(void *); ///< The standard function.
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

8
inc/kernel/system/pci.h
View File

@ -1,9 +1,5 @@
#pragma once #pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
@ -179,7 +175,3 @@ typedef struct {
extern pci_device_t** pci_root_devices; extern pci_device_t** pci_root_devices;
extern pci_entry_t* pci_map; extern pci_entry_t* pci_map;
#ifdef __cplusplus
}
#endif

8
inc/kernel/video/bitmapfont.h
View File

@ -3,10 +3,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
// This file contains all of the bitmap fonts made by me (Curle) and taken from the public domain // This file contains all of the bitmap fonts made by me (Curle) and taken from the public domain
// eg. http://dimensionalrift.homelinux.net/combuster/mos3/?p=viewsource&file=/modules/gfx/font8_8.asm // eg. http://dimensionalrift.homelinux.net/combuster/mos3/?p=viewsource&file=/modules/gfx/font8_8.asm
@ -468,7 +464,3 @@ const unsigned char bitfont_block[32][8] = {
{ 0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F}, // U+259E (boxes top right and bottom left) { 0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F}, // U+259E (boxes top right and bottom left)
{ 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF}, // U+259F (boxes right and bottom) { 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF}, // U+259F (boxes right and bottom)
}; };
#ifdef __cplusplus
}
#endif

8
inc/kernel/video/draw.h
View File

@ -5,10 +5,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/** /**
* Drawing routines for screen manipulation. * Drawing routines for screen manipulation.
* This will be pulled out into the Helix library soon. * This will be pulled out into the Helix library soon.
@ -60,7 +56,3 @@ void DrawLineRoundedRect(size_t x, size_t y, size_t width, size_t height, size_t
void DrawFilledCircle(size_t centerX, size_t centerY, size_t radius); void DrawFilledCircle(size_t centerX, size_t centerY, size_t radius);
void DrawLineCircle(size_t centerX, size_t centerY, size_t radius); void DrawLineCircle(size_t centerX, size_t centerY, size_t radius);
void DrawLineCircleCorners(size_t centerX, size_t centerY, size_t radius, char cornerMask); void DrawLineCircleCorners(size_t centerX, size_t centerY, size_t radius, char cornerMask);
#ifdef __cplusplus
}
#endif

8
inc/lainlib/compression/lzg.h
View File

@ -28,10 +28,6 @@
#ifndef _LIBLZG_H_ #ifndef _LIBLZG_H_
#define _LIBLZG_H_ #define _LIBLZG_H_
#ifdef __cplusplus
extern "C" {
#endif
#define LZG_VERSION "1.0.10" /**< @brief LZG library version string */ #define LZG_VERSION "1.0.10" /**< @brief LZG library version string */
#define LZG_VERNUM 0x0100000a /**< @brief LZG library version number (strictly */ #define LZG_VERNUM 0x0100000a /**< @brief LZG library version number (strictly */
/* incremental) */ /* incremental) */
@ -320,8 +316,4 @@ lzg_uint32_t LZG_Version(void);
*/ */
const char* LZG_VersionString(void); const char* LZG_VersionString(void);
#ifdef __cplusplus
}
#endif
#endif // _LIBLZG_H_ #endif // _LIBLZG_H_

8
inc/lainlib/ethernet/e1000/e1000.h
View File

@ -3,10 +3,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <kernel/system/pci.h> #include <kernel/system/pci.h>
@ -183,7 +179,3 @@ void E1000InterruptFired(INTERRUPT_FRAME* InterruptContext);
uint8_t* E1000GetMAC(e1000_device_t* Device); uint8_t* E1000GetMAC(e1000_device_t* Device);
// Send a packet // Send a packet
int E1000Send(e1000_device_t* Device, const void* Data, uint16_t Length); int E1000Send(e1000_device_t* Device, const void* Data, uint16_t Length);
#ifdef __cplusplus
}
#endif

6
inc/lainlib/lainlib.h
View File

@ -1,9 +1,5 @@
#pragma once #pragma once
#ifdef __cplusplus
extern "C" {
#endif
/************************ /************************
*** Team Kitty, 2020 *** *** Team Kitty, 2020 ***
*** Chroma *** *** Chroma ***
@ -25,5 +21,5 @@ extern "C" {
#include <lainlib/compression/lzg.h> #include <lainlib/compression/lzg.h>
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" #include <lainlib/vector/vector.h>
#endif #endif

8
inc/lainlib/list/list.h
View File

@ -1,9 +1,5 @@
#include <stdbool.h> #include <stdbool.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct list_entry { typedef struct list_entry {
struct list_entry* Previous; struct list_entry* Previous;
struct list_entry* Next; struct list_entry* Next;
@ -36,7 +32,3 @@ bool ListIsEmpty(list_entry_t* Head);
for(pos = UNSAFE_CAST((head)->next, typeof(*(pos)), member); &pos->member != (head); pos = LISTNEXT(pos, member)) for(pos = UNSAFE_CAST((head)->next, typeof(*(pos)), member); &pos->member != (head); pos = LISTNEXT(pos, member))
#define LASTENTRY 0 #define LASTENTRY 0
#ifdef __cplusplus
}
#endif

8
inc/lainlib/mutex/spinlock.h
View File

@ -5,10 +5,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
typedef volatile int spinlock_t; typedef volatile int spinlock_t;
/* A set of macros that acquire and release a mutex spinlock. */ /* A set of macros that acquire and release a mutex spinlock. */
@ -22,7 +18,3 @@ typedef volatile int spinlock_t;
#define SPUNLOCK(name) \ #define SPUNLOCK(name) \
__sync_synchronize(); \ __sync_synchronize(); \
name = 0; name = 0;
#ifdef __cplusplus
}
#endif

11
inc/lainlib/mutex/ticketlock.h
View File

@ -7,11 +7,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file provides a simple implementation of a ticket-based locking system. /* This file provides a simple implementation of a ticket-based locking system.
* You should probably prefer Spinlock over Ticketlock. * You should probably prefer Spinlock over Ticketlock.
* *
@ -22,6 +17,10 @@ extern "C" {
* *
*/ */
#ifdef __cplusplus
extern "C" {
#endif
typedef struct { typedef struct {
size_t NowServing; size_t NowServing;
size_t NextTicket; size_t NextTicket;
@ -35,6 +34,6 @@ bool TicketAttemptLock(ticketlock_t* Lock);
void TicketUnlock(ticketlock_t* Lock); void TicketUnlock(ticketlock_t* Lock);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

10
inc/lainlib/string/str.h
View File

@ -6,14 +6,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
size_t strlen(const char* String); size_t strlen(const char* String);
bool strcmp(char* a, const char* b); bool strcmp(char* a, const char* b);
#ifdef __cplusplus
}
#endif

129
inc/lainlib/vector/vector.h Normal file
View File

@ -0,0 +1,129 @@
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <kernel/system/memory.h>
/************************
*** Team Kitty, 2022 ***
*** Lainlib ***
***********************/
// integer typedefs
using u32 = uint32_t;
namespace lainlib {
template<typename T>
struct vector {
T& operator [] (u32 i) {
return this->data[i];
}
T operator [] (u32 i) const {
return this->data[i];
}
u32 size() {
return bytes / sizeof(T);
}
template<typename access_type>
access_type handle_read(const void *buf) {
access_type v;
memcpy(&v,buf,sizeof(access_type));
return v;
}
template<typename access_type>
void handle_write(void *buf, access_type v) {
memcpy(buf,&v,sizeof(access_type));
}
// insert at end as a var as a raw set of bytes into the Array
template<typename Y>
void emplace_back(Y v) {
const u32 len = sizeof(v);
reserve(len);
// actually write in the data
handle_write(&data[size()], v);
bytes += len;
}
T pop() {
const T v = data[size() - 1];
bytes -= sizeof(v);
return v;
}
void reserve_raw(u32 size) {
capacity = size;
data = (T*)krealloc(data, size);
}
void resize(u32 in) {
const u32 len = in * sizeof(T);
const u32 old_len = size();
reserve_raw( bytes);
bytes = len;
// default initialize the new elements
for(u32 i = old_len; i < size(); i++) {
data[i] = {};
}
}
// make sure there is enough left for the allocation we are doing
void reserve(u32 size) {
const u32 free_size = capacity - bytes;
// we have room to just dump this in
if(free_size >= size) {
return;
} else {
const u32 new_capacity = (capacity + size) * 2;
reserve_raw(new_capacity);
}
}
// raw mem read and writes over the array
T read_var(u32 idx) {
return handle_read<T>(data[idx]);
}
template<typename Y>
void write_var(u32 idx, T v) {
return handle_write(data[idx], v);
}
// insert raw memory block into the array
void push_mem(const void* newData, u32 size)
{
reserve(size);
memcpy(data[bytes], newData, size);
bytes += size;
}
void destroy() {
if(data) {
kfree(data);
data = nullptr;
}
bytes = 0;
capacity = 0;
}
T* data = nullptr;
// in raw bytes
u32 bytes = 0;
u32 capacity = 0;
};
}

4
src/drivers/devices/devices.cpp
View File

@ -22,7 +22,7 @@ Device::GenericStorage* StorageDevicesArray[MAX_STORAGE_DEVICES];
size_t CurrentStorageDevice = 0; size_t CurrentStorageDevice = 0;
// Internal storage. TODO: Make this not a pain to maintain // Internal storage. TODO: Make this not a pain to maintain
const char* DeviceNames[] = {"Storage", "Keyboard", "Networking"}; const char* DeviceNames[] = {"Storage", "Internal", "Peripheral", "Networking"};
// Add a device pointer to the managed list. // Add a device pointer to the managed list.
@ -30,7 +30,7 @@ void Device::RegisterDevice(Device::GenericDevice* Device) {
DevicesArray[CurrentDevice] = Device; DevicesArray[CurrentDevice] = Device;
Device->DeviceID = CurrentDevice; Device->DeviceID = CurrentDevice;
CurrentDevice++; CurrentDevice++;
SerialPrintf("[DEVICE] Registered device %d called %s of type %s\r\n", CurrentDevice - 1, Device->GetName(), SerialPrintf("[ DEV] Registered device %d called %s of type %s\r\n", CurrentDevice - 1, Device->GetName(),
DeviceNames[Device->GetType()]); DeviceNames[Device->GetType()]);
} }

160
src/drivers/devices/input/keyboard.cpp
View File

@ -1,160 +0,0 @@
#include <kernel/chroma.h>
#include <driver/keyboard.h>
/************************
*** Team Kitty, 2020 ***
*** Chroma ***
***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file contains (mostly unused) implementations of a full PS/2 keyboard driver.
*
* It provides provisions for full 2-way communication, as well as auxiliary key commands.
* //TODO: Media keys?
*
* Once this driver is to a workable state, I would like to start adding a proper keyboard buffer,
* which will integrate with a window system.
*
*/
KBD_FLAGS KbdFlags;
char keys[128] = {
0, 27,
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b',
'\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',
0,
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '#',
0,
'\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
0,
'*', 0,
' ', 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
'-',
0,
0,
0,
'+',
0,
0,
0,
0,
0,
0, 0, 0,
0,
0,
0,
};
KeyboardCallback KeyboardCallbacks[16] = {
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
};
static int CurrentCallback = 0;
int SetupKBCallback(void (* Handler)(KeyboardData Frame)) {
KeyboardCallbacks[CurrentCallback++] = Handler;
return CurrentCallback;
}
void UninstallKBCallback(int Number) {
KeyboardCallbacks[Number] = NULL; // 0 is used in the common check to make sure that the function is callable.
// This removes this callback from that check, ergo the function will no longer be called.
}
void KbdEcho() {
if (!KbdFlags.EchoCount) {
if (!KbdFlags.Echo) {
Send8042(0xEE);
}
} else {
KbdFlags.EchoCount = 0;
KbdFlags.Echo = 0;
}
}
void UpdateKeyboard(uint8_t msg) {
switch (msg) {
case 0x0:
KbdFlags.Error = 1;
//ResendBuffer();
break;
case 0xAA:
KbdFlags.SelfTest = 1;
break;
case 0xEE:
KbdFlags.Echo = 0;
KbdFlags.EchoCount = 2;
KbdEcho();
break;
case 0xFA:
KbdFlags.ACK = 1;
//ProgressBuffer();
break;
case 0xFC:
case 0xFD:
KbdFlags.SelfTest = 0;
KbdFlags.Error = 1;
//RestartKbd();
break;
case 0xFE:
//ResendBuffer();
break;
case 0xFF:
KbdFlags.Error = 1;
//ResendBuffer();
break;
default:
break;
}
KeyboardData data = (KeyboardData) {
.Char = msg > 0x80 && msg < 0xD8 ? keys[msg - 0x80] : keys[msg],
.Scancode = static_cast<char>(msg),
.Pressed = !(msg > 0x80 && msg < 0xD8),
};
void (* Handler)(KeyboardData data);
for (size_t handlerNum = 0; handlerNum < 16; handlerNum++) {
Handler = KeyboardCallbacks[handlerNum];
if (Handler) {
Handler(data);
}
}
}
void Send8042(size_t info) {
for (size_t i = 0; i < 8; i++) {
unsigned char chr = (unsigned char) info;
if (chr != 0) {
WritePort(0x60, chr, 1);
WaitFor8042();
}
}
}
void WaitFor8042() {
bool full = true;
while (full) {
full = ReadPort(0x64, 1) & 1;
}
}
#ifdef __cplusplus
}
#endif

2
src/drivers/devices/io/apic.cpp
View File

@ -59,6 +59,8 @@ bool APIC::IsReady() {
} }
void APIC::Init() { void APIC::Init() {
Device::RegisterDevice(this);
SerialPrintf("[ ACPI] Enabling APICs...\r\n"); SerialPrintf("[ ACPI] Enabling APICs...\r\n");
Address = (void*) ACPI::MADT::instance->LocalAPICBase; Address = (void*) ACPI::MADT::instance->LocalAPICBase;

168
src/drivers/devices/io/ps2_keyboard.cpp Normal file
View File

@ -0,0 +1,168 @@
#include <driver/io/ps2_keyboard.h>
#include <kernel/chroma.h>
/************************
*** Team Kitty, 2022 ***
*** Chroma ***
***********************/
char keys[128] = {
0, 27,
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b',
'\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n',
0,
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '#',
0,
'\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
0,
'*', 0,
' ', 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
'-',
0,
0,
0,
'+',
0,
0,
0,
0,
0,
0, 0, 0,
0,
0,
0,
};
char shiftedKeys[128] = {
0,
0, // ESC
33, // !
64, // @
35, // #
36, // $
37, // %
94, // ^
38, // &
42, // *
40, // (
41, // )
95, // _
43, // +
0,
0,
81, // Q
87,
69,
82,
84,
89,
85,
73,
79,
80, // P
123, // {
125, // }
0,
10,
65, // A
83,
68,
70,
71,
72,
74,
75,
76, // L
58, // :
34, // "
126, // ~
0,
124, // |
90, // Z
88,
67,
86,
66,
78,
77, // M
60, // <
62, // >
63, // ?
0,
0,
0,
32, // SPACE
};
Device::PS2Keyboard* Device::PS2Keyboard::driver;
using namespace Device;
void IRQRedirect(INTERRUPT_FRAME* irq) {
UNUSED(irq);
PS2Keyboard::driver->InterruptHandler();
}
PS2Keyboard::PS2Keyboard() {
driver = this;
}
void PS2Keyboard::setState(bool state, uint8_t key) {
keyStates[key] = state;
if(state)
lastPress = key;
else
lastPress = 0;
if(callback != nullptr)
callback[key] = state;
}
bool PS2Keyboard::isPressed(uint8_t key) const {
return keyStates[key];
}
void PS2Keyboard::Init() {
Device::RegisterDevice(this);
buffer.reserve(100);
for (size_t idx = 0; idx < 128; idx++) {
keyStates[idx] = false;
}
InstallIRQ(1, IRQRedirect);
}
void PS2Keyboard::InterruptHandler() {
uint8_t state = ReadPort(0x64, 1);
// while keyboard has input and the buffer is not empty
while (state & 1 && !(state & 0x20)) {
uint8_t keycode = ReadPort(0x60, 1);
uint8_t scancode = keycode & 0x7f;
uint8_t keystate = !(keycode & 0x80);
if (keystate)
SerialPrintf("[ KEY] %c pressed.\r\n", keys[scancode]);
state = ReadPort(0x64, 1);
KeyboardData data { keys[scancode], (char) scancode, (bool) keystate };
buffer.emplace_back(data);
}
}
void PS2Keyboard::SetCallback(uint32_t* data) {
callback = (uint8_t*) data;
for (size_t idx = 0; idx < 128; idx++) {
callback[idx] = false;
}
}

8
src/drivers/elf.cpp
View File

@ -4,10 +4,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* /*
* This file provides utility functions for parsing ELF headers. * This file provides utility functions for parsing ELF headers.
* This exists so that the kernel can find itself for remapping, * This exists so that the kernel can find itself for remapping,
@ -92,7 +88,3 @@ int ParseKernelHeader(size_t InitrdPtr) {
return flag; return flag;
} }
#ifdef __cplusplus
}
#endif

5
src/editor/EditorMain.cpp
View File

@ -1,5 +1,4 @@
#include <kernel/chroma.h> #include <kernel/chroma.h>
#include <driver/keyboard.h>
#include <kernel/video/draw.h> #include <kernel/video/draw.h>
#include <editor/main.h> #include <editor/main.h>
@ -11,11 +10,9 @@
/** /**
* Contains startup and setup routines for the Chroma Editor. * Contains startup and setup routines for the Chroma Editor.
*/ */
static KeyboardCallback KernelHandler;
void Editor::StartEditor(int callbackID) { void Editor::StartEditor(int callbackID) {
KernelHandler = KeyboardCallbacks[callbackID]; UNUSED(callbackID);
EditorLayout layout; EditorLayout layout;
layout.ScreenHeight = PrintInfo.screenHeight; layout.ScreenHeight = PrintInfo.screenHeight;
layout.ScreenWidth = PrintInfo.screenWidth; layout.ScreenWidth = PrintInfo.screenWidth;

41
src/kernel.cpp
View File

@ -1,50 +1,41 @@
#include <kernel/chroma.h> #include <kernel/chroma.h>
#include <kernel/video/draw.h> #include <kernel/video/draw.h>
#include <driver/keyboard.h>
#include <editor/main.h> #include <editor/main.h>
#include "kernel/system/acpi/rsdt.h" #include "kernel/system/acpi/rsdt.h"
#include "kernel/system/acpi/madt.h" #include "kernel/system/acpi/madt.h"
#include "driver/io/apic.h" #include "driver/io/apic.h"
#include "driver/io/ps2_keyboard.h"
/************************ /************************
*** Team Kitty, 2020 *** *** Team Kitty, 2020 ***
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file is the entry point to the system. /* This file is the entry point to the system.
* It dictates the order of operations of everything the kernel actually does. * It dictates the order of operations of everything the kernel actually does.
* If a function isn't fired here, directly or indirectly, it is not run. * If a function isn't fired here, directly or indirectly, it is not run.
*/ */
static bool KernelLoaded = false; bool KernelLoaded = false;
address_space_t KernelAddressSpace; address_space_t KernelAddressSpace;
size_t KernelAddr = (size_t) &LoadAddr; size_t KernelAddr = (size_t) &LoadAddr;
size_t KernelEnd = (size_t) &end; size_t KernelEnd = (size_t) &end;
void PrintPressedChar(KeyboardData data);
int CharPrinterCallbackID; int CharPrinterCallbackID;
void TrackInternalBuffer(KeyboardData data); void TrackInternalBuffer(Device::GenericKeyboard::KeyboardData data);
int InternalBufferID; int InternalBufferID;
size_t BufferLength = 0; size_t BufferLength = 0;
char* InternalBuffer; char* InternalBuffer;
#ifdef __cplusplus
}
#endif
/** /**
* C++ code! Scary! * C++ code! Scary!
* This is a temporary measure to experiment with the Editor system. * This is a temporary measure to experiment with the Editor system.
*/ */
extern "C" [[noreturn]] int Main(void) { extern "C" int Main(void) {
KernelAddressSpace.Lock.NextTicket = 0; KernelAddressSpace.Lock.NextTicket = 0;
KernelAddressSpace.Lock.NowServing = 0; KernelAddressSpace.Lock.NowServing = 0;
KernelAddressSpace.PML4 = nullptr; KernelAddressSpace.PML4 = nullptr;
@ -72,9 +63,7 @@ extern "C" [[noreturn]] int Main(void) {
PrepareCPU(); PrepareCPU();
PCIEnumerate(); PCIEnumerate();
InitMemoryManager(); InitMemoryManager();
InitPaging(); InitPaging();
Printf("Paging complete. System initialized.\n\r"); Printf("Paging complete. System initialized.\n\r");
@ -89,31 +78,20 @@ extern "C" [[noreturn]] int Main(void) {
SetForegroundColor(0x00FFFFFF); SetForegroundColor(0x00FFFFFF);
Device::APIC::driver = new Device::APIC(); Device::APIC::driver = new Device::APIC();
Device::PS2Keyboard::driver = new Device::PS2Keyboard();
ACPI::RSDP::instance->Init(0); ACPI::RSDP::instance->Init(0);
ACPI::MADT::instance->Init(); ACPI::MADT::instance->Init();
Device::APIC::driver->Init(); Device::APIC::driver->Init();
Device::PS2Keyboard::driver->Init();
Core::Init(); Core::Init();
CharPrinterCallbackID = SetupKBCallback(&PrintPressedChar);
InternalBufferID = SetupKBCallback(&TrackInternalBuffer);
for (;;) { } for (;;) { }
} }
extern "C" void PrintPressedChar(KeyboardData data) { /*
if (!KernelLoaded) return;
if (data.Pressed) {
SerialPrintf("Key pressed: [\\%c (%x)]\r\n", data.Char, data.Scancode);
Printf("%c", data.Char);
} else {
SerialPrintf("Key released: [\\%c]\r\n", data.Char);
}
}
extern "C" void TrackInternalBuffer(KeyboardData data) { extern "C" void TrackInternalBuffer(KeyboardData data) {
if (!data.Pressed) return; if (!data.Pressed) return;
@ -147,8 +125,7 @@ extern "C" void TrackInternalBuffer(KeyboardData data) {
InternalBuffer[BufferLength] = data.Char; InternalBuffer[BufferLength] = data.Char;
BufferLength++; BufferLength++;
} }
} }*/
extern "C" void SomethingWentWrong(const char* Message) { extern "C" void SomethingWentWrong(const char* Message) {
SerialPrintf("Assertion failed! %s\r\n", Message); SerialPrintf("Assertion failed! %s\r\n", Message);

10
src/lainlib/compression/lzgmini.c
View File

@ -27,10 +27,6 @@
#include <lainlib/lainlib.h> #include <lainlib/lainlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/*-- PRIVATE -----------------------------------------------------------------*/ /*-- PRIVATE -----------------------------------------------------------------*/
/* Internal definitions */ /* Internal definitions */
@ -191,8 +187,4 @@ lzg_uint32_t LZG_Decode(const unsigned char *in, lzg_uint32_t insize,
return 0; return 0;
else else
return decodedSize; return decodedSize;
} }
#ifdef __cplusplus
}
#endif

8
src/lainlib/ethernet/e1000/E1000Driver.c
View File

@ -8,10 +8,6 @@
*** Lainlib *** *** Lainlib ***
************************/ ************************/
#ifdef __cplusplus
extern "C" {
#endif
/** /**
* This file handles all the logic for interfacing with the E1000 networking device. * This file handles all the logic for interfacing with the E1000 networking device.
* This card is labelled either the Intel I217, or Intel Gigabit 82577LM. * This card is labelled either the Intel I217, or Intel Gigabit 82577LM.
@ -355,7 +351,3 @@ int E1000Send(e1000_device_t* Device, const void* Data, uint16_t Length) {
return 0; return 0;
} }
#ifdef __cplusplus
}
#endif

7
src/lainlib/ethernet/ethernet.h
View File

@ -5,9 +5,6 @@
*** Lainlib *** *** Lainlib ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
struct mac_address { struct mac_address {
uint8_t MAC[6]; uint8_t MAC[6];
@ -25,7 +22,3 @@ struct ethernet_packet {
uint16_t Type; uint16_t Type;
uint8_t Payload[]; uint8_t Payload[];
}; };
#ifdef __cplusplus
}
#endif

7
src/lainlib/list/basic_list.cpp
View File

@ -1,8 +1,5 @@
#include <lainlib/list/list.h> #include <lainlib/list/list.h>
#ifdef __cplusplus
extern "C" {
#endif
void ListAdd(list_entry_t* Head, list_entry_t* New) { void ListAdd(list_entry_t* Head, list_entry_t* New) {
New->Next = Head->Next; New->Next = Head->Next;
@ -29,7 +26,3 @@ void ListRemove(list_entry_t* Entry) {
bool ListIsEmpty(list_entry_t* Head) { bool ListIsEmpty(list_entry_t* Head) {
return Head->Next == Head; return Head->Next == Head;
} }
#ifdef __cplusplus
}
#endif

11
src/lainlib/mutex/ticketlock.cpp
View File

@ -2,14 +2,12 @@
#define PAUSE __asm__ __volatile__("pause") #define PAUSE __asm__ __volatile__("pause")
#ifdef __cplusplus
extern "C" { extern "C" {
#endif
void TicketLock(ticketlock_t* Lock) { void TicketLock(ticketlock_t* Lock) {
size_t Ticket = __atomic_fetch_add(&Lock->NextTicket, 1, __ATOMIC_RELAXED); size_t Ticket = __atomic_fetch_add(&Lock->NextTicket, 1, __ATOMIC_RELAXED);
__sync_synchronize(); __sync_synchronize();
while(__atomic_load_8(&Lock->NowServing, __ATOMIC_ACQUIRE) != Ticket) { while (__atomic_load_8(&Lock->NowServing, __ATOMIC_ACQUIRE) != Ticket) {
PAUSE; PAUSE;
} }
} }
@ -17,7 +15,8 @@ void TicketLock(ticketlock_t* Lock) {
bool TicketAttemptLock(ticketlock_t* Lock) { bool TicketAttemptLock(ticketlock_t* Lock) {
size_t Ticket = __atomic_load_8(&Lock->NowServing, __ATOMIC_RELAXED); size_t Ticket = __atomic_load_8(&Lock->NowServing, __ATOMIC_RELAXED);
__sync_synchronize(); __sync_synchronize();
return __atomic_compare_exchange_8(&Lock->NowServing, &Ticket, Ticket + 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED); return __atomic_compare_exchange_8(&Lock->NowServing, &Ticket, Ticket + 1, false, __ATOMIC_ACQUIRE,
__ATOMIC_RELAXED);
} }
void TicketUnlock(ticketlock_t* Lock) { void TicketUnlock(ticketlock_t* Lock) {
@ -26,6 +25,4 @@ void TicketUnlock(ticketlock_t* Lock) {
__atomic_store_8(&Lock->NowServing, NextTicket, __ATOMIC_RELEASE); __atomic_store_8(&Lock->NowServing, NextTicket, __ATOMIC_RELEASE);
} }
#ifdef __cplusplus }
}
#endif

8
src/lainlib/string/str.cpp
View File

@ -7,10 +7,6 @@
*** Lainlib *** *** Lainlib ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
size_t strlen(const char* String) { size_t strlen(const char* String) {
size_t Len = 0; size_t Len = 0;
while(String[Len] != '\0') { while(String[Len] != '\0') {
@ -28,7 +24,3 @@ bool strcmp(char* a, const char* b) {
bI++; bI++;
} }
} }
#ifdef __cplusplus
}
#endif

6
src/lainlib/vector/vector.cpp Normal file
View File

@ -0,0 +1,6 @@
#include <lainlib/lainlib.h>
/************************
*** Team Kitty, 2022 ***
*** Lainlib ***
***********************/

15
src/system/core.cpp
View File

@ -98,20 +98,7 @@ void Core::Bootstrap() {
} }
void Core::SetupData(size_t Core) { void Core::SetupData(size_t Core) {
// Write page tables UNUSED(Core);
GetCore(Core)->AddressSpace->PML4 = GetCurrent()->AddressSpace->PML4;
*((size_t*) Initialization::PAGETABLES) = (size_t) GetCore(Core)->AddressSpace->PML4;
// Prepare stack
memset(GetCore(Core)->StackData, 0, Constants::Core::STACK_SIZE);
*((size_t*) Initialization::STACK) = (size_t) GetCore(Core)->StackData + Constants::Core::STACK_SIZE;
// GDT = 0x680
// IDT = 0x690
__asm__ __volatile__("sgdt (0x680)\n sidt (0x690)");
// Set startup address
*((size_t*) Initialization::STARTUP) = (size_t) &initcpu;
} }

16
src/system/cpu.cpp
View File

@ -6,10 +6,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This class provides functions for setting up and preparing the CPU for the things the kernel will do. /* This class provides functions for setting up and preparing the CPU for the things the kernel will do.
* Mainly, it allows you to: * Mainly, it allows you to:
* *
@ -70,7 +66,6 @@ static void RefreshCS() {
void PrepareCPU() { void PrepareCPU() {
SetupInitialGDT(); SetupInitialGDT();
SetupIDT(); SetupIDT();
//SetupExtensions(); //SetupExtensions();
@ -227,13 +222,10 @@ void SetupIDT() {
SetISR(46, (size_t) IRQ14Handler); SetISR(46, (size_t) IRQ14Handler);
SetISR(47, (size_t) IRQ15Handler); SetISR(47, (size_t) IRQ15Handler);
for (size_t i = 0; i < 32; i++) {
//TODO: ISRs 32 to 256 IRQHandlers[i] = {{}, 0 };
}
WriteIDT(IDTData); WriteIDT(IDTData);
} }
#ifdef __cplusplus
}
#endif

177
src/system/interrupts.cpp
View File

@ -8,10 +8,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file contains all of the ISR and IRQ /* This file contains all of the ISR and IRQ
* (Interrupt Service Request) functions. * (Interrupt Service Request) functions.
* *
@ -41,6 +37,10 @@ extern "C" {
* these having a size_t input as an error code. * these having a size_t input as an error code.
*/ */
#ifdef __cplusplus
extern "C" {
#endif
const char* ExceptionStrings[] = { const char* ExceptionStrings[] = {
"Division by Zero", "Division by Zero",
"Debug", "Debug",
@ -76,15 +76,7 @@ const char* ExceptionStrings[] = {
"Reserved" "Reserved"
}; };
typedef void (* IRQHandler)(INTERRUPT_FRAME* Frame); IRQHandlerData IRQHandlers[32];
IRQHandler IRQ_Handlers[16] = {
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
};
typedef unsigned long long int uword_t;
/* All of the ISR routines call this function for now. /* All of the ISR routines call this function for now.
! This function is NOT leaf, and it might clobber the stack. ! This function is NOT leaf, and it might clobber the stack.
@ -124,114 +116,105 @@ void ISR_Error_Common(INTERRUPT_FRAME* Frame, size_t ErrorCode, size_t Exception
which was set up earlier by irq_install.*/ which was set up earlier by irq_install.*/
void IRQ_Common(INTERRUPT_FRAME* Frame, size_t Interrupt) { void IRQ_Common(INTERRUPT_FRAME* Frame, size_t Interrupt) {
// First we need to define a function pointer.. // First we need to define a function pointer..
void (* Handler)(INTERRUPT_FRAME* Frame); IRQHandlerData handler;
/* We set all uninitialized routines to 0, so the if(handler) check here allows us to /* We set all uninitialized routines to 0, so the if(handler) check here allows us to
safely tell whether we've actually got something for this IRQ. */ safely tell whether we've actually got something for this IRQ. */
Handler = IRQ_Handlers[Interrupt]; handler = IRQHandlers[Interrupt];
// If there's something there, if (handler.numHandlers > 0) {
if (Handler) {
SerialPrintf("[ IRQ] IRQ %d raised!\r\n", Interrupt); SerialPrintf("[ IRQ] IRQ %d raised!\r\n", Interrupt);
// Call the handler. // Call the handlers
Handler(Frame); for (size_t i = 0; i < handler.numHandlers; i++)
handler.handlers[i](Frame);
} }
/* The Slave PIC must be told it's been read in order to receive another 8+ IRQ. */ /* The Slave PIC must be told it's been read in order to receive another 8+ IRQ. */
if (Interrupt > 7) if (Interrupt > 7)
WritePort(0xA0, 0x20, 1); WritePort(0xA0, 0x20, 1);
/* In either case, we tell the Master PIC it's been read to receive any IRQ. */ /* In either case, we tell the Master PIC it's been read to receive any IRQ. */
WritePort(0x20, 0x20, 1); WritePort(0x20, 0x20, 1);
}
#define PIC1 0x20 /* IO base address for master PIC */
#define PIC2 0xA0 /* IO base address for slave PIC */
#define PIC1_COMMAND PIC1
#define PIC1_DATA (PIC1+1)
#define PIC2_COMMAND PIC2
#define PIC2_DATA (PIC2+1)
#define ICW1_ICW4 0x01 /* ICW4 (not) needed */
#define ICW1_SINGLE 0x02 /* Single (cascade) mode */
#define ICW1_INTERVAL4 0x04 /* Call address interval 4 (8) */
#define ICW1_LEVEL 0x08 /* Level triggered (edge) mode */
#define ICW1_INIT 0x10 /* Initialization - required! */
#define ICW4_8086 0x01 /* 8086/88 (MCS-80/85) mode */
#define ICW4_AUTO 0x02 /* Auto (normal) EOI */
#define ICW4_BUF_SLAVE 0x08 /* Buffered mode/slave */
#define ICW4_BUF_MASTER 0x0C /* Buffered mode/master */
#define ICW4_SFNM 0x10 /* Special fully nested (not) */
void ClearIRQ(size_t idx) {
uint16_t port;
uint8_t value;
if(idx < 8) {
port = PIC1_DATA;
} else {
port = PIC2_DATA;
idx -= 8;
}
value = ReadPort(port, 1) & ~(1 << idx);
WritePort(port, value, 1);
} }
/* However, in order to actually be able to receive IRQs, we need to remap the PICs. */ /* However, in order to actually be able to receive IRQs, we need to remap the PICs. */
void RemapIRQControllers() { void RemapIRQControllers() {
/* 0x20 is the Master PIC, /* 0x20 is the Master PIC,
0xA0 is the Slave PIC. */ 0xA0 is the Slave PIC. */
WritePort(0x20, 0x11, 1); unsigned char a1, a2;
WritePort(0xA0, 0x11, 1);
WritePort(0x21, 0x20, 1); a1 = ReadPort(PIC1_DATA, 1); // save masks
WritePort(0xA1, 0x28, 1); a2 = ReadPort(PIC2_DATA, 1);
WritePort(0x21, 0x04, 1);
WritePort(0xA1, 0x02, 1); WritePort(PIC1_COMMAND, ICW1_INIT | ICW1_ICW4, 1); // starts the initialization sequence (in cascade mode)
WritePort(0x21, 0x01, 1); WritePort(PIC2_COMMAND, ICW1_INIT | ICW1_ICW4, 1);
WritePort(0xA1, 0x01, 1); WritePort(PIC1_DATA, 32, 1); // ICW2: Master PIC vector offset
WritePort(0x21, 0x0, 1); WritePort(PIC2_DATA, 32 + 8, 1); // ICW2: Slave PIC vector offset
WritePort(0xA1, 0x0, 1); WritePort(PIC1_DATA, 4, 1); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100)
WritePort(PIC2_DATA, 2, 1); // ICW3: tell Slave PIC its cascade identity (0000 0010)
WritePort(PIC1_DATA, ICW4_8086, 1);
WritePort(PIC2_DATA, ICW4_8086, 1);
WritePort(PIC1_DATA, a1, 1); // restore saved masks.
WritePort(PIC2_DATA, a2, 1);
ClearIRQ(1);
ClearIRQ(2);
} }
/* In order to actually handle the IRQs, though, we need to tell the kernel *where* the handlers are. */ /* In order to actually handle the IRQs, though, we need to tell the kernel *where* the handlers are. */
/* A simple wrapper that adds a function pointer to the IRQ array. */ /* A simple wrapper that adds a function pointer to the IRQ array. */
void InstallIRQ(int IRQ, void (* Handler)(INTERRUPT_FRAME* Frame)) { size_t InstallIRQ(int IRQ, IRQHandler Handler) {
IRQ_Handlers[IRQ] = Handler; if (IRQ <= 32) {
IRQHandlerData* target = &IRQHandlers[IRQ];
if (target->numHandlers < 7) {
target->handlers[target->numHandlers] = Handler;
target->numHandlers++;
return target->numHandlers;
}
}
return 0;
} }
/* A simple wrapper that unlinks a function pointer, rendering the IRQ unused. */ /* A simple wrapper that unlinks a function pointer, rendering the IRQ unused. */
void UninstallIRQHandler(int IRQ) { void UninstallIRQHandler(int IRQ, size_t ID) {
IRQ_Handlers[IRQ] = NULL; // 0 is used in the common check to make sure that the function is callable. IRQHandlers[IRQ].handlers[ID] = NULL; // 0 is used in the common check to make sure that the function is callable.
// This removes this IRQ from that check, ergo the function will no longer be called. // This removes this IRQ from that check, ergo the function will no longer be called.
} }
void EmptyIRQ(INTERRUPT_FRAME* frame) {
UNUSED(frame);
// Flash the borders green, then back to blue
SetForegroundColor(0x0000FF00);
for (size_t y = 0; y < bootldr.fb_height; y++) {
for (size_t x = 0; x < 20; x++) {
DrawPixel(x, y);
}
for (size_t x = (bootldr.fb_width - 20); x < bootldr.fb_width; x++) {
DrawPixel(x, y);
}
}
for (size_t x = 0; x < bootldr.fb_width; x++) {
for (size_t y = 0; y < 20; y++) {
DrawPixel(x, y);
}
for (size_t y = (bootldr.fb_height - 20); y < bootldr.fb_height; y++) {
DrawPixel(x, y);
}
}
for (size_t i = 0; i < 100000; i++) { }
SetForegroundColor(0x000000FF);
for (size_t y = 0; y < bootldr.fb_height; y++) {
for (size_t x = 0; x < 20; x++) {
DrawPixel(x, y);
}
for (size_t x = (bootldr.fb_width - 20); x < bootldr.fb_width; x++) {
DrawPixel(x, y);
}
}
for (size_t x = 0; x < bootldr.fb_width; x++) {
for (size_t y = 0; y < 20; y++) {
DrawPixel(x, y);
}
for (size_t y = (bootldr.fb_height - 20); y < bootldr.fb_height; y++) {
DrawPixel(x, y);
}
}
}
static void KeyboardCallback(INTERRUPT_FRAME* frame) {
UNUSED(frame);
uint8_t msg = ReadPort(0x60, 1);
UpdateKeyboard(msg);
WaitFor8042();
}
void InitInterrupts() { void InitInterrupts() {
size_t RFLAGS = ReadControlRegister('f'); size_t RFLAGS = ReadControlRegister('f');
@ -239,11 +222,6 @@ void InitInterrupts() {
WriteControlRegister('f', RFLAGS | (1 << 9)); WriteControlRegister('f', RFLAGS | (1 << 9));
} }
InstallIRQ(1, &KeyboardCallback);
Send8042(0xF002);
__asm__ __volatile__("sti"); __asm__ __volatile__("sti");
} }
@ -451,6 +429,7 @@ __attribute__((interrupt)) void IRQ0Handler(INTERRUPT_FRAME* Frame) {
} }
__attribute__((interrupt)) void IRQ1Handler(INTERRUPT_FRAME* Frame) { __attribute__((interrupt)) void IRQ1Handler(INTERRUPT_FRAME* Frame) {
SerialPrintf("IRQ1\r\n");
IRQ_Common(Frame, 1); // Keyboard handler IRQ_Common(Frame, 1); // Keyboard handler
} }
@ -510,6 +489,6 @@ __attribute__((interrupt)) void IRQ15Handler(INTERRUPT_FRAME* Frame) {
IRQ_Common(Frame, 15); IRQ_Common(Frame, 15);
} }
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

59
src/system/memory/abstract_allocator.cpp
View File

@ -7,10 +7,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/************************************************ /************************************************
* C O N S T A N T S A N D M A C R O S * C O N S T A N T S A N D M A C R O S
*************************************************/ *************************************************/
@ -136,10 +132,6 @@ static void BlockSetSize(block_header_t* Block, size_t Size) {
Block->Size = Size | (Block->Size & (BLOCK_FREE | BLOCK_PREV_FREE)); Block->Size = Size | (Block->Size & (BLOCK_FREE | BLOCK_PREV_FREE));
} }
static int BlockIsLast(const block_header_t* Block) {
return BlockSize(Block) == 0;
}
static int BlockIsFree(const block_header_t* Block) { static int BlockIsFree(const block_header_t* Block) {
return CAST(int, Block->Size & BLOCK_FREE); return CAST(int, Block->Size & BLOCK_FREE);
} }
@ -177,13 +169,11 @@ static block_header_t* OffsetToBlock(const void* Address, size_t Size) {
} }
static block_header_t* BlockGetPrevious(const block_header_t* Current) { static block_header_t* BlockGetPrevious(const block_header_t* Current) {
ASSERT(BlockPrevIsFree(Current), "BlockGetPrevious: Previous block NOT free");
return Current->LastBlock; return Current->LastBlock;
} }
static block_header_t* BlockGetNext(const block_header_t* Current) { static block_header_t* BlockGetNext(const block_header_t* Current) {
block_header_t* NextBlock = OffsetToBlock(WhereBlock(Current), BlockSize(Current) - BLOCK_OVERHEAD); block_header_t* NextBlock = OffsetToBlock(WhereBlock(Current), BlockSize(Current) - BLOCK_OVERHEAD);
ASSERT(!BlockIsLast(Current), "BlockGetNext: Current block is last!");
return NextBlock; return NextBlock;
} }
@ -210,17 +200,17 @@ static void BlockMarkUsed(block_header_t* Current) {
* P O I N T E R A L I G N M E N T F U N C T I O N S * P O I N T E R A L I G N M E N T F U N C T I O N S
************************************************************************************/ ************************************************************************************/
size_t AlignUpwards(size_t Pointer, size_t Alignment) { extern "C" size_t AlignUpwards(size_t Pointer, size_t Alignment) {
//ASSERT(((Alignment & (Alignment - 1)) == 0)); //ASSERT(((Alignment & (Alignment - 1)) == 0));
return (Pointer + (Alignment - 1)) & ~(Alignment - 1); return (Pointer + (Alignment - 1)) & ~(Alignment - 1);
} }
size_t AlignDownwards(size_t Pointer, size_t Alignment) { extern "C" size_t AlignDownwards(size_t Pointer, size_t Alignment) {
//ASSERT((Alignment & (Alignment - 1) == 0)); //ASSERT((Alignment & (Alignment - 1) == 0));
return (Pointer - (Pointer & (Alignment - 1))); return (Pointer - (Pointer & (Alignment - 1)));
} }
void* AlignPointer(const void* Pointer, size_t Alignment) { extern "C" void* AlignPointer(const void* Pointer, size_t Alignment) {
const ptrdiff_t AlignedPointer = const ptrdiff_t AlignedPointer =
(( ((
@ -228,7 +218,6 @@ void* AlignPointer(const void* Pointer, size_t Alignment) {
+ (Alignment - 1)) + (Alignment - 1))
& ~(Alignment - 1) & ~(Alignment - 1)
); );
ASSERT(((Alignment & (Alignment - 1)) == 0), "AlignPointer: Requested alignment not aligned!");
return CAST(void*, AlignedPointer); return CAST(void*, AlignedPointer);
} }
@ -297,8 +286,6 @@ static block_header_t* FindSuitableBlock(allocator_control_t* Controller, int* F
SLMap = Controller->SecondLevel_Bitmap[FirstLevel]; SLMap = Controller->SecondLevel_Bitmap[FirstLevel];
} }
ASSERT(SLMap, "FindSuitableBlock: Second level bitmap not present!");
SecondLevel = Alloc_FindFirstOne(SLMap); SecondLevel = Alloc_FindFirstOne(SLMap);
*SecondLevelIndex = SecondLevel; *SecondLevelIndex = SecondLevel;
@ -309,9 +296,6 @@ static void RemoveFreeBlock(allocator_control_t* Controller, block_header_t* Blo
block_header_t* PreviousBlock = Block->LastFreeBlock; block_header_t* PreviousBlock = Block->LastFreeBlock;
block_header_t* NextBlock = Block->NextFreeBlock; block_header_t* NextBlock = Block->NextFreeBlock;
ASSERT(PreviousBlock, "RemoveFreeBlock: PreviousBlock is null!");
ASSERT(NextBlock, "RemoveFreeBlock: NextBlock is null!");
NextBlock->LastFreeBlock = PreviousBlock; NextBlock->LastFreeBlock = PreviousBlock;
PreviousBlock->NextFreeBlock = NextBlock; PreviousBlock->NextFreeBlock = NextBlock;
@ -332,7 +316,6 @@ static void
InsertFreeBlock(allocator_control_t* Controller, block_header_t* NewBlock, int FirstLevel, int SecondLevel) { InsertFreeBlock(allocator_control_t* Controller, block_header_t* NewBlock, int FirstLevel, int SecondLevel) {
block_header_t* Current = Controller->Blocks[FirstLevel][SecondLevel]; block_header_t* Current = Controller->Blocks[FirstLevel][SecondLevel];
ASSERT(Current, "InsertFreeBlock: Current Block is null!");
if (!Current) { if (!Current) {
SerialPrintf( SerialPrintf(
"Extra info: \r\n\tFirst Level: %x Second Level: %x\r\nFirst Level bitmap: %x, Second Level bitmap: %x\r\n\tBlocks %x, BlocksAddress: %x", "Extra info: \r\n\tFirst Level: %x Second Level: %x\r\nFirst Level bitmap: %x, Second Level bitmap: %x\r\n\tBlocks %x, BlocksAddress: %x",
@ -340,16 +323,12 @@ InsertFreeBlock(allocator_control_t* Controller, block_header_t* NewBlock, int F
Controller->Blocks, Controller->Blocks[FirstLevel][SecondLevel]); Controller->Blocks, Controller->Blocks[FirstLevel][SecondLevel]);
for (;;) { } for (;;) { }
} }
ASSERT(NewBlock, "InsertFreeBlock: New Block is null!");
NewBlock->NextFreeBlock = Current; NewBlock->NextFreeBlock = Current;
NewBlock->LastFreeBlock = &Controller->BlockNull; NewBlock->LastFreeBlock = &Controller->BlockNull;
Current->LastFreeBlock = NewBlock; Current->LastFreeBlock = NewBlock;
ASSERT(WhereBlock(NewBlock) == AlignPointer(WhereBlock(NewBlock), ALIGN_SIZE),
"InsertFreeBlock: Current block is not memory aligned!");
Controller->Blocks[FirstLevel][SecondLevel] = NewBlock; Controller->Blocks[FirstLevel][SecondLevel] = NewBlock;
Controller->FirstLevel_Bitmap |= (1U << FirstLevel); Controller->FirstLevel_Bitmap |= (1U << FirstLevel);
Controller->SecondLevel_Bitmap[FirstLevel] |= (1U << SecondLevel); Controller->SecondLevel_Bitmap[FirstLevel] |= (1U << SecondLevel);
@ -378,15 +357,8 @@ static block_header_t* SplitBlock(block_header_t* Block, size_t NewSize) {
const size_t RemainingSize = BlockSize(Block) - (NewSize + BLOCK_OVERHEAD); const size_t RemainingSize = BlockSize(Block) - (NewSize + BLOCK_OVERHEAD);
ASSERT(WhereBlock(Overlap) == AlignPointer(WhereBlock(Overlap), ALIGN_SIZE),
"SplitBlock: Requested size results in intermediary block which is not aligned!");
ASSERT(BlockSize(Block) == RemainingSize + NewSize + BLOCK_OVERHEAD, "SplitBlock: Maths error!");
BlockSetSize(Overlap, RemainingSize); BlockSetSize(Overlap, RemainingSize);
ASSERT(BlockSize(Overlap) >= BLOCK_MIN_SIZE, "SplitBlock: Requested size results in new block that is too small!");
BlockSetSize(Block, NewSize); BlockSetSize(Block, NewSize);
BlockMarkFree(Overlap); BlockMarkFree(Overlap);
@ -395,7 +367,6 @@ static block_header_t* SplitBlock(block_header_t* Block, size_t NewSize) {
} }
static block_header_t* MergeBlockDown(block_header_t* Previous, block_header_t* Block) { static block_header_t* MergeBlockDown(block_header_t* Previous, block_header_t* Block) {
ASSERT(!BlockIsLast(Previous), "MergeBlockDown: Previous block is the last block! (Current block is first block?)");
Previous->Size += BlockSize(Block) + BLOCK_OVERHEAD; Previous->Size += BlockSize(Block) + BLOCK_OVERHEAD;
BlockLinkToNext(Previous); BlockLinkToNext(Previous);
@ -406,8 +377,6 @@ static block_header_t* MergeEmptyBlockDown(allocator_control_t* Controller, bloc
if (BlockPrevIsFree(Block)) { if (BlockPrevIsFree(Block)) {
block_header_t* Previous = BlockGetPrevious(Block); block_header_t* Previous = BlockGetPrevious(Block);
ASSERT(Previous, "MergeEmptyBlockDown: Previous block is null!");
ASSERT(BlockIsFree(Previous), "MergeEmptyBlockDown: Previous block is free!");
RemoveBlock(Controller, Previous); RemoveBlock(Controller, Previous);
Block = MergeBlockDown(Previous, Block); Block = MergeBlockDown(Previous, Block);
} }
@ -417,10 +386,8 @@ static block_header_t* MergeEmptyBlockDown(allocator_control_t* Controller, bloc
static block_header_t* MergeNextBlockDown(allocator_control_t* Controller, block_header_t* Block) { static block_header_t* MergeNextBlockDown(allocator_control_t* Controller, block_header_t* Block) {
block_header_t* NextBlock = BlockGetNext(Block); block_header_t* NextBlock = BlockGetNext(Block);
ASSERT(NextBlock, "MergeNextBlockDown: Next Block is null!");
if (BlockIsFree(NextBlock)) { if (BlockIsFree(NextBlock)) {
ASSERT(!BlockIsLast(Block), "MergeNextBlockDown: Current block is the last block!");
RemoveBlock(Controller, NextBlock); RemoveBlock(Controller, NextBlock);
Block = MergeBlockDown(Block, NextBlock); Block = MergeBlockDown(Block, NextBlock);
} }
@ -429,7 +396,6 @@ static block_header_t* MergeNextBlockDown(allocator_control_t* Controller, block
} }
static void TrimBlockFree(allocator_control_t* Controller, block_header_t* Block, size_t Size) { static void TrimBlockFree(allocator_control_t* Controller, block_header_t* Block, size_t Size) {
ASSERT(BlockIsFree(Block), "TrimBlockFree: Current block is wholly free!");
if (CanBlockSplit(Block, Size)) { if (CanBlockSplit(Block, Size)) {
block_header_t* RemainingBlock = SplitBlock(Block, Size); block_header_t* RemainingBlock = SplitBlock(Block, Size);
@ -443,8 +409,6 @@ static void TrimBlockFree(allocator_control_t* Controller, block_header_t* Block
} }
static void TrimBlockUsed(allocator_control_t* Controller, block_header_t* Block, size_t Size) { static void TrimBlockUsed(allocator_control_t* Controller, block_header_t* Block, size_t Size) {
ASSERT(!BlockIsFree(Block), "TrimBlockUsed: The current block is wholly used!");
if (CanBlockSplit(Block, Size)) { if (CanBlockSplit(Block, Size)) {
block_header_t* RemainingBlock = SplitBlock(Block, Size); block_header_t* RemainingBlock = SplitBlock(Block, Size);
@ -490,7 +454,6 @@ static block_header_t* LocateFreeBlock(allocator_control_t* Controller, size_t S
} }
if (Block) { if (Block) {
ASSERT(BlockSize(Block) >= Size, "LocateFreeBlock: Found a block that is too small!");
RemoveFreeBlock(Controller, Block, FirstLevel, SecondLevel); RemoveFreeBlock(Controller, Block, FirstLevel, SecondLevel);
} }
@ -501,7 +464,6 @@ static void* PrepareUsedBlock(allocator_control_t* Controller, block_header_t* B
void* Pointer = 0; void* Pointer = 0;
if (Block) { if (Block) {
ASSERT(Size, "PrepareUsedBlock: Size is 0!");
TrimBlockFree(Controller, Block, Size); TrimBlockFree(Controller, Block, Size);
BlockMarkUsed(Block); BlockMarkUsed(Block);
Pointer = WhereBlock(Block); Pointer = WhereBlock(Block);
@ -614,10 +576,6 @@ void RemovePoolFromAllocator(allocator_t Allocator, mempool_t Pool) {
int FirstLevel = 0, SecondLevel = 0; int FirstLevel = 0, SecondLevel = 0;
ASSERT(BlockIsFree(Block), "RemovePoolFromAllocator: Current block is free!");
ASSERT(!BlockIsFree(BlockGetNext(Block)), "RemovePoolFromAllocator: Next Block is not free!");
ASSERT(BlockSize(BlockGetNext(Block)) == 0, "RemovePoolFromAllocator: Next block is size 0!");
RoundUpBlockSize(BlockSize(Block), &FirstLevel, &SecondLevel); RoundUpBlockSize(BlockSize(Block), &FirstLevel, &SecondLevel);
RemoveFreeBlock(Controller, Block, FirstLevel, SecondLevel); RemoveFreeBlock(Controller, Block, FirstLevel, SecondLevel);
} }
@ -700,8 +658,6 @@ void* AllocatorMalign(allocator_t Allocator, size_t Alignment, size_t Size) {
block_header_t* Block = LocateFreeBlock(Controller, AlignedSize); block_header_t* Block = LocateFreeBlock(Controller, AlignedSize);
ASSERT(sizeof(block_header_t) == BLOCK_MIN_SIZE + BLOCK_OVERHEAD, "AllocatorMalign: Maths error!");
if (Block) { if (Block) {
void* Address = WhereBlock(Block); void* Address = WhereBlock(Block);
void* AlignedAddress = AlignPointer(Address, Alignment); void* AlignedAddress = AlignPointer(Address, Alignment);
@ -719,8 +675,6 @@ void* AllocatorMalign(allocator_t Allocator, size_t Alignment, size_t Size) {
Gap = CAST(size_t, CAST(ptrdiff_t, AlignedAddress) - CAST(ptrdiff_t, Address)); Gap = CAST(size_t, CAST(ptrdiff_t, AlignedAddress) - CAST(ptrdiff_t, Address));
} }
ASSERT(Gap >= MinimumGap, "AllocatorMalign: Maths error 2!");
Block = TrimBlockLeadingFree(Controller, Block, Gap); Block = TrimBlockLeadingFree(Controller, Block, Gap);
} }
@ -733,7 +687,6 @@ void AllocatorFree(allocator_t Allocator, void* Address) {
if (Address) { if (Address) {
allocator_control_t* Controller = CAST(allocator_control_t*, Allocator); allocator_control_t* Controller = CAST(allocator_control_t*, Allocator);
block_header_t* Block = WhichBlock(Address); block_header_t* Block = WhichBlock(Address);
ASSERT(!BlockIsFree(Block), "AllocatorFree: Attempting to free a freed block!");
BlockMarkFree(Block); BlockMarkFree(Block);
Block = MergeEmptyBlockDown(Controller, Block); Block = MergeEmptyBlockDown(Controller, Block);
@ -778,8 +731,6 @@ void* AllocatorRealloc(allocator_t Allocator, void* Address, size_t NewSize) {
const size_t AdjustedSize = AlignRequestSize(NewSize, ALIGN_SIZE); const size_t AdjustedSize = AlignRequestSize(NewSize, ALIGN_SIZE);
ASSERT(!BlockIsFree(Block), "AllocatorRealloc: Requested block is not free!");
if (AdjustedSize > CurrentSize && (!BlockIsFree(NextBlock) || AdjustedSize > CombinedSize)) { if (AdjustedSize > CurrentSize && (!BlockIsFree(NextBlock) || AdjustedSize > CombinedSize)) {
// We're going to need more room // We're going to need more room
@ -802,7 +753,3 @@ void* AllocatorRealloc(allocator_t Allocator, void* Address, size_t NewSize) {
return Pointer; return Pointer;
} }
#ifdef __cplusplus
}
#endif

8
src/system/memory/liballoc.cpp
View File

@ -3,10 +3,6 @@
/** Durand's Amazing Super Duper Memory functions. */ /** Durand's Amazing Super Duper Memory functions. */
#ifdef __cplusplus
extern "C" {
#endif
#define VERSION "1.1" #define VERSION "1.1"
#define ALIGNMENT 16ul//4ul ///< This is the byte alignment that memory must be allocated on. IMPORTANT for GTK and other stuff. #define ALIGNMENT 16ul//4ul ///< This is the byte alignment that memory must be allocated on. IMPORTANT for GTK and other stuff.
@ -814,10 +810,6 @@ void* PREFIX(realloc)(void* p, size_t size) {
return ptr; return ptr;
} }
#ifdef __cplusplus
}
#endif
void operator delete(void* addr, unsigned long __attribute__((unused)) size) { void operator delete(void* addr, unsigned long __attribute__((unused)) size) {
PREFIX(free)(addr); PREFIX(free)(addr);
} }

8
src/system/memory/paging.cpp
View File

@ -5,10 +5,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
#define PAGE_TABLES_GET_PDPT(address) \ #define PAGE_TABLES_GET_PDPT(address) \
(address & ((size_t) 0x1FF << 39)) >> 39 (address & ((size_t) 0x1FF << 39)) >> 39
#define PAGE_TABLES_GET_PDP(address) \ #define PAGE_TABLES_GET_PDP(address) \
@ -353,10 +349,6 @@ size_t* CreateNewPageTable(address_space_t* AddressSpace) {
return NewPML4; return NewPML4;
} }
#ifdef __cplusplus
}
#endif
void *operator new(size_t size) { void *operator new(size_t size) {
return kmalloc(size); return kmalloc(size);
} }

11
src/system/memory/physmem.c
View File

@ -1,17 +1,11 @@
#include <kernel/chroma.h> #include <kernel/chroma.h>
#include <lainlib/lainlib.h> #include <lainlib/lainlib.h>
/************************ /************************
*** Team Kitty, 2020 *** *** Team Kitty, 2020 ***
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file contains functions for physical memory management. /* This file contains functions for physical memory management.
* *
* Physical Memory Management is performed with Buddy List allocators, which are one of the most performant systems available. * Physical Memory Management is performed with Buddy List allocators, which are one of the most performant systems available.
@ -22,6 +16,9 @@ extern "C" {
* TODO: Document this mess. * TODO: Document this mess.
*/ */
#ifdef __cplusplus
extern "C" {
#endif
#define MIN_ORDER 3 #define MIN_ORDER 3
#define PEEK(type, address) (*((volatile type*)(address))) #define PEEK(type, address) (*((volatile type*)(address)))
@ -347,6 +344,6 @@ void* memset(void* dst, int src, size_t len) {
return dst; return dst;
} }
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

10
src/system/pci.cpp
View File

@ -5,10 +5,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file contains functions for accessing the PCI bus, /* This file contains functions for accessing the PCI bus,
* and devices contained wherein. * and devices contained wherein.
* *
@ -750,8 +746,4 @@ const char* PCIGetClassName(uint8_t DeviceClass) {
} }
return "Invalid device!"; return "Invalid device!";
} }
#ifdef __cplusplus
}
#endif

9
src/system/rw.cpp
View File

@ -5,10 +5,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file serves to allow us to communicate with the computer through raw I/O. /* This file serves to allow us to communicate with the computer through raw I/O.
* It provides interfaces for Ports and commonly used Registers (Control Registers, Model-Specific Registers, GDT, IDT..) * It provides interfaces for Ports and commonly used Registers (Control Registers, Model-Specific Registers, GDT, IDT..)
* *
@ -257,8 +253,3 @@ void WriteTSR(uint16_t TSRData) {
__asm__ __volatile__("ltr %[src]" : : [src] "m"(TSRData) :); __asm__ __volatile__("ltr %[src]" : : [src] "m"(TSRData) :);
} }
#ifdef __cplusplus
}
#endif

10
src/system/serial.cpp
View File

@ -4,10 +4,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file provides functions related to the Serial port. /* This file provides functions related to the Serial port.
* Through this file, you send and receive text and extra debugging information if available. * Through this file, you send and receive text and extra debugging information if available.
*/ */
@ -49,8 +45,4 @@ void WriteSerialString(const char* str, size_t len) {
for (size_t i = 0; i < len; i++) { for (size_t i = 0; i < len; i++) {
WriteSerialChar(str[i]); WriteSerialChar(str[i]);
} }
} }
#ifdef __cplusplus
}
#endif

8
src/video/draw.cpp
View File

@ -7,10 +7,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/** /**
* This file contains all of the draw-to-screen routines. * This file contains all of the draw-to-screen routines.
* It (currently; 23/08/20) handles the keyboard input test routine, * It (currently; 23/08/20) handles the keyboard input test routine,
@ -478,7 +474,3 @@ void DrawFilledCircle(size_t centerX, size_t centerY, size_t radius) {
DrawVerticalLine(centerX, centerY - radius, 2 * radius + 1); DrawVerticalLine(centerX, centerY - radius, 2 * radius + 1);
DrawFilledCircleInternal(centerX, centerY, radius, 3, 0); DrawFilledCircleInternal(centerX, centerY, radius, 3, 0);
} }
#ifdef __cplusplus
}
#endif

10
src/video/print.cpp
View File

@ -6,10 +6,6 @@
*** Chroma *** *** Chroma ***
***********************/ ***********************/
#ifdef __cplusplus
extern "C" {
#endif
/* This file contains all of the String / Print related functions /* This file contains all of the String / Print related functions
* that are required by the core of the kernel. * that are required by the core of the kernel.
* *
@ -36,7 +32,7 @@ void NumToStr(char* Buffer, size_t Num, size_t Base) {
} }
int SerialPrintf(const char* Format, ...) { extern "C" int SerialPrintf(const char* Format, ...) {
va_list Parameters; va_list Parameters;
va_start(Parameters, Format); va_start(Parameters, Format);
@ -283,7 +279,3 @@ size_t ParseHexColor(const char* Stream, bool bgFlag) {
} }
return val; return val;
} }
#ifdef __cplusplus
}
#endif