Merge remote-tracking branch 'Kernel/multiboot2_64' into Kernel-multiboot2_64

Kernel/Tests/MemoryAllocation.cpp

@@ -0,0 +1,233 @@
+#ifdef DEBUG
+
+#include <string.hpp>
+#include <memory.hpp>
+#include <debug.h>
+
+/* Originally from: https://github.com/EnderIce2/FennixProject/blob/main/kernel/test.cpp */
+
+#define MEMTEST_ITERATIONS 1024
+
+class test_mem_new_delete
+{
+public:
+    test_mem_new_delete();
+    ~test_mem_new_delete();
+};
+
+test_mem_new_delete::test_mem_new_delete()
+{
+    for (char i = 0; i < 2; i++)
+        ;
+}
+
+test_mem_new_delete::~test_mem_new_delete()
+{
+    for (char i = 0; i < 2; i++)
+        ;
+}
+
+extern bool EnableExternalMemoryTracer;
+extern bool DebuggerIsAttached;
+
+void TestMemoryAllocation()
+{
+    if (EnableExternalMemoryTracer || DebuggerIsAttached)
+    {
+        debug("The test is disabled when the external memory tracer or a debugger is enabled.");
+        return;
+    }
+
+    void *tmpAlloc1 = kmalloc(176);
+    void *tmpAlloc2 = kmalloc(511);
+    void *tmpAlloc3 = kmalloc(1027);
+    void *tmpAlloc4 = kmalloc(1569);
+    for (int repeat = 0; repeat < 4; repeat++)
+    {
+        debug("---------------[TEST %d]---------------\n", repeat);
+
+        debug("Single Page Request Test");
+        {
+            uint64_t prq1 = (uint64_t)KernelAllocator.RequestPage();
+            KernelAllocator.FreePage((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+                KernelAllocator.FreePage(KernelAllocator.RequestPage());
+
+            uint64_t prq2 = (uint64_t)KernelAllocator.RequestPage();
+            KernelAllocator.FreePage((void *)prq2);
+
+            debug(" Result:\t\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("Multiple Page Request Test");
+        {
+            uint64_t prq1 = (uint64_t)KernelAllocator.RequestPages(10);
+            KernelAllocator.FreePages((void *)prq1, 10);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+                KernelAllocator.FreePages(KernelAllocator.RequestPages(20), 20);
+
+            uint64_t prq2 = (uint64_t)KernelAllocator.RequestPages(10);
+            KernelAllocator.FreePages((void *)prq2, 10);
+
+            debug(" Result:\t\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("Multiple Fixed Malloc Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+                kfree(kmalloc(0x10000));
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:\t\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("Multiple Dynamic Malloc Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+                kfree(kmalloc(i));
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("New/Delete Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+            {
+                test_mem_new_delete *t = new test_mem_new_delete();
+                delete t;
+            }
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:               \t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("New/Delete Fixed Array Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+            {
+                char *t = new char[128];
+                delete[] t;
+            }
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:    \t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("New/Delete Dynamic Array Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+            {
+                if (i == 0)
+                    continue;
+                char *t = new char[i];
+                delete[] t;
+            }
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:\t1-[%#lx]; 2-[%#lx]\n", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("calloc Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+            {
+                char *t = (char *)kcalloc(128, 1);
+                kfree(t);
+            }
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+
+        debug("realloc Test");
+        {
+            uint64_t prq1 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq1);
+
+            for (uint64_t i = 0; i < MEMTEST_ITERATIONS; i++)
+            {
+                char *t = (char *)kmalloc(128);
+                t = (char *)krealloc(t, 256);
+                kfree(t);
+            }
+
+            uint64_t prq2 = (uint64_t)kmalloc(0x1000);
+            kfree((void *)prq2);
+
+            debug(" Result:\t1-[%#lx]; 2-[%#lx]", (void *)prq1, (void *)prq2);
+            assert(prq1 == prq2);
+        }
+    }
+
+    kfree(tmpAlloc1);
+    kfree(tmpAlloc2);
+    kfree(tmpAlloc3);
+    kfree(tmpAlloc4);
+
+    debug("Memory Stress Test");
+    for (size_t i = 0; i < 0x1000; i++)
+        kfree(kmalloc(i));
+
+    debug("Invalid Usage Test");
+    kfree(tmpAlloc1);
+    kfree(tmpAlloc2);
+    kfree(tmpAlloc3);
+    kfree(tmpAlloc4);
+
+    void *InvMlc = kmalloc(0);
+    assert(InvMlc == nullptr);
+    krealloc(InvMlc, 0);
+    assert(InvMlc == nullptr);
+    kcalloc(0, 0);
+    assert(InvMlc == nullptr);
+    kcalloc(1, 0);
+    assert(InvMlc == nullptr);
+    kcalloc(0, 1);
+    assert(InvMlc == nullptr);
+    kfree(InvMlc);
+
+    debug("Memory Test Complete\n");
+}
+
+#endif // DEBUG

Kernel/Tests/RandomNumberGenerator.cpp

@@ -0,0 +1,67 @@
+#ifdef DEBUG
+
+#include <rand.hpp>
+#include <debug.h>
+#include <cpu.hpp>
+
+__constructor void TestRandom()
+{
+    int RDRANDFlag = 0;
+    if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_AMD) == 0)
+    {
+#if defined(a64)
+        CPU::x64::AMD::CPUID0x1 cpuid1amd;
+#elif defined(a32)
+        CPU::x32::AMD::CPUID0x1 cpuid1amd;
+#endif
+#if defined(a64) || defined(a32)
+        asmv("cpuid"
+             : "=a"(cpuid1amd.EAX.raw), "=b"(cpuid1amd.EBX.raw), "=c"(cpuid1amd.ECX.raw), "=d"(cpuid1amd.EDX.raw)
+             : "a"(0x1));
+#endif
+        RDRANDFlag = cpuid1amd.ECX.RDRAND;
+    }
+    else if (strcmp(CPU::Vendor(), x86_CPUID_VENDOR_INTEL) == 0)
+    {
+#if defined(a64)
+        CPU::x64::Intel::CPUID0x1 cpuid1intel;
+#elif defined(a32)
+        CPU::x32::Intel::CPUID0x1 cpuid1intel;
+#endif
+#if defined(a64) || defined(a32)
+        asmv("cpuid"
+             : "=a"(cpuid1intel.EAX.raw), "=b"(cpuid1intel.EBX.raw), "=c"(cpuid1intel.ECX.raw), "=d"(cpuid1intel.EDX.raw)
+             : "a"(0x1));
+#endif
+        RDRANDFlag = cpuid1intel.ECX.RDRAND;
+    }
+
+    if (strcmp(CPU::Hypervisor(), x86_CPUID_VENDOR_TCG) == 0)
+        RDRANDFlag = 0;
+
+#if defined(a64) || defined(a32)
+    if (RDRANDFlag)
+    {
+        uint64_t RDSEEDValue = 0;
+        asmv("1: rdseed %0; jnc 1b"
+             : "=r"(RDSEEDValue));
+        debug("RDSEED: %ld", RDSEEDValue);
+    }
+#endif
+
+    Random::ChangeSeed(0xdeadbeef);
+    uint16_t Seeds16[16];
+    uint32_t Seeds32[16];
+    uint64_t Seeds64[16];
+    for (short i = 0; i < 16; i++)
+    {
+        Seeds16[i] = Random::rand16();
+        Seeds32[i] = Random::rand32();
+        Seeds64[i] = Random::rand64();
+    }
+    debug("Random 16: %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld", Seeds16[0], Seeds16[1], Seeds16[2], Seeds16[3], Seeds16[4], Seeds16[5], Seeds16[6], Seeds16[7], Seeds16[8], Seeds16[9], Seeds16[10], Seeds16[11], Seeds16[12], Seeds16[13], Seeds16[14], Seeds16[15]);
+    debug("Random 32: %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld", Seeds32[0], Seeds32[1], Seeds32[2], Seeds32[3], Seeds32[4], Seeds32[5], Seeds32[6], Seeds32[7], Seeds32[8], Seeds32[9], Seeds32[10], Seeds32[11], Seeds32[12], Seeds32[13], Seeds32[14], Seeds32[15]);
+    debug("Random 64: %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld, %ld", Seeds64[0], Seeds64[1], Seeds64[2], Seeds64[3], Seeds64[4], Seeds64[5], Seeds64[6], Seeds64[7], Seeds64[8], Seeds64[9], Seeds64[10], Seeds64[11], Seeds64[12], Seeds64[13], Seeds64[14], Seeds64[15]);
+}
+
+#endif // DEBUG

Kernel/Tests/String.cpp

@@ -0,0 +1,110 @@
+#ifdef DEBUG
+
+#include <string.hpp>
+#include <debug.h>
+
+void TestString()
+{
+    String hw("Hello, world!");
+    debug("String length: %d", hw.length());
+    debug("String capacity: %d", hw.capacity());
+    debug("String data: %s", hw.c_str());
+    if (hw == "Hello, world!" && hw != "World, hello!")
+        debug("String comparison works!");
+    else
+    {
+        error("String comparison doesn't work! \"%s\"", hw.c_str());
+        while (1)
+            ;
+    }
+
+    String hi("Hi");
+    char chi[3];
+    chi[0] = hi[0];
+    chi[1] = hi[1];
+    chi[2] = '\0';
+    if (strcmp(chi, "Hi") == 0)
+        debug("String indexing works!");
+    else
+    {
+        error("String indexing doesn't work! \"%s\" \"%s\"", chi, hi.c_str());
+        while (1)
+            ;
+    }
+
+    hi << " there!";
+    if (hi == "Hi there!")
+        debug("String concatenation works!");
+    else
+    {
+        error("String concatenation doesn't work! \"%s\"", hi.c_str());
+        while (1)
+            ;
+    }
+
+    hi << " " << hw;
+    if (hi == "Hi there! Hello, world!")
+        debug("String concatenation works!");
+    else
+    {
+        error("String concatenation doesn't work! \"%s\"", hi.c_str());
+        while (1)
+            ;
+    }
+
+    String eq0("Hello, world!");
+    String eq1("Hello, world!");
+    String eq2("World, hello!");
+
+    if (eq0 == eq1)
+        debug("String equality works!");
+    else
+    {
+        error("String equality doesn't work! \"%s\" \"%s\"", eq0.c_str(), eq1.c_str());
+        while (1)
+            ;
+    }
+
+    if (eq0 != eq2)
+        debug("String inequality works!");
+    else
+    {
+        error("String inequality doesn't work! \"%s\" \"%s\"", eq0.c_str(), eq2.c_str());
+        while (1)
+            ;
+    }
+
+    char chw[14];
+    int i = 0;
+    foreach (auto c in hw)
+    {
+        chw[i] = c;
+        i++;
+    }
+    chw[i] = '\0';
+
+    if (strcmp(chw, "Hello, world!") == 0)
+        debug("String iteration works!");
+    else
+    {
+        error("String iteration doesn't work! \"%s\" \"%s\" %d", chw, hw.c_str(), i);
+        while (1)
+            ;
+    }
+
+    String a("Hello");
+    String b("World");
+    String c;
+    c = a + ", " + b + "!";
+
+    if (c == "Hello, World!")
+        debug("String addition works!");
+    else
+    {
+        error("String addition doesn't work! \"%s\"", c.c_str());
+        while (1)
+            ;
+    }
+}
+
+#endif // DEBUG

Kernel/Tests/TypeSize.cpp

@@ -0,0 +1,106 @@
+#ifdef DEBUG
+
+#include <debug.h>
+
+__constructor void TestTypeSize()
+{
+    debug("--- INT TYPES ---");
+    debug("sizeof(__INT8_TYPE__) = %lld", sizeof(__INT8_TYPE__));
+    debug("sizeof(__INT16_TYPE__) = %lld", sizeof(__INT16_TYPE__));
+    debug("sizeof(__INT32_TYPE__) = %lld", sizeof(__INT32_TYPE__));
+    debug("sizeof(__INT64_TYPE__) = %lld", sizeof(__INT64_TYPE__));
+
+    debug("-- UINT TYPES ---");
+    debug("sizeof(__UINT8_TYPE__) = %lld", sizeof(__INT8_TYPE__));
+    debug("sizeof(__UINT16_TYPE__) = %lld", sizeof(__INT16_TYPE__));
+    debug("sizeof(__UINT32_TYPE__) = %lld", sizeof(__INT32_TYPE__));
+    debug("sizeof(__UINT64_TYPE__) = %lld", sizeof(__INT64_TYPE__));
+
+    debug("--- INT LEAST TYPES ---");
+    debug("sizeof(__INT_LEAST8_TYPE__) = %lld", sizeof(__INT_LEAST8_TYPE__));
+    debug("sizeof(__INT_LEAST16_TYPE__) = %lld", sizeof(__INT_LEAST16_TYPE__));
+    debug("sizeof(__INT_LEAST32_TYPE__) = %lld", sizeof(__INT_LEAST32_TYPE__));
+    debug("sizeof(__INT_LEAST64_TYPE__) = %lld", sizeof(__INT_LEAST64_TYPE__));
+
+    debug("--- UINT LEAST TYPES ---");
+    debug("sizeof(__UINT_LEAST8_TYPE__) = %lld", sizeof(__UINT_LEAST8_TYPE__));
+    debug("sizeof(__UINT_LEAST16_TYPE__) = %lld", sizeof(__UINT_LEAST16_TYPE__));
+    debug("sizeof(__UINT_LEAST32_TYPE__) = %lld", sizeof(__UINT_LEAST32_TYPE__));
+    debug("sizeof(__UINT_LEAST64_TYPE__) = %lld", sizeof(__UINT_LEAST64_TYPE__));
+
+    debug("--- INT FAST TYPES ---");
+    debug("sizeof(__INT_FAST8_TYPE__) = %lld", sizeof(__INT_FAST8_TYPE__));
+    debug("sizeof(__INT_FAST16_TYPE__) = %lld", sizeof(__INT_FAST16_TYPE__));
+    debug("sizeof(__INT_FAST32_TYPE__) = %lld", sizeof(__INT_FAST32_TYPE__));
+    debug("sizeof(__INT_FAST64_TYPE__) = %lld", sizeof(__INT_FAST64_TYPE__));
+
+    debug("--- UINT FAST TYPES ---");
+    debug("sizeof(__UINT_FAST8_TYPE__) = %lld", sizeof(__UINT_FAST8_TYPE__));
+    debug("sizeof(__UINT_FAST16_TYPE__) = %lld", sizeof(__UINT_FAST16_TYPE__));
+    debug("sizeof(__UINT_FAST32_TYPE__) = %lld", sizeof(__UINT_FAST32_TYPE__));
+    debug("sizeof(__UINT_FAST64_TYPE__) = %lld", sizeof(__UINT_FAST64_TYPE__));
+
+    debug("--- INTPTR TYPES ---");
+    debug("sizeof(__INTPTR_TYPE__) = %lld", sizeof(__INTPTR_TYPE__));
+    debug("sizeof(__UINTPTR_TYPE__) = %lld", sizeof(__UINTPTR_TYPE__));
+
+    debug("--- OTHER TYPES ---");
+    debug("sizeof(__PTRDIFF_TYPE__) = %lld", sizeof(__PTRDIFF_TYPE__));
+    debug("sizeof(__SIZE_TYPE__) = %lld", sizeof(__SIZE_TYPE__));
+    debug("sizeof(__WCHAR_TYPE__) = %lld", sizeof(__WCHAR_TYPE__));
+    debug("sizeof(__WINT_TYPE__) = %lld", sizeof(__WINT_TYPE__));
+    debug("sizeof(__SIG_ATOMIC_TYPE__) = %lld", sizeof(__SIG_ATOMIC_TYPE__));
+
+    debug("--- INTX MAX TYPES ---");
+    debug("__INT8_MAX__ = %#llx", __INT8_MAX__);
+    debug("__INT16_MAX__ = %#llx", __INT16_MAX__);
+    debug("__INT32_MAX__ = %#llx", __INT32_MAX__);
+    debug("__INT64_MAX__ = %#llx", __INT64_MAX__);
+
+    debug("--- UINTX MAX TYPES ---");
+    debug("__UINT8_MAX__ = %#llx", __UINT8_MAX__);
+    debug("__UINT16_MAX__ = %#llx", __UINT16_MAX__);
+    debug("__UINT32_MAX__ = %#llx", __UINT32_MAX__);
+    debug("__UINT64_MAX__ = %#llx", __UINT64_MAX__);
+
+    // debug("--- INTMAX TYPES ---");
+    // debug("__INTMAX_TYPE__ = %#llx", __INTMAX_TYPE__);
+    // debug("__UINTMAX_TYPE__ = %#llx", __UINTMAX_TYPE__);
+
+    debug("--- INTLEASTX MAX ---");
+    debug("__INT_LEAST8_MAX__ = %#llx", __INT_LEAST8_MAX__);
+    debug("__INT_LEAST16_MAX__ = %#llx", __INT_LEAST16_MAX__);
+    debug("__INT_LEAST32_MAX__ = %#llx", __INT_LEAST32_MAX__);
+    debug("__INT_LEAST64_MAX__ = %#llx", __INT_LEAST64_MAX__);
+
+    debug("--- UINTLEASTX MAX ---");
+    debug("__UINT_LEAST8_MAX__ = %#llx", __UINT_LEAST8_MAX__);
+    debug("__UINT_LEAST16_MAX__ = %#llx", __UINT_LEAST16_MAX__);
+
+    debug("--- INTFASTX MAX ---");
+    debug("__INT_FAST8_MAX__ = %#llx", __INT_FAST8_MAX__);
+    debug("__INT_FAST16_MAX__ = %#llx", __INT_FAST16_MAX__);
+    debug("__INT_FAST32_MAX__ = %#llx", __INT_FAST32_MAX__);
+    debug("__INT_FAST64_MAX__ = %#llx", __INT_FAST64_MAX__);
+
+    debug("--- UINTFASTX MAX ---");
+    debug("__UINT_FAST8_MAX__ = %#llx", __UINT_FAST8_MAX__);
+    debug("__UINT_FAST16_MAX__ = %#llx", __UINT_FAST16_MAX__);
+    debug("__UINT_FAST32_MAX__ = %#llx", __UINT_FAST32_MAX__);
+    debug("__UINT_FAST64_MAX__ = %#llx", __UINT_FAST64_MAX__);
+
+    debug("--- INTPTR MAX ---");
+    debug("__INTPTR_MAX__ = %#llx", __INTPTR_MAX__);
+    debug("__UINTPTR_MAX__ = %#llx", __UINTPTR_MAX__);
+
+    debug("--- OTHER MAX ---");
+    debug("__PTRDIFF_MAX__ = %#llx", __PTRDIFF_MAX__);
+    debug("__SIZE_MAX__ = %#llx", __SIZE_MAX__);
+    debug("__WCHAR_MAX__ = %#llx", __WCHAR_MAX__);
+    debug("__WINT_MAX__ = %#llx", __WINT_MAX__);
+    debug("__SIG_ATOMIC_MAX__ = %#llx", __SIG_ATOMIC_MAX__);
+    debug("__INTMAX_MAX__ = %#llx", __INTMAX_MAX__);
+    debug("__UINTMAX_MAX__ = %#llx", __UINTMAX_MAX__);
+}
+
+#endif // DEBUG

Kernel/Tests/t.h

@@ -0,0 +1,11 @@
+#ifndef __FENNIX_KERNEL_non_constructor_tests_H__
+#define __FENNIX_KERNEL_non_constructor_tests_H__
+#ifdef DEBUG
+
+#include <types.h>
+
+void TestString();
+void TestMemoryAllocation();
+
+#endif // DEBUG
+#endif // !__FENNIX_KERNEL_non_constructor_tests_H__