enderice2/Fennix
enderice2/Fennix
1
0
Fork 0
mirror of https://github.com/EnderIce2/Fennix.git synced 2025-05-28 15:34:31 +00:00
Code Issues Actions Releases Wiki Activity

refactor(kernel): change NIF to nif

Browse Source
This commit is contained in:
EnderIce2 2025-04-08 03:25:38 +00:00
parent 764dfe67a5
commit 69122746de
Signed by: enderice2
GPG Key ID: FEB6B8A8507BA62E
13 changed files with 87 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Kernel/arch/amd64/bootstrap/limine/limine.c
View File

@ -92,7 +92,7 @@ __naked __used __no_stack_protector void InitLimine()
asmv("jmp InitLimineAfterStack"); asmv("jmp InitLimineAfterStack");
} }
nsa NIF void InitLimineAfterStack() nsa nif void InitLimineAfterStack()
{ {
struct BootInfo binfo = {}; struct BootInfo binfo = {};
struct limine_bootloader_info_response *BootloaderInfoResponse = BootloaderInfoRequest.response; struct limine_bootloader_info_response *BootloaderInfoResponse = BootloaderInfoRequest.response;

24
Kernel/arch/amd64/bootstrap/multiboot/Paging/mb_64bit_map.cpp
View File

@ -38,14 +38,14 @@ union __attribute__((packed)) PageTableEntry
}; };
uint64_t raw; uint64_t raw;
__always_inline inline nsa NIF void SetAddress(uintptr_t _Address) __always_inline inline nsa nif void SetAddress(uintptr_t _Address)
{ {
_Address &= 0x000000FFFFFFFFFF; _Address &= 0x000000FFFFFFFFFF;
this->raw &= 0xFFF0000000000FFF; this->raw &= 0xFFF0000000000FFF;
this->raw |= (_Address << 12); this->raw |= (_Address << 12);
} }
__always_inline inline nsa NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; } __always_inline inline nsa nif uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
}; };
struct __attribute__((packed)) PageTableEntryPtr struct __attribute__((packed)) PageTableEntryPtr
@ -72,14 +72,14 @@ union __attribute__((packed)) PageDirectoryEntry
}; };
uint64_t raw; uint64_t raw;
__always_inline inline nsa NIF void SetAddress(uintptr_t _Address) __always_inline inline nsa nif void SetAddress(uintptr_t _Address)
{ {
_Address &= 0x000000FFFFFFFFFF; _Address &= 0x000000FFFFFFFFFF;
this->raw &= 0xFFF0000000000FFF; this->raw &= 0xFFF0000000000FFF;
this->raw |= (_Address << 12); this->raw |= (_Address << 12);
} }
__always_inline inline nsa NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; } __always_inline inline nsa nif uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
}; };
struct __attribute__((packed)) PageDirectoryEntryPtr struct __attribute__((packed)) PageDirectoryEntryPtr
@ -106,14 +106,14 @@ union __attribute__((packed)) PageDirectoryPointerTableEntry
}; };
uint64_t raw; uint64_t raw;
__always_inline inline nsa NIF void SetAddress(uintptr_t _Address) __always_inline inline nsa nif void SetAddress(uintptr_t _Address)
{ {
_Address &= 0x000000FFFFFFFFFF; _Address &= 0x000000FFFFFFFFFF;
this->raw &= 0xFFF0000000000FFF; this->raw &= 0xFFF0000000000FFF;
this->raw |= (_Address << 12); this->raw |= (_Address << 12);
} }
__always_inline inline nsa NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; } __always_inline inline nsa nif uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
}; };
struct __attribute__((packed)) PageDirectoryPointerTableEntryPtr struct __attribute__((packed)) PageDirectoryPointerTableEntryPtr
@ -140,14 +140,14 @@ union __attribute__((packed)) PageMapLevel4
}; };
uint64_t raw; uint64_t raw;
__always_inline inline nsa NIF void SetAddress(uintptr_t _Address) __always_inline inline nsa nif void SetAddress(uintptr_t _Address)
{ {
_Address &= 0x000000FFFFFFFFFF; _Address &= 0x000000FFFFFFFFFF;
this->raw &= 0xFFF0000000000FFF; this->raw &= 0xFFF0000000000FFF;
this->raw |= (_Address << 12); this->raw |= (_Address << 12);
} }
__always_inline inline nsa NIF uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; } __always_inline inline nsa nif uintptr_t GetAddress() { return (this->raw & 0x000FFFFFFFFFF000) >> 12; }
}; };
struct PageTable4 struct PageTable4
@ -161,7 +161,7 @@ extern uintptr_t _kernel_start, _kernel_end;
__attribute__((section(".bootstrap.data"))) static PageTable4 *BPTable = (PageTable4 *)BootPageTable; __attribute__((section(".bootstrap.data"))) static PageTable4 *BPTable = (PageTable4 *)BootPageTable;
__attribute__((section(".bootstrap.data"))) static size_t BPT_Allocated = 0x4000; __attribute__((section(".bootstrap.data"))) static size_t BPT_Allocated = 0x4000;
__always_inline inline nsa NIF void *RequestPage() __always_inline inline nsa nif void *RequestPage()
{ {
void *Page = (void *)(BootPageTable + BPT_Allocated); void *Page = (void *)(BootPageTable + BPT_Allocated);
BPT_Allocated += 0x1000; BPT_Allocated += 0x1000;
@ -180,7 +180,7 @@ public:
uintptr_t PDPTEIndex = 0; uintptr_t PDPTEIndex = 0;
uintptr_t PDEIndex = 0; uintptr_t PDEIndex = 0;
uintptr_t PTEIndex = 0; uintptr_t PTEIndex = 0;
__always_inline inline nsa NIF PageMapIndexer(uintptr_t VirtualAddress) __always_inline inline nsa nif PageMapIndexer(uintptr_t VirtualAddress)
{ {
uintptr_t Address = VirtualAddress; uintptr_t Address = VirtualAddress;
Address >>= 12; Address >>= 12;
@ -194,7 +194,7 @@ public:
} }
}; };
__attribute__((section(".bootstrap.text"))) nsa NIF void MB2_64_Map(void *VirtualAddress, void *PhysicalAddress, uint64_t Flags) __attribute__((section(".bootstrap.text"))) nsa nif void MB2_64_Map(void *VirtualAddress, void *PhysicalAddress, uint64_t Flags)
{ {
PageMapIndexer Index = PageMapIndexer((uintptr_t)VirtualAddress); PageMapIndexer Index = PageMapIndexer((uintptr_t)VirtualAddress);
// Clear any flags that are not 1 << 0 (Present) - 1 << 5 (Accessed) because rest are for page table entries only // Clear any flags that are not 1 << 0 (Present) - 1 << 5 (Accessed) because rest are for page table entries only
@ -280,7 +280,7 @@ __attribute__((section(".bootstrap.text"))) nsa NIF void MB2_64_Map(void *Virtua
: "memory"); : "memory");
} }
EXTERNC __attribute__((section(".bootstrap.text"))) nsa NIF __attribute__((section(".bootstrap.text"))) void UpdatePageTable64() EXTERNC __attribute__((section(".bootstrap.text"))) nsa nif __attribute__((section(".bootstrap.text"))) void UpdatePageTable64()
{ {
BPTable = (PageTable4 *)BootPageTable; BPTable = (PageTable4 *)BootPageTable;

20
Kernel/core/debugger.cpp
View File

@ -27,12 +27,12 @@ NewLock(DebuggerLock);
extern bool serialports[8]; extern bool serialports[8];
EXTERNC NIF void uart_wrapper(char c, void *) EXTERNC nif void uart_wrapper(char c, void *)
{ {
uart.DebugWrite(c); uart.DebugWrite(c);
} }
static inline NIF bool WritePrefix(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, va_list args) static inline nif bool WritePrefix(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, va_list args)
{ {
const char *DbgLvlString; const char *DbgLvlString;
switch (Level) switch (Level)
@ -79,7 +79,7 @@ static inline NIF bool WritePrefix(DebugLevel Level, const char *File, int Line,
namespace SysDbg namespace SysDbg
{ {
NIF void Write(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) nif void Write(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
va_list args; va_list args;
va_start(args, Format); va_start(args, Format);
@ -92,7 +92,7 @@ namespace SysDbg
va_end(args); va_end(args);
} }
NIF void WriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) nif void WriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
va_list args; va_list args;
va_start(args, Format); va_start(args, Format);
@ -106,7 +106,7 @@ namespace SysDbg
uart_wrapper('\n', nullptr); uart_wrapper('\n', nullptr);
} }
NIF void LockedWrite(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) nif void LockedWrite(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
SmartTimeoutLock(DebuggerLock, 1000); SmartTimeoutLock(DebuggerLock, 1000);
va_list args; va_list args;
@ -120,7 +120,7 @@ namespace SysDbg
va_end(args); va_end(args);
} }
NIF void LockedWriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) nif void LockedWriteLine(DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
SmartTimeoutLock(DebuggerLock, 1000); SmartTimeoutLock(DebuggerLock, 1000);
va_list args; va_list args;
@ -137,7 +137,7 @@ namespace SysDbg
} }
// C compatibility // C compatibility
extern "C" NIF void SysDbgWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) extern "C" nif void SysDbgWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
va_list args; va_list args;
va_start(args, Format); va_start(args, Format);
@ -151,7 +151,7 @@ extern "C" NIF void SysDbgWrite(enum DebugLevel Level, const char *File, int Lin
} }
// C compatibility // C compatibility
extern "C" NIF void SysDbgWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) extern "C" nif void SysDbgWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
va_list args; va_list args;
va_start(args, Format); va_start(args, Format);
@ -166,7 +166,7 @@ extern "C" NIF void SysDbgWriteLine(enum DebugLevel Level, const char *File, int
} }
// C compatibility // C compatibility
extern "C" NIF void SysDbgLockedWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) extern "C" nif void SysDbgLockedWrite(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
SmartTimeoutLock(DebuggerLock, 1000); SmartTimeoutLock(DebuggerLock, 1000);
va_list args; va_list args;
@ -181,7 +181,7 @@ extern "C" NIF void SysDbgLockedWrite(enum DebugLevel Level, const char *File, i
} }
// C compatibility // C compatibility
extern "C" NIF void SysDbgLockedWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...) extern "C" nif void SysDbgLockedWriteLine(enum DebugLevel Level, const char *File, int Line, const char *Function, const char *Format, ...)
{ {
SmartTimeoutLock(DebuggerLock, 1000); SmartTimeoutLock(DebuggerLock, 1000);
va_list args; va_list args;

12
Kernel/core/memory/memory.cpp
View File

@ -52,7 +52,7 @@ Xalloc::V1 *XallocV1Allocator = nullptr;
Xalloc::V2 *XallocV2Allocator = nullptr; Xalloc::V2 *XallocV2Allocator = nullptr;
#ifdef DEBUG #ifdef DEBUG
NIF void tracepagetable(PageTable *pt) nif void tracepagetable(PageTable *pt)
{ {
for (int i = 0; i < 512; i++) for (int i = 0; i < 512; i++)
{ {
@ -71,7 +71,7 @@ NIF void tracepagetable(PageTable *pt)
} }
#endif #endif
NIF void MapEntries(PageTable *PT) nif void MapEntries(PageTable *PT)
{ {
debug("mapping %d memory entries", bInfo.Memory.Entries); debug("mapping %d memory entries", bInfo.Memory.Entries);
Virtual vmm = Virtual(PT); Virtual vmm = Virtual(PT);
@ -89,7 +89,7 @@ NIF void MapEntries(PageTable *PT)
vmm.Unmap((void *)0); vmm.Unmap((void *)0);
} }
NIF void MapFramebuffer(PageTable *PT) nif void MapFramebuffer(PageTable *PT)
{ {
debug("Mapping Framebuffer"); debug("Mapping Framebuffer");
Virtual vmm = Virtual(PT); Virtual vmm = Virtual(PT);
@ -123,7 +123,7 @@ NIF void MapFramebuffer(PageTable *PT)
} }
} }
NIF void MapKernel(PageTable *PT) nif void MapKernel(PageTable *PT)
{ {
debug("Mapping Kernel"); debug("Mapping Kernel");
@ -237,7 +237,7 @@ NIF void MapKernel(PageTable *PT)
info("Cannot determine kernel file address. Ignoring."); info("Cannot determine kernel file address. Ignoring.");
} }
NIF void CreatePageTable(PageTable *pt) nif void CreatePageTable(PageTable *pt)
{ {
static int check_cpuid = 0; static int check_cpuid = 0;
@ -286,7 +286,7 @@ NIF void CreatePageTable(PageTable *pt)
#endif #endif
} }
NIF void InitializeMemoryManagement() nif void InitializeMemoryManagement()
{ {
#ifdef DEBUG #ifdef DEBUG
#ifndef __i386__ #ifndef __i386__

2
Kernel/core/symbols.cpp
View File

@ -26,7 +26,7 @@
namespace SymbolResolver namespace SymbolResolver
{ {
const NIF char *Symbols::GetSymbol(uintptr_t Address) const nif char *Symbols::GetSymbol(uintptr_t Address)
{ {
SymbolTable Result{}; SymbolTable Result{};

2
Kernel/include/types.h
View File

@ -461,7 +461,7 @@ typedef uint48_t uint_fast48_t;
#define NoSecurityAnalysis __no_stack_protector __no_sanitize_address __no_sanitize_undefined __no_sanitize_thread #define NoSecurityAnalysis __no_stack_protector __no_sanitize_address __no_sanitize_undefined __no_sanitize_thread
#define nsa NoSecurityAnalysis #define nsa NoSecurityAnalysis
#define NIF __no_instrument_function #define nif __no_instrument_function
#define int3 \ #define int3 \
__asm__ __volatile__("int3" \ __asm__ __volatile__("int3" \

6
Kernel/kernel.cpp
View File

@ -33,7 +33,6 @@
#include "tests/t.h" #include "tests/t.h"
bool DebuggerIsAttached = false; bool DebuggerIsAttached = false;
extern bool EnableProfiler;
NewLock(KernelLock); NewLock(KernelLock);
__aligned(16) BootInfo bInfo{}; __aligned(16) BootInfo bInfo{};
@ -117,7 +116,7 @@ EXTERNC void KPrint(const char *Format, ...)
#endif #endif
} }
EXTERNC NIF cold void Main() EXTERNC nif cold void Main()
{ {
Display = new Video::Display(bInfo.Framebuffer[0]); Display = new Video::Display(bInfo.Framebuffer[0]);
KernelConsole::EarlyInit(); KernelConsole::EarlyInit();
@ -259,7 +258,7 @@ typedef void (*CallPtr)(void);
extern CallPtr __init_array_start[0], __init_array_end[0]; extern CallPtr __init_array_start[0], __init_array_end[0];
extern CallPtr __fini_array_start[0], __fini_array_end[0]; extern CallPtr __fini_array_start[0], __fini_array_end[0];
EXTERNC __no_stack_protector NIF cold void Entry(BootInfo *Info) EXTERNC __no_stack_protector nif cold void Entry(BootInfo *Info)
{ {
memcpy(&bInfo, Info, sizeof(BootInfo)); memcpy(&bInfo, Info, sizeof(BootInfo));
@ -352,7 +351,6 @@ EXTERNC __no_stack_protector NIF cold void Entry(BootInfo *Info)
#warning "FIXME: Test_stl() is not implemented for other architectures" #warning "FIXME: Test_stl() is not implemented for other architectures"
#endif #endif
#endif // DEBUG #endif // DEBUG
EnableProfiler = true;
Main(); Main();
} }

2
Kernel/kernel_vfs.cpp
View File

@ -49,7 +49,7 @@ void SearchForInitrd()
} }
} }
EXTERNC NIF void KernelVFS() EXTERNC nif void KernelVFS()
{ {
KPrint("Initializing Virtual File System"); KPrint("Initializing Virtual File System");

62
Kernel/library/printf.c
View File

@ -268,14 +268,14 @@ typedef union
// 1. Some compilers are finicky about this; // 1. Some compilers are finicky about this;
// 2. Some people may want to convert this to C89; // 2. Some people may want to convert this to C89;
// 3. If you try to use it as C++, only C++20 supports compound literals // 3. If you try to use it as C++, only C++20 supports compound literals
static inline NIF double_with_bit_access get_bit_access(double x) static inline nif double_with_bit_access get_bit_access(double x)
{ {
double_with_bit_access dwba; double_with_bit_access dwba;
dwba.F = x; dwba.F = x;
return dwba; return dwba;
} }
static inline NIF int get_sign_bit(double x) static inline nif int get_sign_bit(double x)
{ {
// The sign is stored in the highest bit // The sign is stored in the highest bit
return (int)(get_bit_access(x).U >> (DOUBLE_SIZE_IN_BITS - 1)); return (int)(get_bit_access(x).U >> (DOUBLE_SIZE_IN_BITS - 1));
@ -319,7 +319,7 @@ typedef struct
// or alternatively, that '\0' can be passed to the function in the output // or alternatively, that '\0' can be passed to the function in the output
// gadget. The former assumption holds within the printf library. It also // gadget. The former assumption holds within the printf library. It also
// assumes that the output gadget has been properly initialized. // assumes that the output gadget has been properly initialized.
static inline NIF void putchar_via_gadget(output_gadget_t *gadget, char c) static inline nif void putchar_via_gadget(output_gadget_t *gadget, char c)
{ {
printf_size_t write_pos = gadget->pos++; printf_size_t write_pos = gadget->pos++;
// We're _always_ increasing pos, so as to count how may characters // We're _always_ increasing pos, so as to count how may characters
@ -342,7 +342,7 @@ static inline NIF void putchar_via_gadget(output_gadget_t *gadget, char c)
} }
// Possibly-write the string-terminating '\0' character // Possibly-write the string-terminating '\0' character
static inline NIF void append_termination_with_gadget(output_gadget_t *gadget) static inline nif void append_termination_with_gadget(output_gadget_t *gadget)
{ {
if (gadget->function != NULL || gadget->max_chars == 0) if (gadget->function != NULL || gadget->max_chars == 0)
{ {
@ -360,13 +360,13 @@ extern void putchar(char c);
// We can't use putchar_ as is, since our output gadget // We can't use putchar_ as is, since our output gadget
// only takes pointers to functions with an extra argument // only takes pointers to functions with an extra argument
static inline NIF void putchar_wrapper(char c, void *unused) static inline nif void putchar_wrapper(char c, void *unused)
{ {
putchar(c); putchar(c);
UNUSED(unused); UNUSED(unused);
} }
static inline NIF output_gadget_t discarding_gadget(void) static inline nif output_gadget_t discarding_gadget(void)
{ {
output_gadget_t gadget; output_gadget_t gadget;
gadget.function = NULL; gadget.function = NULL;
@ -377,7 +377,7 @@ static inline NIF output_gadget_t discarding_gadget(void)
return gadget; return gadget;
} }
static inline NIF output_gadget_t buffer_gadget(char *buffer, size_t buffer_size) static inline nif output_gadget_t buffer_gadget(char *buffer, size_t buffer_size)
{ {
printf_size_t usable_buffer_size = (buffer_size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ? PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printf_size_t)buffer_size; printf_size_t usable_buffer_size = (buffer_size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ? PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printf_size_t)buffer_size;
output_gadget_t result = discarding_gadget(); output_gadget_t result = discarding_gadget();
@ -389,7 +389,7 @@ static inline NIF output_gadget_t buffer_gadget(char *buffer, size_t buffer_size
return result; return result;
} }
static inline NIF output_gadget_t function_gadget(void (*function)(char, void *), void *extra_arg) static inline nif output_gadget_t function_gadget(void (*function)(char, void *), void *extra_arg)
{ {
output_gadget_t result = discarding_gadget(); output_gadget_t result = discarding_gadget();
result.function = function; result.function = function;
@ -398,7 +398,7 @@ static inline NIF output_gadget_t function_gadget(void (*function)(char, void *)
return result; return result;
} }
static inline NIF output_gadget_t extern_putchar_gadget(void) static inline nif output_gadget_t extern_putchar_gadget(void)
{ {
return function_gadget(putchar_wrapper, NULL); return function_gadget(putchar_wrapper, NULL);
} }
@ -407,7 +407,7 @@ static inline NIF output_gadget_t extern_putchar_gadget(void)
// @return The length of the string (excluding the terminating 0) limited by 'maxsize' // @return The length of the string (excluding the terminating 0) limited by 'maxsize'
// @note strlen uses size_t, but wes only use this function with printf_size_t // @note strlen uses size_t, but wes only use this function with printf_size_t
// variables - hence the signature. // variables - hence the signature.
static inline NIF printf_size_t strnlen_s_(const char *str, printf_size_t maxsize) static inline nif printf_size_t strnlen_s_(const char *str, printf_size_t maxsize)
{ {
const char *s; const char *s;
for (s = str; *s && maxsize--; ++s) for (s = str; *s && maxsize--; ++s)
@ -417,13 +417,13 @@ static inline NIF printf_size_t strnlen_s_(const char *str, printf_size_t maxsiz
// internal test if char is a digit (0-9) // internal test if char is a digit (0-9)
// @return true if char is a digit // @return true if char is a digit
static inline NIF bool is_digit_(char ch) static inline nif bool is_digit_(char ch)
{ {
return (ch >= '0') && (ch <= '9'); return (ch >= '0') && (ch <= '9');
} }
// internal ASCII string to printf_size_t conversion // internal ASCII string to printf_size_t conversion
static NIF printf_size_t atou_(const char **str) static nif printf_size_t atou_(const char **str)
{ {
printf_size_t i = 0U; printf_size_t i = 0U;
while (is_digit_(**str)) while (is_digit_(**str))
@ -434,7 +434,7 @@ static NIF printf_size_t atou_(const char **str)
} }
// output the specified string in reverse, taking care of any zero-padding // output the specified string in reverse, taking care of any zero-padding
static NIF void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len, printf_size_t width, printf_flags_t flags) static nif void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len, printf_size_t width, printf_flags_t flags)
{ {
const printf_size_t start_pos = output->pos; const printf_size_t start_pos = output->pos;
@ -465,7 +465,7 @@ static NIF void out_rev_(output_gadget_t *output, const char *buf, printf_size_t
// Invoked by print_integer after the actual number has been printed, performing necessary // Invoked by print_integer after the actual number has been printed, performing necessary
// work on the number's prefix (as the number is initially printed in reverse order) // work on the number's prefix (as the number is initially printed in reverse order)
static NIF void print_integer_finalization(output_gadget_t *output, char *buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) static nif void print_integer_finalization(output_gadget_t *output, char *buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
{ {
printf_size_t unpadded_len = len; printf_size_t unpadded_len = len;
@ -549,7 +549,7 @@ static NIF void print_integer_finalization(output_gadget_t *output, char *buf, p
} }
// An internal itoa-like function // An internal itoa-like function
static NIF void print_integer(output_gadget_t *output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) static nif void print_integer(output_gadget_t *output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
{ {
char buf[PRINTF_INTEGER_BUFFER_SIZE]; char buf[PRINTF_INTEGER_BUFFER_SIZE];
printf_size_t len = 0U; printf_size_t len = 0U;
@ -608,7 +608,7 @@ static const double powers_of_10[NUM_DECIMAL_DIGITS_IN_INT64_T] = {
// Break up a double number - which is known to be a finite non-negative number - // Break up a double number - which is known to be a finite non-negative number -
// into its base-10 parts: integral - before the decimal point, and fractional - after it. // into its base-10 parts: integral - before the decimal point, and fractional - after it.
// Taken the precision into account, but does not change it even internally. // Taken the precision into account, but does not change it even internally.
static struct NIF double_components get_components(double number, printf_size_t precision) static struct nif double_components get_components(double number, printf_size_t precision)
{ {
struct double_components number_; struct double_components number_;
number_.is_negative = get_sign_bit(number); number_.is_negative = get_sign_bit(number);
@ -745,7 +745,7 @@ static struct double_components get_normalized_components(bool negative, printf_
} }
#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS #endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
static NIF void print_broken_up_decimal( static nif void print_broken_up_decimal(
struct double_components number_, output_gadget_t *output, printf_size_t precision, struct double_components number_, output_gadget_t *output, printf_size_t precision,
printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{ {
@ -847,7 +847,7 @@ static NIF void print_broken_up_decimal(
} }
// internal ftoa for fixed decimal floating point // internal ftoa for fixed decimal floating point
static NIF void print_decimal_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) static nif void print_decimal_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{ {
struct double_components value_ = get_components(number, precision); struct double_components value_ = get_components(number, precision);
print_broken_up_decimal(value_, output, precision, width, flags, buf, len); print_broken_up_decimal(value_, output, precision, width, flags, buf, len);
@ -920,7 +920,7 @@ static double pow10_of_int(int floored_exp10)
return dwba.F; return dwba.F;
} }
static NIF void print_exponential_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) static nif void print_exponential_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{ {
const bool negative = get_sign_bit(number); const bool negative = get_sign_bit(number);
// This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it // This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it
@ -1043,7 +1043,7 @@ static NIF void print_exponential_number(output_gadget_t *output, double number,
} }
#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS #endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
static NIF void print_floating_point(output_gadget_t *output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential) static nif void print_floating_point(output_gadget_t *output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential)
{ {
char buf[PRINTF_DECIMAL_BUFFER_SIZE]; char buf[PRINTF_DECIMAL_BUFFER_SIZE];
printf_size_t len = 0U; printf_size_t len = 0U;
@ -1102,7 +1102,7 @@ static NIF void print_floating_point(output_gadget_t *output, double value, prin
// Advances the format pointer past the flags, and returns the parsed flags // Advances the format pointer past the flags, and returns the parsed flags
// due to the characters passed // due to the characters passed
static NIF printf_flags_t parse_flags(const char **format) static nif printf_flags_t parse_flags(const char **format)
{ {
printf_flags_t flags = 0U; printf_flags_t flags = 0U;
do do
@ -1135,7 +1135,7 @@ static NIF printf_flags_t parse_flags(const char **format)
} while (true); } while (true);
} }
static inline NIF void format_string_loop(output_gadget_t *output, const char *format, va_list args) static inline nif void format_string_loop(output_gadget_t *output, const char *format, va_list args)
{ {
#if PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER #if PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER
#define ADVANCE_IN_FORMAT_STRING(cptr_) \ #define ADVANCE_IN_FORMAT_STRING(cptr_) \
@ -1517,7 +1517,7 @@ static inline NIF void format_string_loop(output_gadget_t *output, const char *f
} }
// internal vsnprintf - used for implementing _all library functions // internal vsnprintf - used for implementing _all library functions
static NIF int vsnprintf_impl(output_gadget_t *output, const char *format, va_list args) static nif int vsnprintf_impl(output_gadget_t *output, const char *format, va_list args)
{ {
// Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is // Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is
// possible to call this function with a non-zero pos value for some "remedial printing". // possible to call this function with a non-zero pos value for some "remedial printing".
@ -1532,30 +1532,30 @@ static NIF int vsnprintf_impl(output_gadget_t *output, const char *format, va_li
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
NIF int vprintf(const char *format, va_list arg) nif int vprintf(const char *format, va_list arg)
{ {
output_gadget_t gadget = extern_putchar_gadget(); output_gadget_t gadget = extern_putchar_gadget();
return vsnprintf_impl(&gadget, format, arg); return vsnprintf_impl(&gadget, format, arg);
} }
NIF int vsnprintf(char *s, size_t n, const char *format, va_list arg) nif int vsnprintf(char *s, size_t n, const char *format, va_list arg)
{ {
output_gadget_t gadget = buffer_gadget(s, n); output_gadget_t gadget = buffer_gadget(s, n);
return vsnprintf_impl(&gadget, format, arg); return vsnprintf_impl(&gadget, format, arg);
} }
NIF int vsprintf(char *s, const char *format, va_list arg) nif int vsprintf(char *s, const char *format, va_list arg)
{ {
return vsnprintf(s, PRINTF_MAX_POSSIBLE_BUFFER_SIZE, format, arg); return vsnprintf(s, PRINTF_MAX_POSSIBLE_BUFFER_SIZE, format, arg);
} }
NIF int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg) nif int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg)
{ {
output_gadget_t gadget = function_gadget(out, extra_arg); output_gadget_t gadget = function_gadget(out, extra_arg);
return vsnprintf_impl(&gadget, format, arg); return vsnprintf_impl(&gadget, format, arg);
} }
NIF int printf(const char *format, ...) nif int printf(const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
@ -1564,7 +1564,7 @@ NIF int printf(const char *format, ...)
return ret; return ret;
} }
NIF int sprintf(char *s, const char *format, ...) nif int sprintf(char *s, const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
@ -1573,7 +1573,7 @@ NIF int sprintf(char *s, const char *format, ...)
return ret; return ret;
} }
NIF int snprintf(char *s, size_t n, const char *format, ...) nif int snprintf(char *s, size_t n, const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
@ -1582,7 +1582,7 @@ NIF int snprintf(char *s, size_t n, const char *format, ...)
return ret; return ret;
} }
NIF int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...) nif int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);

92
Kernel/profiling/cyg.cpp
View File

@ -16,95 +16,15 @@
*/ */
#include <types.h> #include <types.h>
#include <printf.h>
#include <uart.hpp>
#include "../kernel.h" EXTERNC nsa nif void __cyg_profile_func_enter(void *this_fn, void *call_site)
bool EnableProfiler = false;
bool Wait = false;
unsigned long long LogDepth = 0;
unsigned int Level = 0;
static inline nsa NIF void profiler_uart_wrapper(char c, void *unused)
{ {
bool renable = EnableProfiler; UNUSED(this_fn);
EnableProfiler = false; UNUSED(call_site);
UNUSED(unused);
if (renable)
EnableProfiler = true;
} }
EXTERNC nsa NIF void __cyg_profile_func_enter(void *Function, void *CallSite) EXTERNC nsa nif void __cyg_profile_func_exit(void *this_fn, void *call_site)
{ {
if (!EnableProfiler) UNUSED(this_fn);
return; UNUSED(call_site);
while (Wait)
#if defined(__amd64__) || defined(__i386__)
asmv("pause");
#elif defined(__aarch64__)
asmv("yield");
#endif
Wait = true;
if (Level > 40)
Level--;
Level++;
if (!KernelSymbolTable)
fctprintf(profiler_uart_wrapper, nullptr, "%lld [%02d]: \033[42m->\033[0m%*c \033[33m%p\033[0m - \033[33m%p\033[0m\n",
LogDepth++,
Level - 1,
Level,
' ',
Function,
CallSite);
else
fctprintf(profiler_uart_wrapper, nullptr, "%lld [%02d]: \033[42m->\033[0m%*c \033[33m%s\033[0m - \033[33m%s\033[0m\n",
LogDepth++,
Level - 1,
Level,
' ',
KernelSymbolTable->GetSymbol((uintptr_t)Function),
KernelSymbolTable->GetSymbol((uintptr_t)CallSite));
Wait = false;
}
EXTERNC nsa NIF void __cyg_profile_func_exit(void *Function, void *CallSite)
{
if (!EnableProfiler)
return;
while (Wait)
#if defined(__amd64__) || defined(__i386__)
asmv("pause");
#elif defined(__aarch64__)
asmv("yield");
#endif
Wait = true;
if (Level > 40)
Level--;
Level--;
if (!KernelSymbolTable)
fctprintf(profiler_uart_wrapper, nullptr, "%lld [%02d]: \033[41m<-\033[0m%*c \033[33m%p\033[0m - \033[33m%p\033[0m\n",
LogDepth++,
Level - 1,
Level,
' ',
Function,
CallSite);
else
fctprintf(profiler_uart_wrapper, nullptr, "%lld [%02d]: \033[41m<-\033[0m%*c \033[33m%s\033[0m - \033[33m%s\033[0m\n",
LogDepth++,
Level - 1,
Level,
' ',
KernelSymbolTable->GetSymbol((uintptr_t)Function),
KernelSymbolTable->GetSymbol((uintptr_t)CallSite));
Wait = false;
} }

23
Kernel/profiling/gcov.cpp
View File

@ -16,10 +16,6 @@
*/ */
#include <types.h> #include <types.h>
#include <printf.h>
#include <uart.hpp>
#include "../kernel.h"
#if BITS_PER_LONG >= 64 #if BITS_PER_LONG >= 64
typedef long gcov_type; typedef long gcov_type;
@ -53,33 +49,26 @@ struct gcov_info
struct gcov_ctr_info counts[0]; struct gcov_ctr_info counts[0];
}; };
static inline nsa NIF void gcov_uart_wrapper(char c, void *unused) EXTERNC nsa nif void __gcov_init(gcov_info *info)
{ {
UNUSED(c); UNUSED(info);
UNUSED(unused);
} }
// TODO: Implement EXTERNC nsa nif void __gcov_exit(void)
EXTERNC nsa NIF void __gcov_init(gcov_info *p __unused)
{ {
} }
EXTERNC nsa NIF void __gcov_exit(void) EXTERNC nsa nif void __gcov_flush(void)
{ {
} }
EXTERNC nsa NIF void __gcov_flush(void) EXTERNC nsa nif void __gcov_merge_add(gcov_type *counters, unsigned int n_counters)
{
}
EXTERNC nsa NIF void __gcov_merge_add(gcov_type *counters, unsigned int n_counters)
{ {
UNUSED(counters); UNUSED(counters);
UNUSED(n_counters); UNUSED(n_counters);
} }
EXTERNC nsa NIF void __gcov_merge_single(gcov_type *counters, unsigned int n_counters) EXTERNC nsa nif void __gcov_merge_single(gcov_type *counters, unsigned int n_counters)
{ {
UNUSED(counters); UNUSED(counters);
UNUSED(n_counters); UNUSED(n_counters);

12
Kernel/profiling/gprof.cpp
View File

@ -16,18 +16,8 @@
*/ */
#include <types.h> #include <types.h>
#include <printf.h>
#include <uart.hpp>
#include "../kernel.h" EXTERNC nsa nif void mcount(void *frompc, size_t selfpc)
static inline nsa NIF void gprof_uart_wrapper(char c, void *unused)
{
UNUSED(c);
UNUSED(unused);
}
EXTERNC nsa NIF void mcount(unsigned long frompc, unsigned long selfpc)
{ {
// TODO: Implement // TODO: Implement
/* https://docs.kernel.org/trace/ftrace-design.html */ /* https://docs.kernel.org/trace/ftrace-design.html */

18
Kernel/tasking/scheduler/custom.cpp
View File

@ -300,7 +300,7 @@ namespace Tasking::Scheduler
Info->KernelTime += TimePassed; Info->KernelTime += TimePassed;
} }
hot nsa NIF bool Custom::FindNewProcess(void *CPUDataPointer) hot nsa nif bool Custom::FindNewProcess(void *CPUDataPointer)
{ {
CPUData *CurrentCPU = (CPUData *)CPUDataPointer; CPUData *CurrentCPU = (CPUData *)CPUDataPointer;
fnp_schedbg("%d processes", ProcessList.size()); fnp_schedbg("%d processes", ProcessList.size());
@ -347,7 +347,7 @@ namespace Tasking::Scheduler
return false; return false;
} }
hot nsa NIF bool Custom::GetNextAvailableThread(void *CPUDataPointer) hot nsa nif bool Custom::GetNextAvailableThread(void *CPUDataPointer)
{ {
CPUData *CurrentCPU = (CPUData *)CPUDataPointer; CPUData *CurrentCPU = (CPUData *)CPUDataPointer;
@ -399,7 +399,7 @@ namespace Tasking::Scheduler
return false; return false;
} }
hot nsa NIF bool Custom::GetNextAvailableProcess(void *CPUDataPointer) hot nsa nif bool Custom::GetNextAvailableProcess(void *CPUDataPointer)
{ {
CPUData *CurrentCPU = (CPUData *)CPUDataPointer; CPUData *CurrentCPU = (CPUData *)CPUDataPointer;
@ -447,7 +447,7 @@ namespace Tasking::Scheduler
return false; return false;
} }
hot nsa NIF bool Custom::SchedulerSearchProcessThread(void *CPUDataPointer) hot nsa nif bool Custom::SchedulerSearchProcessThread(void *CPUDataPointer)
{ {
CPUData *CurrentCPU = (CPUData *)CPUDataPointer; CPUData *CurrentCPU = (CPUData *)CPUDataPointer;
@ -480,7 +480,7 @@ namespace Tasking::Scheduler
return false; return false;
} }
nsa NIF void Custom::UpdateProcessState() nsa nif void Custom::UpdateProcessState()
{ {
for (auto process : ProcessList) for (auto process : ProcessList)
{ {
@ -513,7 +513,7 @@ namespace Tasking::Scheduler
} }
} }
nsa NIF void Custom::WakeUpThreads() nsa nif void Custom::WakeUpThreads()
{ {
for (auto process : ProcessList) for (auto process : ProcessList)
{ {
@ -547,7 +547,7 @@ namespace Tasking::Scheduler
} }
} }
nsa NIF void Custom::CleanupTerminated() nsa nif void Custom::CleanupTerminated()
{ {
for (auto pcb : ProcessList) for (auto pcb : ProcessList)
{ {
@ -566,7 +566,7 @@ namespace Tasking::Scheduler
} }
} }
hot nsa NIF void Custom::Schedule(CPU::SchedulerFrame *Frame) hot nsa nif void Custom::Schedule(CPU::SchedulerFrame *Frame)
{ {
if (unlikely(StopScheduler)) if (unlikely(StopScheduler))
{ {
@ -723,7 +723,7 @@ namespace Tasking::Scheduler
this->SchedulerTicks.store(size_t(TimeManager->GetCounter() - SchedTmpTicks)); this->SchedulerTicks.store(size_t(TimeManager->GetCounter() - SchedTmpTicks));
} }
hot nsa NIF void Custom::OnInterruptReceived(CPU::SchedulerFrame *Frame) hot nsa nif void Custom::OnInterruptReceived(CPU::SchedulerFrame *Frame)
{ {
SmartCriticalSection(SchedulerLock); SmartCriticalSection(SchedulerLock);
this->Schedule(Frame); this->Schedule(Frame);