clang-format alignment rules

.editorconfig

@@ -0,0 +1,37 @@
+root = true
+
+# Default for all files
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# C / header files
+[*.{c,h}]
+indent_style = space
+indent_size = 2
+tab_width = 2
+max_line_length = 80
+
+# Assembly (if present; usually tab-sensitive)
+[*.S]
+indent_style = tab
+tab_width = 8
+trim_trailing_whitespace = false
+
+# Makefiles (MUST use tabs)
+[Makefile]
+indent_style = tab
+tab_width = 8
+trim_trailing_whitespace = false
+
+[*.mk]
+indent_style = tab
+tab_width = 8
+trim_trailing_whitespace = false
+
+# Markdown (avoid wrapping conflicts)
+[*.md]
+trim_trailing_whitespace = false
+max_line_length = off

Makefile

@@ -6,4 +6,7 @@ all_kernel:
 clean_kernel:
 	make -C kernel platform=$(platform) clean
 
-.PHONY: all_kernel clean_kernel
+format_kernel:
+	make -C kernel platform=$(platform) format
+
+.PHONY: all_kernel clean_kernel format_kernel

aux/bochsrc.txt

@@ -8,6 +8,7 @@ vgaromimage: file=/usr/share/bochs/VGABIOS-lgpl-latest.bin
 ata0: enabled=1
 ata0-master: type=cdrom, path=mop3.iso, status=inserted
 com1: enabled=1, mode=file, dev=bochs-com1.txt
+pci: enabled=1, chipset=i440fx
 
 boot: cdrom
 

kernel/.clang-format

@@ -0,0 +1,58 @@
+BasedOnStyle: LLVM
+Language: C
+
+# Indentation
+IndentWidth: 2
+TabWidth: 2
+UseTab: Never
+
+# Braces and blocks
+BreakBeforeBraces: Attach
+BraceWrapping:
+  AfterFunction: false
+  AfterControlStatement: false
+  AfterStruct: false
+  AfterEnum: false
+  AfterUnion: false
+  BeforeElse: false
+
+# Control statements
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
+
+# Line breaking
+ColumnLimit: 80
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakStringLiterals: false
+
+# Spacing
+SpaceBeforeParens: Always
+SpaceBeforeAssignmentOperators: true
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+
+# Pointer alignment
+PointerAlignment: Left
+DerivePointerAlignment: false
+
+# Alignment
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignConsecutiveMacros: true
+AlignOperands: false
+
+# Includes
+SortIncludes: true
+
+# Comments
+ReflowComments: false
+CommentPragmas: '^ IWYU pragma:'
+
+# Misc
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 1

kernel/Makefile

@@ -5,6 +5,7 @@ ldflags :=
 cflags  :=
 buildtype ?= release
 
+include vars.mk
 include flags.mk
 include src.mk
 
@@ -22,4 +23,13 @@ build/kernel.elf: $(o)
 clean:
 	rm -f $(o) build/kernel.elf
 
-.PHONY: all clean
+format:
+	clang-format -i $$(git ls-files '*.c' '*.h' \
+		':!limine/limine.h' \
+		':!c_headers/include/**' \
+		':!uACPI/source/**' \
+		':!uACPI/include/**' \
+		':!uACPI/tests/**' \
+		':!libk/printf*')
+
+.PHONY: all clean format

kernel/amd64/bootmain.c

@@ -1,20 +1,26 @@
-#include <limine/limine.h>
 #include <amd64/init.h>
-#include <sys/debug.h>
+#include <aux/compiler.h>
-#include <mm/pmm.h>
+#include <limine/limine.h>
 #include <mm/liballoc.h>
+#include <mm/pmm.h>
+#include <sys/debug.h>
+#include <uacpi/uacpi.h>
 
-void bootmain(void) {
+#define UACPI_MEMORY_BUFFER_MAX 4096
-  amd64_init();
-  DEBUG("Hello from amd64!\n");
 
-  pmm_init();
+ALIGNED (16) static uint8_t uacpi_memory_buffer[UACPI_MEMORY_BUFFER_MAX];
 
-  int *a = malloc(sizeof(int));
+void bootmain (void) {
+  amd64_init ();
+  pmm_init ();
+
+  uacpi_setup_early_table_access ((void*)uacpi_memory_buffer,
+                                  sizeof (uacpi_memory_buffer));
+
+  int* a = malloc (sizeof (int));
   *a = 6969;
-  DEBUG("a=%p, *a=%d\n", a, *a);
+  DEBUG ("a=%p, *a=%d\n", a, *a);
 
-  *(volatile int *)0 = 123;
+  for (;;)
-
+    ;
-  for (;;);
 }

kernel/amd64/debug.c

@@ -1,46 +1,47 @@
-#include <libk/std.h>
-#include <libk/string.h>
-#include <libk/printf.h>
-#include <sys/debug.h>
 #include <amd64/debug.h>
 #include <amd64/io.h>
+#include <libk/printf.h>
+#include <libk/std.h>
+#include <libk/string.h>
+#include <sys/debug.h>
 
 #define PORT_COM1   0x03F8
 #define BUFFER_SIZE 1024
 
-static bool amd64_debug_serial_tx_empty(void) {
+static bool amd64_debug_serial_tx_empty (void) {
-  return (bool)(amd64_io_inb(PORT_COM1 + 5) & 0x20);
+  return (bool)(amd64_io_inb (PORT_COM1 + 5) & 0x20);
 }
 
-static void amd64_debug_serial_write(char x) {
+static void amd64_debug_serial_write (char x) {
-  while (!amd64_debug_serial_tx_empty());
+  while (!amd64_debug_serial_tx_empty ())
-  amd64_io_outb(PORT_COM1, (uint8_t)x);
+    ;
+  amd64_io_outb (PORT_COM1, (uint8_t)x);
 }
 
-void debugprintf(const char *fmt, ...) {
+void debugprintf (const char* fmt, ...) {
   char buffer[BUFFER_SIZE];
-  memset(buffer, 0, sizeof(buffer));
+  memset (buffer, 0, sizeof (buffer));
 
   va_list ap;
-  va_start(ap, fmt);
+  va_start (ap, fmt);
-  vsnprintf(buffer, sizeof(buffer), fmt, ap);
+  vsnprintf (buffer, sizeof (buffer), fmt, ap);
-  va_end(ap);
+  va_end (ap);
 
-  buffer[sizeof(buffer) - 1] = '\0';
+  buffer[sizeof (buffer) - 1] = '\0';
 
-  const char *p = buffer;
+  const char* p = buffer;
   while (*p) {
-    amd64_debug_serial_write(*p);
+    amd64_debug_serial_write (*p);
     p++;
   }
 }
 
-void amd64_debug_init(void) {
+void amd64_debug_init (void) {
-  amd64_io_outb(PORT_COM1 + 1, 0x00);
+  amd64_io_outb (PORT_COM1 + 1, 0x00);
-  amd64_io_outb(PORT_COM1 + 3, 0x80);
+  amd64_io_outb (PORT_COM1 + 3, 0x80);
-  amd64_io_outb(PORT_COM1 + 0, 0x03);
+  amd64_io_outb (PORT_COM1 + 0, 0x03);
-  amd64_io_outb(PORT_COM1 + 1, 0x00);
+  amd64_io_outb (PORT_COM1 + 1, 0x00);
-  amd64_io_outb(PORT_COM1 + 3, 0x03);
+  amd64_io_outb (PORT_COM1 + 3, 0x03);
-  amd64_io_outb(PORT_COM1 + 2, 0xC7);
+  amd64_io_outb (PORT_COM1 + 2, 0xC7);
-  amd64_io_outb(PORT_COM1 + 4, 0x0B);
+  amd64_io_outb (PORT_COM1 + 4, 0x0B);
 }

kernel/amd64/debug.h

@@ -1,6 +1,6 @@
 #ifndef _KERNEL_AMD64_DEBUG_H
 #define _KERNEL_AMD64_DEBUG_H
 
-void amd64_debug_init(void);
+void amd64_debug_init (void);
 
 #endif // _KERNEL_AMD64_DEBUG_H

kernel/amd64/init.c

@@ -1,20 +1,21 @@
+#include <amd64/debug.h>
+#include <amd64/init.h>
+#include <amd64/intr.h>
+#include <amd64/tss.h>
+#include <aux/compiler.h>
 #include <libk/std.h>
 #include <libk/string.h>
-#include <amd64/init.h>
-#include <amd64/tss.h>
-#include <amd64/debug.h>
-#include <amd64/intr.h>
 
-#define GDT_KCODE     0x08
+#define GDT_KCODE 0x08
-#define GDT_KDATA     0x10
+#define GDT_KDATA 0x10
-#define GDT_UCODE     0x18
+#define GDT_UCODE 0x18
-#define GDT_UDATA     0x20
+#define GDT_UDATA 0x20
-#define GDT_TSS       0x28
+#define GDT_TSS   0x28
 
 #define TSS         0x80
 #define TSS_PRESENT 0x89
 
-#define KSTACK_SIZE   (8*1024)
+#define KSTACK_SIZE (8 * 1024)
 
 struct gdt_entry {
   uint16_t limitlow;
@@ -23,24 +24,24 @@ struct gdt_entry {
   uint8_t access;
   uint8_t gran;
   uint8_t basehigh;
-} __attribute__((packed));
+} PACKED;
 
 struct gdt_ptr {
   uint16_t limit;
   uint64_t base;
-} __attribute__((packed));
+} PACKED;
 
 struct gdt_extended {
   struct gdt_entry old[5];
   struct gdt_entry tsslow;
   struct gdt_entry tsshigh;
-} __attribute__((packed));
+} PACKED;
 
-__attribute__((aligned(16))) static volatile uint8_t kernel_stack[KSTACK_SIZE];
+ALIGNED (16) static volatile uint8_t kernel_stack[KSTACK_SIZE];
-__attribute__((aligned(16))) static volatile struct gdt_extended gdt;
+ALIGNED (16) static volatile struct gdt_extended gdt;
 
-static void amd64_gdt_set(volatile struct gdt_entry *ent, uint32_t base,
+static void amd64_gdt_set (volatile struct gdt_entry* ent, uint32_t base,
-                          uint32_t limit, uint8_t acc, uint8_t gran) {
+                           uint32_t limit, uint8_t acc, uint8_t gran) {
   ent->baselow = (base & 0xFFFF);
   ent->basemid = (base >> 16) & 0xFF;
   ent->basehigh = (base >> 24) & 0xFF;
@@ -49,25 +50,26 @@ static void amd64_gdt_set(volatile struct gdt_entry *ent, uint32_t base,
   ent->access = acc;
 }
 
-static void amd64_gdt_init(void) {
+static void amd64_gdt_init (void) {
-  volatile struct tss *tss = amd64_get_tss();
+  volatile struct tss* tss = amd64_get_tss ();
 
-  memset((void *)&gdt, 0, sizeof(gdt));
+  memset ((void*)&gdt, 0, sizeof (gdt));
-  memset((void *)kernel_stack, 0, sizeof(kernel_stack));
+  memset ((void*)kernel_stack, 0, sizeof (kernel_stack));
-  memset((void *)tss, 0, sizeof(*tss));
+  memset ((void*)tss, 0, sizeof (*tss));
 
-  tss->iopb_off = sizeof(*tss);
+  tss->iopb_off = sizeof (*tss);
-  tss->rsp0 = (uint64_t)((uintptr_t)kernel_stack + sizeof(kernel_stack));
+  tss->rsp0 = (uint64_t)((uintptr_t)kernel_stack + sizeof (kernel_stack));
 
   uint64_t tssbase = (uint64_t)&tss;
-  uint64_t tsslimit = sizeof(*tss) - 1;
+  uint64_t tsslimit = sizeof (*tss) - 1;
 
-  amd64_gdt_set(&gdt.old[0], 0, 0, 0, 0);
+  amd64_gdt_set (&gdt.old[0], 0, 0, 0, 0);
-  amd64_gdt_set(&gdt.old[1], 0, 0xFFFFF, 0x9A, 0xA0);
+  amd64_gdt_set (&gdt.old[1], 0, 0xFFFFF, 0x9A, 0xA0);
-  amd64_gdt_set(&gdt.old[2], 0, 0xFFFFF, 0x92, 0xC0);
+  amd64_gdt_set (&gdt.old[2], 0, 0xFFFFF, 0x92, 0xC0);
-  amd64_gdt_set(&gdt.old[3], 0, 0xFFFFF, 0xFA, 0xA0);
+  amd64_gdt_set (&gdt.old[3], 0, 0xFFFFF, 0xFA, 0xA0);
-  amd64_gdt_set(&gdt.old[4], 0, 0xFFFFF, 0xF2, 0xC0);
+  amd64_gdt_set (&gdt.old[4], 0, 0xFFFFF, 0xF2, 0xC0);
-  amd64_gdt_set(&gdt.tsslow, (tssbase & 0xFFFFFFFF), tsslimit, TSS_PRESENT | TSS, 0);
+  amd64_gdt_set (&gdt.tsslow, (tssbase & 0xFFFFFFFF), tsslimit,
+                 TSS_PRESENT | TSS, 0);
 
   uint32_t tssbasehigh = (tssbase >> 32);
   gdt.tsshigh.limitlow = (tssbasehigh & 0xFFFF);
@@ -78,30 +80,28 @@ static void amd64_gdt_init(void) {
   gdt.tsshigh.gran = 0;
 
   struct gdt_ptr gdtr;
-  gdtr.limit = sizeof(gdt) - 1;
+  gdtr.limit = sizeof (gdt) - 1;
   gdtr.base = (uint64_t)&gdt;
-  __asm__ volatile("lgdt %0" :: "m"(gdtr) : "memory");
+  __asm__ volatile ("lgdt %0" ::"m"(gdtr) : "memory");
 
-  __asm__ volatile(
+  __asm__ volatile ("pushq %[kcode]\n"
-    "pushq %[kcode]\n"
+                    "lea 1f(%%rip), %%rax\n"
-    "lea 1f(%%rip), %%rax\n"
+                    "pushq %%rax\n"
-    "pushq %%rax\n"
+                    "lretq\n"
-    "lretq\n"
+                    "1:\n"
-    "1:\n"
+                    "movw %[kdata], %%ax\n"
-    "movw %[kdata], %%ax\n"
+                    "movw %%ax, %%ds\n"
-    "movw %%ax, %%ds\n"
+                    "movw %%ax, %%es\n"
-    "movw %%ax, %%es\n"
+                    "movw %%ax, %%ss\n"
-    "movw %%ax, %%ss\n"
+                    :
-    :
+                    : [kcode] "i"(GDT_KCODE), [kdata] "i"(GDT_KDATA)
-    : [kcode] "i"(GDT_KCODE), [kdata] "i"(GDT_KDATA)
+                    : "rax", "memory");
-    : "rax", "memory"
-  );
 
-  __asm__ volatile("ltr %0" :: "r"((uint16_t)GDT_TSS));
+  __asm__ volatile ("ltr %0" ::"r"((uint16_t)GDT_TSS));
 }
 
-void amd64_init(void) {
+void amd64_init (void) {
-  amd64_gdt_init();
+  amd64_gdt_init ();
-  amd64_debug_init();
+  amd64_debug_init ();
-  amd64_intr_init();
+  amd64_intr_init ();
 }

kernel/amd64/init.h

@@ -1,6 +1,6 @@
 #ifndef _KERNEL_AMD64_INIT_H
 #define _KERNEL_AMD64_INIT_H
 
-void amd64_init(void);
+void amd64_init (void);
 
 #endif // _KERNEL_AMD64_INIT_H

kernel/amd64/intr.c

@@ -1,23 +1,24 @@
+#include <amd64/intr.h>
+#include <amd64/io.h>
+#include <aux/compiler.h>
 #include <libk/std.h>
 #include <libk/string.h>
 #include <sys/debug.h>
-#include <amd64/intr.h>
-#include <amd64/io.h>
 
 /* 8259 PIC defs. */
-#define PIC1        0x20
+#define PIC1      0x20
-#define PIC2        0xA0
+#define PIC2      0xA0
-#define PIC1_CMD    PIC1
+#define PIC1_CMD  PIC1
-#define PIC1_DATA   (PIC1 + 1)
+#define PIC1_DATA (PIC1 + 1)
-#define PIC2_CMD    PIC2
+#define PIC2_CMD  PIC2
-#define PIC2_DATA   (PIC2 + 1)
+#define PIC2_DATA (PIC2 + 1)
-#define PIC_EOI     0x20
+#define PIC_EOI   0x20
 
-#define ICW1_ICW4     0x01
+#define ICW1_ICW4   0x01
-#define ICW1_SINGLE   0x02
+#define ICW1_SINGLE 0x02
-#define ICW1_INTVL4   0x04
+#define ICW1_INTVL4 0x04
-#define ICW1_LEVEL    0x08
+#define ICW1_LEVEL  0x08
-#define ICW1_INIT     0x10
+#define ICW1_INIT   0x10
 
 #define ICW4_8086     0x01
 #define ICW4_AUTO     0x02
@@ -25,7 +26,7 @@
 #define ICW4_BUFMASER 0x0C
 #define ICW4_SFNM     0x10
 
-#define CASCADE_IRQ   2
+#define CASCADE_IRQ 2
 
 /* IDT defs. */
 
@@ -39,42 +40,45 @@ struct idt_entry {
   uint16_t intrmid;
   uint32_t intrhigh;
   uint32_t resv;
-} __attribute__((packed));
+} PACKED;
 
 struct idt {
   uint16_t limit;
   uint64_t base;
-} __attribute__((packed));
+} PACKED;
 
-__attribute__((aligned(16))) static volatile struct idt_entry idt_entries[IDT_ENTRIES_MAX];
+ALIGNED (16) static volatile struct idt_entry idt_entries[IDT_ENTRIES_MAX];
 static volatile struct idt idt;
 
-extern void amd64_spin(void);
+extern void amd64_spin (void);
 
 /* Remaps and disables old 8259 PIC, since we'll be using APIC. */
-static void amd64_init_pic(void) {
+static void amd64_init_pic (void) {
-#define IO_OP(fn, ...) fn(__VA_ARGS__); amd64_io_wait()
+#define IO_OP(fn, ...)                                                         \
+  fn (__VA_ARGS__);                                                            \
+  amd64_io_wait ()
 
-  IO_OP(amd64_io_outb, PIC1_CMD, (ICW1_INIT | ICW1_ICW4));
+  IO_OP (amd64_io_outb, PIC1_CMD, (ICW1_INIT | ICW1_ICW4));
-  IO_OP(amd64_io_outb, PIC2_CMD, (ICW1_INIT | ICW1_ICW4));
+  IO_OP (amd64_io_outb, PIC2_CMD, (ICW1_INIT | ICW1_ICW4));
 
-  IO_OP(amd64_io_outb, PIC1_DATA, 0x20);
+  IO_OP (amd64_io_outb, PIC1_DATA, 0x20);
-  IO_OP(amd64_io_outb, PIC2_DATA, 0x28);
+  IO_OP (amd64_io_outb, PIC2_DATA, 0x28);
 
-  IO_OP(amd64_io_outb, PIC1_DATA, (1 << CASCADE_IRQ));
+  IO_OP (amd64_io_outb, PIC1_DATA, (1 << CASCADE_IRQ));
-  IO_OP(amd64_io_outb, PIC2_DATA, 2);
+  IO_OP (amd64_io_outb, PIC2_DATA, 2);
 
-  IO_OP(amd64_io_outb, PIC1_DATA, ICW4_8086);
+  IO_OP (amd64_io_outb, PIC1_DATA, ICW4_8086);
-  IO_OP(amd64_io_outb, PIC2_DATA, ICW4_8086);
+  IO_OP (amd64_io_outb, PIC2_DATA, ICW4_8086);
 
   /* Disable */
-  IO_OP(amd64_io_outb, PIC1_DATA, 0xFF);
+  IO_OP (amd64_io_outb, PIC1_DATA, 0xFF);
-  IO_OP(amd64_io_outb, PIC2_DATA, 0xFF);
+  IO_OP (amd64_io_outb, PIC2_DATA, 0xFF);
 
 #undef IO_OP
 }
 
-static void amd64_idt_set(volatile struct idt_entry *ent, uint64_t handler, uint8_t flags) {
+static void amd64_idt_set (volatile struct idt_entry* ent, uint64_t handler,
+                           uint8_t flags) {
   ent->intrlow = (handler & 0xFFFF);
   ent->kernel_cs = 0x08; // GDT_KCODE (init.c)
   ent->ist = 0;
@@ -84,74 +88,105 @@ static void amd64_idt_set(volatile struct idt_entry *ent, uint64_t handler, uint
   ent->resv = 0;
 }
 
-static void amd64_idt_init(void) {
+static void amd64_idt_init (void) {
-  memset((void *)idt_entries, 0, sizeof(idt_entries));
+  memset ((void*)idt_entries, 0, sizeof (idt_entries));
 
-#define IDT_ENTRY(n) \
+#define IDT_ENTRY(n)                                                           \
-  extern void amd64_intr ## n(void); \
+  extern void amd64_intr##n (void);                                            \
-  amd64_idt_set(&idt_entries[(n)], (uint64_t)&amd64_intr ## n, 0x8E)
+  amd64_idt_set (&idt_entries[(n)], (uint64_t)&amd64_intr##n, 0x8E)
-  IDT_ENTRY(0); IDT_ENTRY(1); IDT_ENTRY(2); IDT_ENTRY(3);
+  IDT_ENTRY (0);
-  IDT_ENTRY(4); IDT_ENTRY(5); IDT_ENTRY(6); IDT_ENTRY(7);
+  IDT_ENTRY (1);
-  IDT_ENTRY(8); IDT_ENTRY(9); IDT_ENTRY(10); IDT_ENTRY(11);
+  IDT_ENTRY (2);
-  IDT_ENTRY(12); IDT_ENTRY(13); IDT_ENTRY(14); IDT_ENTRY(15);
+  IDT_ENTRY (3);
-  IDT_ENTRY(16); IDT_ENTRY(17); IDT_ENTRY(18); IDT_ENTRY(19);
+  IDT_ENTRY (4);
-  IDT_ENTRY(20); IDT_ENTRY(21); IDT_ENTRY(22); IDT_ENTRY(23);
+  IDT_ENTRY (5);
-  IDT_ENTRY(24); IDT_ENTRY(25); IDT_ENTRY(26); IDT_ENTRY(27);
+  IDT_ENTRY (6);
-  IDT_ENTRY(28); IDT_ENTRY(29); IDT_ENTRY(30); IDT_ENTRY(31);
+  IDT_ENTRY (7);
-  IDT_ENTRY(32); IDT_ENTRY(33); IDT_ENTRY(34); IDT_ENTRY(35);
+  IDT_ENTRY (8);
-  IDT_ENTRY(36); IDT_ENTRY(37); IDT_ENTRY(38); IDT_ENTRY(39);
+  IDT_ENTRY (9);
-  IDT_ENTRY(40); IDT_ENTRY(41); IDT_ENTRY(42); IDT_ENTRY(43);
+  IDT_ENTRY (10);
-  IDT_ENTRY(44); IDT_ENTRY(45); IDT_ENTRY(46); IDT_ENTRY(47);
+  IDT_ENTRY (11);
+  IDT_ENTRY (12);
+  IDT_ENTRY (13);
+  IDT_ENTRY (14);
+  IDT_ENTRY (15);
+  IDT_ENTRY (16);
+  IDT_ENTRY (17);
+  IDT_ENTRY (18);
+  IDT_ENTRY (19);
+  IDT_ENTRY (20);
+  IDT_ENTRY (21);
+  IDT_ENTRY (22);
+  IDT_ENTRY (23);
+  IDT_ENTRY (24);
+  IDT_ENTRY (25);
+  IDT_ENTRY (26);
+  IDT_ENTRY (27);
+  IDT_ENTRY (28);
+  IDT_ENTRY (29);
+  IDT_ENTRY (30);
+  IDT_ENTRY (31);
+  IDT_ENTRY (32);
+  IDT_ENTRY (33);
+  IDT_ENTRY (34);
+  IDT_ENTRY (35);
+  IDT_ENTRY (36);
+  IDT_ENTRY (37);
+  IDT_ENTRY (38);
+  IDT_ENTRY (39);
+  IDT_ENTRY (40);
+  IDT_ENTRY (41);
+  IDT_ENTRY (42);
+  IDT_ENTRY (43);
+  IDT_ENTRY (44);
+  IDT_ENTRY (45);
+  IDT_ENTRY (46);
+  IDT_ENTRY (47);
 #undef IDT_ENTRY
 
-  idt.limit = sizeof(idt_entries) - 1;
+  idt.limit = sizeof (idt_entries) - 1;
   idt.base = (uint64_t)idt_entries;
 
-  __asm__ volatile("lidt %0" :: "m"(idt));
+  __asm__ volatile ("lidt %0" ::"m"(idt));
-  __asm__ volatile("sti");
+  __asm__ volatile ("sti");
 }
 
-static void amd64_intr_exception(struct saved_regs *regs) {
+static void amd64_intr_exception (struct saved_regs* regs) {
-  DEBUG("cpu exception %lu (%lu)\n", regs->trap, regs->error);
+  DEBUG ("cpu exception %lu (%lu)\n", regs->trap, regs->error);
 
   uint64_t cr2;
-  __asm__ volatile("movq %%cr2, %0" : "=r"(cr2));
+  __asm__ volatile ("movq %%cr2, %0" : "=r"(cr2));
   uint64_t cr3;
-  __asm__ volatile("movq %%cr3, %0" : "=r"(cr3));
+  __asm__ volatile ("movq %%cr3, %0" : "=r"(cr3));
 
-  debugprintf(
+  debugprintf ("r15=%016lx r14=%016lx r13=%016lx\n"
-      "r15=%016lx r14=%016lx r13=%016lx\n"
+               "r12=%016lx r11=%016lx r10=%016lx\n"
-      "r12=%016lx r11=%016lx r10=%016lx\n"
+               "r9 =%016lx r8 =%016lx rbp=%016lx\n"
-      "r9 =%016lx r8 =%016lx rbp=%016lx\n"
+               "rdi=%016lx rsi=%016lx rdx=%016lx\n"
-      "rdi=%016lx rsi=%016lx rdx=%016lx\n"
+               "rcx=%016lx rax=%016lx trp=%016lx\n"
-      "rcx=%016lx rax=%016lx trp=%016lx\n"
+               "err=%016lx rip=%016lx cs =%016lx\n"
-      "err=%016lx rip=%016lx cs =%016lx\n"
+               "rfl=%016lx rsp=%016lx ss =%016lx\n"
-      "rfl=%016lx rsp=%016lx ss =%016lx\n"
+               "cr2=%016lx cr3=%016lx rbx=%016lx\n",
-      "cr2=%016lx cr3=%016lx rbx=%016lx\n",
+               regs->r15, regs->r14, regs->r13, regs->r12, regs->r11, regs->r10,
-      regs->r15,    regs->r14, regs->r13,
+               regs->r9, regs->r8, regs->rbp, regs->rdi, regs->rsi, regs->rdx,
-      regs->r12,    regs->r11, regs->r10,
+               regs->rcx, regs->rax, regs->trap, regs->error, regs->rip,
-      regs->r9,     regs->r8,  regs->rbp,
+               regs->cs, regs->rflags, regs->rsp, regs->ss, cr2, cr3,
-      regs->rdi,    regs->rsi, regs->rdx,
+               regs->rbx);
-      regs->rcx,    regs->rax, regs->trap,
-      regs->error,  regs->rip, regs->cs,
-      regs->rflags, regs->rsp, regs->ss,
-      cr2,          cr3,       regs->rbx
-    );
 
-  amd64_spin();
+  amd64_spin ();
 }
 
-void amd64_intr_handler(void *stack_ptr) {
+void amd64_intr_handler (void* stack_ptr) {
-  struct saved_regs *regs = stack_ptr;
+  struct saved_regs* regs = stack_ptr;
 
   if (regs->trap <= 31) {
-    amd64_intr_exception(regs);
+    amd64_intr_exception (regs);
   } else {
-    DEBUG("unknown trap %lu\n", regs->trap);
+    DEBUG ("unknown trap %lu\n", regs->trap);
   }
 }
 
-void amd64_intr_init(void) {
+void amd64_intr_init (void) {
-  amd64_init_pic();
+  amd64_init_pic ();
-  amd64_idt_init();
+  amd64_idt_init ();
 }

kernel/amd64/intr.h

@@ -1,6 +1,7 @@
 #ifndef _KERNEL_AMD64_INTR_H
 #define _KERNEL_AMD64_INTR_H
 
+#include <aux/compiler.h>
 #include <libk/std.h>
 
 struct saved_regs {
@@ -28,8 +29,8 @@ struct saved_regs {
   uint64_t rflags;
   uint64_t rsp;
   uint64_t ss;
-} __attribute__((packed));
+} PACKED;
 
-void amd64_intr_init(void);
+void amd64_intr_init (void);
 
 #endif // _KERNEL_AMD64_INTR_H

kernel/amd64/io.c

@@ -1,54 +1,48 @@
-#include <libk/std.h>
 #include <amd64/io.h>
+#include <libk/std.h>
 
-void amd64_io_outb(uint16_t port, uint8_t v) {
+void amd64_io_outb (uint16_t port, uint8_t v) {
-  __asm__ volatile("outb %1, %0" :: "dN"(port), "a"(v));
+  __asm__ volatile ("outb %1, %0" ::"dN"(port), "a"(v));
 }
 
-void amd64_io_outw(uint16_t port, uint16_t v) {
+void amd64_io_outw (uint16_t port, uint16_t v) {
-  __asm__ volatile("outw %%ax, %%dx" :: "a"(v), "d"(port));
+  __asm__ volatile ("outw %%ax, %%dx" ::"a"(v), "d"(port));
 }
 
-void amd64_io_outl(uint16_t port, uint32_t v) {
+void amd64_io_outl (uint16_t port, uint32_t v) {
-  __asm__ volatile("outl %%eax, %%dx" :: "d"(port), "a"(v));
+  __asm__ volatile ("outl %%eax, %%dx" ::"d"(port), "a"(v));
 }
 
-void amd64_io_outsw(uint16_t port, const void *addr, int cnt) {
+void amd64_io_outsw (uint16_t port, const void* addr, int cnt) {
-  __asm__ volatile(
+  __asm__ volatile ("cld; rep outsw"
-    "cld; rep outsw"
+                    : "+S"(addr), "+c"(cnt)
-    : "+S"(addr), "+c"(cnt)
+                    : "d"(port)
-    : "d"(port)
+                    : "memory", "cc");
-    : "memory", "cc"
-  );
 }
 
-uint8_t amd64_io_inb(uint16_t port) {
+uint8_t amd64_io_inb (uint16_t port) {
   uint8_t r;
-  __asm__ volatile("inb %1, %0" : "=a"(r) : "dN"(port));
+  __asm__ volatile ("inb %1, %0" : "=a"(r) : "dN"(port));
   return r;
 }
 
-uint16_t amd64_io_inw(uint16_t port) {
+uint16_t amd64_io_inw (uint16_t port) {
   uint16_t r;
-  __asm__ volatile("inw %%dx, %%ax" : "=a"(r) : "d"(port));
+  __asm__ volatile ("inw %%dx, %%ax" : "=a"(r) : "d"(port));
   return r;
 }
 
-uint32_t amd64_io_inl(uint16_t port) {
+uint32_t amd64_io_inl (uint16_t port) {
   uint32_t r;
-  __asm__ volatile("inl %%dx, %%eax" : "=a"(r) : "d"(port));
+  __asm__ volatile ("inl %%dx, %%eax" : "=a"(r) : "d"(port));
   return r;
 }
 
-void amd64_io_insw(uint16_t port, void *addr, int cnt) {
+void amd64_io_insw (uint16_t port, void* addr, int cnt) {
-  __asm__ volatile(
+  __asm__ volatile ("cld; rep insw"
-    "cld; rep insw"
+                    : "+D"(addr), "+c"(cnt)
-    : "+D"(addr), "+c"(cnt)
+                    : "d"(port)
-    : "d"(port)
+                    : "memory", "cc");
-    : "memory", "cc"
-  );
 }
 
-void amd64_io_wait(void) {
+void amd64_io_wait (void) { amd64_io_outb (0x80, 0); }
-  amd64_io_outb(0x80, 0);
-}

kernel/amd64/io.h

@@ -3,14 +3,14 @@
 
 #include <libk/std.h>
 
-void amd64_io_outb(uint16_t port, uint8_t v);
+void amd64_io_outb (uint16_t port, uint8_t v);
-void amd64_io_outw(uint16_t port, uint16_t v);
+void amd64_io_outw (uint16_t port, uint16_t v);
-void amd64_io_outl(uint16_t port, uint32_t v);
+void amd64_io_outl (uint16_t port, uint32_t v);
-void amd64_io_outsw(uint16_t port, const void *addr, int cnt);
+void amd64_io_outsw (uint16_t port, const void* addr, int cnt);
-uint8_t amd64_io_inb(uint16_t port);
+uint8_t amd64_io_inb (uint16_t port);
-uint16_t amd64_io_inw(uint16_t port);
+uint16_t amd64_io_inw (uint16_t port);
-uint32_t amd64_io_inl(uint16_t port);
+uint32_t amd64_io_inl (uint16_t port);
-void amd64_io_insw(uint16_t port, void *addr, int cnt);
+void amd64_io_insw (uint16_t port, void* addr, int cnt);
-void amd64_io_wait(void);
+void amd64_io_wait (void);
 
 #endif // _KERNEL_AMD64_IO_H

kernel/amd64/mm.h

@@ -1,6 +1,6 @@
 #ifndef _KERNEL_AMD64_MM_H
 #define _KERNEL_AMD64_MM_H
 
-#define PAGE_SIZE   4096
+#define PAGE_SIZE 4096
 
 #endif // _KERNEL_AMD64_MM_H

kernel/amd64/spin_lock.c

@@ -1,5 +1,3 @@
 #include <sys/spin_lock.h>
 
-void spin_lock_relax(void) {
+void spin_lock_relax (void) { __asm__ volatile ("pause"); }
-  __asm__ volatile("pause");
-}

kernel/amd64/tss.c

@@ -1,8 +1,7 @@
-#include <libk/std.h>
 #include <amd64/tss.h>
+#include <aux/compiler.h>
+#include <libk/std.h>
 
-__attribute__((aligned(16))) static volatile struct tss tss;
+ALIGNED (16) static volatile struct tss tss;
 
-volatile struct tss *amd64_get_tss(void) {
+volatile struct tss* amd64_get_tss (void) { return &tss; }
-  return &tss;
-}

kernel/amd64/tss.h

@@ -1,6 +1,7 @@
 #ifndef _KERNEL_AMD64_TSS_H
 #define _KERNEL_AMD64_TSS_H
 
+#include <aux/compiler.h>
 #include <libk/std.h>
 
 struct tss {
@@ -13,8 +14,8 @@ struct tss {
   uint64_t resv2;
   uint16_t resv3;
   uint16_t iopb_off;
-} __attribute__((packed));
+} PACKED;
 
-volatile struct tss *amd64_get_tss(void);
+volatile struct tss* amd64_get_tss (void);
 
 #endif // _KERNEL_AMD64_TSS_H

kernel/amd64/vars.mk

@@ -0,0 +1,2 @@
+# make vars
+PLATFORM_ACPI=1

kernel/aux/compiler.h

@@ -0,0 +1,8 @@
+#ifndef _KERNEL_AUX_COMPILER_H
+#define _KERNEL_AUX_COMPILER_H
+
+#define PACKED        __attribute__ ((packed))
+#define ALIGNED(N)    __attribute__ ((aligned ((N))))
+#define SECTION(name) __attribute__ ((section (name)))
+
+#endif // _KERNEL_AUX_COMPILER_H

kernel/flags.mk

@@ -1,2 +1,6 @@
 include $(platform)/flags.mk
 include generic/flags.mk
+
+ifeq ($(PLATFORM_ACPI),1)
+	include uACPI/flags.mk
+endif

kernel/libk/align.h

@@ -2,7 +2,7 @@
 #define _KERNEL_LIBK_ALIGN_H
 
 #define div_align_up(x, div) (((x) + (div) - 1) / (div))
-#define align_down(x, a)  ((x) & ~((a) - 1))
+#define align_down(x, a)     ((x) & ~((a) - 1))
-#define align_up(x, a)  (((x) + ((a) - 1)) & ~((a) - 1))
+#define align_up(x, a)       (((x) + ((a) - 1)) & ~((a) - 1))
 
 #endif // _KERNEL_LIBK_ALIGN_H

kernel/libk/bm.c

@@ -1,74 +1,74 @@
-#include <libk/std.h>
 #include <libk/bm.h>
+#include <libk/std.h>
 #include <libk/string.h>
 
-void bm_init(struct bm *bm, uint8_t *base, size_t nbits) {
+void bm_init (struct bm* bm, uint8_t* base, size_t nbits) {
   bm->base = base;
   bm->nbits = nbits;
-  memset(bm->base, 0, (nbits + 7) / 8);
+  memset (bm->base, 0, (nbits + 7) / 8);
 }
 
 /*
  * Set a bit in a bitmap.
  */
-void bm_set(struct bm *bm, size_t k) {
+void bm_set (struct bm* bm, size_t k) {
   if (k >= bm->nbits)
     return;
 
-  uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
+  uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
   *b = ((*b) | (1 << (k % 8)));
 }
 
 /*
  * Clear a bit in a bitmap.
  */
-void bm_clear(struct bm *bm, size_t k) {
+void bm_clear (struct bm* bm, size_t k) {
   if (k >= bm->nbits)
     return;
 
-  uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
+  uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
   *b = ((*b) & ~(1 << (k % 8)));
 }
 
 /*
  * Test (true/false) a bit in a bitmap.
  */
-bool bm_test(struct bm *bm, size_t k) {
+bool bm_test (struct bm* bm, size_t k) {
   if (k >= bm->nbits)
     return false;
 
-  uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
+  uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
   return (*b) & (1 << (k % 8));
 }
 
 /*
  * Set a range of bits in a bitmap. if starting bit is out of range, we fail.
  */
-bool bm_set_region(struct bm *bm, size_t k, size_t m) {
+bool bm_set_region (struct bm* bm, size_t k, size_t m) {
   if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
     return false;
 
   for (size_t i = k; i < m; i++) {
-    bool taken = bm_test(bm, i);
+    bool taken = bm_test (bm, i);
     if (taken)
       return false;
   }
 
   for (size_t i = k; i < m; i++)
-    bm_set(bm, i);
+    bm_set (bm, i);
-  
+
   return true;
 }
 
 /*
  * Clear a range of bits in a bitmap. starting bit must be in range.
  */
-void bm_clear_region(struct bm *bm, size_t k, size_t m) {
+void bm_clear_region (struct bm* bm, size_t k, size_t m) {
   if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
     return;
 
   for (size_t i = k; i < m; i++)
-    bm_clear(bm, i);
+    bm_clear (bm, i);
 }
 
 /*
@@ -77,12 +77,12 @@ void bm_clear_region(struct bm *bm, size_t k, size_t m) {
  * are out of range, act as if the bits are set / bitmap is full - this is
  * useful for implementing the physical memory manager algorithm.
  */
-bool bm_test_region(struct bm *bm, size_t k, size_t m) {
+bool bm_test_region (struct bm* bm, size_t k, size_t m) {
   if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
     return true;
 
   for (size_t i = k; i < m; i++) {
-    bool test = bm_test(bm, i);
+    bool test = bm_test (bm, i);
     if (test)
       return true;
   }

kernel/libk/bm.h

@@ -4,16 +4,16 @@
 #include <libk/std.h>
 
 struct bm {
-  uint8_t *base;
+  uint8_t* base;
   size_t nbits;
 };
 
-void bm_init(struct bm *bm, uint8_t *base, size_t nbits);
+void bm_init (struct bm* bm, uint8_t* base, size_t nbits);
-void bm_set(struct bm *bm, size_t k);
+void bm_set (struct bm* bm, size_t k);
-bool bm_set_region(struct bm *bm, size_t k, size_t m);
+bool bm_set_region (struct bm* bm, size_t k, size_t m);
-void bm_clear(struct bm *bm, size_t k);
+void bm_clear (struct bm* bm, size_t k);
-void bm_clear_region(struct bm *bm, size_t k, size_t m);
+void bm_clear_region (struct bm* bm, size_t k, size_t m);
-bool bm_test(struct bm *bm, size_t k);
+bool bm_test (struct bm* bm, size_t k);
-bool bm_test_region(struct bm *bm, size_t k, size_t m);
+bool bm_test_region (struct bm* bm, size_t k, size_t m);
 
 #endif // _KERNEL_LIBK_BM_H

kernel/libk/putchar_.c

@@ -1,3 +1,2 @@
 
-void putchar_(char x) { (void)x; }
+void putchar_ (char x) { (void)x; }
-

kernel/libk/std.h

@@ -4,10 +4,10 @@
 #include <limits.h>
 #include <stdalign.h>
 #include <stdarg.h>
+#include <stdatomic.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdnoreturn.h>
-#include <stdatomic.h>
 
 #endif // _KERNEL_LIBK_STD_H

kernel/libk/string.c

@@ -1,17 +1,17 @@
 #include <libk/std.h>
 #include <libk/string.h>
 
-size_t memset(void *dst, uint8_t b, size_t n) {
+size_t memset (void* dst, uint8_t b, size_t n) {
-  uint8_t *dst1 = dst;
+  uint8_t* dst1 = dst;
   size_t i;
   for (i = 0; i < n; i++)
     dst1[i] = b;
   return i;
 }
 
-size_t memcpy(void *dst, const void *src, size_t n) {
+size_t memcpy (void* dst, const void* src, size_t n) {
-  uint8_t *dst1 = dst;
+  uint8_t* dst1 = dst;
-  const uint8_t *src1 = src;
+  const uint8_t* src1 = src;
   size_t i;
   for (i = 0; i < n; i++)
     dst1[i] = src1[i];
@@ -19,20 +19,22 @@ size_t memcpy(void *dst, const void *src, size_t n) {
 }
 
 // SOURCE: https://stackoverflow.com/a/48967408
-void strncpy(char* dst, const char* src, size_t n) {
+void strncpy (char* dst, const char* src, size_t n) {
-   size_t i = 0;
+  size_t i = 0;
-   while(i++ != n && (*dst++ = *src++));
+  while (i++ != n && (*dst++ = *src++))
+    ;
 }
 
-size_t strlen(const char *str) {
+size_t strlen (const char* str) {
-  const char *s;
+  const char* s;
-  for (s = str; *s; ++s);
+  for (s = str; *s; ++s)
+    ;
   return (s - str);
 }
 
-int memcmp(const void *s1, const void *s2, size_t n) {
+int memcmp (const void* s1, const void* s2, size_t n) {
-  unsigned char *p = (unsigned char *)s1;
+  unsigned char* p = (unsigned char*)s1;
-  unsigned char *q = (unsigned char *)s2;
+  unsigned char* q = (unsigned char*)s2;
 
   while (n--) {
     if (*p != *q) {

kernel/libk/string.h

@@ -1,10 +1,10 @@
 #ifndef _KERNEL_LIBK_STRING_H
 #define _KERNEL_LIBK_STRING_H
 
-size_t memset(void *dst, uint8_t b, size_t n);
+size_t memset (void* dst, uint8_t b, size_t n);
-size_t memcpy(void *dst, const void *src, size_t n);
+size_t memcpy (void* dst, const void* src, size_t n);
-void strncpy(char* dst, const char* src, size_t n);
+void strncpy (char* dst, const char* src, size_t n);
-size_t strlen(const char *str);
+size_t strlen (const char* str);
-int memcmp(const void *s1, const void *s2, size_t n);
+int memcmp (const void* s1, const void* s2, size_t n);
 
 #endif // _KERNEL_LIBK_STRING_H

kernel/limine/requests.c

@@ -1,20 +1,20 @@
+#include <aux/compiler.h>
 #include <limine/limine.h>
 
-#define DECL_REQ(small, big) \
+#define DECL_REQ(small, big)                                                   \
-  __attribute__((used, section(".limine_requests"))) \
+  SECTION (".limine_requests")                                                 \
-  struct limine_ ## small ## _request limine_ ## small ## _request = { \
+  struct limine_##small##_request limine_##small##_request = {                 \
-    .id = LIMINE_ ## big ## _REQUEST_ID, \
+      .id = LIMINE_##big##_REQUEST_ID, .revision = 4}
-    .revision = 4 \
-  }
 
-__attribute__((used, section(".limine_requests")))
+SECTION (".limine_requests")
-volatile uint64_t limine_base_revision[] = LIMINE_BASE_REVISION(4);
+volatile uint64_t limine_base_revision[] = LIMINE_BASE_REVISION (4);
 
-__attribute__((used, section(".limine_requests_start")))
+SECTION (".limine_requests_start")
 volatile uint64_t limine_requests_start_marker[] = LIMINE_REQUESTS_START_MARKER;
 
-__attribute__((used, section(".limine_requests_end")))
+SECTION (".limine_requests_end")
 volatile uint64_t limine_requests_end_marker[] = LIMINE_REQUESTS_END_MARKER;
 
-DECL_REQ(hhdm, HHDM);
+DECL_REQ (hhdm, HHDM);
-DECL_REQ(memmap, MEMMAP);
+DECL_REQ (memmap, MEMMAP);
+DECL_REQ (rsdp, RSDP);

kernel/limine/requests.h

@@ -3,10 +3,11 @@
 
 #include <limine/limine.h>
 
-#define EXTERN_REQ(small) \
+#define EXTERN_REQ(small)                                                      \
-  extern struct limine_ ## small ## _request limine_ ## small ## _request
+  extern struct limine_##small##_request limine_##small##_request
 
-EXTERN_REQ(hhdm);
+EXTERN_REQ (hhdm);
-EXTERN_REQ(memmap);
+EXTERN_REQ (memmap);
+EXTERN_REQ (rsdp);
 
 #endif // _KERNEL_LIMINE_REQUESTS_H

kernel/mm/liballoc.c

@@ -1,79 +1,75 @@
 /* liballoc breaks when optimized too aggressively, for eg. clang's -Oz */
 #pragma clang optimize off
 
+#include <limine/requests.h>
 #include <mm/liballoc.h>
 #include <mm/pmm.h>
 #include <mm/types.h>
 #include <sync/spin_lock.h>
-#include <limine/requests.h>
 
 /* Porting */
 spin_lock_t _liballoc_lock = SPIN_LOCK_INIT;
 
-int liballoc_lock(void) {
+int liballoc_lock (void) {
-  spin_lock(&_liballoc_lock);
+  spin_lock (&_liballoc_lock);
   return 0;
 }
 
-int liballoc_unlock(void) {
+int liballoc_unlock (void) {
-  spin_unlock(&_liballoc_lock);
+  spin_unlock (&_liballoc_lock);
   return 0;
 }
 
-void *liballoc_alloc(int pages) {
+void* liballoc_alloc (int pages) {
-  physaddr_t p_addr = pmm_alloc(pages);
+  physaddr_t p_addr = pmm_alloc (pages);
 
   if (p_addr == PMM_ALLOC_ERR)
     return NULL;
 
-  struct limine_hhdm_response *hhdm = limine_hhdm_request.response;
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
   uintptr_t addr = (uintptr_t)(p_addr + hhdm->offset);
-  return (void *)addr;
+  return (void*)addr;
 }
 
-int liballoc_free(void *ptr, int pages) {
+int liballoc_free (void* ptr, int pages) {
-  struct limine_hhdm_response *hhdm = limine_hhdm_request.response;
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
 
   physaddr_t p_addr = (uintptr_t)ptr - hhdm->offset;
 
-  pmm_free(p_addr, pages);
+  pmm_free (p_addr, pages);
 
   return 0;
 }
 
 /**  Durand's Ridiculously Amazing Super Duper Memory functions.  */
 
-//#define DEBUG	
+//#define DEBUG
 
-#define LIBALLOC_MAGIC	0xc001c0de
+#define LIBALLOC_MAGIC 0xc001c0de
-#define MAXCOMPLETE		5
+#define MAXCOMPLETE    5
-#define MAXEXP	32
+#define MAXEXP         32
-#define MINEXP	8	
+#define MINEXP         8
 
-#define MODE_BEST			0
+#define MODE_BEST    0
-#define MODE_INSTANT		1
+#define MODE_INSTANT 1
 
-#define MODE	MODE_BEST
+#define MODE MODE_BEST
 
 #ifdef DEBUG
 #include <stdio.h>
 #endif
 
-
+struct boundary_tag* l_freePages[MAXEXP]; //< Allowing for 2^MAXEXP blocks
-struct boundary_tag* l_freePages[MAXEXP];		//< Allowing for 2^MAXEXP blocks
+int l_completePages[MAXEXP];              //< Allowing for 2^MAXEXP blocks
-int 				 l_completePages[MAXEXP];	//< Allowing for 2^MAXEXP blocks
-
 
 #ifdef DEBUG
-unsigned int l_allocated = 0;		//< The real amount of memory allocated.
+unsigned int l_allocated = 0; //< The real amount of memory allocated.
-unsigned int l_inuse = 0;			//< The amount of memory in use (malloc'ed). 
+unsigned int l_inuse = 0;     //< The amount of memory in use (malloc'ed).
 #endif
 
-
+static int l_initialized = 0; //< Flag to indicate initialization.
-static int l_initialized = 0;			//< Flag to indicate initialization.	
+static int l_pageSize = 4096; //< Individual page size
-static int l_pageSize  = 4096;			//< Individual page size
+static int l_pageCount = 16;  //< Minimum number of pages to allocate.
-static int l_pageCount = 16;			//< Minimum number of pages to allocate.
-
 
 // ***********   HELPER FUNCTIONS  *******************************
 
@@ -81,495 +77,457 @@ static int l_pageCount = 16;			//< Minimum number of pages to allocate.
  *
  *  Returns n where  2^n <= size < 2^(n+1)
  */
-static inline int getexp( unsigned int size )
+static inline int getexp (unsigned int size) {
-{
+  if (size < (1 << MINEXP)) {
-	if ( size < (1<<MINEXP) ) 
+#ifdef DEBUG
-	{
+    printf ("getexp returns -1 for %i less than MINEXP\n", size);
-		#ifdef DEBUG
+#endif
-		printf("getexp returns -1 for %i less than MINEXP\n", size );
+    return -1; // Smaller than the quantum.
-		#endif
+  }
-		return -1;	// Smaller than the quantum.
-	}
-		
-		
-	int shift = MINEXP;
 
-	while ( shift < MAXEXP )
+  int shift = MINEXP;
-	{
-		if ( (1<<shift) > size ) break;
-		shift += 1;
-	}
 
-	#ifdef DEBUG
+  while (shift < MAXEXP) {
-	printf("getexp returns %i (%i bytes) for %i size\n", shift - 1, (1<<(shift -1)), size );
+    if ((1 << shift) > size)
-	#endif
+      break;
+    shift += 1;
+  }
 
-	return shift - 1;	
+#ifdef DEBUG
+  printf ("getexp returns %i (%i bytes) for %i size\n", shift - 1,
+          (1 << (shift - 1)), size);
+#endif
+
+  return shift - 1;
 }
 
+static void* liballoc_memset (void* s, int c, size_t n) {
+  size_t i;
+  for (i = 0; i < n; i++)
+    ((char*)s)[i] = c;
 
-static void* 	liballoc_memset(void* s, int c, size_t n)
+  return s;
-{
-	size_t i;
-	for ( i = 0; i < n ; i++)
-		((char*)s)[i] = c;
-	
-	return s;
 }
 
-static void* 	liballoc_memcpy(void* s1, const void* s2, size_t n)
+static void* liballoc_memcpy (void* s1, const void* s2, size_t n) {
-{
+  char* cdest;
-  char *cdest;
+  char* csrc;
-  char *csrc;
+  unsigned int* ldest = (unsigned int*)s1;
-  unsigned int *ldest = (unsigned int*)s1;
+  unsigned int* lsrc = (unsigned int*)s2;
-  unsigned int *lsrc  = (unsigned int*)s2;
 
-  while ( n >= sizeof(unsigned int) )
+  while (n >= sizeof (unsigned int)) {
-  {
+    *ldest++ = *lsrc++;
-      *ldest++ = *lsrc++;
+    n -= sizeof (unsigned int);
-	  n -= sizeof(unsigned int);
   }
 
   cdest = (char*)ldest;
-  csrc  = (char*)lsrc;
+  csrc = (char*)lsrc;
-  
+
-  while ( n > 0 )
+  while (n > 0) {
-  {
+    *cdest++ = *csrc++;
-      *cdest++ = *csrc++;
+    n -= 1;
-	  n -= 1;
   }
-  
+
   return s1;
 }
 
- 
-
 #ifdef DEBUG
-static void dump_array()
+static void dump_array () {
-{
+  int i = 0;
-	int i = 0;
+  struct boundary_tag* tag = NULL;
-	struct boundary_tag *tag = NULL;
 
-	printf("------ Free pages array ---------\n");
+  printf ("------ Free pages array ---------\n");
-	printf("System memory allocated: %i\n", l_allocated );
+  printf ("System memory allocated: %i\n", l_allocated);
-	printf("Memory in used (malloc'ed): %i\n", l_inuse );
+  printf ("Memory in used (malloc'ed): %i\n", l_inuse);
 
-		for ( i = 0; i < MAXEXP; i++ )
+  for (i = 0; i < MAXEXP; i++) {
-		{
+    printf ("%.2i(%i): ", i, l_completePages[i]);
-			printf("%.2i(%i): ",i, l_completePages[i] );
-	
-			tag = l_freePages[ i ];
-			while ( tag != NULL )
-			{
-				if ( tag->split_left  != NULL  ) printf("*");
-				printf("%i", tag->real_size );
-				if ( tag->split_right != NULL  ) printf("*");
-	
-				printf(" ");
-				tag = tag->next;
-			}
-			printf("\n");
-		}
 
-	printf("'*' denotes a split to the left/right of a tag\n");
+    tag = l_freePages[i];
-	fflush( stdout );
+    while (tag != NULL) {
+      if (tag->split_left != NULL)
+        printf ("*");
+      printf ("%i", tag->real_size);
+      if (tag->split_right != NULL)
+        printf ("*");
+
+      printf (" ");
+      tag = tag->next;
+    }
+    printf ("\n");
+  }
+
+  printf ("'*' denotes a split to the left/right of a tag\n");
+  fflush (stdout);
 }
 #endif
 
+static inline void insert_tag (struct boundary_tag* tag, int index) {
+  int realIndex;
 
+  if (index < 0) {
+    realIndex = getexp (tag->real_size - sizeof (struct boundary_tag));
+    if (realIndex < MINEXP)
+      realIndex = MINEXP;
+  } else
+    realIndex = index;
 
-static inline void insert_tag( struct boundary_tag *tag, int index )
+  tag->index = realIndex;
-{
-	int realIndex;
-	
-	if ( index < 0 ) 
-	{
-		realIndex = getexp( tag->real_size - sizeof(struct boundary_tag) );
-		if ( realIndex < MINEXP ) realIndex = MINEXP;
-	}
-	else
-		realIndex = index;
-	
-	tag->index = realIndex;
-	
-	if ( l_freePages[ realIndex ] != NULL ) 
-	{
-		l_freePages[ realIndex ]->prev = tag;
-		tag->next = l_freePages[ realIndex ];
-	}
 
-	l_freePages[ realIndex ] = tag;
+  if (l_freePages[realIndex] != NULL) {
+    l_freePages[realIndex]->prev = tag;
+    tag->next = l_freePages[realIndex];
+  }
+
+  l_freePages[realIndex] = tag;
 }
 
-static inline void remove_tag( struct boundary_tag *tag )
+static inline void remove_tag (struct boundary_tag* tag) {
-{
+  if (l_freePages[tag->index] == tag)
-	if ( l_freePages[ tag->index ] == tag ) l_freePages[ tag->index ] = tag->next;
+    l_freePages[tag->index] = tag->next;
 
-	if ( tag->prev != NULL ) tag->prev->next = tag->next;
+  if (tag->prev != NULL)
-	if ( tag->next != NULL ) tag->next->prev = tag->prev;
+    tag->prev->next = tag->next;
+  if (tag->next != NULL)
+    tag->next->prev = tag->prev;
 
-	tag->next = NULL;
+  tag->next = NULL;
-	tag->prev = NULL;
+  tag->prev = NULL;
-	tag->index = -1;
+  tag->index = -1;
 }
 
+static inline struct boundary_tag* melt_left (struct boundary_tag* tag) {
+  struct boundary_tag* left = tag->split_left;
 
-static inline struct boundary_tag* melt_left( struct boundary_tag *tag )
+  left->real_size += tag->real_size;
-{
+  left->split_right = tag->split_right;
-	struct boundary_tag *left = tag->split_left;
-							
-	left->real_size   += tag->real_size;
-	left->split_right  = tag->split_right;
-	
-	if ( tag->split_right != NULL ) tag->split_right->split_left = left;
 
-	return left;
+  if (tag->split_right != NULL)
+    tag->split_right->split_left = left;
+
+  return left;
 }
 
+static inline struct boundary_tag* absorb_right (struct boundary_tag* tag) {
+  struct boundary_tag* right = tag->split_right;
 
-static inline struct boundary_tag* absorb_right( struct boundary_tag *tag )
+  remove_tag (right); // Remove right from free pages.
-{
-	struct boundary_tag *right = tag->split_right;
 
-		remove_tag( right );		// Remove right from free pages.
+  tag->real_size += right->real_size;
 
-		tag->real_size   += right->real_size;
+  tag->split_right = right->split_right;
+  if (right->split_right != NULL)
+    right->split_right->split_left = tag;
 
-		tag->split_right  = right->split_right;
+  return tag;
-		if ( right->split_right != NULL )
-					right->split_right->split_left = tag;
-
-	return tag;
 }
 
-static inline struct boundary_tag* split_tag( struct boundary_tag* tag )
+static inline struct boundary_tag* split_tag (struct boundary_tag* tag) {
-{
+  unsigned int remainder =
-	unsigned int remainder = tag->real_size - sizeof(struct boundary_tag) - tag->size;
+      tag->real_size - sizeof (struct boundary_tag) - tag->size;
-		
-	struct boundary_tag *new_tag = 
-				   (struct boundary_tag*)((uintptr_t)tag + sizeof(struct boundary_tag) + tag->size);	
-	
-						new_tag->magic = LIBALLOC_MAGIC;
-						new_tag->real_size = remainder;	
 
-						new_tag->next = NULL;
+  struct boundary_tag* new_tag =
-						new_tag->prev = NULL;
+      (struct boundary_tag*)((uintptr_t)tag + sizeof (struct boundary_tag) +
-	
+                             tag->size);
-						new_tag->split_left = tag;
+
-						new_tag->split_right = tag->split_right;
+  new_tag->magic = LIBALLOC_MAGIC;
-	
+  new_tag->real_size = remainder;
-						if (new_tag->split_right != NULL) new_tag->split_right->split_left = new_tag;
+
-						tag->split_right = new_tag;
+  new_tag->next = NULL;
-	
+  new_tag->prev = NULL;
-						tag->real_size -= new_tag->real_size;
+
-	
+  new_tag->split_left = tag;
-						insert_tag( new_tag, -1 );
+  new_tag->split_right = tag->split_right;
-	
+
-	return new_tag;
+  if (new_tag->split_right != NULL)
+    new_tag->split_right->split_left = new_tag;
+  tag->split_right = new_tag;
+
+  tag->real_size -= new_tag->real_size;
+
+  insert_tag (new_tag, -1);
+
+  return new_tag;
 }
 
-
 // ***************************************************************
 
+static struct boundary_tag* allocate_new_tag (unsigned int size) {
+  unsigned int pages;
+  unsigned int usage;
+  struct boundary_tag* tag;
 
+  // This is how much space is required.
+  usage = size + sizeof (struct boundary_tag);
 
+  // Perfect amount of space
+  pages = usage / l_pageSize;
+  if ((usage % l_pageSize) != 0)
+    pages += 1;
 
-static struct boundary_tag* allocate_new_tag( unsigned int size )
+  // Make sure it's >= the minimum size.
-{
+  if (pages < (unsigned int)l_pageCount)
-	unsigned int pages;
+    pages = l_pageCount;
-	unsigned int usage;
-	struct boundary_tag *tag;
 
-		// This is how much space is required.
+  tag = (struct boundary_tag*)liballoc_alloc (pages);
-		usage  = size + sizeof(struct boundary_tag);
 
-				// Perfect amount of space
+  if (tag == NULL)
-		pages = usage / l_pageSize;
+    return NULL; // uh oh, we ran out of memory.
-		if ( (usage % l_pageSize) != 0 ) pages += 1;
 
-		// Make sure it's >= the minimum size.
+  tag->magic = LIBALLOC_MAGIC;
-		if ( pages < (unsigned int)l_pageCount ) pages = l_pageCount;
+  tag->size = size;
+  tag->real_size = pages * l_pageSize;
+  tag->index = -1;
 
-		tag = (struct boundary_tag*)liballoc_alloc( pages );
+  tag->next = NULL;
+  tag->prev = NULL;
+  tag->split_left = NULL;
+  tag->split_right = NULL;
 
-		if ( tag == NULL ) return NULL;	// uh oh, we ran out of memory.
+#ifdef DEBUG
-		
+  printf ("Resource allocated %x of %i pages (%i bytes) for %i size.\n", tag,
-				tag->magic 		= LIBALLOC_MAGIC;
+          pages, pages * l_pageSize, size);
-				tag->size 		= size;
-				tag->real_size 	= pages * l_pageSize;
-				tag->index 		= -1;
 
-				tag->next		= NULL;
+  l_allocated += pages * l_pageSize;
-				tag->prev		= NULL;
-				tag->split_left 	= NULL;
-				tag->split_right 	= NULL;
 
+  printf ("Total memory usage = %i KB\n", (int)((l_allocated / (1024))));
+#endif
 
-		#ifdef DEBUG
+  return tag;
-		printf("Resource allocated %x of %i pages (%i bytes) for %i size.\n", tag, pages, pages * l_pageSize, size );
-
-		l_allocated += pages * l_pageSize;
-
-		printf("Total memory usage = %i KB\n",  (int)((l_allocated / (1024))) );
-		#endif
-		
-      return tag;
 }
 
+void* malloc (size_t size) {
+  int index;
+  void* ptr;
+  struct boundary_tag* tag = NULL;
 
+  liballoc_lock ();
 
-void *malloc(size_t size)
+  if (l_initialized == 0) {
-{
+#ifdef DEBUG
-	int index;
+    printf ("%s\n", "liballoc initializing.");
-	void *ptr;
+#endif
-	struct boundary_tag *tag = NULL;
+    for (index = 0; index < MAXEXP; index++) {
+      l_freePages[index] = NULL;
+      l_completePages[index] = 0;
+    }
+    l_initialized = 1;
+  }
 
-	liballoc_lock();
+  index = getexp (size) + MODE;
+  if (index < MINEXP)
+    index = MINEXP;
 
-		if ( l_initialized == 0 )
+  // Find one big enough.
-		{
+  tag = l_freePages[index]; // Start at the front of the list.
-			#ifdef DEBUG
+  while (tag != NULL) {
-			printf("%s\n","liballoc initializing.");
+    // If there's enough space in this tag.
-			#endif
+    if ((tag->real_size - sizeof (struct boundary_tag)) >=
-			for ( index = 0; index < MAXEXP; index++ )
+        (size + sizeof (struct boundary_tag))) {
-			{
+#ifdef DEBUG
-				l_freePages[index] = NULL;
+      printf ("Tag search found %i >= %i\n",
-				l_completePages[index] = 0;
+              (tag->real_size - sizeof (struct boundary_tag)),
-			}
+              (size + sizeof (struct boundary_tag)));
-			l_initialized = 1;
+#endif
-		}
+      break;
+    }
 
-		index = getexp( size ) + MODE;
+    tag = tag->next;
-		if ( index < MINEXP ) index = MINEXP;
+  }
-		
 
-		// Find one big enough.
+  // No page found. Make one.
-			tag = l_freePages[ index ];				// Start at the front of the list.
+  if (tag == NULL) {
-			while ( tag != NULL )
+    if ((tag = allocate_new_tag (size)) == NULL) {
-			{
+      liballoc_unlock ();
-					// If there's enough space in this tag.
+      return NULL;
-				if ( (tag->real_size - sizeof(struct boundary_tag))
+    }
-								>= (size + sizeof(struct boundary_tag) ) )
-				{
-					#ifdef DEBUG
-					printf("Tag search found %i >= %i\n",(tag->real_size - sizeof(struct boundary_tag)), (size + sizeof(struct boundary_tag) ) );
-					#endif
-					break;
-				}
 
-				tag = tag->next;
+    index = getexp (tag->real_size - sizeof (struct boundary_tag));
-			}
+  } else {
+    remove_tag (tag);
 
-		
+    if ((tag->split_left == NULL) && (tag->split_right == NULL))
-			// No page found. Make one.
+      l_completePages[index] -= 1;
-			if ( tag == NULL )
+  }
-			{	
-				if ( (tag = allocate_new_tag( size )) == NULL )
-				{
-					liballoc_unlock();
-					return NULL;
-				}
-				
-				index = getexp( tag->real_size - sizeof(struct boundary_tag) );
-			}
-			else
-			{
-				remove_tag( tag );
 
-				if ( (tag->split_left == NULL) && (tag->split_right == NULL) )
+  // We have a free page.  Remove it from the free pages list.
-					l_completePages[ index ] -= 1;
-			}
-		
-		// We have a free page.  Remove it from the free pages list.
-	
-		tag->size = size;
 
-		// Removed... see if we can re-use the excess space.
+  tag->size = size;
 
-		#ifdef DEBUG
+  // Removed... see if we can re-use the excess space.
-		printf("Found tag with %i bytes available (requested %i bytes, leaving %i), which has exponent: %i (%i bytes)\n", tag->real_size - sizeof(struct boundary_tag), size, tag->real_size - size - sizeof(struct boundary_tag), index, 1<<index );
-		#endif
-		
-		unsigned int remainder = tag->real_size - size - sizeof( struct boundary_tag ) * 2; // Support a new tag + remainder
 
-		if ( ((int)(remainder) > 0) /*&& ( (tag->real_size - remainder) >= (1<<MINEXP))*/ )
+#ifdef DEBUG
-		{
+  printf (
-			int childIndex = getexp( remainder );
+      "Found tag with %i bytes available (requested %i bytes, leaving %i), which has exponent: %i (%i bytes)\n",
-	
+      tag->real_size - sizeof (struct boundary_tag), size,
-			if ( childIndex >= 0 )
+      tag->real_size - size - sizeof (struct boundary_tag), index, 1 << index);
-			{
+#endif
-				#ifdef DEBUG
-				printf("Seems to be splittable: %i >= 2^%i .. %i\n", remainder, childIndex, (1<<childIndex) );
-				#endif
 
-				struct boundary_tag *new_tag = split_tag( tag ); 
+  unsigned int remainder = tag->real_size - size -
+      sizeof (struct boundary_tag) * 2; // Support a new tag + remainder
 
-        (void)new_tag;
+  if (((int)(remainder) >
+       0) /*&& ( (tag->real_size - remainder) >= (1<<MINEXP))*/) {
+    int childIndex = getexp (remainder);
 
-				#ifdef DEBUG
+    if (childIndex >= 0) {
-				printf("Old tag has become %i bytes, new tag is now %i bytes (%i exp)\n", tag->real_size, new_tag->real_size, new_tag->index );
+#ifdef DEBUG
-				#endif
+      printf ("Seems to be splittable: %i >= 2^%i .. %i\n", remainder,
-			}	
+              childIndex, (1 << childIndex));
-		}
+#endif
-		
-		
 
-	ptr = (void*)((uintptr_t)tag + sizeof( struct boundary_tag ) );
+      struct boundary_tag* new_tag = split_tag (tag);
 
+      (void)new_tag;
 
-	
+#ifdef DEBUG
-	#ifdef DEBUG
+      printf ("Old tag has become %i bytes, new tag is now %i bytes (%i exp)\n",
-	l_inuse += size;
+              tag->real_size, new_tag->real_size, new_tag->index);
-	printf("malloc: %x,  %i, %i\n", ptr, (int)l_inuse / 1024, (int)l_allocated / 1024 );
+#endif
-	dump_array();
+    }
-	#endif
+  }
 
+  ptr = (void*)((uintptr_t)tag + sizeof (struct boundary_tag));
 
-	liballoc_unlock();
+#ifdef DEBUG
-	return ptr;
+  l_inuse += size;
+  printf ("malloc: %x,  %i, %i\n", ptr, (int)l_inuse / 1024,
+          (int)l_allocated / 1024);
+  dump_array ();
+#endif
+
+  liballoc_unlock ();
+  return ptr;
 }
 
+void free (void* ptr) {
+  int index;
+  struct boundary_tag* tag;
 
+  if (ptr == NULL)
+    return;
 
+  liballoc_lock ();
 
+  tag = (struct boundary_tag*)((uintptr_t)ptr - sizeof (struct boundary_tag));
 
-void free(void *ptr)
+  if (tag->magic != LIBALLOC_MAGIC) {
-{
+    liballoc_unlock (); // release the lock
-	int index;
+    return;
-	struct boundary_tag *tag;
+  }
 
-	if ( ptr == NULL ) return;
+#ifdef DEBUG
+  l_inuse -= tag->size;
+  printf ("free: %x, %i, %i\n", ptr, (int)l_inuse / 1024,
+          (int)l_allocated / 1024);
+#endif
 
-	liballoc_lock();
+  // MELT LEFT...
-	
+  while ((tag->split_left != NULL) && (tag->split_left->index >= 0)) {
+#ifdef DEBUG
+    printf (
+        "Melting tag left into available memory. Left was %i, becomes %i (%i)\n",
+        tag->split_left->real_size, tag->split_left->real_size + tag->real_size,
+        tag->split_left->real_size);
+#endif
+    tag = melt_left (tag);
+    remove_tag (tag);
+  }
 
-		tag = (struct boundary_tag*)((uintptr_t)ptr - sizeof( struct boundary_tag ));
+  // MELT RIGHT...
-	
+  while ((tag->split_right != NULL) && (tag->split_right->index >= 0)) {
-		if ( tag->magic != LIBALLOC_MAGIC ) 
+#ifdef DEBUG
-		{
+    printf (
-			liballoc_unlock();		// release the lock
+        "Melting tag right into available memory. This was was %i, becomes %i (%i)\n",
-			return;
+        tag->real_size, tag->split_right->real_size + tag->real_size,
-		}
+        tag->split_right->real_size);
+#endif
+    tag = absorb_right (tag);
+  }
 
+  // Where is it going back to?
+  index = getexp (tag->real_size - sizeof (struct boundary_tag));
+  if (index < MINEXP)
+    index = MINEXP;
 
+  // A whole, empty block?
+  if ((tag->split_left == NULL) && (tag->split_right == NULL)) {
+    if (l_completePages[index] == MAXCOMPLETE) {
+      // Too many standing by to keep. Free this one.
+      unsigned int pages = tag->real_size / l_pageSize;
 
-		#ifdef DEBUG
+      if ((tag->real_size % l_pageSize) != 0)
-		l_inuse -= tag->size;
+        pages += 1;
-		printf("free: %x, %i, %i\n", ptr, (int)l_inuse / 1024, (int)l_allocated / 1024 );
+      if (pages < (unsigned int)l_pageCount)
-		#endif
+        pages = l_pageCount;
-		
 
-		// MELT LEFT...
+      liballoc_free (tag, pages);
-		while ( (tag->split_left != NULL) && (tag->split_left->index >= 0) )
-		{
-			#ifdef DEBUG
-			printf("Melting tag left into available memory. Left was %i, becomes %i (%i)\n", tag->split_left->real_size, tag->split_left->real_size + tag->real_size, tag->split_left->real_size );
-			#endif
-			tag = melt_left( tag );
-			remove_tag( tag );
-		}
 
-		// MELT RIGHT...
+#ifdef DEBUG
-		while ( (tag->split_right != NULL) && (tag->split_right->index >= 0) )
+      l_allocated -= pages * l_pageSize;
-		{
+      printf ("Resource freeing %x of %i pages\n", tag, pages);
-			#ifdef DEBUG
+      dump_array ();
-			printf("Melting tag right into available memory. This was was %i, becomes %i (%i)\n", tag->real_size, tag->split_right->real_size + tag->real_size, tag->split_right->real_size );
+#endif
-			#endif
-			tag = absorb_right( tag );
-		}
 
-		
+      liballoc_unlock ();
-		// Where is it going back to?
+      return;
-		index = getexp( tag->real_size - sizeof(struct boundary_tag) );
+    }
-		if ( index < MINEXP ) index = MINEXP;
-		
-		// A whole, empty block?
-		if ( (tag->split_left == NULL) && (tag->split_right == NULL) )
-		{	
 
-			if ( l_completePages[ index ] == MAXCOMPLETE )
+    l_completePages[index] += 1; // Increase the count of complete pages.
-			{
+  }
-				// Too many standing by to keep. Free this one.
-				unsigned int pages = tag->real_size / l_pageSize;
 
-				if ( (tag->real_size % l_pageSize) != 0 ) pages += 1;
+  // ..........
-				if ( pages < (unsigned int)l_pageCount ) pages = l_pageCount;
 
-				liballoc_free( tag, pages );
+  insert_tag (tag, index);
 
-				#ifdef DEBUG
+#ifdef DEBUG
-				l_allocated -= pages * l_pageSize;
+  printf (
-				printf("Resource freeing %x of %i pages\n", tag, pages );
+      "Returning tag with %i bytes (requested %i bytes), which has exponent: %i\n",
-				dump_array();
+      tag->real_size, tag->size, index);
-				#endif
+  dump_array ();
+#endif
 
-				liballoc_unlock();
+  liballoc_unlock ();
-				return;
-			}
-
-
-			l_completePages[ index ] += 1;	// Increase the count of complete pages.
-		}
-
-
-		// ..........
-
-
-		insert_tag( tag, index );
-
-	#ifdef DEBUG
-	printf("Returning tag with %i bytes (requested %i bytes), which has exponent: %i\n", tag->real_size, tag->size, index ); 
-	dump_array();
-	#endif
-
-	liballoc_unlock();
 }
 
+void* calloc (size_t nobj, size_t size) {
+  int real_size;
+  void* p;
 
+  real_size = nobj * size;
 
+  p = malloc (real_size);
 
-void* calloc(size_t nobj, size_t size)
+  liballoc_memset (p, 0, real_size);
-{
-       int real_size;
-       void *p;
 
-       real_size = nobj * size;
+  return p;
-       
-       p = malloc( real_size );
-
-       liballoc_memset( p, 0, real_size );
-
-       return p;
 }
 
+void* realloc (void* p, size_t size) {
+  void* ptr;
+  struct boundary_tag* tag;
+  int real_size;
 
+  if (size == 0) {
+    free (p);
+    return NULL;
+  }
+  if (p == NULL)
+    return malloc (size);
 
-void*   realloc(void *p, size_t size)
+  if (&liballoc_lock != NULL)
-{
+    liballoc_lock (); // lockit
-	void *ptr;
+  tag = (struct boundary_tag*)((uintptr_t)p - sizeof (struct boundary_tag));
-	struct boundary_tag *tag;
+  real_size = tag->size;
-	int real_size;
+  if (&liballoc_unlock != NULL)
-	
+    liballoc_unlock ();
-	if ( size == 0 )
-	{
-		free( p );
-		return NULL;
-	}
-	if ( p == NULL ) return malloc( size );
 
-	if ( &liballoc_lock != NULL ) liballoc_lock();		// lockit
+  if ((size_t)real_size > size)
-		tag = (struct boundary_tag*)((uintptr_t)p - sizeof( struct boundary_tag ));
+    real_size = size;
-		real_size = tag->size;
-	if ( &liballoc_unlock != NULL ) liballoc_unlock();
 
-	if ( (size_t)real_size > size ) real_size = size;
+  ptr = malloc (size);
+  liballoc_memcpy (ptr, p, real_size);
+  free (p);
 
-	ptr = malloc( size );
+  return ptr;
-	liballoc_memcpy( ptr, p, real_size );
-	free( p );
-
-	return ptr;
 }
-
-
-

kernel/mm/liballoc.h

@@ -9,12 +9,11 @@
 
 #ifndef _HAVE_SIZE_T
 #define _HAVE_SIZE_T
-typedef	unsigned int	size_t;
+typedef unsigned int size_t;
 #endif
 
-
+#ifndef NULL
-#ifndef	NULL
+#define NULL 0
-#define NULL		0
 #endif
 
 #endif
@@ -23,29 +22,24 @@ typedef	unsigned int	size_t;
 extern "C" {
 #endif
 
-
 /** This is a boundary tag which is prepended to the
  * page or section of a page which we have allocated. It is
  * used to identify valid memory blocks that the
  * application is trying to free.
  */
-struct	boundary_tag
+struct boundary_tag {
-{
+  unsigned int magic;     //< It's a kind of ...
-	unsigned int magic;			//< It's a kind of ...
+  unsigned int size;      //< Requested size.
-	unsigned int size; 			//< Requested size.
+  unsigned int real_size; //< Actual size.
-	unsigned int real_size;		//< Actual size.
+  int index;              //< Location in the page table.
-	int index;					//< Location in the page table.
 
-	struct boundary_tag *split_left;	//< Linked-list info for broken pages.	
+  struct boundary_tag* split_left;  //< Linked-list info for broken pages.
-	struct boundary_tag *split_right;	//< The same.
+  struct boundary_tag* split_right; //< The same.
-	
+
-	struct boundary_tag *next;	//< Linked list info.
+  struct boundary_tag* next; //< Linked list info.
-	struct boundary_tag *prev;	//< Linked list info.
+  struct boundary_tag* prev; //< Linked list info.
 };
 
-
- 
-
 /** This function is supposed to lock the memory data structures. It
  * could be as simple as disabling interrupts or acquiring a spinlock.
  * It's up to you to decide. 
@@ -53,7 +47,7 @@ struct	boundary_tag
  * \return 0 if the lock was acquired successfully. Anything else is
  * failure.
  */
-extern int liballoc_lock();
+extern int liballoc_lock ();
 
 /** This function unlocks what was previously locked by the liballoc_lock
  * function.  If it disabled interrupts, it enables interrupts. If it
@@ -61,7 +55,7 @@ extern int liballoc_lock();
  *
  * \return 0 if the lock was successfully released.
  */
-extern int liballoc_unlock();
+extern int liballoc_unlock ();
 
 /** This is the hook into the local system which allocates pages. It
  * accepts an integer parameter which is the number of pages
@@ -70,7 +64,7 @@ extern int liballoc_unlock();
  * \return NULL if the pages were not allocated.
  * \return A pointer to the allocated memory.
  */
-extern void* liballoc_alloc(int);
+extern void* liballoc_alloc (int);
 
 /** This frees previously allocated memory. The void* parameter passed
  * to the function is the exact same value returned from a previous
@@ -80,20 +74,15 @@ extern void* liballoc_alloc(int);
  *
  * \return 0 if the memory was successfully freed.
  */
-extern int liballoc_free(void*,int);
+extern int liballoc_free (void*, int);
-
-       
-
-void     *malloc(size_t);				//< The standard function.
-void     *realloc(void *, size_t);		//< The standard function.
-void     *calloc(size_t, size_t);		//< The standard function.
-void      free(void *);					//< The standard function.
 
+void* malloc (size_t);         //< The standard function.
+void* realloc (void*, size_t); //< The standard function.
+void* calloc (size_t, size_t); //< The standard function.
+void free (void*);             //< The standard function.
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-
-

kernel/mm/pmm.c

@@ -1,52 +1,57 @@
-#include <libk/std.h>
-#include <libk/bm.h>
-#include <libk/string.h>
 #include <libk/align.h>
-#include <sys/mm.h>
+#include <libk/bm.h>
-#include <sys/debug.h>
+#include <libk/std.h>
-#include <sync/spin_lock.h>
+#include <libk/string.h>
-#include <mm/types.h>
-#include <mm/pmm.h>
 #include <limine/limine.h>
 #include <limine/requests.h>
+#include <mm/pmm.h>
+#include <mm/types.h>
+#include <sync/spin_lock.h>
+#include <sys/debug.h>
+#include <sys/mm.h>
 
 static struct pmm pmm;
 
-void pmm_init(void) {
+void pmm_init (void) {
-  memset(&pmm, 0, sizeof(pmm));
+  memset (&pmm, 0, sizeof (pmm));
 
-  struct limine_memmap_response *memmap = limine_memmap_request.response;
+  struct limine_memmap_response* memmap = limine_memmap_request.response;
-  struct limine_hhdm_response *hhdm = limine_hhdm_request.response;
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
 
   size_t region = 0;
   for (size_t i = 0; i < memmap->entry_count; i++) {
-    struct limine_memmap_entry *entry = memmap->entries[i];
+    struct limine_memmap_entry* entry = memmap->entries[i];
-    static const char *entry_strings[] = {
+    static const char* entry_strings[] = {"usable",
-      "usable", "reserved", "acpi reclaimable", "acpi nvs",
+                                          "reserved",
-      "bad memory", "bootloader reclaimable", "executable and modules",
+                                          "acpi reclaimable",
-      "framebuffer", "acpi tables"
+                                          "acpi nvs",
-    };
+                                          "bad memory",
+                                          "bootloader reclaimable",
+                                          "executable and modules",
+                                          "framebuffer",
+                                          "acpi tables"};
 
-    DEBUG("memmap entry: %-25s %p (%zu bytes)\n", entry_strings[entry->type], entry->base, entry->length);
+    DEBUG ("memmap entry: %-25s %p (%zu bytes)\n", entry_strings[entry->type],
+           entry->base, entry->length);
 
     if (entry->type == LIMINE_MEMMAP_USABLE && region < PMM_REGIONS_MAX) {
-      struct pmm_region *pmm_region = &pmm.regions[region];
+      struct pmm_region* pmm_region = &pmm.regions[region];
 
       /*
        * We need to calculate sizes for the pmm region and the bitmap. The bitmap MUSTN'T include it's
        * own region within the bit range.
        * */
 
-      size_t size = align_down(entry->length, PAGE_SIZE);
+      size_t size = align_down (entry->length, PAGE_SIZE);
-      physaddr_t start = align_up(entry->base, PAGE_SIZE);
+      physaddr_t start = align_up (entry->base, PAGE_SIZE);
 
       size_t max_pages = (size * 8) / (PAGE_SIZE * 8 + 1);
 
       size_t bm_nbits = max_pages;
-      size_t bm_size = align_up(bm_nbits, 8) / 8;
+      size_t bm_size = align_up (bm_nbits, 8) / 8;
 
       physaddr_t bm_base = start;
-      physaddr_t data_base = align_up(bm_base + bm_size, PAGE_SIZE);
+      physaddr_t data_base = align_up (bm_base + bm_size, PAGE_SIZE);
 
       if (bm_base + bm_size >= start + size)
         continue;
@@ -57,22 +62,22 @@ void pmm_init(void) {
 
       if (final_pages < max_pages) {
         bm_nbits = final_pages;
-        bm_size = align_up(bm_nbits, 8) / 8;
+        bm_size = align_up (bm_nbits, 8) / 8;
-        data_base = align_up(bm_base + bm_size, PAGE_SIZE);
+        data_base = align_up (bm_base + bm_size, PAGE_SIZE);
       }
 
       size_t managed_size = final_pages * PAGE_SIZE;
 
-      uint8_t *bm_base1 = (uint8_t *)(bm_base + hhdm->offset);
+      uint8_t* bm_base1 = (uint8_t*)(bm_base + hhdm->offset);
 
       /* Init the pm region. */
       pmm_region->lock = SPIN_LOCK_INIT;
       pmm_region->membase = data_base;
       pmm_region->size = managed_size;
-      bm_init(&pmm_region->bm, bm_base1, bm_nbits);
+      bm_init (&pmm_region->bm, bm_base1, bm_nbits);
-      bm_clear_region(&pmm_region->bm, 0, bm_nbits);
+      bm_clear_region (&pmm_region->bm, 0, bm_nbits);
       pmm_region->flags |= PMM_REGION_ACTIVE; /* mark as active */
-      
+
       region++;
     }
   }
@@ -82,9 +87,10 @@ void pmm_init(void) {
  * Find free space for a block range. For every bit of the bitmap, we test nblks bits forward.
  * bm_test_region helps us out, because it automatically does range checks. See comments there.
  */
-static size_t pmm_find_free_space(struct pmm_region *pmm_region, size_t nblks) {
+static size_t pmm_find_free_space (struct pmm_region* pmm_region,
+                                   size_t nblks) {
   for (size_t bit = 0; bit < pmm_region->bm.nbits; bit++) {
-    if (bm_test_region(&pmm_region->bm, bit, nblks)) {
+    if (bm_test_region (&pmm_region->bm, bit, nblks)) {
       continue;
     }
 
@@ -94,56 +100,57 @@ static size_t pmm_find_free_space(struct pmm_region *pmm_region, size_t nblks) {
   return (size_t)-1;
 }
 
-physaddr_t pmm_alloc(size_t nblks) {
+physaddr_t pmm_alloc (size_t nblks) {
   for (size_t region = 0; region < PMM_REGIONS_MAX; region++) {
-    struct pmm_region *pmm_region = &pmm.regions[region];
+    struct pmm_region* pmm_region = &pmm.regions[region];
 
     /* Inactive region, so don't bother with it. */
     if (!(pmm_region->flags & PMM_REGION_ACTIVE))
       continue;
 
-    spin_lock(&pmm_region->lock);
+    spin_lock (&pmm_region->lock);
 
     /* Find starting bit of the free bit range */
-    size_t bit = pmm_find_free_space(pmm_region, nblks);
+    size_t bit = pmm_find_free_space (pmm_region, nblks);
 
     /* Found a free range? */
     if (bit != (size_t)-1) {
       /* Mark it */
-      bm_set_region(&pmm_region->bm, bit, nblks);
+      bm_set_region (&pmm_region->bm, bit, nblks);
-      spin_unlock(&pmm_region->lock);
+      spin_unlock (&pmm_region->lock);
 
       return pmm_region->membase + bit * PAGE_SIZE;
     }
 
-    spin_unlock(&pmm_region->lock);
+    spin_unlock (&pmm_region->lock);
   }
 
   return PMM_ALLOC_ERR;
 }
 
-void pmm_free(physaddr_t p_addr, size_t nblks) {
+void pmm_free (physaddr_t p_addr, size_t nblks) {
   /* Round down to nearest page boundary */
-  physaddr_t aligned_p_addr = align_down(p_addr, PAGE_SIZE);
+  physaddr_t aligned_p_addr = align_down (p_addr, PAGE_SIZE);
 
   for (size_t region = 0; region < PMM_REGIONS_MAX; region++) {
-    struct pmm_region *pmm_region = &pmm.regions[region];
+    struct pmm_region* pmm_region = &pmm.regions[region];
 
     /* Inactive region, so don't bother with it. */
     if (!(pmm_region->flags & PMM_REGION_ACTIVE))
       continue;
 
     /* If aligned_p_addr is within the range if this region, it belongs to it. */
-    if (aligned_p_addr >= pmm_region->membase && aligned_p_addr < pmm_region->size) {
+    if (aligned_p_addr >= pmm_region->membase &&
+        aligned_p_addr < pmm_region->size) {
       physaddr_t addr = aligned_p_addr - pmm_region->membase;
 
-      size_t bit = div_align_up(addr, PAGE_SIZE);
+      size_t bit = div_align_up (addr, PAGE_SIZE);
 
-      spin_lock(&pmm_region->lock);
+      spin_lock (&pmm_region->lock);
-      
-      bm_clear_region(&pmm_region->bm, bit, nblks);
 
-      spin_unlock(&pmm_region->lock);
+      bm_clear_region (&pmm_region->bm, bit, nblks);
+
+      spin_unlock (&pmm_region->lock);
 
       break;
     }

kernel/mm/pmm.h

@@ -1,16 +1,16 @@
 #ifndef _KERNEL_MM_PMM_H
 #define _KERNEL_MM_PMM_H
 
-#include <libk/std.h>
 #include <libk/bm.h>
-#include <sync/spin_lock.h>
+#include <libk/std.h>
 #include <mm/types.h>
+#include <sync/spin_lock.h>
 
-#define PMM_ALLOC_ERR ((physaddr_t)-1)
+#define PMM_ALLOC_ERR ((physaddr_t) - 1)
 
 #define PMM_REGIONS_MAX 32
 
-#define PMM_REGION_ACTIVE     (1 << 0)
+#define PMM_REGION_ACTIVE (1 << 0)
 
 struct pmm_region {
   spin_lock_t lock;
@@ -24,8 +24,8 @@ struct pmm {
   struct pmm_region regions[PMM_REGIONS_MAX];
 };
 
-void pmm_init(void);
+void pmm_init (void);
-physaddr_t pmm_alloc(size_t nblks);
+physaddr_t pmm_alloc (size_t nblks);
-void pmm_free(physaddr_t p_addr, size_t nblks);
+void pmm_free (physaddr_t p_addr, size_t nblks);
 
 #endif // _KERNEL_MM_PMM_H

kernel/src.mk

@@ -3,3 +3,4 @@ include libk/src.mk
 include sync/src.mk
 include mm/src.mk
 include limine/src.mk
+include uACPI/src.mk

kernel/sync/spin_lock.c

@@ -1,12 +1,12 @@
 #include <libk/std.h>
-#include <sys/spin_lock.h>
 #include <sync/spin_lock.h>
+#include <sys/spin_lock.h>
 
-void spin_lock(spin_lock_t *sl) {
+void spin_lock (spin_lock_t* sl) {
-  while (atomic_flag_test_and_set_explicit(sl, memory_order_acquire))
+  while (atomic_flag_test_and_set_explicit (sl, memory_order_acquire))
-    spin_lock_relax();
+    spin_lock_relax ();
 }
 
-void spin_unlock(spin_lock_t *sl) {
+void spin_unlock (spin_lock_t* sl) {
-  atomic_flag_clear_explicit(sl, memory_order_release);
+  atomic_flag_clear_explicit (sl, memory_order_release);
 }

kernel/sync/spin_lock.h

@@ -3,11 +3,11 @@
 
 #include <libk/std.h>
 
-#define SPIN_LOCK_INIT  ATOMIC_FLAG_INIT
+#define SPIN_LOCK_INIT ATOMIC_FLAG_INIT
 
 typedef atomic_flag spin_lock_t;
 
-void spin_lock(spin_lock_t *sl);
+void spin_lock (spin_lock_t* sl);
-void spin_unlock(spin_lock_t *sl);
+void spin_unlock (spin_lock_t* sl);
 
 #endif // _KERNEL_SYNC_SPIN_LOCK_H

kernel/sys/debug.h

@@ -1,10 +1,11 @@
 #ifndef _KERNEL_SYS_DEBUG_H
 #define _KERNEL_SYS_DEBUG_H
 
-void debugprintf(const char *fmt, ...);
+void debugprintf (const char* fmt, ...);
 
-#define DEBUG(fmt, ...) do {                                      \
+#define DEBUG(fmt, ...)                                                        \
-    debugprintf("%s: " fmt, __func__, ##__VA_ARGS__);  \
+  do {                                                                         \
-  } while(0)
+    debugprintf ("%s: " fmt, __func__, ##__VA_ARGS__);                         \
+  } while (0)
 
 #endif // _KERNEL_SYS_DEBUG_H

kernel/sys/mm.h

@@ -2,7 +2,7 @@
 #define _KERNEL_SYS_MM_H
 
 #if defined(__x86_64__)
-  #include <amd64/mm.h>
+#include <amd64/mm.h>
 #endif
 
 #endif // _KERNEL_SYS_MM_H

kernel/sys/spin_lock.h

@@ -1,6 +1,6 @@
 #ifndef _KERNEL_SYS_SPIN_LOCK_H
 #define _KERNEL_SYS_SPIN_LOCK_H
 
-void spin_lock_relax(void);
+void spin_lock_relax (void);
 
 #endif // _KERNEL_SYS_SPIN_LOCK_H

kernel/uACPI/.github/workflows/main.yml

@@ -0,0 +1,81 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  lint-python-scripts:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install flake8 & mypy
+        run: |
+          sudo apt update
+          sudo apt install python3 python3-pip
+          export PIP_BREAK_SYSTEM_PACKAGES=1
+          pip install flake8 mypy
+
+      - name: Run flake8 on the project
+        run: flake8 --ignore=E743 tests/*.py tests/utilities/*.py tests/generated_test_cases/*.py
+
+      - name: Run mypy on the project
+        run: mypy --disallow-incomplete-defs --no-implicit-optional tests/*.py tests/utilities/*.py tests/generated_test_cases/*.py
+  build-and-run-tests:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+      - if: ${{ matrix.os != 'macos-latest' }}
+        name: Set up OpenWatcom
+        uses: open-watcom/setup-watcom@v0
+        with:
+          version: '2.0'
+      - if: ${{ matrix.os == 'ubuntu-latest' }}
+        name: Install tools & libraries (Ubuntu)
+        run: |
+          sudo apt update
+          sudo apt install python3 python3-pytest acpica-tools cmake gcc-multilib g++-multilib
+          # https://github.com/actions/runner-images/issues/9491#issuecomment-1989718917
+          sudo sysctl vm.mmap_rnd_bits=28
+      - if: ${{ matrix.os == 'macos-latest' }}
+        name: Install tools & libraries (MacOS)
+        run: |
+          export PIP_BREAK_SYSTEM_PACKAGES=1
+          brew install python3 acpica cmake
+          python3 -m pip install pytest
+      - if: ${{ matrix.os == 'windows-latest' }}
+        name: Install tools & libraries (Windows)
+        run: |
+          choco install python3 iasl cmake llvm
+          python3 -m pip install pytest
+
+      - name: Ensure reduced-hardware/unsized-frees/fmt-logging/no-kernel-init/builtin-string build compiles
+        run: |
+          cd ${{ github.workspace}}/tests/runner
+          mkdir reduced-hw-build && cd reduced-hw-build
+          cmake .. -DREDUCED_HARDWARE_BUILD=1 -DSIZED_FREES_BUILD=0 -DFORMATTED_LOGGING_BUILD=1 -DNATIVE_ALLOC_ZEROED=1 -DKERNEL_INITIALIZATION=0 -DBUILTIN_STRING=1
+          cmake --build .
+
+      - name: Run tests (64-bit)
+        run: python3 ${{ github.workspace }}/tests/run_tests.py --bitness=64 --large --barebones
+
+      # MacOS doesn't want to compile i386 (at least easily) so just ignore it:
+      #     ld: warning: The i386 architecture is deprecated for macOS
+      #     ld: dynamic executables or dylibs must link with libSystem.dylib for architecture i386
+      #     clang: error: linker command failed with exit code 1 (use -v to see invocation)
+      - if: ${{ matrix.os != 'macos-latest' }}
+        name: Run tests (32-bit)
+        run: python3 ${{ github.workspace }}/tests/run_tests.py --bitness=32 --large --barebones
+
+      - if: ${{ matrix.os != 'macos-latest' }}
+        name: Run tests (OpenWatcom)
+        run: python3 ${{ github.workspace }}/tests/run_tests.py --large --barebones --watcom

kernel/uACPI/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+*.aml
+*.dsl
+.idea/
+cmake-build-*/
+build-*/
+tests/bin/
+tests/acpi-dumps/
+__pycache__
+*.o

kernel/uACPI/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2025 Daniil Tatianin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kernel/uACPI/README.md

@@ -0,0 +1,401 @@
+# uACPI
+
+A portable and easy-to-integrate implementation of the Advanced Configuration and Power Interface (ACPI).
+
+[![CI](https://github.com/UltraOS/uACPI/actions/workflows/main.yml/badge.svg)](https://github.com/UltraOS/uACPI/actions/workflows/main.yml)
+
+## Features
+
+- A fast and well-tested AML interpreter optimized to use very little stack space
+- NT-compatible on a fundamental level (see [examples](#more-detailed-overview))
+- Very easy to integrate (ships with own overridable standard library implementation)
+- Highly flexible and configurable (optional sized frees, reduced-hw-only mode, etc.)
+- A fairly advanced event subsystem (GPE/fixed, wake, implicit notify, AML handlers)
+- Table management API (search, dynamic installation/loading, overrides, etc.)
+- Operation region subsystem (user handlers, support for BufferAcc opregions, builtins for common types)
+- Sleep state management (transition to any S state, wake vector programming)
+- PCI routing table retrieval & interrupt model API
+- Device search API
+- Resource subsystem supporting every resource defined by ACPI 6.6
+- Interface & feature management exposed via _OSI
+- Client-defined Notify() handlers
+- Firmware global lock management (_GL, locked fields, public API)
+- GAS read/write API
+- Fully thread safe
+- Supports both 32-bit and 64-bit platforms
+- A special barebones mode with only table API (see [config.h](include/uacpi/platform/config.h#L127))
+
+## Why would I use this over ACPICA?
+
+### 1. Performance
+
+uACPI shows a consistent speedup of about **3.5x** over ACPICA in synthetic AML tests.
+
+<details><summary>More details</summary>
+
+Code that was tested:
+```asl
+Method (TOMS, 2, NotSerialized) {
+    Return ((Arg1 - Arg0) / 10000)
+}
+
+Method (ADDM, 1, NotSerialized) {
+    Local0 = 0
+
+    While (Arg0) {
+        Local0 += Arg0 + Arg0
+        Arg0--
+    }
+
+    Return (Local0)
+}
+
+// Record start time
+Local0 = Timer
+
+// Run 10 million additions
+Local1 = ADDM(10000000)
+
+// Make sure the answer matches expected
+If (Local1 != 0x5AF31112D680) {
+    Printf("Bad test result %o", Local1)
+    Return (1)
+}
+
+// Record end time
+Local2 = Timer
+
+Printf("10,000,000 additions took %o ms",
+       ToDecimalString(TOMS(Local0, Local2)))
+```
+
+Compile options (acpiexec and uACPI's test-runner): `-O3 -flto -march=znver4 -mtune=znver4`  
+CPU: AMD Ryzen 9 9950X3D  
+Raw test scores (~average over 10 runs):
+- ACPICA: 16661 ms
+- uACPI: 4753 ms
+
+**Raw difference: 3.5053x**
+
+</details>
+
+Real hardware tests of the same operating system using uACPI vs ACPICA show
+at least a **1.75-2x speedup** while measuring the time it takes to load the initial
+AML namespace.
+
+<details><summary>More details</summary>
+
+OS: [proxima](https://github.com/proxima-os)
+
+Compile options: `-O3 -flto`
+
+### Test Subject 1
+
+Specs: Gigabyte B550M S2H, AMD Ryzen 5800X, 64GB RAM  
+Firmware: F19d (10097 AML opcodes)
+
+Results:
+- ACPICA: 3,936,953 ns
+- uACPI: 1,902,077 ns
+
+**Raw difference: 2.0698x**
+
+### Test Subject 2
+
+Specs: Toshiba Portege R30-A, Intel Core i5-4200M, 4GB RAM   
+Firmware: 4.40 (4962 AML opcodes)
+
+Results:
+- ACPICA: 10,899,233 ns
+- uACPI: 6,227,036 ns
+
+**Raw difference: 1.7503x**
+
+</details>
+
+### 2. NT-compatible from the ground up
+                              
+Over the decades of development, ACPICA has accumulated a lot of workarounds for
+AML expecting NT-specific behaviors, and is still missing compatibility in a lot
+of critical aspects.
+
+uACPI, on the other hand, is built to be natively NT-compatible without extra
+workarounds.
+
+Some specific highlights include:
+- Reference objects, especially multi-level reference chains
+- Implicit cast semantics
+- Object mutability
+- Named object resolution, especially for named objects inside packages
+                             
+### 3. Fundamental safety
+             
+uACPI is built to always assume the worst about the AML byte code it's executing,
+and as such, has a more sophisticated object lifetime tracking system, as well
+as carefully designed handling for various edge-cases, including race conditions.
+
+Some of the standard uACPI test cases crash both ACPICA, and the NT AML 
+interpreters.
+
+While a permanent fuzzing solution for uACPI is currently WIP, it has already
+been fuzzed quite extensively and all known issues have been fixed.
+
+### 4. No recursion
+
+Running at kernel level has a lot of very strict limitations, one of which is a
+tiny stack size, which can sometimes be only a few pages in length.
+
+Of course, both ACPICA and uACPI have non-recursive AML interpreters, but there
+are still edge cases that cause potentially unbounded recursion.
+
+One such example are the dynamic table load operators from AML
+(`Load`/`LoadTable`): these cause a linear growth in stack usage per call in
+ACPICA, whereas in uACPI these  are treated as special method calls,
+and as such, don't increase stack usage whatsoever.
+
+### More detailed overview
+Expressions within package:
+```asl
+Method (TEST) {
+    Local0 = 10
+    Local1 = Package { Local0 * 5 }
+    Return (DerefOf(Local1[0]))
+}
+
+// ACPICA: AE_SUPPORT, Expressions within package elements are not supported
+// Windows, uACPI: Local0 = 50
+Local0 = TEST()
+```
+
+Packages outside of a control method:
+```asl
+// ACPICA: internal error
+// Windows, uACPI: ok
+Local0 = Package { 1 }
+```
+
+Reference rebind semantics:
+```asl
+Local0 = 123
+Local1 = RefOf(Local0)
+
+// ACPICA: Local1 = 321, Local0 = 123
+// Windows, uACPI: Local1 = reference->Local0, Local0 = 321
+Local1 = 321
+```
+
+Increment/Decrement:
+```asl
+Local0 = 123
+Local1 = RefOf(Local0)
+
+// ACPICA: error
+// Windows, uACPI: Local0 = 124
+Local1++
+```
+
+Multilevel references:
+```asl
+Local0 = 123
+Local1 = RefOf(Local0)
+Local2 = RefOf(Local1)
+
+// ACPICA: Local3 = reference->Local0
+// Windows, uACPI: Local3 = 123
+Local3 = DerefOf(Local2)
+```
+
+Implict-cast semantics:
+```asl
+Name (TEST, "BAR")
+
+// ACPICA: TEST = "00000000004F4F46"
+// Windows, uACPI: TEST = "FOO"
+TEST = 0x4F4F46
+```
+                                
+Buffer size mutability:
+```asl
+Name (TEST, "XXXX")
+Name (VAL, "")
+
+// ACPICA: TEST = "LONGSTRING"
+// Windows, UACPI: TEST = "LONG"
+TEST = "LONGSTRING"
+
+// ACPICA: VAL = "FOO"
+// Windows, UACPI: VAL = ""
+VAL = "FOO"
+```
+
+Returning a reference to a local object:
+```asl
+Method (TEST) {
+    Local0 = 123
+
+    // Use-after-free in ACPICA, perfectly fine in uACPI
+    Return (RefOf(Local0))
+}
+
+Method (FOO) {
+    Name (TEST, 123)
+
+    // Use-after-free in ACPICA, object lifetime prolonged in uACPI (node is still removed from the namespace)
+    Return (RefOf(TEST))
+}
+```
+
+CopyObject into self:
+```asl
+Method (TEST) {
+    CopyObject(123, TEST)
+    Return (1)
+}
+
+// Segfault in ACPICA, prints 1 in uACPI  
+Debug = TEST()
+
+// Unreachable in ACPICA, prints 123 in uACPI
+Debug = TEST
+```
+
+There's even more examples, but this should be enough to demonstrate the fundamental differences in designs.
+
+## Integrating into a kernel
+
+### 1. Add uACPI sources & include directories into your project
+
+#### If you're using CMake
+Simply add the following lines to your cmake:
+```cmake
+include(uacpi/uacpi.cmake)
+
+target_sources(
+    my-kernel
+    PRIVATE
+    ${UACPI_SOURCES}
+)
+
+target_include_directories(
+    my-kernel
+    PRIVATE
+    ${UACPI_INCLUDES}
+)
+```
+
+#### If you're using Meson
+Add the following lines to your meson.build:
+```meson
+uacpi = subproject('uacpi')
+
+uacpi_sources = uacpi.get_variable('sources')
+my_kernel_sources += uacpi_sources
+
+uacpi_includes = uacpi.get_variable('includes')
+my_kernel_includes += uacpi_includes
+```
+
+#### Any other build system
+- Add all .c files from [source](source) into your target sources
+- Add [include](include) into your target include directories
+
+### 2. Implement/override platform-specific headers
+
+uACPI defines all platform/architecture-specific functionality in a few headers inside [include/uacpi/platform](include/uacpi/platform)
+
+All of the headers can be "implemented" by your project in a few ways:
+- Implement the expected helpers exposed by the headers
+- Replace the expected helpers by your own and override uACPI to use them by defining the respective `UACPI_OVERRIDE_X` variable.
+In this case, the header becomes a proxy that includes a corresponding `uacpi_x.h` header exported by your project.
+
+Currently used platform-specific headers are:
+- [arch_helpers.h](include/uacpi/platform/arch_helpers.h) - defines architecture/cpu-specific helpers & thread-id-related interfaces
+- [compiler.h](include/uacpi/platform/compiler.h) - defines compiler-specific helpers like attributes and intrinsics.
+This already works for MSVC, clang & GCC so you most likely won't have to override it.
+- [atomic.h](include/uacpi/platform/atomic.h) - defines compiler-specific helpers for dealing with atomic operations.
+  Same as the header above, this should work out of the box for MSVC, clang & GCC.
+- [libc.h](include/uacpi/platform/libc.h) - an empty header by default, but may be overriden by your project
+if it implements any of the libc functions used by uACPI (by default uACPI uses its
+own implementations to be platform-independent and to make porting easier). The
+internal implementation is just the bare minimum and not optimized in any way.
+- [types.h](include/uacpi/platform/types.h) - typedefs a bunch of uacpi-specific types using the `stdint.h` header. You don't have to override this
+unless you don't provide `stdint.h`.
+- [config.h](include/uacpi/platform/config.h) - various compile-time options and settings, preconfigured to reasonable defaults.
+
+### 3. Implement kernel API
+
+uACPI relies on kernel-specific API to do things like mapping/unmapping memory, writing/reading to/from IO, PCI config space, and many more things.
+
+This API is declared in [kernel_api.h](include/uacpi/kernel_api.h) and is implemented by your kernel.
+
+### 4. Initialize uACPI
+
+That's it, uACPI is now integrated into your project.
+
+You should proceed to initialization.  
+Refer to the [uACPI page](https://wiki.osdev.org/uACPI) on osdev wiki to see a
+snippet for basic initialization, as well as some code examples of how you may 
+want to use certain APIs.
+
+All of the headers and APIs defined in [uacpi](include/uacpi/) are public and may be utilized by your project.  
+Anything inside [uacpi/internal](include/uacpi/internal) is considered private/undocumented and unstable API.
+
+## Developing and contributing
+
+Most development work is fully doable in userland using the test runner.
+
+### Setting up an IDE:
+
+Simply open [tests/runner/CMakeLists.txt](tests/runner/CMakeLists.txt) in your favorite IDE.
+
+For Visual Studio:
+```
+cd tests\runner && mkdir build && cd build && cmake ..
+```
+
+Then just simply open the .sln file generated by cmake.
+
+### Running the test suite:
+```
+./tests/run_tests.py
+```
+
+If you want to contribute:
+- Commits are expected to be atomic (changing one specific thing, or introducing one feature) with detailed description (if one is warranted for), an S-o-b line is welcome
+- Code style is 4-space tabs, 80 cols, the rest can be seen by just looking at the current code
+
+**All contributions are very welcome!**
+
+## Notable projects using uACPI & performance leaderboards
+
+|  Project | Description | (qemu w/ Q35 + KVM) ops/s  | CPU |
+|---  |--- |--- |--- |
+| [proxima](https://github.com/proxima-os/) | Unix-like microkernel-based operating system with uACPI running in userspace | 10,454,158 | AMD Ryzen 9 9950X3D |
+| [ilobilix](https://github.com/ilobilo/ilobilix) | Yet another monolithic Linux clone wannabe. Currently under a rewrite | 8,703,286 | AMD Ryzen 9 9950X3D |
+| [Crescent2](https://github.com/Qwinci/crescent2) | An NT driver compatible kernel and userspace | 6,818,418 | Intel Core i5-13600K |
+| [davix](https://github.com/dbstream/davix) | Yet another unix-like by some bored nerd | 6,364,623 | Intel Core i7-13700K |
+| [Ironclad](https://ironclad-os.org) | Formally verified, hard real-time capable kernel written in SPARK and Ada | 6,196,937 | Intel Core i9-13900KS |
+| [Managarm](https://github.com/managarm/managarm)  | Pragmatic microkernel-based OS with fully asynchronous I/O | 5,618,646 | Intel Core i7-14700K |
+| [ChronOS](https://github.com/BUGO07/chronos) | Another basic hobby os held together by duct tape, made in rust | 5,416,703 | Intel Core Ultra 7 265KF |
+| [pmOS](https://gitlab.com/mishakov/pmos) | Microkernel-based operating system written from scratch with uACPI running in userspace | 5,354,445 | AMD Ryzen 9 5900X |
+| [menix](https://github.com/menix-os/menix) | A minimal and expandable Unix-like operating system | 5,239,043 | Intel Core Ultra 7 265KF |
+| [Orange](https://github.com/cpplover0/orange) | Unix-like x86_64 OS with some microkernel features | 4,204,053 | AMD Ryzen 5 3600 |
+| [Astral](https://github.com/mathewnd/astral) | Operating system written in C which aims be POSIX-compliant | 4,189,189 | Intel Core i5-13600K |
+| [Keyronex](https://github.com/Keyronex/Keyronex) | Layered kernel with fundamentally asynchronous I/O and working set model-based memory management | 4,013,691 | AMD Ryzen 5800X |
+| [Orange](https://github.com/cppLover0/Orange) | x86_64 Unix-like OS | 2,377,330 | AMD Ryzen 5 3600 |
+| [OBOS](https://github.com/OBOS-dev/obos) | Hybrid Kernel with advanced driver loading | 2,141,179 | Intel Core i5-13600K |
+| [NyauxKC](https://github.com/rayanmargham/NyauxKC) | Monolithic UNIX-like multi-architecture kernel | 1,966,580 | Intel Core i7-13700K |
+| [ElysiumOS](https://github.com/imwux/elysium-os) | Hybrid Unix-like kernel | 1,737,654 | AMD Ryzen 7 5800X3D |
+| [imaginarium](https://github.com/Khitiara/imaginarium) | Ziggy osdev experiments inspired by the NT kernel (using the zig general purpose allocator) | 1,504,436 | AMD Ryzen 7 3700X |
+| [BadgerOS](https://github.com/badgeteam/BadgerOS) | A monolithic lightweight UNIX clone | 1,018,518 | AMD Ryzen 5 3600 |
+| [Retro Rocket](https://github.com/brainboxdotcc/retro-rocket) | A BASIC _powered_ 64-bit SMP multitasking OS | 441,329 | Intel Xeon E5-2680 |
+| [Hyra](https://github.com/sigsegv7/Hyra) | Monolithic UNIX-like OS by [OSMORA.ORG](https://osmora.org) | 199,873 | Intel Core i3-3220 |
+
+## License
+
+<a href="https://opensource.org/licenses/MIT">
+  <img align="right" height="96" alt="MIT License" src="https://branding.cute.engineering/licenses/mit.svg" />
+</a>
+
+uACPI is licensed under the **MIT License**.  
+The full license text is provided in the [LICENSE](LICENSE) file inside the root directory.

kernel/uACPI/flags.mk

@@ -0,0 +1,2 @@
+cflags += -DUACPI_BAREBONES_MODE
+cflags += -isystem uACPI/include

kernel/uACPI/include/uacpi/context.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Set the minimum log level to be accepted by the logging facilities. Any logs
+ * below this level are discarded and not passed to uacpi_kernel_log, etc.
+ *
+ * 0 is treated as a special value that resets the setting to the default value.
+ *
+ * E.g. for a log level of UACPI_LOG_INFO:
+ *   UACPI_LOG_DEBUG -> discarded
+ *   UACPI_LOG_TRACE -> discarded
+ *   UACPI_LOG_INFO -> allowed
+ *   UACPI_LOG_WARN -> allowed
+ *   UACPI_LOG_ERROR -> allowed
+ */
+void uacpi_context_set_log_level(uacpi_log_level);
+
+/*
+ * Enables table checksum validation at installation time instead of first use.
+ * Note that this makes uACPI map the entire table at once, which not all
+ * hosts are able to handle at early init.
+ */
+void uacpi_context_set_proactive_table_checksum(uacpi_bool);
+
+#ifndef UACPI_BAREBONES_MODE
+/*
+ * Set the maximum number of seconds a While loop is allowed to run for before
+ * getting timed out.
+ *
+ * 0 is treated a special value that resets the setting to the default value.
+ */
+void uacpi_context_set_loop_timeout(uacpi_u32 seconds);
+
+/*
+ * Set the maximum call stack depth AML can reach before getting aborted.
+ *
+ * 0 is treated as a special value that resets the setting to the default value.
+ */
+void uacpi_context_set_max_call_stack_depth(uacpi_u32 depth);
+
+uacpi_u32 uacpi_context_get_loop_timeout(void);
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/event.h

@@ -0,0 +1,286 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/uacpi.h>
+#include <uacpi/acpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_fixed_event {
+    UACPI_FIXED_EVENT_TIMER_STATUS = 1,
+    UACPI_FIXED_EVENT_POWER_BUTTON,
+    UACPI_FIXED_EVENT_SLEEP_BUTTON,
+    UACPI_FIXED_EVENT_RTC,
+    UACPI_FIXED_EVENT_MAX = UACPI_FIXED_EVENT_RTC,
+} uacpi_fixed_event;
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_fixed_event_handler(
+    uacpi_fixed_event event, uacpi_interrupt_handler handler, uacpi_handle user
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_fixed_event_handler(
+    uacpi_fixed_event event
+))
+
+/*
+ * Enable/disable a fixed event. Note that the event is automatically enabled
+ * upon installing a handler to it.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_enable_fixed_event(uacpi_fixed_event event)
+)
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_disable_fixed_event(uacpi_fixed_event event)
+)
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_clear_fixed_event(uacpi_fixed_event event)
+)
+
+typedef enum uacpi_event_info {
+    // Event is enabled in software
+    UACPI_EVENT_INFO_ENABLED = (1 << 0),
+
+    // Event is enabled in software (only for wake)
+    UACPI_EVENT_INFO_ENABLED_FOR_WAKE = (1 << 1),
+
+    // Event is masked
+    UACPI_EVENT_INFO_MASKED = (1 << 2),
+
+    // Event has a handler attached
+    UACPI_EVENT_INFO_HAS_HANDLER = (1 << 3),
+
+    // Hardware enable bit is set
+    UACPI_EVENT_INFO_HW_ENABLED = (1 << 4),
+
+    // Hardware status bit is set
+    UACPI_EVENT_INFO_HW_STATUS = (1 << 5),
+} uacpi_event_info;
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_fixed_event_info(
+    uacpi_fixed_event event, uacpi_event_info *out_info
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_gpe_info(
+   uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+   uacpi_event_info *out_info
+))
+
+// Set if the handler wishes to reenable the GPE it just handled
+#define UACPI_GPE_REENABLE (1 << 7)
+
+typedef uacpi_interrupt_ret (*uacpi_gpe_handler)(
+    uacpi_handle ctx, uacpi_namespace_node *gpe_device, uacpi_u16 idx
+);
+
+typedef enum uacpi_gpe_triggering {
+    UACPI_GPE_TRIGGERING_LEVEL = 0,
+    UACPI_GPE_TRIGGERING_EDGE = 1,
+    UACPI_GPE_TRIGGERING_MAX = UACPI_GPE_TRIGGERING_EDGE,
+} uacpi_gpe_triggering;
+
+const uacpi_char *uacpi_gpe_triggering_to_string(
+    uacpi_gpe_triggering triggering
+);
+
+/*
+ * Installs a handler to the provided GPE at 'idx' controlled by device
+ * 'gpe_device'. The GPE is automatically disabled & cleared according to the
+ * configured triggering upon invoking the handler. The event is optionally
+ * re-enabled (by returning UACPI_GPE_REENABLE from the handler)
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_handler(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_gpe_triggering triggering, uacpi_gpe_handler handler, uacpi_handle ctx
+))
+
+/*
+ * Installs a raw handler to the provided GPE at 'idx' controlled by device
+ * 'gpe_device'. The handler is dispatched immediately after the event is
+ * received, status & enable bits are untouched.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_handler_raw(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_gpe_triggering triggering, uacpi_gpe_handler handler, uacpi_handle ctx
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_gpe_handler(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx, uacpi_gpe_handler handler
+))
+
+/*
+ * Marks the GPE 'idx' managed by 'gpe_device' as wake-capable. 'wake_device' is
+ * optional and configures the GPE to generate an implicit notification whenever
+ * an event occurs.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_setup_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_namespace_node *wake_device
+))
+
+/*
+ * Mark a GPE managed by 'gpe_device' as enabled/disabled for wake. The GPE must
+ * have previously been marked by calling uacpi_gpe_setup_for_wake. This
+ * function only affects the GPE enable register state following the call to
+ * uacpi_gpe_enable_all_for_wake.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Finalize GPE initialization by enabling all GPEs not configured for wake and
+ * having a matching AML handler detected.
+ *
+ * This should be called after the kernel power managment subsystem has
+ * enumerated all of the devices, executing their _PRW methods etc., and
+ * marking those it wishes to use for wake by calling uacpi_setup_gpe_for_wake
+ * or uacpi_mark_gpe_for_wake.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_finalize_gpe_initialization(void)
+)
+
+/*
+ * Enable/disable a general purpose event managed by 'gpe_device'. Internally
+ * this uses reference counting to make sure a GPE is not disabled until all
+ * possible users of it do so. GPEs not marked for wake are enabled
+ * automatically so this API is only needed for wake events or those that don't
+ * have a corresponding AML handler.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Clear the status bit of the event 'idx' managed by 'gpe_device'.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_clear_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Suspend/resume a general purpose event managed by 'gpe_device'. This bypasses
+ * the reference counting mechanism and unconditionally clears/sets the
+ * corresponding bit in the enable registers. This is used for switching the GPE
+ * to poll mode.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_suspend_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_resume_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Finish handling the GPE managed by 'gpe_device' at 'idx'. This clears the
+ * status registers if it hasn't been cleared yet and re-enables the event if
+ * it was enabled before.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_finish_handling_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Hard mask/umask a general purpose event at 'idx' managed by 'gpe_device'.
+ * This is used to permanently silence an event so that further calls to
+ * enable/disable as well as suspend/resume get ignored. This might be necessary
+ * for GPEs that cause an event storm due to the kernel's inability to properly
+ * handle them. The only way to enable a masked event is by a call to unmask.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_mask_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_unmask_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Disable all GPEs currently set up on the system.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_all_gpes(void)
+)
+
+/*
+ * Enable all GPEs not marked as wake. This is only needed after the system
+ * wakes from a shallow sleep state and is called automatically by wake code.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_all_runtime_gpes(void)
+)
+
+/*
+ * Enable all GPEs marked as wake. This is only needed before the system goes
+ * to sleep is called automatically by sleep code.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_all_wake_gpes(void)
+)
+
+/*
+ * Install/uninstall a new GPE block, usually defined by a device in the
+ * namespace with a _HID of ACPI0006.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_block(
+    uacpi_namespace_node *gpe_device, uacpi_u64 address,
+    uacpi_address_space address_space, uacpi_u16 num_registers,
+    uacpi_u32 irq
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_gpe_block(
+    uacpi_namespace_node *gpe_device
+))
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/helpers.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <uacpi/platform/compiler.h>
+
+#define UACPI_BUILD_BUG_ON_WITH_MSG(expr, msg) UACPI_STATIC_ASSERT(!(expr), msg)
+
+#define UACPI_BUILD_BUG_ON(expr) \
+    UACPI_BUILD_BUG_ON_WITH_MSG(expr, "BUILD BUG: " #expr " evaluated to true")
+
+#define UACPI_EXPECT_SIZEOF(type, size)                        \
+    UACPI_BUILD_BUG_ON_WITH_MSG(sizeof(type) != size,          \
+                                "BUILD BUG: invalid type size")

kernel/uACPI/include/uacpi/internal/compiler.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <uacpi/platform/compiler.h>

kernel/uACPI/include/uacpi/internal/context.h

@@ -0,0 +1,155 @@
+#pragma once
+
+#include <uacpi/acpi.h>
+#include <uacpi/types.h>
+#include <uacpi/uacpi.h>
+#include <uacpi/internal/dynamic_array.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/context.h>
+
+struct uacpi_runtime_context {
+    /*
+     * A local copy of FADT that has been verified & converted to most optimal
+     * format for faster access to the registers.
+     */
+    struct acpi_fadt fadt;
+
+    uacpi_u64 flags;
+
+#ifndef UACPI_BAREBONES_MODE
+    /*
+     * A cached pointer to FACS so that we don't have to look it up in interrupt
+     * contexts as we can't take mutexes.
+     */
+    struct acpi_facs *facs;
+
+    /*
+     * pm1{a,b}_evt_blk split into two registers for convenience
+     */
+    struct acpi_gas pm1a_status_blk;
+    struct acpi_gas pm1b_status_blk;
+    struct acpi_gas pm1a_enable_blk;
+    struct acpi_gas pm1b_enable_blk;
+
+#define UACPI_SLEEP_TYP_INVALID 0xFF
+    uacpi_u8 last_sleep_typ_a;
+    uacpi_u8 last_sleep_typ_b;
+
+    uacpi_u8 s0_sleep_typ_a;
+    uacpi_u8 s0_sleep_typ_b;
+
+    uacpi_bool global_lock_acquired;
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_bool was_in_legacy_mode;
+    uacpi_bool has_global_lock;
+    uacpi_bool sci_handle_valid;
+    uacpi_handle sci_handle;
+#endif
+    uacpi_u64 opcodes_executed;
+
+    uacpi_u32 loop_timeout_seconds;
+    uacpi_u32 max_call_stack_depth;
+
+    uacpi_u32 global_lock_seq_num;
+
+    /*
+     * These are stored here to protect against stuff like:
+     * - CopyObject(JUNK, \)
+     * - CopyObject(JUNK, \_GL)
+     */
+    uacpi_mutex *global_lock_mutex;
+    uacpi_object *root_object;
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_handle *global_lock_event;
+    uacpi_handle *global_lock_spinlock;
+    uacpi_bool global_lock_pending;
+#endif
+
+    uacpi_bool bad_timesource;
+    uacpi_u8 init_level;
+#endif // !UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_bool is_hardware_reduced;
+#endif
+
+    /*
+     * This is a per-table value but we mimic the NT implementation:
+     * treat all other definition blocks as if they were the same revision
+     * as DSDT.
+     */
+    uacpi_bool is_rev1;
+
+    uacpi_u8 log_level;
+};
+
+extern struct uacpi_runtime_context g_uacpi_rt_ctx;
+
+static inline uacpi_bool uacpi_check_flag(uacpi_u64 flag)
+{
+    return (g_uacpi_rt_ctx.flags & flag) == flag;
+}
+
+static inline uacpi_bool uacpi_should_log(enum uacpi_log_level lvl)
+{
+    return lvl <= g_uacpi_rt_ctx.log_level;
+}
+
+static inline uacpi_bool uacpi_is_hardware_reduced(void)
+{
+#ifndef UACPI_REDUCED_HARDWARE
+    return g_uacpi_rt_ctx.is_hardware_reduced;
+#else
+    return UACPI_TRUE;
+#endif
+}
+
+#ifndef UACPI_BAREBONES_MODE
+
+static inline const uacpi_char *uacpi_init_level_to_string(uacpi_u8 lvl)
+{
+    switch (lvl) {
+    case UACPI_INIT_LEVEL_EARLY:
+        return "early";
+    case UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED:
+        return "subsystem initialized";
+    case UACPI_INIT_LEVEL_NAMESPACE_LOADED:
+        return "namespace loaded";
+    case UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED:
+        return "namespace initialized";
+    default:
+        return "<invalid>";
+    }
+}
+
+#define UACPI_ENSURE_INIT_LEVEL_AT_LEAST(lvl)                               \
+    do {                                                                    \
+        if (uacpi_unlikely(g_uacpi_rt_ctx.init_level < lvl)) {              \
+            uacpi_error(                                                    \
+                "while evaluating %s: init level %d (%s) is too low, "      \
+                "expected at least %d (%s)\n", __FUNCTION__,                \
+                g_uacpi_rt_ctx.init_level,                                  \
+                uacpi_init_level_to_string(g_uacpi_rt_ctx.init_level), lvl, \
+                uacpi_init_level_to_string(lvl)                             \
+            );                                                              \
+            return UACPI_STATUS_INIT_LEVEL_MISMATCH;                        \
+        }                                                                   \
+    } while (0)
+
+#define UACPI_ENSURE_INIT_LEVEL_IS(lvl)                                     \
+    do {                                                                    \
+        if (uacpi_unlikely(g_uacpi_rt_ctx.init_level != lvl)) {             \
+            uacpi_error(                                                    \
+                "while evaluating %s: invalid init level %d (%s), "         \
+                "expected %d (%s)\n", __FUNCTION__,                         \
+                g_uacpi_rt_ctx.init_level,                                  \
+                uacpi_init_level_to_string(g_uacpi_rt_ctx.init_level), lvl, \
+                uacpi_init_level_to_string(lvl)                             \
+            );                                                              \
+            return UACPI_STATUS_INIT_LEVEL_MISMATCH;                        \
+        }                                                                   \
+    } while (0)
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/dynamic_array.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/kernel_api.h>
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE(name, type, inline_capacity)       \
+    struct name {                                                            \
+        type inline_storage[inline_capacity];                                \
+        type *dynamic_storage;                                               \
+        uacpi_size dynamic_capacity;                                         \
+        uacpi_size size_including_inline;                                    \
+    };                                                                       \
+
+#define DYNAMIC_ARRAY_SIZE(arr) ((arr)->size_including_inline)
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE_EXPORTS(name, type, prefix) \
+    prefix uacpi_size name##_inline_capacity(struct name *arr);       \
+    prefix type *name##_at(struct name *arr, uacpi_size idx);         \
+    prefix type *name##_alloc(struct name *arr);                      \
+    prefix type *name##_calloc(struct name *arr);                     \
+    prefix void name##_pop(struct name *arr);                         \
+    prefix uacpi_size name##_size(struct name *arr);                  \
+    prefix type *name##_last(struct name *arr)                        \
+    prefix void name##_clear(struct name *arr);
+
+#ifndef UACPI_BAREBONES_MODE
+#define DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_alloc(struct name *arr)                              \
+    {                                                                        \
+        uacpi_size inline_cap;                                               \
+        type *out_ptr;                                                       \
+                                                                             \
+        inline_cap = name##_inline_capacity(arr);                            \
+                                                                             \
+        if (arr->size_including_inline >= inline_cap) {                      \
+            uacpi_size dynamic_size;                                         \
+                                                                             \
+            dynamic_size = arr->size_including_inline - inline_cap;          \
+            if (dynamic_size == arr->dynamic_capacity) {                     \
+                uacpi_size bytes, type_size;                                 \
+                void *new_buf;                                               \
+                                                                             \
+                type_size = sizeof(*arr->dynamic_storage);                   \
+                                                                             \
+                if (arr->dynamic_capacity == 0) {                            \
+                    bytes = type_size * inline_cap;                          \
+                } else {                                                     \
+                    bytes = (arr->dynamic_capacity / 2) * type_size;         \
+                    if (bytes == 0)                                          \
+                        bytes += type_size;                                  \
+                                                                             \
+                    bytes += arr->dynamic_capacity * type_size;              \
+                }                                                            \
+                                                                             \
+                new_buf = uacpi_kernel_alloc(bytes);                         \
+                if (uacpi_unlikely(new_buf == UACPI_NULL))                   \
+                    return UACPI_NULL;                                       \
+                                                                             \
+                arr->dynamic_capacity = bytes / type_size;                   \
+                                                                             \
+                if (arr->dynamic_storage) {                                  \
+                    uacpi_memcpy(new_buf, arr->dynamic_storage,              \
+                                 dynamic_size * type_size);                  \
+                }                                                            \
+                uacpi_free(arr->dynamic_storage, dynamic_size * type_size);  \
+                arr->dynamic_storage = new_buf;                              \
+            }                                                                \
+                                                                             \
+            out_ptr = &arr->dynamic_storage[dynamic_size];                   \
+            goto ret;                                                        \
+        }                                                                    \
+        out_ptr = &arr->inline_storage[arr->size_including_inline];          \
+    ret:                                                                     \
+        arr->size_including_inline++;                                        \
+        return out_ptr;                                                      \
+    }
+
+#define DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)                           \
+    prefix void name##_clear(struct name *arr)                               \
+    {                                                                        \
+        uacpi_free(                                                          \
+            arr->dynamic_storage,                                            \
+            arr->dynamic_capacity * sizeof(*arr->dynamic_storage)            \
+        );                                                                   \
+        arr->size_including_inline = 0;                                      \
+        arr->dynamic_capacity = 0;                                           \
+        arr->dynamic_storage = UACPI_NULL;                                   \
+    }
+#else
+#define DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_alloc(struct name *arr)                              \
+    {                                                                        \
+        uacpi_size inline_cap;                                               \
+        type *out_ptr;                                                       \
+                                                                             \
+        inline_cap = name##_inline_capacity(arr);                            \
+                                                                             \
+        if (arr->size_including_inline >= inline_cap) {                      \
+            uacpi_size dynamic_size;                                         \
+                                                                             \
+            dynamic_size = arr->size_including_inline - inline_cap;          \
+            if (uacpi_unlikely(dynamic_size == arr->dynamic_capacity))       \
+                return UACPI_NULL;                                           \
+                                                                             \
+            out_ptr = &arr->dynamic_storage[dynamic_size];                   \
+            goto ret;                                                        \
+        }                                                                    \
+        out_ptr = &arr->inline_storage[arr->size_including_inline];          \
+    ret:                                                                     \
+        arr->size_including_inline++;                                        \
+        return out_ptr;                                                      \
+    }
+
+#define DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)                           \
+    prefix void name##_clear(struct name *arr)                               \
+    {                                                                        \
+        arr->size_including_inline = 0;                                      \
+        arr->dynamic_capacity = 0;                                           \
+        arr->dynamic_storage = UACPI_NULL;                                   \
+    }
+#endif
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(name, type, prefix)           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_inline_capacity(struct name *arr)               \
+    {                                                                        \
+        return sizeof(arr->inline_storage) / sizeof(arr->inline_storage[0]); \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_capacity(struct name *arr)                      \
+    {                                                                        \
+        return name##_inline_capacity(arr) + arr->dynamic_capacity;          \
+    }                                                                        \
+                                                                             \
+    prefix type *name##_at(struct name *arr, uacpi_size idx)                 \
+    {                                                                        \
+        if (idx >= arr->size_including_inline)                               \
+            return UACPI_NULL;                                               \
+                                                                             \
+        if (idx < name##_inline_capacity(arr))                               \
+            return &arr->inline_storage[idx];                                \
+                                                                             \
+        return &arr->dynamic_storage[idx - name##_inline_capacity(arr)];     \
+    }                                                                        \
+                                                                             \
+    DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                               \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_calloc(struct name *arr)                             \
+    {                                                                        \
+        type *ret;                                                           \
+                                                                             \
+        ret = name##_alloc(arr);                                             \
+        if (ret)                                                             \
+            uacpi_memzero(ret, sizeof(*ret));                                \
+                                                                             \
+        return ret;                                                          \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix void name##_pop(struct name *arr)                                 \
+    {                                                                        \
+        if (arr->size_including_inline == 0)                                 \
+            return;                                                          \
+                                                                             \
+        arr->size_including_inline--;                                        \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_size(struct name *arr)                          \
+    {                                                                        \
+        return arr->size_including_inline;                                   \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_last(struct name *arr)                               \
+    {                                                                        \
+        return name##_at(arr, arr->size_including_inline - 1);               \
+    }                                                                        \
+                                                                             \
+    DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)

kernel/uACPI/include/uacpi/internal/event.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <uacpi/event.h>
+
+// This fixed event is internal-only, and we don't expose it in the enum
+#define UACPI_FIXED_EVENT_GLOBAL_LOCK 0
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_initialize_events_early(void)
+)
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_initialize_events(void)
+)
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_deinitialize_events(void)
+)
+
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_events_match_post_dynamic_table_load(void)
+)
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_clear_all_events(void)
+)

kernel/uACPI/include/uacpi/internal/helpers.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <uacpi/helpers.h>
+
+#define UACPI_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+#define UACPI_UNUSED(x) (void)(x)

kernel/uACPI/include/uacpi/internal/interpreter.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/internal/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+enum uacpi_table_load_cause {
+    UACPI_TABLE_LOAD_CAUSE_LOAD_OP,
+    UACPI_TABLE_LOAD_CAUSE_LOAD_TABLE_OP,
+    UACPI_TABLE_LOAD_CAUSE_INIT,
+    UACPI_TABLE_LOAD_CAUSE_HOST,
+};
+
+uacpi_status uacpi_execute_table(void*, enum uacpi_table_load_cause cause);
+uacpi_status uacpi_osi(uacpi_handle handle, uacpi_object *retval);
+
+uacpi_status uacpi_execute_control_method(
+    uacpi_namespace_node *scope, uacpi_control_method *method,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/io.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/acpi.h>
+#include <uacpi/io.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef struct uacpi_mapped_gas {
+    uacpi_handle mapping;
+    uacpi_u8 access_bit_width;
+    uacpi_u8 total_bit_width;
+    uacpi_u8 bit_offset;
+
+    uacpi_status (*read)(
+        uacpi_handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+    );
+    uacpi_status (*write)(
+        uacpi_handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+    );
+
+    void (*unmap)(uacpi_handle, uacpi_size);
+} uacpi_mapped_gas;
+
+uacpi_status uacpi_map_gas_noalloc(
+    const struct acpi_gas *gas, uacpi_mapped_gas *out_mapped
+);
+void uacpi_unmap_gas_nofree(uacpi_mapped_gas *gas);
+
+uacpi_size uacpi_round_up_bits_to_bytes(uacpi_size bit_length);
+
+void uacpi_read_buffer_field(
+    const uacpi_buffer_field *field, void *dst
+);
+void uacpi_write_buffer_field(
+    uacpi_buffer_field *field, const void *src, uacpi_size size
+);
+
+uacpi_status uacpi_field_unit_get_read_type(
+    struct uacpi_field_unit *field, uacpi_object_type *out_type
+);
+
+uacpi_status uacpi_field_unit_get_bit_length(
+    struct uacpi_field_unit *field, uacpi_size *out_length
+);
+
+uacpi_status uacpi_read_field_unit(
+    uacpi_field_unit *field, void *dst, uacpi_size size,
+    uacpi_data_view *wtr_response
+);
+uacpi_status uacpi_write_field_unit(
+    uacpi_field_unit *field, const void *src, uacpi_size size,
+    uacpi_data_view *wtr_response
+);
+
+uacpi_status uacpi_system_memory_read(
+    void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_system_memory_write(
+    void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+uacpi_status uacpi_system_io_read(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_system_io_write(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+uacpi_status uacpi_pci_read(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_pci_write(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/log.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <uacpi/kernel_api.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/log.h>
+
+#ifdef UACPI_FORMATTED_LOGGING
+#define uacpi_log uacpi_kernel_log
+#else
+UACPI_PRINTF_DECL(2, 3)
+void uacpi_log(uacpi_log_level, const uacpi_char*, ...);
+#endif
+
+#define uacpi_log_lvl(lvl, ...) \
+    do { if (uacpi_should_log(lvl)) uacpi_log(lvl, __VA_ARGS__); } while (0)
+
+#define uacpi_debug(...) uacpi_log_lvl(UACPI_LOG_DEBUG, __VA_ARGS__)
+#define uacpi_trace(...) uacpi_log_lvl(UACPI_LOG_TRACE, __VA_ARGS__)
+#define uacpi_info(...)  uacpi_log_lvl(UACPI_LOG_INFO, __VA_ARGS__)
+#define uacpi_warn(...)  uacpi_log_lvl(UACPI_LOG_WARN, __VA_ARGS__)
+#define uacpi_error(...) uacpi_log_lvl(UACPI_LOG_ERROR, __VA_ARGS__)
+
+void uacpi_logger_initialize(void);

kernel/uACPI/include/uacpi/internal/mutex.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/kernel_api.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_bool uacpi_this_thread_owns_aml_mutex(uacpi_mutex*);
+
+uacpi_status uacpi_acquire_aml_mutex(uacpi_mutex*, uacpi_u16 timeout);
+uacpi_status uacpi_release_aml_mutex(uacpi_mutex*);
+
+static inline uacpi_status uacpi_acquire_native_mutex(uacpi_handle mtx)
+{
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    return uacpi_kernel_acquire_mutex(mtx, 0xFFFF);
+}
+
+uacpi_status uacpi_acquire_native_mutex_with_timeout(
+    uacpi_handle mtx, uacpi_u16 timeout
+);
+
+static inline uacpi_status uacpi_release_native_mutex(uacpi_handle mtx)
+{
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    uacpi_kernel_release_mutex(mtx);
+    return UACPI_STATUS_OK;
+}
+
+static inline uacpi_status uacpi_acquire_native_mutex_may_be_null(
+    uacpi_handle mtx
+)
+{
+    if (mtx == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    return uacpi_kernel_acquire_mutex(mtx, 0xFFFF);
+}
+
+static inline uacpi_status uacpi_release_native_mutex_may_be_null(
+    uacpi_handle mtx
+)
+{
+    if (mtx == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    uacpi_kernel_release_mutex(mtx);
+    return UACPI_STATUS_OK;
+}
+
+struct uacpi_recursive_lock {
+    uacpi_handle mutex;
+    uacpi_size depth;
+    uacpi_thread_id owner;
+};
+
+uacpi_status uacpi_recursive_lock_init(struct uacpi_recursive_lock *lock);
+uacpi_status uacpi_recursive_lock_deinit(struct uacpi_recursive_lock *lock);
+
+uacpi_status uacpi_recursive_lock_acquire(struct uacpi_recursive_lock *lock);
+uacpi_status uacpi_recursive_lock_release(struct uacpi_recursive_lock *lock);
+
+struct uacpi_rw_lock {
+    uacpi_handle read_mutex;
+    uacpi_handle write_mutex;
+    uacpi_size num_readers;
+};
+
+uacpi_status uacpi_rw_lock_init(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_lock_deinit(struct uacpi_rw_lock *lock);
+
+uacpi_status uacpi_rw_lock_read(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_unlock_read(struct uacpi_rw_lock *lock);
+
+uacpi_status uacpi_rw_lock_write(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_unlock_write(struct uacpi_rw_lock *lock);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/namespace.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/status.h>
+#include <uacpi/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define UACPI_NAMESPACE_NODE_FLAG_ALIAS (1 << 0)
+
+/*
+ * This node has been uninstalled and has no object associated with it.
+ *
+ * This is used to handle edge cases where an object needs to reference
+ * a namespace node, where the node might end up going out of scope before
+ * the object lifetime ends.
+ */
+#define UACPI_NAMESPACE_NODE_FLAG_DANGLING (1u << 1)
+
+/*
+ * This node is method-local and must not be exposed via public API as its
+ * lifetime is limited.
+ */
+#define UACPI_NAMESPACE_NODE_FLAG_TEMPORARY (1u << 2)
+
+#define UACPI_NAMESPACE_NODE_PREDEFINED (1u << 31)
+
+typedef struct uacpi_namespace_node {
+    struct uacpi_shareable shareable;
+    uacpi_object_name name;
+    uacpi_u32 flags;
+    uacpi_object *object;
+    struct uacpi_namespace_node *parent;
+    struct uacpi_namespace_node *child;
+    struct uacpi_namespace_node *next;
+} uacpi_namespace_node;
+
+uacpi_status uacpi_initialize_namespace(void);
+void uacpi_deinitialize_namespace(void);
+
+uacpi_namespace_node *uacpi_namespace_node_alloc(uacpi_object_name name);
+void uacpi_namespace_node_unref(uacpi_namespace_node *node);
+
+
+uacpi_status uacpi_namespace_node_type_unlocked(
+    const uacpi_namespace_node *node, uacpi_object_type *out_type
+);
+uacpi_status uacpi_namespace_node_is_one_of_unlocked(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+    uacpi_bool *out
+);
+
+uacpi_object *uacpi_namespace_node_get_object(const uacpi_namespace_node *node);
+
+uacpi_object *uacpi_namespace_node_get_object_typed(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask
+);
+
+uacpi_status uacpi_namespace_node_acquire_object(
+    const uacpi_namespace_node *node, uacpi_object **out_obj
+);
+uacpi_status uacpi_namespace_node_acquire_object_typed(
+    const uacpi_namespace_node *node, uacpi_object_type_bits,
+    uacpi_object **out_obj
+);
+
+uacpi_status uacpi_namespace_node_reacquire_object(
+    uacpi_object *obj
+);
+uacpi_status uacpi_namespace_node_release_object(
+    uacpi_object *obj
+);
+
+uacpi_status uacpi_namespace_node_install(
+    uacpi_namespace_node *parent, uacpi_namespace_node *node
+);
+uacpi_status uacpi_namespace_node_uninstall(uacpi_namespace_node *node);
+
+uacpi_namespace_node *uacpi_namespace_node_find_sub_node(
+    uacpi_namespace_node *parent,
+    uacpi_object_name name
+);
+
+enum uacpi_may_search_above_parent {
+    UACPI_MAY_SEARCH_ABOVE_PARENT_NO,
+    UACPI_MAY_SEARCH_ABOVE_PARENT_YES,
+};
+
+enum uacpi_permanent_only {
+    UACPI_PERMANENT_ONLY_NO,
+    UACPI_PERMANENT_ONLY_YES,
+};
+
+enum uacpi_should_lock {
+    UACPI_SHOULD_LOCK_NO,
+    UACPI_SHOULD_LOCK_YES,
+};
+
+uacpi_status uacpi_namespace_node_resolve(
+    uacpi_namespace_node *scope, const uacpi_char *path, enum uacpi_should_lock,
+    enum uacpi_may_search_above_parent, enum uacpi_permanent_only,
+    uacpi_namespace_node **out_node
+);
+
+uacpi_status uacpi_namespace_do_for_each_child(
+    uacpi_namespace_node *parent, uacpi_iteration_callback descending_callback,
+    uacpi_iteration_callback ascending_callback,
+    uacpi_object_type_bits, uacpi_u32 max_depth, enum uacpi_should_lock,
+    enum uacpi_permanent_only, void *user
+);
+
+uacpi_bool uacpi_namespace_node_is_dangling(uacpi_namespace_node *node);
+uacpi_bool uacpi_namespace_node_is_temporary(uacpi_namespace_node *node);
+uacpi_bool uacpi_namespace_node_is_predefined(uacpi_namespace_node *node);
+
+uacpi_status uacpi_namespace_read_lock(void);
+uacpi_status uacpi_namespace_read_unlock(void);
+
+uacpi_status uacpi_namespace_write_lock(void);
+uacpi_status uacpi_namespace_write_unlock(void);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/notify.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/notify.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_initialize_notify(void);
+void uacpi_deinitialize_notify(void);
+
+uacpi_status uacpi_notify_all(uacpi_namespace_node *node, uacpi_u64 value);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/opregion.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/opregion.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_initialize_opregion(void);
+void uacpi_deinitialize_opregion(void);
+
+void uacpi_trace_region_error(
+    uacpi_namespace_node *node, uacpi_char *message, uacpi_status ret
+);
+
+uacpi_status uacpi_install_address_space_handler_with_flags(
+    uacpi_namespace_node *device_node, enum uacpi_address_space space,
+    uacpi_region_handler handler, uacpi_handle handler_context,
+    uacpi_u16 flags
+);
+
+void uacpi_opregion_uninstall_handler(uacpi_namespace_node *node);
+
+uacpi_bool uacpi_address_space_handler_is_default(
+    uacpi_address_space_handler *handler
+);
+
+uacpi_address_space_handlers *uacpi_node_get_address_space_handlers(
+    uacpi_namespace_node *node
+);
+
+uacpi_status uacpi_initialize_opregion_node(uacpi_namespace_node *node);
+
+uacpi_status uacpi_opregion_attach(uacpi_namespace_node *node);
+
+void uacpi_install_default_address_space_handlers(void);
+
+uacpi_bool uacpi_is_buffer_access_address_space(uacpi_address_space space);
+
+union uacpi_opregion_io_data {
+    uacpi_u64 *integer;
+    uacpi_data_view buffer;
+};
+
+uacpi_status uacpi_dispatch_opregion_io(
+    uacpi_field_unit *field, uacpi_u32 offset,
+    uacpi_region_op op, union uacpi_opregion_io_data data
+);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/osi.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <uacpi/osi.h>
+
+uacpi_status uacpi_initialize_interfaces(void);
+void uacpi_deinitialize_interfaces(void);
+
+uacpi_status uacpi_handle_osi(const uacpi_char *string, uacpi_bool *out_value);

kernel/uACPI/include/uacpi/internal/registers.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/registers.h>
+
+uacpi_status uacpi_initialize_registers(void);
+void uacpi_deinitialize_registers(void);

kernel/uACPI/include/uacpi/internal/resources.h

@@ -0,0 +1,327 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/resources.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+enum uacpi_aml_resource {
+    UACPI_AML_RESOURCE_TYPE_INVALID = 0,
+
+    // Small resources
+    UACPI_AML_RESOURCE_IRQ,
+    UACPI_AML_RESOURCE_DMA,
+    UACPI_AML_RESOURCE_START_DEPENDENT,
+    UACPI_AML_RESOURCE_END_DEPENDENT,
+    UACPI_AML_RESOURCE_IO,
+    UACPI_AML_RESOURCE_FIXED_IO,
+    UACPI_AML_RESOURCE_FIXED_DMA,
+    UACPI_AML_RESOURCE_VENDOR_TYPE0,
+    UACPI_AML_RESOURCE_END_TAG,
+
+    // Large resources
+    UACPI_AML_RESOURCE_MEMORY24,
+    UACPI_AML_RESOURCE_GENERIC_REGISTER,
+    UACPI_AML_RESOURCE_VENDOR_TYPE1,
+    UACPI_AML_RESOURCE_MEMORY32,
+    UACPI_AML_RESOURCE_FIXED_MEMORY32,
+    UACPI_AML_RESOURCE_ADDRESS32,
+    UACPI_AML_RESOURCE_ADDRESS16,
+    UACPI_AML_RESOURCE_EXTENDED_IRQ,
+    UACPI_AML_RESOURCE_ADDRESS64,
+    UACPI_AML_RESOURCE_ADDRESS64_EXTENDED,
+    UACPI_AML_RESOURCE_GPIO_CONNECTION,
+    UACPI_AML_RESOURCE_PIN_FUNCTION,
+    UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+    UACPI_AML_RESOURCE_PIN_CONFIGURATION,
+    UACPI_AML_RESOURCE_PIN_GROUP,
+    UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION,
+    UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION,
+    UACPI_AML_RESOURCE_CLOCK_INPUT,
+    UACPI_AML_RESOURCE_MAX = UACPI_AML_RESOURCE_CLOCK_INPUT,
+};
+
+enum uacpi_aml_resource_size_kind {
+    UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+    UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS,
+    UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+};
+
+enum uacpi_aml_resource_kind {
+    UACPI_AML_RESOURCE_KIND_SMALL = 0,
+    UACPI_AML_RESOURCE_KIND_LARGE,
+};
+
+enum uacpi_resource_convert_opcode {
+    UACPI_RESOURCE_CONVERT_OPCODE_END = 0,
+
+    /*
+     * AML -> native:
+     * Take the mask at 'aml_offset' and convert to an array of uacpi_u8
+     * at 'native_offset' with the value corresponding to the bit index.
+     * The array size is written to the byte at offset 'arg2'.
+     *
+     * native -> AML:
+     * Walk each element of the array at 'native_offset' and set the
+     * corresponding bit in the mask at 'aml_offset' to 1. The array size is
+     * read from the byte at offset 'arg2'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8,
+    UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16,
+
+    /*
+     * AML -> native:
+     * Grab the bits at the byte at 'aml_offset' + 'bit_index', and copy its
+     * value into the byte at 'native_offset'.
+     *
+     * native -> AML:
+     * Grab first N bits at 'native_offset' and copy to 'aml_offset' starting
+     * at the 'bit_index'.
+     *
+     * NOTE:
+     * These must be contiguous in this order.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6 =
+        UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3 + 3,
+
+    /*
+     * AML -> native:
+     * Copy N bytes at 'aml_offset' to 'native_offset'.
+     *
+     * native -> AML:
+     * Copy N bytes at 'native_offset' to 'aml_offset'.
+     *
+     * 'imm' is added to the accumulator.
+     *
+     * NOTE: These are affected by the current value in the accumulator. If it's
+     *       set to 0 at the time of evalution, this is executed once, N times
+     *       otherwise. 0xFF is considered a special value, which resets the
+     *       accumulator to 0 unconditionally.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_8,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_16,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_32,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_64,
+
+    /*
+     * If the length of the current resource is less than 'arg0', then skip
+     * 'imm' instructions.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_AML_SIZE_LESS_THAN,
+
+    /*
+     * Skip 'imm' instructions if 'arg0' is not equal to the value in the
+     * accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_NOT_EQUALS,
+
+    /*
+     * AML -> native:
+     * Set the byte at 'native_offset' to 'imm'.
+     *
+     * native -> AML:
+     * Set the byte at 'aml_offset' to 'imm'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SET_TO_IMM,
+
+    /*
+     * AML -> native:
+     * Load the AML resoruce length into the accumulator as well as the field at
+     * 'native_offset' of width N.
+     *
+     * native -> AML:
+     * Load the resource length into the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32,
+
+    /*
+     * AML -> native:
+     * Load the 8 bit field at 'aml_offset' into the accumulator and store at
+     * 'native_offset'.
+     *
+     * native -> AML:
+     * Load the 8 bit field at 'native_offset' into the accumulator and store
+     * at 'aml_offset'.
+     *
+     * The accumulator is multiplied by 'imm' unless it's set to zero.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_STORE,
+
+    /*
+     * Load the N bit field at 'native_offset' into the accumulator
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_NATIVE,
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_16_NATIVE,
+
+    /*
+     * Load 'imm' into the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_IMM,
+
+    /*
+     * AML -> native:
+     * Load the resource source at offset = aml size + accumulator into the
+     * uacpi_resource_source struct at 'native_offset'. The string bytes are
+     * written to the offset at resource size + accumulator. The presence is
+     * detected by comparing the length of the resource to the offset,
+     * 'arg2' optionally specifies the offset to the upper bound of the string.
+     *
+     * native -> AML:
+     * Load the resource source from the uacpi_resource_source struct at
+     * 'native_offset' to aml_size + accumulator. aml_size + accumulator is
+     * optionally written to 'aml_offset' if it's specified.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE,
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX,
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL,
+
+    /*
+     * AML -> native:
+     * Load the pin table with upper bound specified at 'aml_offset'.
+     * The table length is calculated by subtracting the upper bound from
+     * aml_size and is written into the accumulator.
+     *
+     * native -> AML:
+     * Load the pin table length from 'native_offset' and multiply by 2, store
+     * the result in the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH,
+
+    /*
+     * AML -> native:
+     * Store the accumulator divided by 2 at 'native_offset'.
+     * The table is copied to the offset at resource size from offset at
+     * aml_size with the pointer written to the offset at 'arg2'.
+     *
+     * native -> AML:
+     * Read the pin table from resource size offset, write aml_size to
+     * 'aml_offset'. Copy accumulator bytes to the offset at aml_size.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE,
+
+    /*
+     * AML -> native:
+     * Load vendor data with offset stored at 'aml_offset'. The length is
+     * calculated as aml_size - aml_offset and is written to 'native_offset'.
+     * The data is written to offset - aml_size with the pointer written back
+     * to the offset at 'arg2'.
+     *
+     * native -> AML:
+     * Read vendor data from the pointer at offset 'arg2' and size at
+     * 'native_offset', the offset to write to is calculated as the difference
+     * between the data pointer and the native resource end pointer.
+     * offset + aml_size is written to 'aml_offset' and the data is copied
+     * there as well.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA,
+
+    /*
+     * AML -> native:
+     * Read the serial type from the byte at 'aml_offset' and write it to the
+     * type field of the uacpi_resource_serial_bus_common structure. Convert
+     * the serial type to native and set the resource type to it. Copy the
+     * vendor data to the offset at native size, the length is calculated
+     * as type_data_length - extra-type-specific-size, and is written to
+     * vendor_data_length, as well as the accumulator. The data pointer is
+     * written to vendor_data.
+     *
+     * native -> AML:
+     * Set the serial type at 'aml_offset' to the value stored at
+     * 'native_offset'. Load the vendor data to the offset at aml_size,
+     * the length is read from 'vendor_data_length', and the data is copied from
+     * 'vendor_data'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC,
+
+    /*
+     * Produces an error if encountered in the instruction stream.
+     * Used to trap invalid/unexpected code flow.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_UNREACHABLE,
+};
+
+struct uacpi_resource_convert_instruction {
+    uacpi_u8 code;
+
+    union {
+        uacpi_u8 aml_offset;
+        uacpi_u8 arg0;
+    } f1;
+
+    union {
+        uacpi_u8 native_offset;
+        uacpi_u8 arg1;
+    } f2;
+
+    union {
+        uacpi_u8 imm;
+        uacpi_u8 bit_index;
+        uacpi_u8 arg2;
+    } f3;
+};
+
+struct uacpi_resource_spec {
+    uacpi_u8 type : 5;
+    uacpi_u8 native_type : 5;
+    uacpi_u8 resource_kind : 1;
+    uacpi_u8 size_kind : 2;
+
+    /*
+     * Size of the resource as appears in the AML byte stream, for variable
+     * length resources this is the minimum.
+     */
+    uacpi_u16 aml_size;
+
+    /*
+     * Size of the native human-readable uacpi resource, for variable length
+     * resources this is the minimum. The final length is this field plus the
+     * result of extra_size_for_native().
+     */
+    uacpi_u16 native_size;
+
+    /*
+     * Calculate the amount of extra bytes that must be allocated for a specific
+     * native resource given the AML counterpart. This being NULL means no extra
+     * bytes are needed, aka native resources is always the same size.
+     */
+    uacpi_size (*extra_size_for_native)(
+        const struct uacpi_resource_spec*, void*, uacpi_size
+    );
+
+    /*
+     * Calculate the number of bytes needed to represent a native resource as
+     * AML. The 'aml_size' field is used if this is NULL.
+     */
+    uacpi_size (*size_for_aml)(
+        const struct uacpi_resource_spec*, uacpi_resource*
+    );
+
+    const struct uacpi_resource_convert_instruction *to_native;
+    const struct uacpi_resource_convert_instruction *to_aml;
+};
+
+typedef uacpi_iteration_decision (*uacpi_aml_resource_iteration_callback)(
+    void*, uacpi_u8 *data, uacpi_u16 resource_size,
+    const struct uacpi_resource_spec*
+);
+
+uacpi_status uacpi_for_each_aml_resource(
+    uacpi_data_view, uacpi_aml_resource_iteration_callback cb, void *user
+);
+
+uacpi_status uacpi_find_aml_resource_end_tag(
+    uacpi_data_view, uacpi_size *out_offset
+);
+
+uacpi_status uacpi_native_resources_from_aml(
+    uacpi_data_view, uacpi_resources **out_resources
+);
+
+uacpi_status uacpi_native_resources_to_aml(
+    uacpi_resources *resources, uacpi_object **out_template
+);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/shareable.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+struct uacpi_shareable {
+    uacpi_u32 reference_count;
+};
+
+void uacpi_shareable_init(uacpi_handle);
+
+uacpi_bool uacpi_bugged_shareable(uacpi_handle);
+void uacpi_make_shareable_bugged(uacpi_handle);
+
+uacpi_u32 uacpi_shareable_ref(uacpi_handle);
+uacpi_u32 uacpi_shareable_unref(uacpi_handle);
+
+void uacpi_shareable_unref_and_delete_if_last(
+    uacpi_handle, void (*do_free)(uacpi_handle)
+);
+
+uacpi_u32 uacpi_shareable_refcount(uacpi_handle);

kernel/uACPI/include/uacpi/internal/stdlib.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/platform/libc.h>
+#include <uacpi/platform/config.h>
+#include <uacpi/kernel_api.h>
+
+#ifdef UACPI_USE_BUILTIN_STRING
+
+#ifndef uacpi_memcpy
+void *uacpi_memcpy(void *dest, const void *src, uacpi_size count);
+#endif
+
+#ifndef uacpi_memmove
+void *uacpi_memmove(void *dest, const void *src, uacpi_size count);
+#endif
+
+#ifndef uacpi_memset
+void *uacpi_memset(void *dest, uacpi_i32 ch, uacpi_size count);
+#endif
+
+#ifndef uacpi_memcmp
+uacpi_i32 uacpi_memcmp(const void *lhs, const void *rhs, uacpi_size count);
+#endif
+
+#else
+
+#ifndef uacpi_memcpy
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMCPY
+        #define uacpi_memcpy __builtin_memcpy
+    #else
+        extern void *memcpy(void *dest, const void *src, uacpi_size count);
+        #define uacpi_memcpy memcpy
+    #endif
+#endif
+
+#ifndef uacpi_memmove
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMMOVE
+        #define uacpi_memmove __builtin_memmove
+    #else
+        extern void *memmove(void *dest, const void *src, uacpi_size count);
+        #define uacpi_memmove memmove
+    #endif
+#endif
+
+#ifndef uacpi_memset
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMSET
+        #define uacpi_memset __builtin_memset
+    #else
+        extern void *memset(void *dest, int ch, uacpi_size count);
+        #define uacpi_memset memset
+    #endif
+#endif
+
+#ifndef uacpi_memcmp
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMCMP
+        #define uacpi_memcmp __builtin_memcmp
+    #else
+        extern int memcmp(const void *lhs, const void *rhs, uacpi_size count);
+        #define uacpi_memcmp memcmp
+    #endif
+#endif
+
+#endif
+
+#ifndef uacpi_strlen
+uacpi_size uacpi_strlen(const uacpi_char *str);
+#endif
+
+#ifndef uacpi_strnlen
+uacpi_size uacpi_strnlen(const uacpi_char *str, uacpi_size max);
+#endif
+
+#ifndef uacpi_strcmp
+uacpi_i32 uacpi_strcmp(const uacpi_char *lhs, const uacpi_char *rhs);
+#endif
+
+#ifndef uacpi_snprintf
+UACPI_PRINTF_DECL(3, 4)
+uacpi_i32 uacpi_snprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, ...
+);
+#endif
+
+#ifndef uacpi_vsnprintf
+uacpi_i32 uacpi_vsnprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,
+    uacpi_va_list vlist
+);
+#endif
+
+#ifdef UACPI_SIZED_FREES
+#define uacpi_free(mem, size) uacpi_kernel_free(mem, size)
+#else
+#define uacpi_free(mem, _) uacpi_kernel_free(mem)
+#endif
+
+#define uacpi_memzero(ptr, size) uacpi_memset(ptr, 0, size)
+
+#define UACPI_COMPARE(x, y, op) ((x) op (y) ? (x) : (y))
+#define UACPI_MIN(x, y) UACPI_COMPARE(x, y, <)
+#define UACPI_MAX(x, y) UACPI_COMPARE(x, y, >)
+
+#define UACPI_ALIGN_UP_MASK(x, mask) (((x) + (mask)) & ~(mask))
+#define UACPI_ALIGN_UP(x, val, type) UACPI_ALIGN_UP_MASK(x, (type)(val) - 1)
+
+#define UACPI_ALIGN_DOWN_MASK(x, mask) ((x) & ~(mask))
+#define UACPI_ALIGN_DOWN(x, val, type) UACPI_ALIGN_DOWN_MASK(x, (type)(val) - 1)
+
+#define UACPI_IS_ALIGNED_MASK(x, mask) (((x) & (mask)) == 0)
+#define UACPI_IS_ALIGNED(x, val, type) UACPI_IS_ALIGNED_MASK(x, (type)(val) - 1)
+
+#define UACPI_IS_POWER_OF_TWO(x, type) UACPI_IS_ALIGNED(x, x, type)
+
+void uacpi_memcpy_zerout(void *dst, const void *src,
+                         uacpi_size dst_size, uacpi_size src_size);
+
+// Returns the one-based bit location of LSb or 0
+uacpi_u8 uacpi_bit_scan_forward(uacpi_u64);
+
+// Returns the one-based bit location of MSb or 0
+uacpi_u8 uacpi_bit_scan_backward(uacpi_u64);
+
+#ifndef UACPI_NATIVE_ALLOC_ZEROED
+void *uacpi_builtin_alloc_zeroed(uacpi_size size);
+#define uacpi_kernel_alloc_zeroed uacpi_builtin_alloc_zeroed
+#endif

kernel/uACPI/include/uacpi/internal/tables.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/tables.h>
+
+enum uacpi_table_origin {
+#ifndef UACPI_BAREBONES_MODE
+    UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL = 0,
+#endif
+    UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL = 1,
+
+    UACPI_TABLE_ORIGIN_HOST_VIRTUAL,
+    UACPI_TABLE_ORIGIN_HOST_PHYSICAL,
+};
+
+struct uacpi_installed_table {
+    uacpi_phys_addr phys_addr;
+    struct acpi_sdt_hdr hdr;
+    void *ptr;
+
+    uacpi_u16 reference_count;
+
+#define UACPI_TABLE_LOADED (1 << 0)
+#define UACPI_TABLE_CSUM_VERIFIED (1 << 1)
+#define UACPI_TABLE_INVALID (1 << 2)
+    uacpi_u8 flags;
+    uacpi_u8 origin;
+};
+
+uacpi_status uacpi_initialize_tables(void);
+void uacpi_deinitialize_tables(void);
+
+uacpi_bool uacpi_signatures_match(const void *const lhs, const void *const rhs);
+uacpi_status uacpi_check_table_signature(void *table, const uacpi_char *expect);
+uacpi_status uacpi_verify_table_checksum(void *table, uacpi_size size);
+
+uacpi_status uacpi_table_install_physical_with_origin(
+    uacpi_phys_addr phys, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+uacpi_status uacpi_table_install_with_origin(
+    void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+
+#ifndef UACPI_BAREBONES_MODE
+void uacpi_table_mark_as_loaded(uacpi_size idx);
+
+uacpi_status uacpi_table_load_with_cause(
+    uacpi_size idx, enum uacpi_table_load_cause cause
+);
+#endif // !UACPI_BAREBONES_MODE
+
+typedef uacpi_iteration_decision (*uacpi_table_iteration_callback)
+    (void *user, struct uacpi_installed_table *tbl, uacpi_size idx);
+
+uacpi_status uacpi_for_each_table(
+    uacpi_size base_idx, uacpi_table_iteration_callback, void *user
+);
+
+typedef uacpi_bool (*uacpi_table_match_callback)
+    (struct uacpi_installed_table *tbl);
+
+uacpi_status uacpi_table_match(
+    uacpi_size base_idx, uacpi_table_match_callback, uacpi_table *out_table
+);
+
+#define UACPI_PRI_TBL_HDR "'%.4s' (OEM ID '%.6s' OEM Table ID '%.8s')"
+#define UACPI_FMT_TBL_HDR(hdr) (hdr)->signature, (hdr)->oemid, (hdr)->oem_table_id

kernel/uACPI/include/uacpi/internal/types.h

@@ -0,0 +1,310 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/types.h>
+#include <uacpi/internal/shareable.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+// object->flags field if object->type == UACPI_OBJECT_REFERENCE
+enum uacpi_reference_kind {
+    UACPI_REFERENCE_KIND_REFOF = 0,
+    UACPI_REFERENCE_KIND_LOCAL = 1,
+    UACPI_REFERENCE_KIND_ARG = 2,
+    UACPI_REFERENCE_KIND_NAMED = 3,
+    UACPI_REFERENCE_KIND_PKG_INDEX = 4,
+};
+
+// object->flags field if object->type == UACPI_OBJECT_STRING
+enum uacpi_string_kind {
+    UACPI_STRING_KIND_NORMAL = 0,
+    UACPI_STRING_KIND_PATH,
+};
+
+typedef struct uacpi_buffer {
+    struct uacpi_shareable shareable;
+    union {
+        void *data;
+        uacpi_u8 *byte_data;
+        uacpi_char *text;
+    };
+    uacpi_size size;
+} uacpi_buffer;
+
+typedef struct uacpi_package {
+    struct uacpi_shareable shareable;
+    uacpi_object **objects;
+    uacpi_size count;
+} uacpi_package;
+
+typedef struct uacpi_buffer_field {
+    uacpi_buffer *backing;
+    uacpi_size bit_index;
+    uacpi_u32 bit_length;
+    uacpi_bool force_buffer;
+} uacpi_buffer_field;
+
+typedef struct uacpi_buffer_index {
+    uacpi_size idx;
+    uacpi_buffer *buffer;
+} uacpi_buffer_index;
+
+typedef struct uacpi_mutex {
+    struct uacpi_shareable shareable;
+    uacpi_handle handle;
+    uacpi_thread_id owner;
+    uacpi_u16 depth;
+    uacpi_u8 sync_level;
+} uacpi_mutex;
+
+typedef struct uacpi_event {
+    struct uacpi_shareable shareable;
+    uacpi_handle handle;
+} uacpi_event;
+
+typedef struct uacpi_address_space_handler {
+    struct uacpi_shareable shareable;
+    uacpi_region_handler callback;
+    uacpi_handle user_context;
+    struct uacpi_address_space_handler *next;
+    struct uacpi_operation_region *regions;
+    uacpi_u16 space;
+
+#define UACPI_ADDRESS_SPACE_HANDLER_DEFAULT (1 << 0)
+    uacpi_u16 flags;
+} uacpi_address_space_handler;
+
+/*
+ * NOTE: These are common object headers.
+ * Any changes to these structs must be propagated to all objects.
+ * ==============================================================
+ * Common for the following objects:
+ * - UACPI_OBJECT_OPERATION_REGION
+ * - UACPI_OBJECT_PROCESSOR
+ * - UACPI_OBJECT_DEVICE
+ * - UACPI_OBJECT_THERMAL_ZONE
+ */
+typedef struct uacpi_address_space_handlers {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *head;
+} uacpi_address_space_handlers;
+
+typedef struct uacpi_device_notify_handler {
+    uacpi_notify_handler callback;
+    uacpi_handle user_context;
+    struct uacpi_device_notify_handler *next;
+} uacpi_device_notify_handler;
+
+/*
+ * Common for the following objects:
+ * - UACPI_OBJECT_PROCESSOR
+ * - UACPI_OBJECT_DEVICE
+ * - UACPI_OBJECT_THERMAL_ZONE
+ */
+typedef struct uacpi_handlers {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_head;
+    uacpi_device_notify_handler *notify_head;
+} uacpi_handlers;
+
+// This region has a corresponding _REG method that was succesfully executed
+#define UACPI_OP_REGION_STATE_REG_EXECUTED (1 << 0)
+
+// This region was successfully attached to a handler
+#define UACPI_OP_REGION_STATE_ATTACHED (1 << 1)
+
+typedef struct uacpi_operation_region {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *handler;
+    uacpi_handle user_context;
+    uacpi_u16 space;
+    uacpi_u8 state_flags;
+    uacpi_u64 offset;
+    uacpi_u64 length;
+
+    union {
+        // If space == TABLE_DATA
+        uacpi_u64 table_idx;
+
+        // If space == PCC
+        uacpi_u8 *internal_buffer;
+    };
+
+    // Used to link regions sharing the same handler
+    struct uacpi_operation_region *next;
+} uacpi_operation_region;
+
+typedef struct uacpi_device {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+} uacpi_device;
+
+typedef struct uacpi_processor {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+    uacpi_u8 id;
+    uacpi_u32 block_address;
+    uacpi_u8 block_length;
+} uacpi_processor;
+
+typedef struct uacpi_thermal_zone {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+} uacpi_thermal_zone;
+
+typedef struct uacpi_power_resource {
+    uacpi_u8 system_level;
+    uacpi_u16 resource_order;
+} uacpi_power_resource;
+
+typedef uacpi_status (*uacpi_native_call_handler)(
+    uacpi_handle ctx, uacpi_object *retval
+);
+
+typedef struct uacpi_control_method {
+    struct uacpi_shareable shareable;
+    union {
+        uacpi_u8 *code;
+        uacpi_native_call_handler handler;
+    };
+    uacpi_mutex *mutex;
+    uacpi_u32 size;
+    uacpi_u8 sync_level : 4;
+    uacpi_u8 args : 3;
+    uacpi_u8 is_serialized : 1;
+    uacpi_u8 named_objects_persist: 1;
+    uacpi_u8 native_call : 1;
+    uacpi_u8 owns_code : 1;
+} uacpi_control_method;
+
+typedef enum uacpi_access_type {
+    UACPI_ACCESS_TYPE_ANY = 0,
+    UACPI_ACCESS_TYPE_BYTE = 1,
+    UACPI_ACCESS_TYPE_WORD = 2,
+    UACPI_ACCESS_TYPE_DWORD = 3,
+    UACPI_ACCESS_TYPE_QWORD = 4,
+    UACPI_ACCESS_TYPE_BUFFER = 5,
+} uacpi_access_type;
+
+typedef enum uacpi_lock_rule {
+    UACPI_LOCK_RULE_NO_LOCK = 0,
+    UACPI_LOCK_RULE_LOCK = 1,
+} uacpi_lock_rule;
+
+typedef enum uacpi_update_rule {
+    UACPI_UPDATE_RULE_PRESERVE = 0,
+    UACPI_UPDATE_RULE_WRITE_AS_ONES = 1,
+    UACPI_UPDATE_RULE_WRITE_AS_ZEROES = 2,
+} uacpi_update_rule;
+
+typedef enum uacpi_field_unit_kind {
+    UACPI_FIELD_UNIT_KIND_NORMAL = 0,
+    UACPI_FIELD_UNIT_KIND_INDEX = 1,
+    UACPI_FIELD_UNIT_KIND_BANK = 2,
+} uacpi_field_unit_kind;
+
+typedef struct uacpi_field_unit {
+    struct uacpi_shareable shareable;
+
+    union {
+        // UACPI_FIELD_UNIT_KIND_NORMAL
+        struct {
+            uacpi_namespace_node *region;
+        };
+
+        // UACPI_FIELD_UNIT_KIND_INDEX
+        struct {
+            struct uacpi_field_unit *index;
+            struct uacpi_field_unit *data;
+        };
+
+        // UACPI_FIELD_UNIT_KIND_BANK
+        struct {
+            uacpi_namespace_node *bank_region;
+            struct uacpi_field_unit *bank_selection;
+            uacpi_u64 bank_value;
+        };
+    };
+
+    uacpi_object *connection;
+
+    uacpi_u32 byte_offset;
+    uacpi_u32 bit_length;
+    uacpi_u32 pin_offset;
+    uacpi_u8 bit_offset_within_first_byte;
+    uacpi_u8 access_width_bytes;
+    uacpi_u8 access_length;
+
+    uacpi_u8 attributes : 4;
+    uacpi_u8 update_rule : 2;
+    uacpi_u8 kind : 2;
+    uacpi_u8 lock_rule : 1;
+} uacpi_field_unit;
+
+typedef struct uacpi_object {
+    struct uacpi_shareable shareable;
+    uacpi_u8 type;
+    uacpi_u8 flags;
+
+    union {
+        uacpi_u64 integer;
+        uacpi_package *package;
+        uacpi_buffer_field buffer_field;
+        uacpi_object *inner_object;
+        uacpi_control_method *method;
+        uacpi_buffer *buffer;
+        uacpi_mutex *mutex;
+        uacpi_event *event;
+        uacpi_buffer_index buffer_index;
+        uacpi_operation_region *op_region;
+        uacpi_device *device;
+        uacpi_processor *processor;
+        uacpi_thermal_zone *thermal_zone;
+        uacpi_address_space_handlers *address_space_handlers;
+        uacpi_handlers *handlers;
+        uacpi_power_resource power_resource;
+        uacpi_field_unit *field_unit;
+    };
+} uacpi_object;
+
+uacpi_object *uacpi_create_object(uacpi_object_type type);
+
+enum uacpi_assign_behavior {
+    UACPI_ASSIGN_BEHAVIOR_DEEP_COPY,
+    UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY,
+};
+
+uacpi_status uacpi_object_assign(uacpi_object *dst, uacpi_object *src,
+                                 enum uacpi_assign_behavior);
+
+void uacpi_object_attach_child(uacpi_object *parent, uacpi_object *child);
+void uacpi_object_detach_child(uacpi_object *parent);
+
+struct uacpi_object *uacpi_create_internal_reference(
+    enum uacpi_reference_kind kind, uacpi_object *child
+);
+uacpi_object *uacpi_unwrap_internal_reference(uacpi_object *object);
+
+enum uacpi_prealloc_objects {
+    UACPI_PREALLOC_OBJECTS_NO,
+    UACPI_PREALLOC_OBJECTS_YES,
+};
+
+uacpi_bool uacpi_package_fill(
+    uacpi_package *pkg, uacpi_size num_elements,
+    enum uacpi_prealloc_objects prealloc_objects
+);
+
+uacpi_mutex *uacpi_create_mutex(void);
+void uacpi_mutex_unref(uacpi_mutex*);
+
+void uacpi_method_unref(uacpi_control_method*);
+
+void uacpi_address_space_handler_unref(uacpi_address_space_handler *handler);
+
+void uacpi_buffer_to_view(uacpi_buffer*, uacpi_data_view*);
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/include/uacpi/internal/utilities.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/utilities.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/stdlib.h>
+
+static inline uacpi_phys_addr uacpi_truncate_phys_addr_with_warn(uacpi_u64 large_addr)
+{
+    if (sizeof(uacpi_phys_addr) < 8 && large_addr > 0xFFFFFFFF) {
+        uacpi_warn(
+            "truncating a physical address 0x%"UACPI_PRIX64
+            " outside of address space\n", UACPI_FMT64(large_addr)
+        );
+    }
+
+    return (uacpi_phys_addr)large_addr;
+}
+
+#define UACPI_PTR_TO_VIRT_ADDR(ptr)   ((uacpi_virt_addr)(ptr))
+#define UACPI_VIRT_ADDR_TO_PTR(vaddr) ((void*)(vaddr))
+
+#define UACPI_PTR_ADD(ptr, value) ((void*)(((uacpi_u8*)(ptr)) + value))
+
+/*
+ * Target buffer must have a length of at least 8 bytes.
+ */
+void uacpi_eisa_id_to_string(uacpi_u32, uacpi_char *out_string);
+
+enum uacpi_base {
+    UACPI_BASE_AUTO,
+    UACPI_BASE_OCT = 8,
+    UACPI_BASE_DEC = 10,
+    UACPI_BASE_HEX = 16,
+};
+uacpi_status uacpi_string_to_integer(
+    const uacpi_char *str, uacpi_size max_chars, enum uacpi_base base,
+    uacpi_u64 *out_value
+);
+
+uacpi_bool uacpi_is_valid_nameseg(uacpi_u8 *nameseg);
+
+void uacpi_free_dynamic_string(const uacpi_char *str);
+
+#define UACPI_NANOSECONDS_PER_SEC (1000ull * 1000ull * 1000ull)

kernel/uACPI/include/uacpi/io.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/acpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_gas_read(const struct acpi_gas *gas, uacpi_u64 *value);
+uacpi_status uacpi_gas_write(const struct acpi_gas *gas, uacpi_u64 value);
+
+typedef struct uacpi_mapped_gas uacpi_mapped_gas;
+
+/*
+ * Map a GAS for faster access in the future. The handle returned via
+ * 'out_mapped' must be freed & unmapped using uacpi_unmap_gas() when
+ * no longer needed.
+ */
+uacpi_status uacpi_map_gas(const struct acpi_gas *gas, uacpi_mapped_gas **out_mapped);
+void uacpi_unmap_gas(uacpi_mapped_gas*);
+
+/*
+ * Same as uacpi_gas_{read,write} but operates on a pre-mapped handle for faster
+ * access and/or ability to use in critical sections/irq contexts.
+ */
+uacpi_status uacpi_gas_read_mapped(const uacpi_mapped_gas *gas, uacpi_u64 *value);
+uacpi_status uacpi_gas_write_mapped(const uacpi_mapped_gas *gas, uacpi_u64 value);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/kernel_api.h

@@ -0,0 +1,375 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/platform/arch_helpers.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns the PHYSICAL address of the RSDP structure via *out_rsdp_address.
+uacpi_status uacpi_kernel_get_rsdp(uacpi_phys_addr *out_rsdp_address);
+
+/*
+ * Map a physical memory range starting at 'addr' with length 'len', and return
+ * a virtual address that can be used to access it.
+ *
+ * NOTE: 'addr' may be misaligned, in this case the host is expected to round it
+ *       down to the nearest page-aligned boundary and map that, while making
+ *       sure that at least 'len' bytes are still mapped starting at 'addr'. The
+ *       return value preserves the misaligned offset.
+ *
+ *       Example for uacpi_kernel_map(0x1ABC, 0xF00):
+ *           1. Round down the 'addr' we got to the nearest page boundary.
+ *              Considering a PAGE_SIZE of 4096 (or 0x1000), 0x1ABC rounded down
+ *              is 0x1000, offset within the page is 0x1ABC - 0x1000 => 0xABC
+ *           2. Requested 'len' is 0xF00 bytes, but we just rounded the address
+ *              down by 0xABC bytes, so add those on top. 0xF00 + 0xABC => 0x19BC
+ *           3. Round up the final 'len' to the nearest PAGE_SIZE boundary, in
+ *              this case 0x19BC is 0x2000 bytes (2 pages if PAGE_SIZE is 4096)
+ *           4. Call the VMM to map the aligned address 0x1000 (from step 1)
+ *              with length 0x2000 (from step 3). Let's assume the returned
+ *              virtual address for the mapping is 0xF000.
+ *           5. Add the original offset within page 0xABC (from step 1) to the
+ *              resulting virtual address 0xF000 + 0xABC => 0xFABC. Return it
+ *              to uACPI.
+ */
+void *uacpi_kernel_map(uacpi_phys_addr addr, uacpi_size len);
+
+/*
+ * Unmap a virtual memory range at 'addr' with a length of 'len' bytes.
+ *
+ * NOTE: 'addr' may be misaligned, see the comment above 'uacpi_kernel_map'.
+ *       Similar steps to uacpi_kernel_map can be taken to retrieve the
+ *       virtual address originally returned by the VMM for this mapping
+ *       as well as its true length.
+ */
+void uacpi_kernel_unmap(void *addr, uacpi_size len);
+
+#ifndef UACPI_FORMATTED_LOGGING
+void uacpi_kernel_log(uacpi_log_level, const uacpi_char*);
+#else
+UACPI_PRINTF_DECL(2, 3)
+void uacpi_kernel_log(uacpi_log_level, const uacpi_char*, ...);
+void uacpi_kernel_vlog(uacpi_log_level, const uacpi_char*, uacpi_va_list);
+#endif
+
+/*
+ * Only the above ^^^ API may be used by early table access and
+ * UACPI_BAREBONES_MODE.
+ */
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Convenience initialization/deinitialization hooks that will be called by
+ * uACPI automatically when appropriate if compiled-in.
+ */
+#ifdef UACPI_KERNEL_INITIALIZATION
+/*
+ * This API is invoked for each initialization level so that appropriate parts
+ * of the host kernel and/or glue code can be initialized at different stages.
+ *
+ * uACPI API that triggers calls to uacpi_kernel_initialize and the respective
+ * 'current_init_lvl' passed to the hook at that stage:
+ * 1. uacpi_initialize() -> UACPI_INIT_LEVEL_EARLY
+ * 2. uacpi_namespace_load() -> UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED
+ * 3. (start of) uacpi_namespace_initialize() -> UACPI_INIT_LEVEL_NAMESPACE_LOADED
+ * 4. (end of) uacpi_namespace_initialize() -> UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED
+ */
+uacpi_status uacpi_kernel_initialize(uacpi_init_level current_init_lvl);
+void uacpi_kernel_deinitialize(void);
+#endif
+
+/*
+ * Open a PCI device at 'address' for reading & writing.
+ *
+ * Note that this must be able to open any arbitrary PCI device, not just those
+ * detected during kernel PCI enumeration, since the following pattern is
+ * relatively common in AML firmware:
+ *    Device (THC0)
+ *    {
+ *        // Device at 00:10.06
+ *        Name (_ADR, 0x00100006)  // _ADR: Address
+ *
+ *        OperationRegion (THCR, PCI_Config, Zero, 0x0100)
+ *        Field (THCR, ByteAcc, NoLock, Preserve)
+ *        {
+ *            // Vendor ID field in the PCI configuration space
+ *            VDID,   32
+ *        }
+ *
+ *        // Check if the device at 00:10.06 actually exists, that is reading
+ *        // from its configuration space returns something other than 0xFFs.
+ *        If ((VDID != 0xFFFFFFFF))
+ *        {
+ *            // Actually create the rest of the device's body if it's present
+ *            // in the system, otherwise skip it.
+ *        }
+ *    }
+ *
+ * The handle returned via 'out_handle' is used to perform IO on the
+ * configuration space of the device.
+ */
+uacpi_status uacpi_kernel_pci_device_open(
+    uacpi_pci_address address, uacpi_handle *out_handle
+);
+void uacpi_kernel_pci_device_close(uacpi_handle);
+
+/*
+ * Read & write the configuration space of a previously open PCI device.
+ */
+uacpi_status uacpi_kernel_pci_read8(
+    uacpi_handle device, uacpi_size offset, uacpi_u8 *value
+);
+uacpi_status uacpi_kernel_pci_read16(
+    uacpi_handle device, uacpi_size offset, uacpi_u16 *value
+);
+uacpi_status uacpi_kernel_pci_read32(
+    uacpi_handle device, uacpi_size offset, uacpi_u32 *value
+);
+
+uacpi_status uacpi_kernel_pci_write8(
+    uacpi_handle device, uacpi_size offset, uacpi_u8 value
+);
+uacpi_status uacpi_kernel_pci_write16(
+    uacpi_handle device, uacpi_size offset, uacpi_u16 value
+);
+uacpi_status uacpi_kernel_pci_write32(
+    uacpi_handle device, uacpi_size offset, uacpi_u32 value
+);
+
+/*
+ * Map a SystemIO address at [base, base + len) and return a kernel-implemented
+ * handle that can be used for reading and writing the IO range.
+ *
+ * NOTE: The x86 architecture uses the in/out family of instructions
+ *       to access the SystemIO address space.
+ */
+uacpi_status uacpi_kernel_io_map(
+    uacpi_io_addr base, uacpi_size len, uacpi_handle *out_handle
+);
+void uacpi_kernel_io_unmap(uacpi_handle handle);
+
+/*
+ * Read/Write the IO range mapped via uacpi_kernel_io_map
+ * at a 0-based 'offset' within the range.
+ *
+ * NOTE:
+ * The x86 architecture uses the in/out family of instructions
+ * to access the SystemIO address space.
+ *
+ * You are NOT allowed to break e.g. a 4-byte access into four 1-byte accesses.
+ * Hardware ALWAYS expects accesses to be of the exact width.
+ */
+uacpi_status uacpi_kernel_io_read8(
+    uacpi_handle, uacpi_size offset, uacpi_u8 *out_value
+);
+uacpi_status uacpi_kernel_io_read16(
+    uacpi_handle, uacpi_size offset, uacpi_u16 *out_value
+);
+uacpi_status uacpi_kernel_io_read32(
+    uacpi_handle, uacpi_size offset, uacpi_u32 *out_value
+);
+
+uacpi_status uacpi_kernel_io_write8(
+    uacpi_handle, uacpi_size offset, uacpi_u8 in_value
+);
+uacpi_status uacpi_kernel_io_write16(
+    uacpi_handle, uacpi_size offset, uacpi_u16 in_value
+);
+uacpi_status uacpi_kernel_io_write32(
+    uacpi_handle, uacpi_size offset, uacpi_u32 in_value
+);
+
+/*
+ * Allocate a block of memory of 'size' bytes.
+ * The contents of the allocated memory are unspecified.
+ */
+void *uacpi_kernel_alloc(uacpi_size size);
+
+#ifdef UACPI_NATIVE_ALLOC_ZEROED
+/*
+ * Allocate a block of memory of 'size' bytes.
+ * The returned memory block is expected to be zero-filled.
+ */
+void *uacpi_kernel_alloc_zeroed(uacpi_size size);
+#endif
+
+/*
+ * Free a previously allocated memory block.
+ *
+ * 'mem' might be a NULL pointer. In this case, the call is assumed to be a
+ * no-op.
+ *
+ * An optionally enabled 'size_hint' parameter contains the size of the original
+ * allocation. Note that in some scenarios this incurs additional cost to
+ * calculate the object size.
+ */
+#ifndef UACPI_SIZED_FREES
+void uacpi_kernel_free(void *mem);
+#else
+void uacpi_kernel_free(void *mem, uacpi_size size_hint);
+#endif
+
+/*
+ * Returns the number of nanosecond ticks elapsed since boot,
+ * strictly monotonic.
+ */
+uacpi_u64 uacpi_kernel_get_nanoseconds_since_boot(void);
+
+/*
+ * Spin for N microseconds.
+ */
+void uacpi_kernel_stall(uacpi_u8 usec);
+
+/*
+ * Sleep for N milliseconds.
+ */
+void uacpi_kernel_sleep(uacpi_u64 msec);
+
+/*
+ * Create/free an opaque non-recursive kernel mutex object.
+ */
+uacpi_handle uacpi_kernel_create_mutex(void);
+void uacpi_kernel_free_mutex(uacpi_handle);
+
+/*
+ * Create/free an opaque kernel (semaphore-like) event object.
+ */
+uacpi_handle uacpi_kernel_create_event(void);
+void uacpi_kernel_free_event(uacpi_handle);
+
+/*
+ * Returns a unique identifier of the currently executing thread.
+ *
+ * The returned thread id cannot be UACPI_THREAD_ID_NONE.
+ */
+uacpi_thread_id uacpi_kernel_get_thread_id(void);
+
+/*
+ * Try to acquire the mutex with a millisecond timeout.
+ *
+ * The timeout value has the following meanings:
+ * 0x0000 - Attempt to acquire the mutex once, in a non-blocking manner
+ * 0x0001...0xFFFE - Attempt to acquire the mutex for at least 'timeout'
+ *                   milliseconds
+ * 0xFFFF - Infinite wait, block until the mutex is acquired
+ *
+ * The following are possible return values:
+ * 1. UACPI_STATUS_OK - successful acquire operation
+ * 2. UACPI_STATUS_TIMEOUT - timeout reached while attempting to acquire (or the
+ *                           single attempt to acquire was not successful for
+ *                           calls with timeout=0)
+ * 3. Any other value - signifies a host internal error and is treated as such
+ */
+uacpi_status uacpi_kernel_acquire_mutex(uacpi_handle, uacpi_u16);
+void uacpi_kernel_release_mutex(uacpi_handle);
+
+/*
+ * Try to wait for an event (counter > 0) with a millisecond timeout.
+ * A timeout value of 0xFFFF implies infinite wait.
+ *
+ * The internal counter is decremented by 1 if wait was successful.
+ *
+ * A successful wait is indicated by returning UACPI_TRUE.
+ */
+uacpi_bool uacpi_kernel_wait_for_event(uacpi_handle, uacpi_u16);
+
+/*
+ * Signal the event object by incrementing its internal counter by 1.
+ *
+ * This function may be used in interrupt contexts.
+ */
+void uacpi_kernel_signal_event(uacpi_handle);
+
+/*
+ * Reset the event counter to 0.
+ */
+void uacpi_kernel_reset_event(uacpi_handle);
+
+/*
+ * Handle a firmware request.
+ *
+ * Currently either a Breakpoint or Fatal operators.
+ */
+uacpi_status uacpi_kernel_handle_firmware_request(uacpi_firmware_request*);
+
+/*
+ * Install an interrupt handler at 'irq', 'ctx' is passed to the provided
+ * handler for every invocation.
+ *
+ * 'out_irq_handle' is set to a kernel-implemented value that can be used to
+ * refer to this handler from other API.
+ */
+uacpi_status uacpi_kernel_install_interrupt_handler(
+    uacpi_u32 irq, uacpi_interrupt_handler, uacpi_handle ctx,
+    uacpi_handle *out_irq_handle
+);
+
+/*
+ * Uninstall an interrupt handler. 'irq_handle' is the value returned via
+ * 'out_irq_handle' during installation.
+ */
+uacpi_status uacpi_kernel_uninstall_interrupt_handler(
+    uacpi_interrupt_handler, uacpi_handle irq_handle
+);
+
+/*
+ * Create/free a kernel spinlock object.
+ *
+ * Unlike other types of locks, spinlocks may be used in interrupt contexts.
+ */
+uacpi_handle uacpi_kernel_create_spinlock(void);
+void uacpi_kernel_free_spinlock(uacpi_handle);
+
+/*
+ * Lock/unlock helpers for spinlocks.
+ *
+ * These are expected to disable interrupts, returning the previous state of cpu
+ * flags, that can be used to possibly re-enable interrupts if they were enabled
+ * before.
+ *
+ * Note that lock is infalliable.
+ */
+uacpi_cpu_flags uacpi_kernel_lock_spinlock(uacpi_handle);
+void uacpi_kernel_unlock_spinlock(uacpi_handle, uacpi_cpu_flags);
+
+typedef enum uacpi_work_type {
+    /*
+     * Schedule a GPE handler method for execution.
+     * This should be scheduled to run on CPU0 to avoid potential SMI-related
+     * firmware bugs.
+     */
+    UACPI_WORK_GPE_EXECUTION,
+
+    /*
+     * Schedule a Notify(device) firmware request for execution.
+     * This can run on any CPU.
+     */
+    UACPI_WORK_NOTIFICATION,
+} uacpi_work_type;
+
+typedef void (*uacpi_work_handler)(uacpi_handle);
+
+/*
+ * Schedules deferred work for execution.
+ * Might be invoked from an interrupt context.
+ */
+uacpi_status uacpi_kernel_schedule_work(
+    uacpi_work_type, uacpi_work_handler, uacpi_handle ctx
+);
+
+/*
+ * Waits for two types of work to finish:
+ * 1. All in-flight interrupts installed via uacpi_kernel_install_interrupt_handler
+ * 2. All work scheduled via uacpi_kernel_schedule_work
+ *
+ * Note that the waits must be done in this order specifically.
+ */
+uacpi_status uacpi_kernel_wait_for_work_completion(void);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/log.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum uacpi_log_level {
+    /*
+     * Super verbose logging, every op & uop being processed is logged.
+     * Mostly useful for tracking down hangs/lockups.
+     */
+    UACPI_LOG_DEBUG = 5,
+
+    /*
+     * A little verbose, every operation region access is traced with a bit of
+     * extra information on top.
+     */
+    UACPI_LOG_TRACE = 4,
+
+    /*
+     * Only logs the bare minimum information about state changes and/or
+     * initialization progress.
+     */
+    UACPI_LOG_INFO = 3,
+
+    /*
+     * Logs recoverable errors and/or non-important aborts.
+     */
+    UACPI_LOG_WARN = 2,
+
+    /*
+     * Logs only critical errors that might affect the ability to initialize or
+     * prevent stable runtime.
+     */
+    UACPI_LOG_ERROR = 1,
+} uacpi_log_level;
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/namespace.h

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef struct uacpi_namespace_node uacpi_namespace_node;
+
+uacpi_namespace_node *uacpi_namespace_root(void);
+
+typedef enum uacpi_predefined_namespace {
+    UACPI_PREDEFINED_NAMESPACE_ROOT = 0,
+    UACPI_PREDEFINED_NAMESPACE_GPE,
+    UACPI_PREDEFINED_NAMESPACE_PR,
+    UACPI_PREDEFINED_NAMESPACE_SB,
+    UACPI_PREDEFINED_NAMESPACE_SI,
+    UACPI_PREDEFINED_NAMESPACE_TZ,
+    UACPI_PREDEFINED_NAMESPACE_GL,
+    UACPI_PREDEFINED_NAMESPACE_OS,
+    UACPI_PREDEFINED_NAMESPACE_OSI,
+    UACPI_PREDEFINED_NAMESPACE_REV,
+    UACPI_PREDEFINED_NAMESPACE_MAX = UACPI_PREDEFINED_NAMESPACE_REV,
+} uacpi_predefined_namespace;
+uacpi_namespace_node *uacpi_namespace_get_predefined(
+    uacpi_predefined_namespace
+);
+
+/*
+ * Returns UACPI_TRUE if the provided 'node' is an alias.
+ */
+uacpi_bool uacpi_namespace_node_is_alias(uacpi_namespace_node *node);
+
+uacpi_object_name uacpi_namespace_node_name(const uacpi_namespace_node *node);
+
+/*
+ * Returns the type of object stored at the namespace node.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_type(
+    const uacpi_namespace_node *node, uacpi_object_type *out_type
+);
+
+/*
+ * Returns UACPI_TRUE via 'out' if the type of the object stored at the
+ * namespace node matches the provided value, UACPI_FALSE otherwise.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_is(
+    const uacpi_namespace_node *node, uacpi_object_type type, uacpi_bool *out
+);
+
+/*
+ * Returns UACPI_TRUE via 'out' if the type of the object stored at the
+ * namespace node matches any of the type bits in the provided value,
+ * UACPI_FALSE otherwise.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_is_one_of(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+    uacpi_bool *out
+);
+
+uacpi_size uacpi_namespace_node_depth(const uacpi_namespace_node *node);
+
+uacpi_namespace_node *uacpi_namespace_node_parent(
+    uacpi_namespace_node *node
+);
+
+uacpi_status uacpi_namespace_node_find(
+    uacpi_namespace_node *parent,
+    const uacpi_char *path,
+    uacpi_namespace_node **out_node
+);
+
+/*
+ * Same as uacpi_namespace_node_find, except the search recurses upwards when
+ * the namepath consists of only a single nameseg. Usually, this behavior is
+ * only desired if resolving a namepath specified in an aml-provided object,
+ * such as a package element.
+ */
+uacpi_status uacpi_namespace_node_resolve_from_aml_namepath(
+    uacpi_namespace_node *scope,
+    const uacpi_char *path,
+    uacpi_namespace_node **out_node
+);
+
+typedef uacpi_iteration_decision (*uacpi_iteration_callback) (
+    void *user, uacpi_namespace_node *node, uacpi_u32 node_depth
+);
+
+#define UACPI_MAX_DEPTH_ANY 0xFFFFFFFF
+
+/*
+ * Depth-first iterate the namespace starting at the first child of 'parent'.
+ */
+uacpi_status uacpi_namespace_for_each_child_simple(
+    uacpi_namespace_node *parent, uacpi_iteration_callback callback, void *user
+);
+
+/*
+ * Depth-first iterate the namespace starting at the first child of 'parent'.
+ *
+ * 'descending_callback' is invoked the first time a node is visited when
+ * walking down. 'ascending_callback' is invoked the second time a node is
+ * visited after we reach the leaf node without children and start walking up.
+ * Either of the callbacks may be NULL, but not both at the same time.
+ *
+ * Only nodes matching 'type_mask' are passed to the callbacks.
+ *
+ * 'max_depth' is used to limit the maximum reachable depth from 'parent',
+ * where 1 is only direct children of 'parent', 2 is children of first-level
+ * children etc. Use UACPI_MAX_DEPTH_ANY or -1 to specify infinite depth.
+ */
+uacpi_status uacpi_namespace_for_each_child(
+    uacpi_namespace_node *parent, uacpi_iteration_callback descending_callback,
+    uacpi_iteration_callback ascending_callback,
+    uacpi_object_type_bits type_mask, uacpi_u32 max_depth, void *user
+);
+
+/*
+ * Retrieve the next peer namespace node of '*iter', or, if '*iter' is
+ * UACPI_NULL, retrieve the first child of 'parent' instead. The resulting
+ * namespace node is stored at '*iter'.
+ *
+ * This API can be used to implement an "iterator" version of the
+ * for_each_child helpers.
+ *
+ * Example usage:
+ *     void recurse(uacpi_namespace_node *parent) {
+ *        uacpi_namespace_node *iter = UACPI_NULL;
+ *
+ *        while (uacpi_namespace_node_next(parent, &iter) == UACPI_STATUS_OK) {
+ *             // Do something with iter...
+ *             descending_callback(iter);
+ *
+ *             // Recurse down to walk over the children of iter
+ *             recurse(iter);
+ *        }
+ *     }
+ *
+ * Prefer the for_each_child family of helpers if possible instead of this API
+ * as they avoid recursion and/or the need to use dynamic data structures
+ * entirely.
+ */
+uacpi_status uacpi_namespace_node_next(
+    uacpi_namespace_node *parent, uacpi_namespace_node **iter
+);
+
+/*
+ * Retrieve the next peer namespace node of '*iter', or, if '*iter' is
+ * UACPI_NULL, retrieve the first child of 'parent' instead. The resulting
+ * namespace node is stored at '*iter'. Only nodes which type matches one
+ * of the types set in 'type_mask' are returned.
+ *
+ * See comment above 'uacpi_namespace_node_next' for usage examples.
+ *
+ * Prefer the for_each_child family of helpers if possible instead of this API
+ * as they avoid recursion and/or the need to use dynamic data structures
+ * entirely.
+ */
+uacpi_status uacpi_namespace_node_next_typed(
+    uacpi_namespace_node *parent, uacpi_namespace_node **iter,
+    uacpi_object_type_bits type_mask
+);
+
+const uacpi_char *uacpi_namespace_node_generate_absolute_path(
+    const uacpi_namespace_node *node
+);
+void uacpi_free_absolute_path(const uacpi_char *path);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/notify.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Install a Notify() handler to a device node.
+ * A handler installed to the root node will receive all notifications, even if
+ * a device already has a dedicated Notify handler.
+ * 'handler_context' is passed to the handler on every invocation.
+ */
+uacpi_status uacpi_install_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler,
+    uacpi_handle handler_context
+);
+
+uacpi_status uacpi_uninstall_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/opregion.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Install an address space handler to a device node.
+ * The handler is recursively connected to all of the operation regions of
+ * type 'space' underneath 'device_node'. Note that this recursion stops as
+ * soon as another device node that already has an address space handler of
+ * this type installed is encountered.
+ */
+uacpi_status uacpi_install_address_space_handler(
+    uacpi_namespace_node *device_node, enum uacpi_address_space space,
+    uacpi_region_handler handler, uacpi_handle handler_context
+);
+
+/*
+ * Uninstall the handler of type 'space' from a given device node.
+ */
+uacpi_status uacpi_uninstall_address_space_handler(
+    uacpi_namespace_node *device_node,
+    enum uacpi_address_space space
+);
+
+/*
+ * Execute _REG(space, ACPI_REG_CONNECT) for all of the opregions with this
+ * address space underneath this device. This should only be called manually
+ * if you want to register an early handler that must be available before the
+ * call to uacpi_namespace_initialize().
+ */
+uacpi_status uacpi_reg_all_opregions(
+    uacpi_namespace_node *device_node,
+    enum uacpi_address_space space
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/osi.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_vendor_interface {
+    UACPI_VENDOR_INTERFACE_NONE = 0,
+    UACPI_VENDOR_INTERFACE_WINDOWS_2000,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2003,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP_SP2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2003_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2008,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA_SP2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_7,
+    UACPI_VENDOR_INTERFACE_WINDOWS_8,
+    UACPI_VENDOR_INTERFACE_WINDOWS_8_1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS3,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS4,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS5,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_19H1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_20H1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_11,
+    UACPI_VENDOR_INTERFACE_WINDOWS_11_22H2,
+} uacpi_vendor_interface;
+
+/*
+ * Returns the "latest" AML-queried _OSI vendor interface.
+ *
+ * E.g. for the following AML code:
+ *     _OSI("Windows 2021")
+ *     _OSI("Windows 2000")
+ *
+ * This function will return UACPI_VENDOR_INTERFACE_WINDOWS_11, since this is
+ * the latest version of the interface the code queried, even though the
+ * "Windows 2000" query came after "Windows 2021".
+ */
+uacpi_vendor_interface uacpi_latest_queried_vendor_interface(void);
+
+typedef enum uacpi_interface_kind {
+    UACPI_INTERFACE_KIND_VENDOR = (1 << 0),
+    UACPI_INTERFACE_KIND_FEATURE = (1 << 1),
+    UACPI_INTERFACE_KIND_ALL = UACPI_INTERFACE_KIND_VENDOR |
+                               UACPI_INTERFACE_KIND_FEATURE,
+} uacpi_interface_kind;
+
+/*
+ * Install or uninstall an interface.
+ *
+ * The interface kind is used for matching during interface enumeration in
+ * uacpi_bulk_configure_interfaces().
+ *
+ * After installing an interface, all _OSI queries report it as supported.
+ */
+uacpi_status uacpi_install_interface(
+    const uacpi_char *name, uacpi_interface_kind
+);
+uacpi_status uacpi_uninstall_interface(const uacpi_char *name);
+
+typedef enum uacpi_host_interface {
+    UACPI_HOST_INTERFACE_MODULE_DEVICE = 1,
+    UACPI_HOST_INTERFACE_PROCESSOR_DEVICE,
+    UACPI_HOST_INTERFACE_3_0_THERMAL_MODEL,
+    UACPI_HOST_INTERFACE_3_0_SCP_EXTENSIONS,
+    UACPI_HOST_INTERFACE_PROCESSOR_AGGREGATOR_DEVICE,
+} uacpi_host_interface;
+
+/*
+ * Same as install/uninstall interface, but comes with an enum of known
+ * interfaces defined by the ACPI specification. These are disabled by default
+ * as they depend on the host kernel support.
+ */
+uacpi_status uacpi_enable_host_interface(uacpi_host_interface);
+uacpi_status uacpi_disable_host_interface(uacpi_host_interface);
+
+typedef uacpi_bool (*uacpi_interface_handler)
+    (const uacpi_char *name, uacpi_bool supported);
+
+/*
+ * Set a custom interface query (_OSI) handler.
+ *
+ * This callback will be invoked for each _OSI query with the value
+ * passed in the _OSI, as well as whether the interface was detected as
+ * supported. The callback is able to override the return value dynamically
+ * or leave it untouched if desired (e.g. if it simply wants to log something or
+ * do internal bookkeeping of some kind).
+ */
+uacpi_status uacpi_set_interface_query_handler(uacpi_interface_handler);
+
+typedef enum uacpi_interface_action {
+    UACPI_INTERFACE_ACTION_DISABLE = 0,
+    UACPI_INTERFACE_ACTION_ENABLE,
+} uacpi_interface_action;
+
+/*
+ * Bulk interface configuration, used to disable or enable all interfaces that
+ * match 'kind'.
+ *
+ * This is generally only needed to work around buggy hardware, for example if
+ * requested from the kernel command line.
+ *
+ * By default, all vendor strings (like "Windows 2000") are enabled, and all
+ * host features (like "3.0 Thermal Model") are disabled.
+ */
+uacpi_status uacpi_bulk_configure_interfaces(
+    uacpi_interface_action action, uacpi_interface_kind kind
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/platform/arch_helpers.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_ARCH_HELPERS
+#include "uacpi_arch_helpers.h"
+#else
+
+#include <uacpi/platform/atomic.h>
+
+#ifndef UACPI_ARCH_FLUSH_CPU_CACHE
+#define UACPI_ARCH_FLUSH_CPU_CACHE() do {} while (0)
+#endif
+
+typedef unsigned long uacpi_cpu_flags;
+
+typedef void *uacpi_thread_id;
+
+/*
+ * Replace as needed depending on your platform's way to represent thread ids.
+ * uACPI offers a few more helpers like uacpi_atomic_{load,store}{8,16,32,64,ptr}
+ * (or you could provide your own helpers)
+ */
+#ifndef UACPI_ATOMIC_LOAD_THREAD_ID
+#define UACPI_ATOMIC_LOAD_THREAD_ID(ptr) ((uacpi_thread_id)uacpi_atomic_load_ptr(ptr))
+#endif
+
+#ifndef UACPI_ATOMIC_STORE_THREAD_ID
+#define UACPI_ATOMIC_STORE_THREAD_ID(ptr, value) uacpi_atomic_store_ptr(ptr, value)
+#endif
+
+/*
+ * A sentinel value that the kernel promises to NEVER return from
+ * uacpi_kernel_get_current_thread_id or this will break
+ */
+#ifndef UACPI_THREAD_ID_NONE
+#define UACPI_THREAD_ID_NONE ((uacpi_thread_id)-1)
+#endif
+
+#endif

kernel/uACPI/include/uacpi/platform/atomic.h

@@ -0,0 +1,347 @@
+#pragma once
+
+/*
+ * Most of this header is a giant workaround for MSVC to make atomics into a
+ * somewhat unified interface with how GCC and Clang handle them.
+ *
+ * We don't use the absolutely disgusting C11 stdatomic.h header because it is
+ * unable to operate on non _Atomic types, which enforce implicit sequential
+ * consistency and alter the behavior of the standard C binary/unary operators.
+ *
+ * The strictness of the atomic helpers defined here is assumed to be at least
+ * acquire for loads and release for stores. Cmpxchg uses the standard acq/rel
+ * for success, acq for failure, and is assumed to be strong.
+ */
+
+#ifdef UACPI_OVERRIDE_ATOMIC
+#include "uacpi_atomic.h"
+#else
+
+#include <uacpi/platform/compiler.h>
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#include <intrin.h>
+
+// mimic __atomic_compare_exchange_n that doesn't exist on MSVC
+#define UACPI_MAKE_MSVC_CMPXCHG(width, type, suffix)                            \
+    static inline int uacpi_do_atomic_cmpxchg##width(                           \
+        type volatile *ptr, type volatile *expected, type desired               \
+    )                                                                           \
+    {                                                                           \
+        type current;                                                           \
+                                                                                \
+        current = _InterlockedCompareExchange##suffix(ptr, *expected, desired); \
+        if (current != *expected) {                                             \
+            *expected = current;                                                \
+            return 0;                                                           \
+        }                                                                       \
+        return 1;                                                               \
+    }
+
+#define UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, width, type) \
+    uacpi_do_atomic_cmpxchg##width(                                    \
+        (type volatile*)ptr, (type volatile*)expected, desired         \
+    )
+
+#define UACPI_MSVC_ATOMIC_STORE(ptr, value, type, width) \
+    _InterlockedExchange##width((type volatile*)(ptr), (type)(value))
+
+#define UACPI_MSVC_ATOMIC_LOAD(ptr, type, width) \
+    _InterlockedOr##width((type volatile*)(ptr), 0)
+
+#define UACPI_MSVC_ATOMIC_INC(ptr, type, width) \
+    _InterlockedIncrement##width((type volatile*)(ptr))
+
+#define UACPI_MSVC_ATOMIC_DEC(ptr, type, width) \
+    _InterlockedDecrement##width((type volatile*)(ptr))
+
+UACPI_MAKE_MSVC_CMPXCHG(64, __int64, 64)
+UACPI_MAKE_MSVC_CMPXCHG(32, long,)
+UACPI_MAKE_MSVC_CMPXCHG(16, short, 16)
+
+#define uacpi_atomic_cmpxchg16(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 16, short)
+
+#define uacpi_atomic_cmpxchg32(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 32, long)
+
+#define uacpi_atomic_cmpxchg64(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 64, __int64)
+
+#define uacpi_atomic_load8(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, char, 8)
+#define uacpi_atomic_load16(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, short, 16)
+#define uacpi_atomic_load32(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, long,)
+#define uacpi_atomic_load64(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, __int64, 64)
+
+#define uacpi_atomic_store8(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, char, 8)
+#define uacpi_atomic_store16(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, short, 16)
+#define uacpi_atomic_store32(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, long,)
+#define uacpi_atomic_store64(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, __int64, 64)
+
+#define uacpi_atomic_inc16(ptr) UACPI_MSVC_ATOMIC_INC(ptr, short, 16)
+#define uacpi_atomic_inc32(ptr) UACPI_MSVC_ATOMIC_INC(ptr, long,)
+#define uacpi_atomic_inc64(ptr) UACPI_MSVC_ATOMIC_INC(ptr, __int64, 64)
+
+#define uacpi_atomic_dec16(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, short, 16)
+#define uacpi_atomic_dec32(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, long,)
+#define uacpi_atomic_dec64(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, __int64, 64)
+#elif defined(__WATCOMC__)
+
+#include <stdint.h>
+
+static int uacpi_do_atomic_cmpxchg16(volatile uint16_t *ptr, volatile uint16_t *expected, uint16_t desired);
+#pragma aux uacpi_do_atomic_cmpxchg16 = \
+    ".486"                              \
+    "mov ax, [esi]"                     \
+    "lock cmpxchg [edi], bx"            \
+    "mov [esi], ax"                     \
+    "setz al"                           \
+    "movzx eax, al"                     \
+    parm [ edi ] [ esi ] [ ebx ]        \
+    value [ eax ]
+
+static int uacpi_do_atomic_cmpxchg32(volatile uint32_t *ptr, volatile uint32_t *expected, uint32_t desired);
+#pragma aux uacpi_do_atomic_cmpxchg32 = \
+    ".486"                              \
+    "mov eax, [esi]"                    \
+    "lock cmpxchg [edi], ebx"           \
+    "mov [esi], eax"                    \
+    "setz al"                           \
+    "movzx eax, al"                     \
+    parm [ edi ] [ esi ] [ ebx ]        \
+    value [ eax ]
+
+static int uacpi_do_atomic_cmpxchg64_asm(volatile uint64_t *ptr, volatile uint64_t *expected, uint32_t low, uint32_t high);
+#pragma aux uacpi_do_atomic_cmpxchg64_asm = \
+    ".586"                                  \
+    "mov eax, [esi]"                        \
+    "mov edx, [esi + 4]"                    \
+    "lock cmpxchg8b [edi]"                  \
+    "mov [esi], eax"                        \
+    "mov [esi + 4], edx"                    \
+    "setz al"                               \
+    "movzx eax, al"                         \
+    modify [ edx ]                          \
+    parm [ edi ] [ esi ] [ ebx ] [ ecx ]    \
+    value [ eax ]
+
+static inline int uacpi_do_atomic_cmpxchg64(volatile uint64_t *ptr, volatile uint64_t *expected, uint64_t desired) {
+    return uacpi_do_atomic_cmpxchg64_asm(ptr, expected, desired, desired >> 32);
+}
+
+#define uacpi_atomic_cmpxchg16(ptr, expected, desired) \
+    uacpi_do_atomic_cmpxchg16((volatile uint16_t*)ptr, (volatile uint16_t*)expected, (uint16_t)desired)
+#define uacpi_atomic_cmpxchg32(ptr, expected, desired) \
+    uacpi_do_atomic_cmpxchg32((volatile uint32_t*)ptr, (volatile uint32_t*)expected, (uint32_t)desired)
+#define uacpi_atomic_cmpxchg64(ptr, expected, desired) \
+    uacpi_do_atomic_cmpxchg64((volatile uint64_t*)ptr, (volatile uint64_t*)expected, (uint64_t)desired)
+
+static uint8_t uacpi_do_atomic_load8(volatile uint8_t *ptr);
+#pragma aux uacpi_do_atomic_load8 = \
+    "mov al, [esi]"                 \
+    parm [ esi ]                    \
+    value [ al ]
+
+static uint16_t uacpi_do_atomic_load16(volatile uint16_t *ptr);
+#pragma aux uacpi_do_atomic_load16 = \
+    "mov ax, [esi]"                  \
+    parm [ esi ]                     \
+    value [ ax ]
+
+static uint32_t uacpi_do_atomic_load32(volatile uint32_t *ptr);
+#pragma aux uacpi_do_atomic_load32 = \
+    "mov eax, [esi]"                 \
+    parm [ esi ]                     \
+    value [ eax ]
+
+static void uacpi_do_atomic_load64_asm(volatile uint64_t *ptr, uint64_t *out);
+#pragma aux uacpi_do_atomic_load64_asm =   \
+    ".586"                                 \
+    "xor eax, eax"                         \
+    "xor ebx, ebx"                         \
+    "xor ecx, ecx"                         \
+    "xor edx, edx"                         \
+    "lock cmpxchg8b [esi]"                 \
+    "mov [edi], eax"                       \
+    "mov [edi + 4], edx"                   \
+    modify [ eax ebx ecx edx ]             \
+    parm [ esi ] [ edi ]
+
+static inline uint64_t uacpi_do_atomic_load64(volatile uint64_t *ptr) {
+    uint64_t value;
+    uacpi_do_atomic_load64_asm(ptr, &value);
+    return value;
+}
+
+#define uacpi_atomic_load8(ptr) uacpi_do_atomic_load8((volatile uint8_t*)ptr)
+#define uacpi_atomic_load16(ptr) uacpi_do_atomic_load16((volatile uint16_t*)ptr)
+#define uacpi_atomic_load32(ptr) uacpi_do_atomic_load32((volatile uint32_t*)ptr)
+#define uacpi_atomic_load64(ptr) uacpi_do_atomic_load64((volatile uint64_t*)ptr)
+
+static void uacpi_do_atomic_store8(volatile uint8_t *ptr, uint8_t value);
+#pragma aux uacpi_do_atomic_store8 = \
+    "mov [edi], al"                  \
+    parm [ edi ] [ eax ]
+
+static void uacpi_do_atomic_store16(volatile uint16_t *ptr, uint16_t value);
+#pragma aux uacpi_do_atomic_store16 = \
+    "mov [edi], ax"                   \
+    parm [ edi ] [ eax ]
+
+static void uacpi_do_atomic_store32(volatile uint32_t *ptr, uint32_t value);
+#pragma aux uacpi_do_atomic_store32 = \
+    "mov [edi], eax"                  \
+    parm [ edi ] [ eax ]
+
+static void uacpi_do_atomic_store64_asm(volatile uint64_t *ptr, uint32_t low, uint32_t high);
+#pragma aux uacpi_do_atomic_store64_asm =  \
+    ".586"                                 \
+    "xor eax, eax"                         \
+    "xor edx, edx"                         \
+    "retry: lock cmpxchg8b [edi]"          \
+    "jnz retry"                            \
+    modify [ eax edx ]                     \
+    parm [ edi ] [ ebx ] [ ecx ]
+
+static inline void uacpi_do_atomic_store64(volatile uint64_t *ptr, uint64_t value) {
+    uacpi_do_atomic_store64_asm(ptr, value, value >> 32);
+}
+
+#define uacpi_atomic_store8(ptr, value) uacpi_do_atomic_store8((volatile uint8_t*)ptr, (uint8_t)value)
+#define uacpi_atomic_store16(ptr, value) uacpi_do_atomic_store16((volatile uint16_t*)ptr, (uint16_t)value)
+#define uacpi_atomic_store32(ptr, value) uacpi_do_atomic_store32((volatile uint32_t*)ptr, (uint32_t)value)
+#define uacpi_atomic_store64(ptr, value) uacpi_do_atomic_store64((volatile uint64_t*)ptr, (uint64_t)value)
+
+static uint16_t uacpi_do_atomic_inc16(volatile uint16_t *ptr);
+#pragma aux uacpi_do_atomic_inc16 = \
+    ".486"                          \
+    "mov ax, 1"                     \
+    "lock xadd [edi], ax"           \
+    "add ax, 1"                     \
+    parm [ edi ]                    \
+    value [ ax ]
+
+static uint32_t uacpi_do_atomic_inc32(volatile uint32_t *ptr);
+#pragma aux uacpi_do_atomic_inc32 = \
+    ".486"                          \
+    "mov eax, 1"                    \
+    "lock xadd [edi], eax"          \
+    "add eax, 1"                    \
+    parm [ edi ]                    \
+    value [ eax ]
+
+static void uacpi_do_atomic_inc64_asm(volatile uint64_t *ptr, uint64_t *out);
+#pragma aux uacpi_do_atomic_inc64_asm = \
+    ".586"                              \
+    "xor eax, eax"                      \
+    "xor edx, edx"                      \
+    "mov ebx, 1"                        \
+    "mov ecx, 1"                        \
+    "retry: lock cmpxchg8b [esi]"       \
+    "mov ebx, eax"                      \
+    "mov ecx, edx"                      \
+    "add ebx, 1"                        \
+    "adc ecx, 0"                        \
+    "jnz retry"                         \
+    "mov [edi], ebx"                    \
+    "mov [edi + 4], ecx"                \
+    modify [ eax ebx ecx edx ]          \
+    parm [ esi ] [ edi ]
+
+static inline uint64_t uacpi_do_atomic_inc64(volatile uint64_t *ptr) {
+    uint64_t value;
+    uacpi_do_atomic_inc64_asm(ptr, &value);
+    return value;
+}
+
+#define uacpi_atomic_inc16(ptr) uacpi_do_atomic_inc16((volatile uint16_t*)ptr)
+#define uacpi_atomic_inc32(ptr) uacpi_do_atomic_inc32((volatile uint32_t*)ptr)
+#define uacpi_atomic_inc64(ptr) uacpi_do_atomic_inc64((volatile uint64_t*)ptr)
+
+static uint16_t uacpi_do_atomic_dec16(volatile uint16_t *ptr);
+#pragma aux uacpi_do_atomic_dec16 = \
+    ".486"                          \
+    "mov ax, -1"                    \
+    "lock xadd [edi], ax"           \
+    "add ax, -1"                    \
+    parm [ edi ]                    \
+    value [ ax ]
+
+static uint32_t uacpi_do_atomic_dec32(volatile uint32_t *ptr);
+#pragma aux uacpi_do_atomic_dec32 = \
+    ".486"                          \
+    "mov eax, -1"                   \
+    "lock xadd [edi], eax"          \
+    "add eax, -1"                   \
+    parm [ edi ]                    \
+    value [ eax ]
+
+static void uacpi_do_atomic_dec64_asm(volatile uint64_t *ptr, uint64_t *out);
+#pragma aux uacpi_do_atomic_dec64_asm = \
+    ".586"                              \
+    "xor eax, eax"                      \
+    "xor edx, edx"                      \
+    "mov ebx, -1"                       \
+    "mov ecx, -1"                       \
+    "retry: lock cmpxchg8b [esi]"       \
+    "mov ebx, eax"                      \
+    "mov ecx, edx"                      \
+    "sub ebx, 1"                        \
+    "sbb ecx, 0"                        \
+    "jnz retry"                         \
+    "mov [edi], ebx"                    \
+    "mov [edi + 4], ecx"                \
+    modify [ eax ebx ecx edx ]          \
+    parm [ esi ] [ edi ]
+
+static inline uint64_t uacpi_do_atomic_dec64(volatile uint64_t *ptr) {
+    uint64_t value;
+    uacpi_do_atomic_dec64_asm(ptr, &value);
+    return value;
+}
+
+#define uacpi_atomic_dec16(ptr) uacpi_do_atomic_dec16((volatile uint16_t*)ptr)
+#define uacpi_atomic_dec32(ptr) uacpi_do_atomic_dec32((volatile uint32_t*)ptr)
+#define uacpi_atomic_dec64(ptr) uacpi_do_atomic_dec64((volatile uint64_t*)ptr)
+#else
+
+#define UACPI_DO_CMPXCHG(ptr, expected, desired)           \
+    __atomic_compare_exchange_n(ptr, expected, desired, 0, \
+                                __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)
+
+#define uacpi_atomic_cmpxchg16(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+#define uacpi_atomic_cmpxchg32(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+#define uacpi_atomic_cmpxchg64(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+
+#define uacpi_atomic_load8(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load16(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load32(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load64(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+
+#define uacpi_atomic_store8(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store16(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store32(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store64(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+
+#define uacpi_atomic_inc16(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_inc32(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_inc64(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+
+#define uacpi_atomic_dec16(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_dec32(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_dec64(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#endif
+
+#if UACPI_POINTER_SIZE == 4
+#define uacpi_atomic_load_ptr(ptr_to_ptr) uacpi_atomic_load32(ptr_to_ptr)
+#define uacpi_atomic_store_ptr(ptr_to_ptr, value) uacpi_atomic_store32(ptr_to_ptr, value)
+#else
+#define uacpi_atomic_load_ptr(ptr_to_ptr) uacpi_atomic_load64(ptr_to_ptr)
+#define uacpi_atomic_store_ptr(ptr_to_ptr, value) uacpi_atomic_store64(ptr_to_ptr, value)
+#endif
+
+#endif

kernel/uACPI/include/uacpi/platform/compiler.h

@@ -0,0 +1,125 @@
+#pragma once
+
+/*
+ * Compiler-specific attributes/macros go here. This is the default placeholder
+ * that should work for MSVC/GCC/clang.
+ */
+
+#ifdef UACPI_OVERRIDE_COMPILER
+#include "uacpi_compiler.h"
+#else
+
+#define UACPI_ALIGN(x) __declspec(align(x))
+
+#if defined(__WATCOMC__)
+#define UACPI_STATIC_ASSERT(expr, msg)
+#elif defined(__cplusplus)
+#define UACPI_STATIC_ASSERT static_assert
+#else
+#define UACPI_STATIC_ASSERT _Static_assert
+#endif
+
+#ifdef _MSC_VER
+    #include <intrin.h>
+
+    #define UACPI_ALWAYS_INLINE __forceinline
+
+    #define UACPI_PACKED(decl)  \
+        __pragma(pack(push, 1)) \
+        decl;                   \
+        __pragma(pack(pop))
+#elif defined(__WATCOMC__)
+    #define UACPI_ALWAYS_INLINE inline
+    #define UACPI_PACKED(decl) _Packed decl;
+#else
+    #define UACPI_ALWAYS_INLINE inline __attribute__((always_inline))
+    #define UACPI_PACKED(decl) decl __attribute__((packed));
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define uacpi_unlikely(expr) __builtin_expect(!!(expr), 0)
+    #define uacpi_likely(expr)   __builtin_expect(!!(expr), 1)
+
+    #ifdef __has_attribute
+        #if __has_attribute(__fallthrough__)
+            #define UACPI_FALLTHROUGH __attribute__((__fallthrough__))
+        #endif
+    #endif
+
+    #define UACPI_MAYBE_UNUSED __attribute__ ((unused))
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN             \
+        _Pragma("GCC diagnostic push")                           \
+        _Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_END \
+        _Pragma("GCC diagnostic pop")
+
+    #ifdef __clang__
+        #define UACPI_PRINTF_DECL(fmt_idx, args_idx) \
+            __attribute__((format(printf, fmt_idx, args_idx)))
+    #else
+        #define UACPI_PRINTF_DECL(fmt_idx, args_idx) \
+            __attribute__((format(gnu_printf, fmt_idx, args_idx)))
+    #endif
+
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMCPY
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMMOVE
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMSET
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMCMP
+#elif defined(__WATCOMC__)
+    #define uacpi_unlikely(expr) expr
+    #define uacpi_likely(expr) expr
+
+    /*
+     * The OpenWatcom documentation suggests this should be done using
+     * _Pragma("off (unreferenced)") and _Pragma("pop (unreferenced)"),
+     * but these pragmas appear to be no-ops. Use inline as the next best thing.
+     * Note that OpenWatcom accepts redundant modifiers without a warning,
+     * so UACPI_MAYBE_UNUSED inline still works.
+     */
+    #define UACPI_MAYBE_UNUSED inline
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_END
+
+    #define UACPI_PRINTF_DECL(fmt_idx, args_idx)
+#else
+    #define uacpi_unlikely(expr) expr
+    #define uacpi_likely(expr)   expr
+
+    #define UACPI_MAYBE_UNUSED
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_END
+
+    #define UACPI_PRINTF_DECL(fmt_idx, args_idx)
+#endif
+
+#ifndef UACPI_FALLTHROUGH
+    #define UACPI_FALLTHROUGH do {} while (0)
+#endif
+
+#ifndef UACPI_POINTER_SIZE
+    #ifdef _WIN32
+        #ifdef _WIN64
+            #define UACPI_POINTER_SIZE 8
+        #else
+            #define UACPI_POINTER_SIZE 4
+        #endif
+    #elif defined(__GNUC__)
+        #define UACPI_POINTER_SIZE __SIZEOF_POINTER__
+    #elif defined(__WATCOMC__)
+        #ifdef __386__
+            #define UACPI_POINTER_SIZE 4
+        #elif defined(__I86__)
+            #error uACPI does not support 16-bit mode compilation
+        #else
+            #error Unknown target architecture
+        #endif
+    #else
+        #error Failed to detect pointer size
+    #endif
+#endif
+
+#endif

kernel/uACPI/include/uacpi/platform/config.h

@@ -0,0 +1,162 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_CONFIG
+#include "uacpi_config.h"
+#else
+
+#include <uacpi/helpers.h>
+#include <uacpi/log.h>
+
+/*
+ * =======================
+ * Context-related options
+ * =======================
+ */
+#ifndef UACPI_DEFAULT_LOG_LEVEL
+    #define UACPI_DEFAULT_LOG_LEVEL UACPI_LOG_INFO
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_LOG_LEVEL < UACPI_LOG_ERROR ||
+    UACPI_DEFAULT_LOG_LEVEL > UACPI_LOG_DEBUG,
+    "configured default log level is invalid"
+);
+
+#ifndef UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS
+    #define UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS 30
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS < 1,
+    "configured default loop timeout is invalid (expecting at least 1 second)"
+);
+
+#ifndef UACPI_DEFAULT_MAX_CALL_STACK_DEPTH
+    #define UACPI_DEFAULT_MAX_CALL_STACK_DEPTH 256
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_MAX_CALL_STACK_DEPTH < 4,
+    "configured default max call stack depth is invalid "
+    "(expecting at least 4 frames)"
+);
+
+/*
+ * ===================
+ * Kernel-api options
+ * ===================
+ */
+
+/*
+ * Convenience initialization/deinitialization hooks that will be called by
+ * uACPI automatically when appropriate if compiled-in.
+ */
+// #define UACPI_KERNEL_INITIALIZATION
+
+/*
+ * Makes kernel api logging callbacks work with unformatted printf-style
+ * strings and va_args instead of a pre-formatted string. Can be useful if
+ * your native logging is implemented in terms of this format as well.
+ */
+// #define UACPI_FORMATTED_LOGGING
+
+/*
+ * Makes uacpi_kernel_free take in an additional 'size_hint' parameter, which
+ * contains the size of the original allocation. Note that this comes with a
+ * performance penalty in some cases.
+ */
+// #define UACPI_SIZED_FREES
+
+
+/*
+ * Makes uacpi_kernel_alloc_zeroed mandatory to implement by the host, uACPI
+ * will not provide a default implementation if this is enabled.
+ */
+// #define UACPI_NATIVE_ALLOC_ZEROED
+
+/*
+ * =========================
+ * Platform-specific options
+ * =========================
+ */
+
+/*
+ * Makes uACPI use the internal versions of mem{cpy,move,set,cmp} instead of
+ * relying on the host to provide them. Note that compilers like clang and GCC
+ * rely on these being available by default, even in freestanding mode, so
+ * compiling uACPI may theoretically generate implicit dependencies on them
+ * even if this option is defined.
+ */
+// #define UACPI_USE_BUILTIN_STRING
+
+/*
+ * Turns uacpi_phys_addr and uacpi_io_addr into a 32-bit type, and adds extra
+ * code for address truncation. Needed for e.g. i686 platforms without PAE
+ * support.
+ */
+// #define UACPI_PHYS_ADDR_IS_32BITS
+
+/*
+ * Switches uACPI into reduced-hardware-only mode. Strips all full-hardware
+ * ACPI support code at compile-time, including the event subsystem, the global
+ * lock, and other full-hardware features.
+ */
+// #define UACPI_REDUCED_HARDWARE
+
+/*
+ * Switches uACPI into tables-subsystem-only mode and strips all other code.
+ * This means only the table API will be usable, no other subsystems are
+ * compiled in. In this mode, uACPI only depends on the following kernel APIs:
+ * - uacpi_kernel_get_rsdp
+ * - uacpi_kernel_{map,unmap}
+ * - uacpi_kernel_log
+ *
+ * Use uacpi_setup_early_table_access to initialize, uacpi_state_reset to
+ * deinitialize.
+ *
+ * This mode is primarily designed for these three use-cases:
+ * - Bootloader/pre-kernel environments that need to parse ACPI tables, but
+ *   don't actually need a fully-featured AML interpreter, and everything else
+ *   that a full APCI implementation entails.
+ * - A micro-kernel that has the full AML interpreter running in userspace, but
+ *   still needs to parse ACPI tables to bootstrap allocators, timers, SMP etc.
+ * - A WIP kernel that needs to parse ACPI tables for bootrapping SMP/timers,
+ *   ECAM, etc., but doesn't yet have enough subsystems implemented in order
+ *   to run a fully-featured AML interpreter.
+ */
+// #define UACPI_BAREBONES_MODE
+
+/*
+ * =============
+ * Misc. options
+ * =============
+ */
+
+/*
+ * If UACPI_FORMATTED_LOGGING is not enabled, this is the maximum length of the
+ * pre-formatted message that is passed to the logging callback.
+ */
+#ifndef UACPI_PLAIN_LOG_BUFFER_SIZE
+    #define UACPI_PLAIN_LOG_BUFFER_SIZE 128
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_PLAIN_LOG_BUFFER_SIZE < 16,
+    "configured log buffer size is too small (expecting at least 16 bytes)"
+);
+
+/*
+ * The size of the table descriptor inline storage. All table descriptors past
+ * this length will be stored in a dynamically allocated heap array. The size
+ * of one table descriptor is approximately 56 bytes.
+ */
+#ifndef UACPI_STATIC_TABLE_ARRAY_LEN
+    #define UACPI_STATIC_TABLE_ARRAY_LEN 16
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_STATIC_TABLE_ARRAY_LEN < 1,
+    "configured static table array length is too small (expecting at least 1)"
+);
+
+#endif

kernel/uACPI/include/uacpi/platform/libc.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_LIBC
+#include "uacpi_libc.h"
+#else
+/*
+ * The following libc functions are used internally by uACPI and have a default
+ * (sub-optimal) implementation:
+ * - strcmp
+ * - strnlen
+ * - strlen
+ * - snprintf
+ * - vsnprintf
+ *
+ * The following use a builtin implementation only if UACPI_USE_BUILTIN_STRING
+ * is defined (more information can be found in the config.h header):
+ * - memcpy
+ * - memmove
+ * - memset
+ * - memcmp
+ *
+ * In case your platform happens to implement optimized verisons of the helpers
+ * above, you are able to make uACPI use those instead by overriding them like so:
+ *
+ * #define uacpi_memcpy my_fast_memcpy
+ * #define uacpi_snprintf my_fast_snprintf
+ */
+#endif

kernel/uACPI/include/uacpi/platform/types.h

@@ -0,0 +1,64 @@
+#pragma once
+
+/*
+ * Platform-specific types go here. This is the default placeholder using
+ * types from the standard headers.
+ */
+
+#ifdef UACPI_OVERRIDE_TYPES
+#include "uacpi_types.h"
+#else
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+
+#include <uacpi/helpers.h>
+
+typedef uint8_t uacpi_u8;
+typedef uint16_t uacpi_u16;
+typedef uint32_t uacpi_u32;
+typedef uint64_t uacpi_u64;
+
+typedef int8_t uacpi_i8;
+typedef int16_t uacpi_i16;
+typedef int32_t uacpi_i32;
+typedef int64_t uacpi_i64;
+
+#define UACPI_TRUE true
+#define UACPI_FALSE false
+typedef bool uacpi_bool;
+
+#define UACPI_NULL NULL
+
+typedef uintptr_t uacpi_uintptr;
+typedef uacpi_uintptr uacpi_virt_addr;
+typedef size_t uacpi_size;
+
+typedef va_list uacpi_va_list;
+#define uacpi_va_start va_start
+#define uacpi_va_end va_end
+#define uacpi_va_arg va_arg
+
+typedef char uacpi_char;
+
+#define uacpi_offsetof offsetof
+
+/*
+ * We use unsignd long long for 64-bit number formatting because 64-bit types
+ * don't have a standard way to format them. The inttypes.h header is not
+ * freestanding therefore it's not practical to force the user to define the
+ * corresponding PRI macros. Moreover, unsignd long long  is required to be
+ * at least 64-bits as per C99.
+ */
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    sizeof(unsigned long long) < 8,
+    "unsigned long long must be at least 64 bits large as per C99"
+);
+#define UACPI_PRIu64 "llu"
+#define UACPI_PRIx64 "llx"
+#define UACPI_PRIX64 "llX"
+#define UACPI_FMT64(val) ((unsigned long long)(val))
+
+#endif

kernel/uACPI/include/uacpi/registers.h

@@ -0,0 +1,105 @@
+#include <uacpi/types.h>
+
+/*
+ * BEFORE YOU USE THIS API:
+ * uACPI manages FADT registers on its own entirely, you should only use this
+ * API directly if there's absolutely no other way for your use case, e.g.
+ * implementing a CPU idle state driver that does C state switching or similar.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_register {
+    UACPI_REGISTER_PM1_STS = 0,
+    UACPI_REGISTER_PM1_EN,
+    UACPI_REGISTER_PM1_CNT,
+    UACPI_REGISTER_PM_TMR,
+    UACPI_REGISTER_PM2_CNT,
+    UACPI_REGISTER_SLP_CNT,
+    UACPI_REGISTER_SLP_STS,
+    UACPI_REGISTER_RESET,
+    UACPI_REGISTER_SMI_CMD,
+    UACPI_REGISTER_MAX = UACPI_REGISTER_SMI_CMD,
+} uacpi_register;
+
+/*
+ * Read a register from FADT
+ *
+ * NOTE: write-only bits (if any) are cleared automatically
+ */
+uacpi_status uacpi_read_register(uacpi_register, uacpi_u64*);
+
+/*
+ * Write a register from FADT
+ *
+ * NOTE:
+ * - Preserved bits (if any) are preserved automatically
+ * - If a register is made up of two (e.g. PM1a and PM1b) parts, the input
+ *   is written to both at the same time
+ */
+uacpi_status uacpi_write_register(uacpi_register, uacpi_u64);
+
+/*
+ * Write a register from FADT
+ *
+ * NOTE:
+ * - Preserved bits (if any) are preserved automatically
+ * - For registers that are made up of two (e.g. PM1a and PM1b) parts, the
+ *   provided values are written to their respective physical register
+ */
+uacpi_status uacpi_write_registers(uacpi_register, uacpi_u64, uacpi_u64);
+
+typedef enum uacpi_register_field {
+    UACPI_REGISTER_FIELD_TMR_STS = 0,
+    UACPI_REGISTER_FIELD_BM_STS,
+    UACPI_REGISTER_FIELD_GBL_STS,
+    UACPI_REGISTER_FIELD_PWRBTN_STS,
+    UACPI_REGISTER_FIELD_SLPBTN_STS,
+    UACPI_REGISTER_FIELD_RTC_STS,
+    UACPI_REGISTER_FIELD_PCIEX_WAKE_STS,
+    UACPI_REGISTER_FIELD_HWR_WAK_STS,
+    UACPI_REGISTER_FIELD_WAK_STS,
+    UACPI_REGISTER_FIELD_TMR_EN,
+    UACPI_REGISTER_FIELD_GBL_EN,
+    UACPI_REGISTER_FIELD_PWRBTN_EN,
+    UACPI_REGISTER_FIELD_SLPBTN_EN,
+    UACPI_REGISTER_FIELD_RTC_EN,
+    UACPI_REGISTER_FIELD_PCIEXP_WAKE_DIS,
+    UACPI_REGISTER_FIELD_SCI_EN,
+    UACPI_REGISTER_FIELD_BM_RLD,
+    UACPI_REGISTER_FIELD_GBL_RLS,
+    UACPI_REGISTER_FIELD_SLP_TYP,
+    UACPI_REGISTER_FIELD_HWR_SLP_TYP,
+    UACPI_REGISTER_FIELD_SLP_EN,
+    UACPI_REGISTER_FIELD_HWR_SLP_EN,
+    UACPI_REGISTER_FIELD_ARB_DIS,
+    UACPI_REGISTER_FIELD_MAX = UACPI_REGISTER_FIELD_ARB_DIS,
+} uacpi_register_field;
+
+/*
+ * Read a field from a FADT register
+ *
+ * NOTE: The value is automatically masked and shifted down as appropriate,
+ *       the client code doesn't have to do any bit manipulation. E.g. for
+ *       a field at 0b???XX??? the returned value will contain just the 0bXX
+ */
+uacpi_status uacpi_read_register_field(uacpi_register_field, uacpi_u64*);
+
+/*
+ * Write to a field of a FADT register
+ *
+ * NOTE: The value is automatically masked and shifted up as appropriate,
+ *       the client code doesn't have to do any bit manipulation. E.g. for
+ *       a field at 0b???XX??? the passed value should be just 0bXX
+ */
+uacpi_status uacpi_write_register_field(uacpi_register_field, uacpi_u64);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/resources.h

@@ -0,0 +1,759 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_resource_type {
+    UACPI_RESOURCE_TYPE_IRQ,
+    UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
+
+    UACPI_RESOURCE_TYPE_DMA,
+    UACPI_RESOURCE_TYPE_FIXED_DMA,
+
+    UACPI_RESOURCE_TYPE_IO,
+    UACPI_RESOURCE_TYPE_FIXED_IO,
+
+    UACPI_RESOURCE_TYPE_ADDRESS16,
+    UACPI_RESOURCE_TYPE_ADDRESS32,
+    UACPI_RESOURCE_TYPE_ADDRESS64,
+    UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
+
+    UACPI_RESOURCE_TYPE_MEMORY24,
+    UACPI_RESOURCE_TYPE_MEMORY32,
+    UACPI_RESOURCE_TYPE_FIXED_MEMORY32,
+
+    UACPI_RESOURCE_TYPE_START_DEPENDENT,
+    UACPI_RESOURCE_TYPE_END_DEPENDENT,
+
+    // Up to 7 bytes
+    UACPI_RESOURCE_TYPE_VENDOR_SMALL,
+
+    // Up to 2^16 - 1 bytes
+    UACPI_RESOURCE_TYPE_VENDOR_LARGE,
+
+    UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
+    UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
+
+    // These must always be contiguous in this order
+    UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_SPI_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_UART_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_CSI2_CONNECTION,
+
+    UACPI_RESOURCE_TYPE_PIN_FUNCTION,
+    UACPI_RESOURCE_TYPE_PIN_CONFIGURATION,
+    UACPI_RESOURCE_TYPE_PIN_GROUP,
+    UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION,
+    UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION,
+
+    UACPI_RESOURCE_TYPE_CLOCK_INPUT,
+
+    UACPI_RESOURCE_TYPE_END_TAG,
+    UACPI_RESOURCE_TYPE_MAX = UACPI_RESOURCE_TYPE_END_TAG,
+} uacpi_resource_type;
+
+typedef struct uacpi_resource_source {
+    uacpi_u8 index;
+    uacpi_bool index_present;
+    uacpi_u16 length;
+    uacpi_char *string;
+} uacpi_resource_source;
+
+/*
+ * This applies to IRQ & StartDependent resources only. The DONT_CARE value is
+ * used for deserialization into the AML format to signify that the serializer
+ * is allowed to optimize the length down if possible. Note that this is
+ * generally not allowed unless the resource is generated by the caller:
+ *
+ * -- ACPI 6.5 ------------------------------------------------------------
+ * The resource descriptors in the byte stream argument must be specified
+ * exactly as listed in the _CRS byte stream - meaning that the identical
+ * resource descriptors must appear in the identical order, resulting in a
+ * buffer of exactly the same length. Optimizations such as changing an
+ * IRQ descriptor to an IRQNoFlags descriptor (or vice-versa) must not be
+ * performed. Similarly, changing StartDependentFn to StartDependentFnNoPri
+ * is not allowed.
+ * ------------------------------------------------------------------------
+ */
+enum uacpi_resource_length_kind {
+    UACPI_RESOURCE_LENGTH_KIND_DONT_CARE = 0,
+    UACPI_RESOURCE_LENGTH_KIND_ONE_LESS,
+    UACPI_RESOURCE_LENGTH_KIND_FULL,
+};
+
+// triggering fields
+#define UACPI_TRIGGERING_EDGE 1
+#define UACPI_TRIGGERING_LEVEL 0
+
+// polarity
+#define UACPI_POLARITY_ACTIVE_HIGH 0
+#define UACPI_POLARITY_ACTIVE_LOW 1
+#define UACPI_POLARITY_ACTIVE_BOTH 2
+
+// sharing
+#define UACPI_EXCLUSIVE 0
+#define UACPI_SHARED 1
+
+// wake_capability
+#define UACPI_WAKE_CAPABLE 1
+#define UACPI_NOT_WAKE_CAPABLE 0
+
+typedef struct uacpi_resource_irq {
+    uacpi_u8 length_kind;
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+    uacpi_u8 num_irqs;
+    uacpi_u8 irqs[];
+} uacpi_resource_irq;
+
+typedef struct uacpi_resource_extended_irq {
+    uacpi_u8 direction;
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+    uacpi_u8 num_irqs;
+    uacpi_resource_source source;
+    uacpi_u32 irqs[];
+} uacpi_resource_extended_irq;
+
+// transfer_type
+#define UACPI_TRANSFER_TYPE_8_BIT 0b00
+#define UACPI_TRANSFER_TYPE_8_AND_16_BIT 0b01
+#define UACPI_TRANSFER_TYPE_16_BIT 0b10
+
+// bus_master_status
+#define UACPI_BUS_MASTER 0b1
+
+// channel_speed
+#define UACPI_DMA_COMPATIBILITY 0b00
+#define UACPI_DMA_TYPE_A 0b01
+#define UACPI_DMA_TYPE_B 0b10
+#define UACPI_DMA_TYPE_F 0b11
+
+// transfer_width
+#define UACPI_TRANSFER_WIDTH_8 0x00
+#define UACPI_TRANSFER_WIDTH_16 0x01
+#define UACPI_TRANSFER_WIDTH_32 0x02
+#define UACPI_TRANSFER_WIDTH_64 0x03
+#define UACPI_TRANSFER_WIDTH_128 0x04
+#define UACPI_TRANSFER_WIDTH_256 0x05
+
+typedef struct uacpi_resource_dma {
+    uacpi_u8 transfer_type;
+    uacpi_u8 bus_master_status;
+    uacpi_u8 channel_speed;
+    uacpi_u8 num_channels;
+    uacpi_u8 channels[];
+} uacpi_resource_dma;
+
+typedef struct uacpi_resource_fixed_dma {
+    uacpi_u16 request_line;
+    uacpi_u16 channel;
+    uacpi_u8 transfer_width;
+} uacpi_resource_fixed_dma;
+
+// decode_type
+#define UACPI_DECODE_16 0b1
+#define UACPI_DECODE_10 0b0
+
+typedef struct uacpi_resource_io {
+    uacpi_u8 decode_type;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u8 alignment;
+    uacpi_u8 length;
+} uacpi_resource_io;
+
+typedef struct uacpi_resource_fixed_io {
+    uacpi_u16 address;
+    uacpi_u8 length;
+} uacpi_resource_fixed_io;
+
+// write_status
+#define UACPI_NON_WRITABLE 0
+#define UACPI_WRITABLE 1
+
+// caching
+#define UACPI_NON_CACHEABLE 0
+#define UACPI_CACHEABLE 1
+#define UACPI_CACHEABLE_WRITE_COMBINING 2
+#define UACPI_PREFETCHABLE 3
+
+// range_type
+#define UACPI_RANGE_TYPE_MEMORY 0
+#define UACPI_RANGE_TYPE_RESERVED 1
+#define UACPI_RANGE_TYPE_ACPI 2
+#define UACPI_RANGE_TYPE_NVS 3
+
+// address_common->type
+#define UACPI_RANGE_MEMORY 0
+#define UACPI_RANGE_IO 1
+#define UACPI_RANGE_BUS 2
+
+// translation
+#define UACPI_IO_MEM_TRANSLATION 1
+#define UACPI_IO_MEM_STATIC 0
+
+// translation_type
+#define UACPI_TRANSLATION_DENSE 0
+#define UACPI_TRANSLATION_SPARSE 1
+
+// direction
+#define UACPI_PRODUCER 0
+#define UACPI_CONSUMER 1
+
+// decode_type
+#define UACPI_POSITIVE_DECODE 0
+#define UACPI_SUBTRACTIVE_DECODE 1
+
+// fixed_min_address & fixed_max_address
+#define UACPI_ADDRESS_NOT_FIXED 0
+#define UACPI_ADDRESS_FIXED 1
+
+typedef struct uacpi_memory_attribute {
+    uacpi_u8 write_status;
+    uacpi_u8 caching;
+    uacpi_u8 range_type;
+    uacpi_u8 translation;
+} uacpi_memory_attribute;
+
+typedef struct uacpi_io_attribute {
+    uacpi_u8 range_type;
+    uacpi_u8 translation;
+    uacpi_u8 translation_type;
+} uacpi_io_attribute;
+
+typedef union uacpi_address_attribute {
+    uacpi_memory_attribute memory;
+    uacpi_io_attribute io;
+    uacpi_u8 type_specific;
+} uacpi_address_attribute;
+
+typedef struct uacpi_resource_address_common {
+    uacpi_address_attribute attribute;
+    uacpi_u8 type;
+    uacpi_u8 direction;
+    uacpi_u8 decode_type;
+    uacpi_u8 fixed_min_address;
+    uacpi_u8 fixed_max_address;
+} uacpi_resource_address_common;
+
+typedef struct uacpi_resource_address16 {
+    uacpi_resource_address_common common;
+    uacpi_u16 granularity;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u16 translation_offset;
+    uacpi_u16 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address16;
+
+typedef struct uacpi_resource_address32 {
+    uacpi_resource_address_common common;
+    uacpi_u32 granularity;
+    uacpi_u32 minimum;
+    uacpi_u32 maximum;
+    uacpi_u32 translation_offset;
+    uacpi_u32 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address32;
+
+typedef struct uacpi_resource_address64 {
+    uacpi_resource_address_common common;
+    uacpi_u64 granularity;
+    uacpi_u64 minimum;
+    uacpi_u64 maximum;
+    uacpi_u64 translation_offset;
+    uacpi_u64 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address64;
+
+typedef struct uacpi_resource_address64_extended {
+    uacpi_resource_address_common common;
+    uacpi_u8 revision_id;
+    uacpi_u64 granularity;
+    uacpi_u64 minimum;
+    uacpi_u64 maximum;
+    uacpi_u64 translation_offset;
+    uacpi_u64 address_length;
+    uacpi_u64 attributes;
+} uacpi_resource_address64_extended;
+
+typedef struct uacpi_resource_memory24 {
+    uacpi_u8 write_status;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u16 alignment;
+    uacpi_u16 length;
+} uacpi_resource_memory24;
+
+typedef struct uacpi_resource_memory32 {
+    uacpi_u8 write_status;
+    uacpi_u32 minimum;
+    uacpi_u32 maximum;
+    uacpi_u32 alignment;
+    uacpi_u32 length;
+} uacpi_resource_memory32;
+
+typedef struct uacpi_resource_fixed_memory32 {
+    uacpi_u8 write_status;
+    uacpi_u32 address;
+    uacpi_u32 length;
+} uacpi_resource_fixed_memory32;
+
+// compatibility & performance
+#define UACPI_GOOD 0
+#define UACPI_ACCEPTABLE 1
+#define UACPI_SUB_OPTIMAL 2
+
+typedef struct uacpi_resource_start_dependent {
+    uacpi_u8 length_kind;
+    uacpi_u8 compatibility;
+    uacpi_u8 performance;
+} uacpi_resource_start_dependent;
+
+typedef struct uacpi_resource_vendor_defined {
+    uacpi_u8 length;
+    uacpi_u8 data[];
+} uacpi_resource_vendor;
+
+typedef struct uacpi_resource_vendor_typed {
+    uacpi_u16 length;
+    uacpi_u8 sub_type;
+    uacpi_u8 uuid[16];
+    uacpi_u8 data[];
+} uacpi_resource_vendor_typed;
+
+typedef struct uacpi_resource_generic_register {
+    uacpi_u8 address_space_id;
+    uacpi_u8 bit_width;
+    uacpi_u8 bit_offset;
+    uacpi_u8 access_size;
+    uacpi_u64 address;
+} uacpi_resource_generic_register;
+
+// type
+#define UACPI_GPIO_CONNECTION_INTERRUPT 0x00
+#define UACPI_GPIO_CONNECTION_IO 0x01
+
+typedef struct uacpi_interrupt_connection_flags {
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+} uacpi_interrupt_connection_flags;
+
+// restriction
+#define UACPI_IO_RESTRICTION_NONE 0x0
+#define UACPI_IO_RESTRICTION_INPUT 0x1
+#define UACPI_IO_RESTRICTION_OUTPUT 0x2
+#define UACPI_IO_RESTRICTION_NONE_PRESERVE 0x3
+
+typedef struct uacpi_io_connection_flags {
+    uacpi_u8 restriction;
+    uacpi_u8 sharing;
+} uacpi_io_connection_flags;
+
+// pull_configuration
+#define UACPI_PIN_CONFIG_DEFAULT 0x00
+#define UACPI_PIN_CONFIG_PULL_UP 0x01
+#define UACPI_PIN_CONFIG_PULL_DOWN 0x02
+#define UACPI_PIN_CONFIG_NO_PULL 0x03
+
+typedef struct uacpi_resource_gpio_connection {
+    uacpi_u8 revision_id;
+    uacpi_u8 type;
+    uacpi_u8 direction;
+
+    union {
+        uacpi_interrupt_connection_flags intr;
+        uacpi_io_connection_flags io;
+        uacpi_u16 type_specific;
+    };
+
+    uacpi_u8 pull_configuration;
+    uacpi_u16 drive_strength;
+    uacpi_u16 debounce_timeout;
+    uacpi_u16 vendor_data_length;
+    uacpi_u16 pin_table_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_gpio_connection;
+
+// mode
+#define UACPI_MODE_CONTROLLER_INITIATED 0x0
+#define UACPI_MODE_DEVICE_INITIATED 0x1
+
+typedef struct uacpi_resource_serial_bus_common {
+    uacpi_u8 revision_id;
+    uacpi_u8 type;
+    uacpi_u8 mode;
+    uacpi_u8 direction;
+    uacpi_u8 sharing;
+    uacpi_u8 type_revision_id;
+    uacpi_u16 type_data_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_serial_bus_common;
+
+// addressing_mode
+#define UACPI_I2C_7BIT 0x0
+#define UACPI_I2C_10BIT 0x1
+
+typedef struct uacpi_resource_i2c_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 addressing_mode;
+    uacpi_u16 slave_address;
+    uacpi_u32 connection_speed;
+} uacpi_resource_i2c_connection;
+
+// wire_mode
+#define UACPI_SPI_4_WIRES 0
+#define UACPI_SPI_3_WIRES 1
+
+// device_polarity
+#define UACPI_SPI_ACTIVE_LOW 0
+#define UACPI_SPI_ACTIVE_HIGH 1
+
+// phase
+#define UACPI_SPI_PHASE_FIRST 0
+#define UACPI_SPI_PHASE_SECOND 1
+
+// polarity
+#define UACPI_SPI_START_LOW 0
+#define UACPI_SPI_START_HIGH 1
+
+typedef struct uacpi_resource_spi_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 wire_mode;
+    uacpi_u8 device_polarity;
+    uacpi_u8 data_bit_length;
+    uacpi_u8 phase;
+    uacpi_u8 polarity;
+    uacpi_u16 device_selection;
+    uacpi_u32 connection_speed;
+} uacpi_resource_spi_connection;
+
+// stop_bits
+#define UACPI_UART_STOP_BITS_NONE 0b00
+#define UACPI_UART_STOP_BITS_1 0b01
+#define UACPI_UART_STOP_BITS_1_5 0b10
+#define UACPI_UART_STOP_BITS_2 0b11
+
+// data_bits
+#define UACPI_UART_DATA_5BITS 0b000
+#define UACPI_UART_DATA_6BITS 0b001
+#define UACPI_UART_DATA_7BITS 0b010
+#define UACPI_UART_DATA_8BITS 0b011
+#define UACPI_UART_DATA_9BITS 0b100
+
+// endianness
+#define UACPI_UART_LITTLE_ENDIAN 0
+#define UACPI_UART_BIG_ENDIAN 1
+
+// parity
+#define UACPI_UART_PARITY_NONE 0x00
+#define UACPI_UART_PARITY_EVEN 0x01
+#define UACPI_UART_PARITY_ODD 0x02
+#define UACPI_UART_PARITY_MARK 0x03
+#define UACPI_UART_PARITY_SPACE 0x04
+
+// lines_enabled
+#define UACPI_UART_DATA_CARRIER_DETECT (1 << 2)
+#define UACPI_UART_RING_INDICATOR (1 << 3)
+#define UACPI_UART_DATA_SET_READY (1 << 4)
+#define UACPI_UART_DATA_TERMINAL_READY (1 << 5)
+#define UACPI_UART_CLEAR_TO_SEND (1 << 6)
+#define UACPI_UART_REQUEST_TO_SEND (1 << 7)
+
+// flow_control
+#define UACPI_UART_FLOW_CONTROL_NONE 0b00
+#define UACPI_UART_FLOW_CONTROL_HW 0b01
+#define UACPI_UART_FLOW_CONTROL_XON_XOFF 0b10
+
+typedef struct uacpi_resource_uart_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 stop_bits;
+    uacpi_u8 data_bits;
+    uacpi_u8 endianness;
+    uacpi_u8 parity;
+    uacpi_u8 lines_enabled;
+    uacpi_u8 flow_control;
+    uacpi_u32 baud_rate;
+    uacpi_u16 rx_fifo;
+    uacpi_u16 tx_fifo;
+} uacpi_resource_uart_connection;
+
+// phy_type
+#define UACPI_CSI2_PHY_C 0b00
+#define UACPI_CSI2_PHY_D 0b01
+
+typedef struct uacpi_resource_csi2_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 phy_type;
+    uacpi_u8 local_port;
+} uacpi_resource_csi2_connection;
+
+typedef struct uacpi_resource_pin_function {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 pull_configuration;
+    uacpi_u16 function_number;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_function;
+
+// type
+#define UACPI_PIN_CONFIG_DEFAULT 0x00
+#define UACPI_PIN_CONFIG_BIAS_PULL_UP 0x01
+#define UACPI_PIN_CONFIG_BIAS_PULL_DOWN 0x02
+#define UACPI_PIN_CONFIG_BIAS_DEFAULT 0x03
+#define UACPI_PIN_CONFIG_BIAS_DISABLE 0x04
+#define UACPI_PIN_CONFIG_BIAS_HIGH_IMPEDANCE 0x05
+#define UACPI_PIN_CONFIG_BIAS_BUS_HOLD 0x06
+#define UACPI_PIN_CONFIG_DRIVE_OPEN_DRAIN 0x07
+#define UACPI_PIN_CONFIG_DRIVE_OPEN_SOURCE 0x08
+#define UACPI_PIN_CONFIG_DRIVE_PUSH_PULL 0x09
+#define UACPI_PIN_CONFIG_DRIVE_STRENGTH 0x0A
+#define UACPI_PIN_CONFIG_SLEW_RATE 0x0B
+#define UACPI_PIN_CONFIG_INPUT_DEBOUNCE 0x0C
+#define UACPI_PIN_CONFIG_INPUT_SCHMITT_TRIGGER 0x0D
+
+typedef struct uacpi_resource_pin_configuration {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u8 type;
+    uacpi_u32 value;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_configuration;
+
+typedef struct uacpi_resource_label {
+    uacpi_u16 length;
+    const uacpi_char *string;
+} uacpi_resource_label;
+
+typedef struct uacpi_resource_pin_group {
+    uacpi_u8 revision_id;
+    uacpi_u8 direction;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_label label;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group;
+
+typedef struct uacpi_resource_pin_group_function {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u16 function;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_resource_label label;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group_function;
+
+typedef struct uacpi_resource_pin_group_configuration {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u8 type;
+    uacpi_u32 value;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_resource_label label;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group_configuration;
+
+// scale
+#define UACPI_SCALE_HZ 0b00
+#define UACPI_SCALE_KHZ 0b01
+#define UACPI_SCALE_MHZ 0b10
+
+// frequency
+#define UACPI_FREQUENCY_FIXED 0x0
+#define UACPI_FREQUENCY_VARIABLE 0x1
+
+typedef struct uacpi_resource_clock_input {
+    uacpi_u8 revision_id;
+    uacpi_u8 frequency;
+    uacpi_u8 scale;
+    uacpi_u16 divisor;
+    uacpi_u32 numerator;
+    uacpi_resource_source source;
+} uacpi_resource_clock_input;
+
+typedef struct uacpi_resource {
+    uacpi_u32 type;
+    uacpi_u32 length;
+
+    union {
+        uacpi_resource_irq irq;
+        uacpi_resource_extended_irq extended_irq;
+        uacpi_resource_dma dma;
+        uacpi_resource_fixed_dma fixed_dma;
+        uacpi_resource_io io;
+        uacpi_resource_fixed_io fixed_io;
+        uacpi_resource_address16 address16;
+        uacpi_resource_address32 address32;
+        uacpi_resource_address64 address64;
+        uacpi_resource_address64_extended address64_extended;
+        uacpi_resource_memory24 memory24;
+        uacpi_resource_memory32 memory32;
+        uacpi_resource_fixed_memory32 fixed_memory32;
+        uacpi_resource_start_dependent start_dependent;
+        uacpi_resource_vendor vendor;
+        uacpi_resource_vendor_typed vendor_typed;
+        uacpi_resource_generic_register generic_register;
+        uacpi_resource_gpio_connection gpio_connection;
+        uacpi_resource_serial_bus_common serial_bus_common;
+        uacpi_resource_i2c_connection i2c_connection;
+        uacpi_resource_spi_connection spi_connection;
+        uacpi_resource_uart_connection uart_connection;
+        uacpi_resource_csi2_connection csi2_connection;
+        uacpi_resource_pin_function pin_function;
+        uacpi_resource_pin_configuration pin_configuration;
+        uacpi_resource_pin_group pin_group;
+        uacpi_resource_pin_group_function pin_group_function;
+        uacpi_resource_pin_group_configuration pin_group_configuration;
+        uacpi_resource_clock_input clock_input;
+    };
+} uacpi_resource;
+
+#define UACPI_NEXT_RESOURCE(cur) \
+    ((uacpi_resource*)((uacpi_u8*)(cur) + (cur)->length))
+
+typedef struct uacpi_resources {
+    /*
+     * Length of the 'entries' array in BYTES (NOT the count of resources),
+     * see comment above 'entries' for more information.
+     */
+    uacpi_size length;
+
+    /*
+     * Resources are variable length! See UACPI_NEXT_RESOURCE to see how to
+     * retrieve the next resource. You can alternatively use
+     * uacpi_for_each_resource instead of iterating manually.
+     *
+     * Resources are guaranteed to be naturally aligned and are always
+     * terminated by a resource of type UACPI_RESOURCE_TYPE_END_TAG.
+     */
+    uacpi_resource *entries;
+} uacpi_resources;
+void uacpi_free_resources(uacpi_resources*);
+
+typedef uacpi_iteration_decision (*uacpi_resource_iteration_callback)
+    (void *user, uacpi_resource *resource);
+
+/*
+ * Evaluate the _CRS method for a 'device' and get the returned resource list
+ * via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resources()
+ *
+ * If you don't need to keep the resource array for later use you can
+ * uacpi_for_each_device_resource(device, "_CRS", ...) instead, which takes
+ * care of iteration & memory management on its own.
+ */
+uacpi_status uacpi_get_current_resources(
+    uacpi_namespace_node *device, uacpi_resources **out_resources
+);
+
+/*
+ * Evaluate the _PRS method for a 'device' and get the returned resource list
+ * via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resources()
+ *
+ * If you don't need to keep the resource array for later use you can
+ * uacpi_for_each_device_resource(device, "_PRS", ...) instead, which takes
+ * care of iteration & memory management on its own.
+ */
+uacpi_status uacpi_get_possible_resources(
+    uacpi_namespace_node *device, uacpi_resources **out_resources
+);
+
+/*
+ * Evaluate an arbitrary method that is expected to return an AML resource
+ * buffer for a 'device' and get the returned resource list via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resources()
+ *
+ * If you don't need to keep the resource array for later use you can
+ * uacpi_for_each_device_resource(device, method, ...) instead, which takes
+ * care of iteration & memory management on its own.
+ */
+uacpi_status uacpi_get_device_resources(
+    uacpi_namespace_node *device, const uacpi_char *method,
+    uacpi_resources **out_resources
+);
+
+/*
+ * Set the configuration to be used by the 'device' by calling its _SRS method.
+ *
+ * Note that this expects 'resources' in the normal 'uacpi_resources' format,
+ * and not the raw AML resources bytestream, the conversion to the latter is
+ * done automatically by this API. If you want to _SRS a raw AML resources
+ * bytestream, use 'uacpi_execute' or similar API directly.
+ */
+uacpi_status uacpi_set_resources(
+    uacpi_namespace_node *device, uacpi_resources *resources
+);
+
+/*
+ * A convenience helper for iterating over the resource list returned by any
+ * of the uacpi_get_*_resources functions.
+ */
+uacpi_status uacpi_for_each_resource(
+    uacpi_resources *resources, uacpi_resource_iteration_callback cb, void *user
+);
+
+/*
+ * A shorthand for uacpi_get_device_resources() + uacpi_for_each_resource().
+ *
+ * Use if you don't actually want to save the 'resources' list, but simply want
+ * to iterate it once to extract the resources you care about and then free it
+ * right away.
+ */
+uacpi_status uacpi_for_each_device_resource(
+    uacpi_namespace_node *device, const uacpi_char *method,
+    uacpi_resource_iteration_callback cb, void *user
+);
+
+/*
+ * Convert a single AML-encoded resource to native format.
+ *
+ * This should be used for converting Connection() fields (passed during IO on
+ * GeneralPurposeIO or GenericSerialBus operation regions) or other similar
+ * buffers with only one resource to native format.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resource()
+ */
+uacpi_status uacpi_get_resource_from_buffer(
+    uacpi_data_view aml_buffer, uacpi_resource **out_resource
+);
+void uacpi_free_resource(uacpi_resource*);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/sleep.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/uacpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Set the firmware waking vector in FACS.
+ *
+ * 'addr32' is the real mode entry-point address
+ * 'addr64' is the protected mode entry-point address
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_set_waking_vector(
+    uacpi_phys_addr addr32, uacpi_phys_addr addr64
+))
+
+typedef enum uacpi_sleep_state {
+    UACPI_SLEEP_STATE_S0 = 0,
+    UACPI_SLEEP_STATE_S1,
+    UACPI_SLEEP_STATE_S2,
+    UACPI_SLEEP_STATE_S3,
+    UACPI_SLEEP_STATE_S4,
+    UACPI_SLEEP_STATE_S5,
+    UACPI_SLEEP_STATE_MAX = UACPI_SLEEP_STATE_S5,
+} uacpi_sleep_state;
+
+/*
+ * Prepare for a given sleep state.
+ * Must be caled with interrupts ENABLED.
+ */
+uacpi_status uacpi_prepare_for_sleep_state(uacpi_sleep_state);
+
+/*
+ * Enter the given sleep state after preparation.
+ * Must be called with interrupts DISABLED.
+ */
+uacpi_status uacpi_enter_sleep_state(uacpi_sleep_state);
+
+/*
+ * Prepare to leave the given sleep state.
+ * Must be called with interrupts DISABLED.
+ */
+uacpi_status uacpi_prepare_for_wake_from_sleep_state(uacpi_sleep_state);
+
+/*
+ * Wake from the given sleep state.
+ * Must be called with interrupts ENABLED.
+ */
+uacpi_status uacpi_wake_from_sleep_state(uacpi_sleep_state);
+
+/*
+ * Attempt reset via the FADT reset register.
+ */
+uacpi_status uacpi_reboot(void);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/status.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <uacpi/internal/compiler.h>
+#include <uacpi/platform/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum uacpi_status {
+    UACPI_STATUS_OK = 0,
+    UACPI_STATUS_MAPPING_FAILED = 1,
+    UACPI_STATUS_OUT_OF_MEMORY = 2,
+    UACPI_STATUS_BAD_CHECKSUM = 3,
+    UACPI_STATUS_INVALID_SIGNATURE = 4,
+    UACPI_STATUS_INVALID_TABLE_LENGTH = 5,
+    UACPI_STATUS_NOT_FOUND = 6,
+    UACPI_STATUS_INVALID_ARGUMENT = 7,
+    UACPI_STATUS_UNIMPLEMENTED = 8,
+    UACPI_STATUS_ALREADY_EXISTS = 9,
+    UACPI_STATUS_INTERNAL_ERROR = 10,
+    UACPI_STATUS_TYPE_MISMATCH = 11,
+    UACPI_STATUS_INIT_LEVEL_MISMATCH = 12,
+    UACPI_STATUS_NAMESPACE_NODE_DANGLING = 13,
+    UACPI_STATUS_NO_HANDLER = 14,
+    UACPI_STATUS_NO_RESOURCE_END_TAG = 15,
+    UACPI_STATUS_COMPILED_OUT = 16,
+    UACPI_STATUS_HARDWARE_TIMEOUT = 17,
+    UACPI_STATUS_TIMEOUT = 18,
+    UACPI_STATUS_OVERRIDDEN = 19,
+    UACPI_STATUS_DENIED = 20,
+
+    // All errors that have bytecode-related origin should go here
+    UACPI_STATUS_AML_UNDEFINED_REFERENCE = 0x0EFF0000,
+    UACPI_STATUS_AML_INVALID_NAMESTRING = 0x0EFF0001,
+    UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS = 0x0EFF0002,
+    UACPI_STATUS_AML_INVALID_OPCODE = 0x0EFF0003,
+    UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE = 0x0EFF0004,
+    UACPI_STATUS_AML_BAD_ENCODING = 0x0EFF0005,
+    UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX = 0x0EFF0006,
+    UACPI_STATUS_AML_SYNC_LEVEL_TOO_HIGH = 0x0EFF0007,
+    UACPI_STATUS_AML_INVALID_RESOURCE = 0x0EFF0008,
+    UACPI_STATUS_AML_LOOP_TIMEOUT = 0x0EFF0009,
+    UACPI_STATUS_AML_CALL_STACK_DEPTH_LIMIT = 0x0EFF000A,
+} uacpi_status;
+
+const uacpi_char *uacpi_status_to_string(uacpi_status);
+
+#define uacpi_unlikely_error(expr) uacpi_unlikely((expr) != UACPI_STATUS_OK)
+#define uacpi_likely_error(expr)   uacpi_likely((expr) != UACPI_STATUS_OK)
+
+#define uacpi_unlikely_success(expr) uacpi_unlikely((expr) == UACPI_STATUS_OK)
+#define uacpi_likely_success(expr)   uacpi_likely((expr) == UACPI_STATUS_OK)
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/tables.h

@@ -0,0 +1,167 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward-declared to avoid including the entire acpi.h here
+struct acpi_fadt;
+struct acpi_entry_hdr;
+struct acpi_sdt_hdr;
+
+typedef struct uacpi_table_identifiers {
+    uacpi_object_name signature;
+
+    // if oemid[0] == 0 this field is ignored
+    char oemid[6];
+
+    // if oem_table_id[0] == 0 this field is ignored
+    char oem_table_id[8];
+} uacpi_table_identifiers;
+
+typedef struct uacpi_table {
+    union {
+        uacpi_virt_addr virt_addr;
+        void *ptr;
+        struct acpi_sdt_hdr *hdr;
+    };
+
+     // Index number used to identify this table internally
+    uacpi_size index;
+} uacpi_table;
+
+/*
+ * Install a table from either a virtual or a physical address.
+ * The table is simply stored in the internal table array, and not loaded by
+ * the interpreter (see uacpi_table_load).
+ *
+ * The table is optionally returned via 'out_table'.
+ *
+ * Manual calls to uacpi_table_install are not subject to filtering via the
+ * table installation callback (if any).
+ */
+uacpi_status uacpi_table_install(
+    void*, uacpi_table *out_table
+);
+uacpi_status uacpi_table_install_physical(
+    uacpi_phys_addr, uacpi_table *out_table
+);
+
+#ifndef UACPI_BAREBONES_MODE
+/*
+ * Load a previously installed table by feeding it to the interpreter.
+ */
+uacpi_status uacpi_table_load(uacpi_size index);
+#endif // !UACPI_BAREBONES_MODE
+
+/*
+ * Helpers for finding tables.
+ *
+ * for find_by_signature:
+ *     'signature' is an array of 4 characters, a null terminator is not
+ *     necessary and can be omitted (especially useful for non-C language
+ *     bindings)
+ *
+ * 'out_table' is a pointer to a caller allocated uacpi_table structure that
+ * receives the table pointer & its internal index in case the call was
+ * successful.
+ *
+ * NOTE:
+ * The returned table's reference count is incremented by 1, which keeps its
+ * mapping alive forever unless uacpi_table_unref() is called for this table
+ * later on. Calling uacpi_table_find_next_with_same_signature() on a table also
+ * drops its reference count by 1, so if you want to keep it mapped you must
+ * manually call uacpi_table_ref() beforehand.
+ */
+uacpi_status uacpi_table_find_by_signature(
+    const uacpi_char *signature, uacpi_table *out_table
+);
+uacpi_status uacpi_table_find_next_with_same_signature(
+    uacpi_table *in_out_table
+);
+uacpi_status uacpi_table_find(
+    const uacpi_table_identifiers *id, uacpi_table *out_table
+);
+
+/*
+ * Increment/decrement a table's reference count.
+ * The table is unmapped when the reference count drops to 0.
+ */
+uacpi_status uacpi_table_ref(uacpi_table*);
+uacpi_status uacpi_table_unref(uacpi_table*);
+
+/*
+ * Returns the pointer to a sanitized internal version of FADT.
+ *
+ * The revision is guaranteed to be correct. All of the registers are converted
+ * to GAS format. Fields that might contain garbage are cleared.
+ */
+uacpi_status uacpi_table_fadt(struct acpi_fadt**);
+
+typedef enum uacpi_table_installation_disposition {
+    // Allow the table to be installed as-is
+    UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW = 0,
+
+    /*
+     * Deny the table from being installed completely. This is useful for
+     * debugging various problems, e.g. AML loading bad SSDTs that cause the
+     * system to hang or enter an undesired state.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_DENY,
+
+    /*
+     * Override the table being installed with the table at the virtual address
+     * returned in 'out_override_address'.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_VIRTUAL_OVERRIDE,
+
+    /*
+     * Override the table being installed with the table at the physical address
+     * returned in 'out_override_address'.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_PHYSICAL_OVERRIDE,
+} uacpi_table_installation_disposition;
+
+typedef uacpi_table_installation_disposition (*uacpi_table_installation_handler)
+    (struct acpi_sdt_hdr *hdr, uacpi_u64 *out_override_address);
+
+/*
+ * Set a handler that is invoked for each table before it gets installed.
+ *
+ * Depending on the return value, the table is either allowed to be installed
+ * as-is, denied, or overriden with a new one.
+ */
+uacpi_status uacpi_set_table_installation_handler(
+    uacpi_table_installation_handler handler
+);
+
+typedef uacpi_iteration_decision (*uacpi_subtable_iteration_callback)
+    (uacpi_handle, struct acpi_entry_hdr*);
+
+/*
+ * Iterate every subtable of a table such as MADT or SRAT.
+ *
+ * 'hdr' is the pointer to the main table, 'hdr_size' is the number of bytes in
+ * the table before the beginning of the subtable records. 'cb' is the callback
+ * invoked for each subtable with the 'user' context pointer passed for every
+ * invocation.
+ *
+ * Example usage:
+ *    uacpi_table tbl;
+ *
+ *    uacpi_table_find_by_signature(ACPI_MADT_SIGNATURE, &tbl);
+ *    uacpi_for_each_subtable(
+ *        tbl.hdr, sizeof(struct acpi_madt), parse_madt, NULL
+ *    );
+ */
+uacpi_status uacpi_for_each_subtable(
+    struct acpi_sdt_hdr *hdr, size_t hdr_size,
+    uacpi_subtable_iteration_callback cb, void *user
+);
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/types.h

@@ -0,0 +1,550 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/platform/types.h>
+#include <uacpi/platform/compiler.h>
+#include <uacpi/platform/arch_helpers.h>
+#include <uacpi/platform/config.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if UACPI_POINTER_SIZE == 4 && defined(UACPI_PHYS_ADDR_IS_32BITS)
+typedef uacpi_u32 uacpi_phys_addr;
+typedef uacpi_u32 uacpi_io_addr;
+#else
+typedef uacpi_u64 uacpi_phys_addr;
+typedef uacpi_u64 uacpi_io_addr;
+#endif
+
+typedef void *uacpi_handle;
+
+typedef union uacpi_object_name {
+    uacpi_char text[4];
+    uacpi_u32 id;
+} uacpi_object_name;
+
+typedef enum uacpi_iteration_decision {
+    UACPI_ITERATION_DECISION_CONTINUE = 0,
+    UACPI_ITERATION_DECISION_BREAK,
+
+    /*
+     * Ignore all of the children of the current node and proceed directly to
+     * its peer nodes.
+     *
+     * Only applicable for API that interacts with the AML namespace such as
+     * uacpi_namespace_for_each_child, uacpi_find_deivces, etc.
+     */
+    UACPI_ITERATION_DECISION_NEXT_PEER,
+} uacpi_iteration_decision;
+
+typedef enum uacpi_address_space {
+    UACPI_ADDRESS_SPACE_SYSTEM_MEMORY = 0,
+    UACPI_ADDRESS_SPACE_SYSTEM_IO = 1,
+    UACPI_ADDRESS_SPACE_PCI_CONFIG = 2,
+    UACPI_ADDRESS_SPACE_EMBEDDED_CONTROLLER = 3,
+    UACPI_ADDRESS_SPACE_SMBUS = 4,
+    UACPI_ADDRESS_SPACE_SYSTEM_CMOS = 5,
+    UACPI_ADDRESS_SPACE_PCI_BAR_TARGET = 6,
+    UACPI_ADDRESS_SPACE_IPMI = 7,
+    UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO = 8,
+    UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS = 9,
+    UACPI_ADDRESS_SPACE_PCC = 0x0A,
+    UACPI_ADDRESS_SPACE_PRM = 0x0B,
+    UACPI_ADDRESS_SPACE_FFIXEDHW = 0x7F,
+
+    // Internal type
+    UACPI_ADDRESS_SPACE_TABLE_DATA = 0xDA1A,
+} uacpi_address_space;
+const uacpi_char *uacpi_address_space_to_string(uacpi_address_space space);
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_init_level {
+    // Reboot state, nothing is available
+    UACPI_INIT_LEVEL_EARLY = 0,
+
+    /*
+     * State after a successfull call to uacpi_initialize. Table API and
+     * other helpers that don't depend on the ACPI namespace may be used.
+     */
+    UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED = 1,
+
+    /*
+     * State after a successfull call to uacpi_namespace_load. Most API may be
+     * used, namespace can be iterated, etc.
+     */
+    UACPI_INIT_LEVEL_NAMESPACE_LOADED = 2,
+
+    /*
+     * The final initialization stage, this is entered after the call to
+     * uacpi_namespace_initialize. All API is available to use.
+     */
+    UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED = 3,
+} uacpi_init_level;
+
+typedef struct uacpi_pci_address {
+    uacpi_u16 segment;
+    uacpi_u8 bus;
+    uacpi_u8 device;
+    uacpi_u8 function;
+} uacpi_pci_address;
+
+typedef struct uacpi_data_view {
+    union {
+        uacpi_u8 *bytes;
+        const uacpi_u8 *const_bytes;
+
+        uacpi_char *text;
+        const uacpi_char *const_text;
+
+        void *data;
+        const void *const_data;
+    };
+    uacpi_size length;
+} uacpi_data_view;
+
+typedef struct uacpi_namespace_node uacpi_namespace_node;
+
+typedef enum uacpi_object_type {
+    UACPI_OBJECT_UNINITIALIZED = 0,
+    UACPI_OBJECT_INTEGER = 1,
+    UACPI_OBJECT_STRING = 2,
+    UACPI_OBJECT_BUFFER = 3,
+    UACPI_OBJECT_PACKAGE = 4,
+    UACPI_OBJECT_FIELD_UNIT = 5,
+    UACPI_OBJECT_DEVICE = 6,
+    UACPI_OBJECT_EVENT = 7,
+    UACPI_OBJECT_METHOD = 8,
+    UACPI_OBJECT_MUTEX = 9,
+    UACPI_OBJECT_OPERATION_REGION = 10,
+    UACPI_OBJECT_POWER_RESOURCE = 11,
+    UACPI_OBJECT_PROCESSOR = 12,
+    UACPI_OBJECT_THERMAL_ZONE = 13,
+    UACPI_OBJECT_BUFFER_FIELD = 14,
+    UACPI_OBJECT_DEBUG = 16,
+
+    UACPI_OBJECT_REFERENCE = 20,
+    UACPI_OBJECT_BUFFER_INDEX = 21,
+    UACPI_OBJECT_MAX_TYPE_VALUE = UACPI_OBJECT_BUFFER_INDEX
+} uacpi_object_type;
+
+// Type bits for API requiring a bit mask, e.g. uacpi_eval_typed
+typedef enum uacpi_object_type_bits {
+    UACPI_OBJECT_INTEGER_BIT = (1 << UACPI_OBJECT_INTEGER),
+    UACPI_OBJECT_STRING_BIT = (1 << UACPI_OBJECT_STRING),
+    UACPI_OBJECT_BUFFER_BIT = (1 << UACPI_OBJECT_BUFFER),
+    UACPI_OBJECT_PACKAGE_BIT = (1 << UACPI_OBJECT_PACKAGE),
+    UACPI_OBJECT_FIELD_UNIT_BIT = (1 << UACPI_OBJECT_FIELD_UNIT),
+    UACPI_OBJECT_DEVICE_BIT = (1 << UACPI_OBJECT_DEVICE),
+    UACPI_OBJECT_EVENT_BIT = (1 << UACPI_OBJECT_EVENT),
+    UACPI_OBJECT_METHOD_BIT = (1 << UACPI_OBJECT_METHOD),
+    UACPI_OBJECT_MUTEX_BIT = (1 << UACPI_OBJECT_MUTEX),
+    UACPI_OBJECT_OPERATION_REGION_BIT = (1 << UACPI_OBJECT_OPERATION_REGION),
+    UACPI_OBJECT_POWER_RESOURCE_BIT = (1 << UACPI_OBJECT_POWER_RESOURCE),
+    UACPI_OBJECT_PROCESSOR_BIT = (1 << UACPI_OBJECT_PROCESSOR),
+    UACPI_OBJECT_THERMAL_ZONE_BIT = (1 << UACPI_OBJECT_THERMAL_ZONE),
+    UACPI_OBJECT_BUFFER_FIELD_BIT = (1 << UACPI_OBJECT_BUFFER_FIELD),
+    UACPI_OBJECT_DEBUG_BIT = (1 << UACPI_OBJECT_DEBUG),
+    UACPI_OBJECT_REFERENCE_BIT = (1 << UACPI_OBJECT_REFERENCE),
+    UACPI_OBJECT_BUFFER_INDEX_BIT = (1 << UACPI_OBJECT_BUFFER_INDEX),
+    UACPI_OBJECT_ANY_BIT = 0xFFFFFFFF,
+} uacpi_object_type_bits;
+
+typedef struct uacpi_object uacpi_object;
+
+void uacpi_object_ref(uacpi_object *obj);
+void uacpi_object_unref(uacpi_object *obj);
+
+uacpi_object_type uacpi_object_get_type(uacpi_object*);
+uacpi_object_type_bits uacpi_object_get_type_bit(uacpi_object*);
+
+/*
+ * Returns UACPI_TRUE if the provided object's type matches this type.
+ */
+uacpi_bool uacpi_object_is(uacpi_object*, uacpi_object_type);
+
+/*
+ * Returns UACPI_TRUE if the provided object's type is one of the values
+ * specified in the 'type_mask' of UACPI_OBJECT_*_BIT.
+ */
+uacpi_bool uacpi_object_is_one_of(
+    uacpi_object*, uacpi_object_type_bits type_mask
+);
+
+const uacpi_char *uacpi_object_type_to_string(uacpi_object_type);
+
+/*
+ * Create an uninitialized object. The object can be further overwritten via
+ * uacpi_object_assign_* to anything.
+ */
+uacpi_object *uacpi_object_create_uninitialized(void);
+
+/*
+ * Create an integer object with the value provided.
+ */
+uacpi_object *uacpi_object_create_integer(uacpi_u64);
+
+typedef enum uacpi_overflow_behavior {
+    UACPI_OVERFLOW_ALLOW = 0,
+    UACPI_OVERFLOW_TRUNCATE,
+    UACPI_OVERFLOW_DISALLOW,
+} uacpi_overflow_behavior;
+
+/*
+ * Same as uacpi_object_create_integer, but introduces additional ways to
+ * control what happens if the provided integer is larger than 32-bits, and the
+ * AML code expects 32-bit integers.
+ *
+ * - UACPI_OVERFLOW_ALLOW -> do nothing, same as the vanilla helper
+ * - UACPI_OVERFLOW_TRUNCATE -> truncate the integer to 32-bits if it happens to
+ *                              be larger than allowed by the DSDT
+ * - UACPI_OVERFLOW_DISALLOW -> fail object creation with
+ *                              UACPI_STATUS_INVALID_ARGUMENT if the provided
+ *                              value happens to be too large
+ */
+uacpi_status uacpi_object_create_integer_safe(
+    uacpi_u64, uacpi_overflow_behavior, uacpi_object **out_obj
+);
+
+uacpi_status uacpi_object_assign_integer(uacpi_object*, uacpi_u64 value);
+uacpi_status uacpi_object_get_integer(uacpi_object*, uacpi_u64 *out);
+
+/*
+ * Create a string/buffer object. Takes in a constant view of the data.
+ *
+ * NOTE: The data is copied to a separately allocated buffer and is not taken
+ *       ownership of.
+ */
+uacpi_object *uacpi_object_create_string(uacpi_data_view);
+uacpi_object *uacpi_object_create_cstring(const uacpi_char*);
+uacpi_object *uacpi_object_create_buffer(uacpi_data_view);
+
+/*
+ * Returns a writable view of the data stored in the string or buffer type
+ * object.
+ */
+uacpi_status uacpi_object_get_string_or_buffer(
+    uacpi_object*, uacpi_data_view *out
+);
+uacpi_status uacpi_object_get_string(uacpi_object*, uacpi_data_view *out);
+uacpi_status uacpi_object_get_buffer(uacpi_object*, uacpi_data_view *out);
+
+/*
+ * Returns UACPI_TRUE if the provided string object is actually an AML namepath.
+ *
+ * This can only be the case for package elements. If a package element is
+ * specified as a path to an object in AML, it's not resolved by the interpreter
+ * right away as it might not have been defined at that point yet, and is
+ * instead stored as a special string object to be resolved by client code
+ * when needed.
+ *
+ * Example usage:
+ *     uacpi_namespace_node *target_node = UACPI_NULL;
+ *
+ *     uacpi_object *obj = UACPI_NULL;
+ *     uacpi_eval(scope, path, UACPI_NULL, &obj);
+ *
+ *     uacpi_object_array arr;
+ *     uacpi_object_get_package(obj, &arr);
+ *
+ *     if (uacpi_object_is_aml_namepath(arr.objects[0])) {
+ *         uacpi_object_resolve_as_aml_namepath(
+ *             arr.objects[0], scope, &target_node
+ *         );
+ *     }
+ */
+uacpi_bool uacpi_object_is_aml_namepath(uacpi_object*);
+
+/*
+ * Resolve an AML namepath contained in a string object.
+ *
+ * This is only applicable to objects that are package elements. See an
+ * explanation of how this works in the comment above the declaration of
+ * uacpi_object_is_aml_namepath.
+ *
+ * This is a shorthand for:
+ *     uacpi_data_view view;
+ *     uacpi_object_get_string(object, &view);
+ *
+ *     target_node = uacpi_namespace_node_resolve_from_aml_namepath(
+ *         scope, view.text
+ *     );
+ */
+uacpi_status uacpi_object_resolve_as_aml_namepath(
+    uacpi_object*, uacpi_namespace_node *scope, uacpi_namespace_node **out_node
+);
+
+/*
+ * Make the provided object a string/buffer.
+ * Takes in a constant view of the data to be stored in the object.
+ *
+ * NOTE: The data is copied to a separately allocated buffer and is not taken
+ *       ownership of.
+ */
+uacpi_status uacpi_object_assign_string(uacpi_object*, uacpi_data_view in);
+uacpi_status uacpi_object_assign_buffer(uacpi_object*, uacpi_data_view in);
+
+typedef struct uacpi_object_array {
+    uacpi_object **objects;
+    uacpi_size count;
+} uacpi_object_array;
+
+/*
+ * Create a package object and store all of the objects in the array inside.
+ * The array is allowed to be empty.
+ *
+ * NOTE: the reference count of each object is incremented before being stored
+ *       in the object. Client code must remove all of the locally created
+ *       references at its own discretion.
+ */
+uacpi_object *uacpi_object_create_package(uacpi_object_array in);
+
+/*
+ * Returns the list of objects stored in a package object.
+ *
+ * NOTE: the reference count of the objects stored inside is not incremented,
+ *       which means destorying/overwriting the object also potentially destroys
+ *       all of the objects stored inside unless the reference count is
+ *       incremented by the client via uacpi_object_ref.
+ */
+uacpi_status uacpi_object_get_package(uacpi_object*, uacpi_object_array *out);
+
+/*
+ * Make the provided object a package and store all of the objects in the array
+ * inside. The array is allowed to be empty.
+ *
+ * NOTE: the reference count of each object is incremented before being stored
+ *       in the object. Client code must remove all of the locally created
+ *       references at its own discretion.
+ */
+uacpi_status uacpi_object_assign_package(uacpi_object*, uacpi_object_array in);
+
+/*
+ * Create a reference object and make it point to 'child'.
+ *
+ * NOTE: child's reference count is incremented by one. Client code must remove
+ *       all of the locally created references at its own discretion.
+ */
+uacpi_object *uacpi_object_create_reference(uacpi_object *child);
+
+/*
+ * Make the provided object a reference and make it point to 'child'.
+ *
+ * NOTE: child's reference count is incremented by one. Client code must remove
+ *       all of the locally created references at its own discretion.
+ */
+uacpi_status uacpi_object_assign_reference(uacpi_object*, uacpi_object *child);
+
+/*
+ * Retrieve the object pointed to by a reference object.
+ *
+ * NOTE: the reference count of the returned object is incremented by one and
+ *       must be uacpi_object_unref'ed by the client when no longer needed.
+ */
+uacpi_status uacpi_object_get_dereferenced(uacpi_object*, uacpi_object **out);
+
+typedef struct uacpi_processor_info {
+    uacpi_u8 id;
+    uacpi_u32 block_address;
+    uacpi_u8 block_length;
+} uacpi_processor_info;
+
+/*
+ * Returns the information about the provided processor object.
+ */
+uacpi_status uacpi_object_get_processor_info(
+    uacpi_object*, uacpi_processor_info *out
+);
+
+typedef struct uacpi_power_resource_info {
+    uacpi_u8 system_level;
+    uacpi_u16 resource_order;
+} uacpi_power_resource_info;
+
+/*
+ * Returns the information about the provided power resource object.
+ */
+uacpi_status uacpi_object_get_power_resource_info(
+    uacpi_object*, uacpi_power_resource_info *out
+);
+
+typedef enum uacpi_region_op {
+    // data => uacpi_region_attach_data
+    UACPI_REGION_OP_ATTACH = 0,
+    // data => uacpi_region_detach_data
+    UACPI_REGION_OP_DETACH,
+
+    // data => uacpi_region_rw_data
+    UACPI_REGION_OP_READ,
+    UACPI_REGION_OP_WRITE,
+
+    // data => uacpi_region_pcc_send_data
+    UACPI_REGION_OP_PCC_SEND,
+
+    // data => uacpi_region_gpio_rw_data
+    UACPI_REGION_OP_GPIO_READ,
+    UACPI_REGION_OP_GPIO_WRITE,
+
+    // data => uacpi_region_ipmi_rw_data
+    UACPI_REGION_OP_IPMI_COMMAND,
+
+    // data => uacpi_region_ffixedhw_rw_data
+    UACPI_REGION_OP_FFIXEDHW_COMMAND,
+
+    // data => uacpi_region_prm_rw_data
+    UACPI_REGION_OP_PRM_COMMAND,
+
+    // data => uacpi_region_serial_rw_data
+    UACPI_REGION_OP_SERIAL_READ,
+    UACPI_REGION_OP_SERIAL_WRITE,
+} uacpi_region_op;
+
+typedef struct uacpi_generic_region_info {
+    uacpi_u64 base;
+    uacpi_u64 length;
+} uacpi_generic_region_info;
+
+typedef struct uacpi_pcc_region_info {
+    uacpi_data_view buffer;
+    uacpi_u8 subspace_id;
+} uacpi_pcc_region_info;
+
+typedef struct uacpi_gpio_region_info
+{
+    uacpi_u64 num_pins;
+} uacpi_gpio_region_info;
+
+typedef struct uacpi_region_attach_data {
+    void *handler_context;
+    uacpi_namespace_node *region_node;
+    union {
+        uacpi_generic_region_info generic_info;
+        uacpi_pcc_region_info pcc_info;
+        uacpi_gpio_region_info gpio_info;
+    };
+    void *out_region_context;
+} uacpi_region_attach_data;
+
+typedef struct uacpi_region_rw_data {
+    void *handler_context;
+    void *region_context;
+    union {
+        uacpi_phys_addr address;
+        uacpi_u64 offset;
+    };
+    uacpi_u64 value;
+    uacpi_u8 byte_width;
+} uacpi_region_rw_data;
+
+typedef struct uacpi_region_pcc_send_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view buffer;
+} uacpi_region_pcc_send_data;
+
+typedef struct uacpi_region_gpio_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view connection;
+    uacpi_u32 pin_offset;
+    uacpi_u32 num_pins;
+    uacpi_u64 value;
+} uacpi_region_gpio_rw_data;
+
+typedef struct uacpi_region_ipmi_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view in_out_message;
+    uacpi_u64 command;
+} uacpi_region_ipmi_rw_data;
+
+typedef uacpi_region_ipmi_rw_data uacpi_region_ffixedhw_rw_data;
+
+typedef struct uacpi_region_prm_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view in_out_message;
+} uacpi_region_prm_rw_data;
+
+typedef enum uacpi_access_attribute {
+    UACPI_ACCESS_ATTRIBUTE_QUICK = 0x02,
+    UACPI_ACCESS_ATTRIBUTE_SEND_RECEIVE = 0x04,
+    UACPI_ACCESS_ATTRIBUTE_BYTE = 0x06,
+    UACPI_ACCESS_ATTRIBUTE_WORD = 0x08,
+    UACPI_ACCESS_ATTRIBUTE_BLOCK = 0x0A,
+    UACPI_ACCESS_ATTRIBUTE_BYTES = 0x0B,
+    UACPI_ACCESS_ATTRIBUTE_PROCESS_CALL = 0x0C,
+    UACPI_ACCESS_ATTRIBUTE_BLOCK_PROCESS_CALL = 0x0D,
+    UACPI_ACCESS_ATTRIBUTE_RAW_BYTES = 0x0E,
+    UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES = 0x0F,
+} uacpi_access_attribute;
+
+typedef struct uacpi_region_serial_rw_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_u64 command;
+    uacpi_data_view connection;
+    uacpi_data_view in_out_buffer;
+    uacpi_access_attribute access_attribute;
+
+    /*
+     * Applicable if access_attribute is one of:
+     * - UACPI_ACCESS_ATTRIBUTE_BYTES
+     * - UACPI_ACCESS_ATTRIBUTE_RAW_BYTES
+     * - UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES
+     */
+    uacpi_u8 access_length;
+} uacpi_region_serial_rw_data;
+
+typedef struct uacpi_region_detach_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_namespace_node *region_node;
+} uacpi_region_detach_data;
+
+typedef uacpi_status (*uacpi_region_handler)
+    (uacpi_region_op op, uacpi_handle op_data);
+
+typedef uacpi_status (*uacpi_notify_handler)
+    (uacpi_handle context, uacpi_namespace_node *node, uacpi_u64 value);
+
+typedef enum uacpi_firmware_request_type {
+    UACPI_FIRMWARE_REQUEST_TYPE_BREAKPOINT,
+    UACPI_FIRMWARE_REQUEST_TYPE_FATAL,
+} uacpi_firmware_request_type;
+
+typedef struct uacpi_firmware_request {
+    uacpi_u8 type;
+
+    union {
+        // UACPI_FIRMWARE_REQUEST_BREAKPOINT
+        struct {
+            // The context of the method currently being executed
+            uacpi_handle ctx;
+        } breakpoint;
+
+        // UACPI_FIRMWARE_REQUEST_FATAL
+        struct {
+            uacpi_u8 type;
+            uacpi_u32 code;
+            uacpi_u64 arg;
+        } fatal;
+    };
+} uacpi_firmware_request;
+
+#define UACPI_INTERRUPT_NOT_HANDLED 0
+#define UACPI_INTERRUPT_HANDLED 1
+typedef uacpi_u32 uacpi_interrupt_ret;
+
+typedef uacpi_interrupt_ret (*uacpi_interrupt_handler)(uacpi_handle);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/uacpi.h

@@ -0,0 +1,269 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/namespace.h>
+
+#define UACPI_MAJOR 3
+#define UACPI_MINOR 2
+#define UACPI_PATCH 0
+
+#ifdef UACPI_REDUCED_HARDWARE
+#define UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, ret) \
+    UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN          \
+    static inline fn { return ret; }                \
+    UACPI_NO_UNUSED_PARAMETER_WARNINGS_END
+
+#define UACPI_STUB_IF_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn,)
+#define UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, UACPI_STATUS_COMPILED_OUT)
+#define UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, UACPI_STATUS_OK)
+#else
+
+#define UACPI_STUB_IF_REDUCED_HARDWARE(fn) fn;
+#define UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(fn) fn;
+#define UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(fn) fn;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Set up early access to the table subsystem. What this means is:
+ * - uacpi_table_find() and similar API becomes usable before the call to
+ *   uacpi_initialize().
+ * - No kernel API besides logging and map/unmap will be invoked at this stage,
+ *   allowing for heap and scheduling to still be fully offline.
+ * - The provided 'temporary_buffer' will be used as a temporary storage for the
+ *   internal metadata about the tables (list, reference count, addresses,
+ *   sizes, etc).
+ * - The 'temporary_buffer' is replaced with a normal heap buffer allocated via
+ *   uacpi_kernel_alloc() after the call to uacpi_initialize() and can therefore
+ *   be reclaimed by the kernel.
+ *
+ * The approximate overhead per table is 56 bytes, so a buffer of 4096 bytes
+ * yields about 73 tables in terms of capacity. uACPI also has an internal
+ * static buffer for tables, "UACPI_STATIC_TABLE_ARRAY_LEN", which is configured
+ * as 16 descriptors in length by default.
+ *
+ * This function is used to initialize the barebones mode, see
+ * UACPI_BAREBONES_MODE in config.h for more information.
+ */
+uacpi_status uacpi_setup_early_table_access(
+    void *temporary_buffer, uacpi_size buffer_size
+);
+
+/*
+ * Bad table checksum should be considered a fatal error
+ * (table load is fully aborted in this case)
+ */
+#define UACPI_FLAG_BAD_CSUM_FATAL (1ull << 0)
+
+/*
+ * Unexpected table signature should be considered a fatal error
+ * (table load is fully aborted in this case)
+ */
+#define UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL (1ull << 1)
+
+/*
+ * Force uACPI to use RSDT even for later revisions
+ */
+#define UACPI_FLAG_BAD_XSDT (1ull << 2)
+
+/*
+ * If this is set, ACPI mode is not entered during the call to
+ * uacpi_initialize. The caller is expected to enter it later at their own
+ * discretion by using uacpi_enter_acpi_mode().
+ */
+#define UACPI_FLAG_NO_ACPI_MODE (1ull << 3)
+
+/*
+ * Don't create the \_OSI method when building the namespace.
+ * Only enable this if you're certain that having this method breaks your AML
+ * blob, a more atomic/granular interface management is available via osi.h
+ */
+#define UACPI_FLAG_NO_OSI (1ull << 4)
+
+/*
+ * Validate table checksums at installation time instead of first use.
+ * Note that this makes uACPI map the entire table at once, which not all
+ * hosts are able to handle at early init.
+ */
+#define UACPI_FLAG_PROACTIVE_TBL_CSUM (1ull << 5)
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Initializes the uACPI subsystem, iterates & records all relevant RSDT/XSDT
+ * tables. Enters ACPI mode.
+ *
+ * 'flags' is any combination of UACPI_FLAG_* above
+ */
+uacpi_status uacpi_initialize(uacpi_u64 flags);
+
+/*
+ * Parses & executes all of the DSDT/SSDT tables.
+ * Initializes the event subsystem.
+ */
+uacpi_status uacpi_namespace_load(void);
+
+/*
+ * Initializes all the necessary objects in the namespaces by calling
+ * _STA/_INI etc.
+ */
+uacpi_status uacpi_namespace_initialize(void);
+
+// Returns the current subsystem initialization level
+uacpi_init_level uacpi_get_current_init_level(void);
+
+/*
+ * Evaluate an object within the namespace and get back its value.
+ * Either root or path must be valid.
+ * A value of NULL for 'parent' implies uacpi_namespace_root() relative
+ * lookups, unless 'path' is already absolute.
+ */
+uacpi_status uacpi_eval(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * Same as uacpi_eval() but without a return value.
+ */
+uacpi_status uacpi_execute(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args
+);
+uacpi_status uacpi_execute_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path
+);
+
+/*
+ * Same as uacpi_eval, but the return value type is validated against
+ * the 'ret_mask'. UACPI_STATUS_TYPE_MISMATCH is returned on error.
+ */
+uacpi_status uacpi_eval_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object_type_bits ret_mask,
+    uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    uacpi_object_type_bits ret_mask, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_INTEGER_BIT.
+ */
+uacpi_status uacpi_eval_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_u64 *out_value
+);
+uacpi_status uacpi_eval_simple_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_u64 *out_value
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with
+ *     UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT
+ *
+ * Use uacpi_object_get_string_or_buffer to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_STRING_BIT.
+ *
+ * Use uacpi_object_get_string to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_BUFFER_BIT.
+ *
+ * Use uacpi_object_get_buffer to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_PACKAGE_BIT.
+ *
+ * Use uacpi_object_get_package to retrieve the resulting object array.
+ */
+uacpi_status uacpi_eval_package(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_package(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * Get the bitness of the currently loaded AML code according to the DSDT.
+ *
+ * Returns either 32 or 64.
+ */
+uacpi_status uacpi_get_aml_bitness(uacpi_u8 *out_bitness);
+
+/*
+ * Helpers for entering & leaving ACPI mode. Note that ACPI mode is entered
+ * automatically during the call to uacpi_initialize().
+ */
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_enter_acpi_mode(void)
+)
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_leave_acpi_mode(void)
+)
+
+/*
+ * Attempt to acquire the global lock for 'timeout' milliseconds.
+ * 0xFFFF implies infinite wait.
+ *
+ * On success, 'out_seq' is set to a unique sequence number for the current
+ * acquire transaction. This number is used for validation during release.
+ */
+uacpi_status uacpi_acquire_global_lock(uacpi_u16 timeout, uacpi_u32 *out_seq);
+uacpi_status uacpi_release_global_lock(uacpi_u32 seq);
+
+#endif // !UACPI_BAREBONES_MODE
+
+/*
+ * Reset the global uACPI state by freeing all internally allocated data
+ * structures & resetting any global variables. After this call, uACPI must be
+ * re-initialized from scratch to be used again.
+ *
+ * This is called by uACPI automatically if a fatal error occurs during a call
+ * to uacpi_initialize/uacpi_namespace_load etc. in order to prevent accidental
+ * use of partially uninitialized subsystems.
+ */
+void uacpi_state_reset(void);
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/include/uacpi/utilities.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/types.h>
+#include <uacpi/namespace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Checks whether the device at 'node' matches any of the PNP ids provided in
+ * 'list' (terminated by a UACPI_NULL). This is done by first attempting to
+ * match the value returned from _HID and then the value(s) from _CID.
+ *
+ * Note that the presence of the device (_STA) is not verified here.
+ */
+uacpi_bool uacpi_device_matches_pnp_id(
+    uacpi_namespace_node *node,
+    const uacpi_char *const *list
+);
+
+/*
+ * Find all the devices in the namespace starting at 'parent' matching the
+ * specified 'hids' (terminated by a UACPI_NULL) against any value from _HID or
+ * _CID. Only devices reported as present via _STA are checked. Any matching
+ * devices are then passed to the 'cb'.
+ */
+uacpi_status uacpi_find_devices_at(
+    uacpi_namespace_node *parent,
+    const uacpi_char *const *hids,
+    uacpi_iteration_callback cb,
+    void *user
+);
+
+/*
+ * Same as uacpi_find_devices_at, except this starts at the root and only
+ * matches one hid.
+ */
+uacpi_status uacpi_find_devices(
+    const uacpi_char *hid,
+    uacpi_iteration_callback cb,
+    void *user
+);
+
+typedef enum uacpi_interrupt_model {
+    UACPI_INTERRUPT_MODEL_PIC = 0,
+    UACPI_INTERRUPT_MODEL_IOAPIC,
+    UACPI_INTERRUPT_MODEL_IOSAPIC,
+    UACPI_INTERRUPT_MODEL_PLATFORM_SPECIFIC,
+    UACPI_INTERRUPT_MODEL_GIC,
+    UACPI_INTERRUPT_MODEL_LPIC,
+    UACPI_INTERRUPT_MODEL_RINTC,
+} uacpi_interrupt_model;
+
+uacpi_status uacpi_set_interrupt_model(uacpi_interrupt_model);
+
+typedef struct uacpi_pci_routing_table_entry {
+    uacpi_u32 address;
+    uacpi_u32 index;
+    uacpi_namespace_node *source;
+    uacpi_u8 pin;
+} uacpi_pci_routing_table_entry;
+
+typedef struct uacpi_pci_routing_table {
+    uacpi_size num_entries;
+    uacpi_pci_routing_table_entry entries[];
+} uacpi_pci_routing_table;
+void uacpi_free_pci_routing_table(uacpi_pci_routing_table*);
+
+uacpi_status uacpi_get_pci_routing_table(
+    uacpi_namespace_node *parent, uacpi_pci_routing_table **out_table
+);
+
+typedef struct uacpi_id_string {
+    // size of the string including the null byte
+    uacpi_u32 size;
+    uacpi_char *value;
+} uacpi_id_string;
+void uacpi_free_id_string(uacpi_id_string *id);
+
+/*
+ * Evaluate a device's _HID method and get its value.
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_hid(uacpi_namespace_node*, uacpi_id_string **out_id);
+
+typedef struct uacpi_pnp_id_list {
+    // number of 'ids' in the list
+    uacpi_u32 num_ids;
+
+    // size of the 'ids' list including the string lengths
+    uacpi_u32 size;
+
+    // list of PNP ids
+    uacpi_id_string ids[];
+} uacpi_pnp_id_list;
+void uacpi_free_pnp_id_list(uacpi_pnp_id_list *list);
+
+/*
+ * Evaluate a device's _CID method and get its value.
+ * The returned structure must be freed using uacpi_free_pnp_id_list.
+ */
+uacpi_status uacpi_eval_cid(uacpi_namespace_node*, uacpi_pnp_id_list **out_list);
+
+/*
+ * Evaluate a device's _STA method and get its value.
+ * If this method is not found, the value of 'flags' is set to all ones.
+ */
+uacpi_status uacpi_eval_sta(uacpi_namespace_node*, uacpi_u32 *flags);
+
+/*
+ * Evaluate a device's _ADR method and get its value.
+ */
+uacpi_status uacpi_eval_adr(uacpi_namespace_node*, uacpi_u64 *out);
+
+/*
+ * Evaluate a device's _CLS method and get its value.
+ * The format of returned string is BBSSPP where:
+ *     BB => Base Class (e.g. 01 => Mass Storage)
+ *     SS => Sub-Class (e.g. 06 => SATA)
+ *     PP => Programming Interface (e.g. 01 => AHCI)
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_cls(uacpi_namespace_node*, uacpi_id_string **out_id);
+
+/*
+ * Evaluate a device's _UID method and get its value.
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_uid(uacpi_namespace_node*, uacpi_id_string **out_uid);
+
+
+// uacpi_namespace_node_info->flags
+#define UACPI_NS_NODE_INFO_HAS_ADR (1 << 0)
+#define UACPI_NS_NODE_INFO_HAS_HID (1 << 1)
+#define UACPI_NS_NODE_INFO_HAS_UID (1 << 2)
+#define UACPI_NS_NODE_INFO_HAS_CID (1 << 3)
+#define UACPI_NS_NODE_INFO_HAS_CLS (1 << 4)
+#define UACPI_NS_NODE_INFO_HAS_SXD (1 << 5)
+#define UACPI_NS_NODE_INFO_HAS_SXW (1 << 6)
+
+typedef struct uacpi_namespace_node_info {
+    // Size of the entire structure
+    uacpi_u32 size;
+
+    // Object information
+    uacpi_object_name name;
+    uacpi_object_type type;
+    uacpi_u8 num_params;
+
+    // UACPI_NS_NODE_INFO_HAS_*
+    uacpi_u8 flags;
+
+    /*
+     * A mapping of [S1..S4] to the shallowest D state supported by the device
+     * in that S state.
+     */
+    uacpi_u8 sxd[4];
+
+    /*
+     * A mapping of [S0..S4] to the deepest D state supported by the device
+     * in that S state to be able to wake itself.
+     */
+    uacpi_u8 sxw[5];
+
+    uacpi_u64 adr;
+    uacpi_id_string hid;
+    uacpi_id_string uid;
+    uacpi_id_string cls;
+    uacpi_pnp_id_list cid;
+} uacpi_namespace_node_info;
+void uacpi_free_namespace_node_info(uacpi_namespace_node_info*);
+
+/*
+ * Retrieve information about a namespace node. This includes the attached
+ * object's type, name, number of parameters (if it's a method), the result of
+ * evaluating _ADR, _UID, _CLS, _HID, _CID, as well as _SxD and _SxW.
+ *
+ * The returned structure must be freed with uacpi_free_namespace_node_info.
+ */
+uacpi_status uacpi_get_namespace_node_info(
+    uacpi_namespace_node *node, uacpi_namespace_node_info **out_info
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

kernel/uACPI/meson.build

@@ -0,0 +1,25 @@
+project('uacpi', 'c')
+
+sources = files(
+    'source/tables.c',
+    'source/types.c',
+    'source/uacpi.c',
+    'source/utilities.c',
+    'source/interpreter.c',
+    'source/opcodes.c',
+    'source/namespace.c',
+    'source/stdlib.c',
+    'source/shareable.c',
+    'source/opregion.c',
+    'source/default_handlers.c',
+    'source/io.c',
+    'source/notify.c',
+    'source/sleep.c',
+    'source/registers.c',
+    'source/resources.c',
+    'source/event.c',
+    'source/mutex.c',
+    'source/osi.c',
+)
+
+includes = include_directories('include')

kernel/uACPI/platform_mop3.c

@@ -0,0 +1,48 @@
+#include <libk/std.h>
+#include <limine/requests.h>
+#include <mm/liballoc.h>
+#include <sys/debug.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/status.h>
+
+uacpi_status uacpi_kernel_get_rsdp (uacpi_phys_addr* out_rsdp_address) {
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  struct limine_rsdp_response* rsdp = limine_rsdp_request.response;
+
+  *out_rsdp_address =
+      (uacpi_phys_addr)((uintptr_t)rsdp->address - (uintptr_t)hhdm->offset);
+
+  return UACPI_STATUS_OK;
+}
+
+void* uacpi_kernel_map (uacpi_phys_addr addr, uacpi_size len) {
+  (void)len;
+  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
+  return (void*)((uintptr_t)hhdm->offset + (uintptr_t)addr);
+}
+
+void uacpi_kernel_unmap (void* addr, uacpi_size len) { (void)addr, (void)len; }
+
+void uacpi_kernel_log (uacpi_log_level level, const uacpi_char* msg) {
+  const char* prefix = NULL;
+
+  switch (level) {
+  case UACPI_LOG_DEBUG:
+    prefix = "Debug";
+    break;
+  case UACPI_LOG_TRACE:
+    prefix = "Trace";
+    break;
+  case UACPI_LOG_INFO:
+    prefix = "Info";
+    break;
+  case UACPI_LOG_WARN:
+    prefix = "Warning";
+    break;
+  case UACPI_LOG_ERROR:
+    prefix = "Error";
+    break;
+  }
+
+  DEBUG ("%s %s", prefix, msg);
+}

kernel/uACPI/source/.gitignore

@@ -0,0 +1 @@
+*.o

kernel/uACPI/source/default_handlers.c

@@ -0,0 +1,336 @@
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/uacpi.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define PCI_ROOT_PNP_ID "PNP0A03"
+#define PCI_EXPRESS_ROOT_PNP_ID "PNP0A08"
+
+static uacpi_namespace_node *find_pci_root(uacpi_namespace_node *node)
+{
+    static const uacpi_char *pci_root_ids[] = {
+        PCI_ROOT_PNP_ID,
+        PCI_EXPRESS_ROOT_PNP_ID,
+        UACPI_NULL
+    };
+    uacpi_namespace_node *parent = node->parent;
+
+    while (parent != uacpi_namespace_root()) {
+        if (uacpi_device_matches_pnp_id(parent, pci_root_ids)) {
+            uacpi_trace(
+                "found a PCI root node %.4s controlling region %.4s\n",
+                parent->name.text, node->name.text
+            );
+            return parent;
+        }
+
+        parent = parent->parent;
+    }
+
+    uacpi_trace_region_error(
+        node, "unable to find PCI root controlling",
+        UACPI_STATUS_NOT_FOUND
+    );
+    return node;
+}
+
+static uacpi_status pci_region_attach(uacpi_region_attach_data *data)
+{
+    uacpi_namespace_node *node, *pci_root, *device;
+    uacpi_pci_address address = { 0 };
+    uacpi_u64 value;
+    uacpi_status ret;
+
+    node = data->region_node;
+    pci_root = find_pci_root(node);
+
+    /*
+     * Find the actual device object that is supposed to be controlling
+     * this operation region.
+     */
+    device = node;
+    while (device) {
+        uacpi_object_type type;
+
+        ret = uacpi_namespace_node_type(device, &type);
+        if (uacpi_unlikely_error(ret))
+            return ret;
+
+        if (type == UACPI_OBJECT_DEVICE)
+            break;
+
+        device = device->parent;
+    }
+
+    if (uacpi_unlikely(device == UACPI_NULL)) {
+        ret = UACPI_STATUS_NOT_FOUND;
+        uacpi_trace_region_error(
+            node, "unable to find device responsible for", ret
+        );
+        return ret;
+    }
+
+    ret = uacpi_eval_simple_integer(device, "_ADR", &value);
+    if (ret == UACPI_STATUS_OK) {
+        address.function = (value >> 0)  & 0xFF;
+        address.device   = (value >> 16) & 0xFF;
+    }
+
+    ret = uacpi_eval_simple_integer(pci_root, "_SEG", &value);
+    if (ret == UACPI_STATUS_OK)
+        address.segment = value;
+
+    ret = uacpi_eval_simple_integer(pci_root, "_BBN", &value);
+    if (ret == UACPI_STATUS_OK)
+        address.bus = value;
+
+    uacpi_trace(
+        "detected PCI device %.4s@%04X:%02X:%02X:%01X\n",
+        device->name.text, address.segment, address.bus,
+        address.device, address.function
+    );
+
+    return uacpi_kernel_pci_device_open(address, &data->out_region_context);
+}
+
+static uacpi_status pci_region_detach(uacpi_region_detach_data *data)
+{
+    uacpi_kernel_pci_device_close(data->region_context);
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status pci_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    uacpi_handle dev = data->region_context;
+    uacpi_u8 width;
+    uacpi_size offset;
+
+    offset = data->offset;
+    width = data->byte_width;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_pci_read(dev, offset, width, &data->value) :
+        uacpi_pci_write(dev, offset, width, data->value);
+}
+
+static uacpi_status handle_pci_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return pci_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return pci_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return pci_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+struct memory_region_ctx {
+    uacpi_phys_addr phys;
+    uacpi_u8 *virt;
+    uacpi_size size;
+};
+
+static uacpi_status memory_region_attach(uacpi_region_attach_data *data)
+{
+    struct memory_region_ctx *ctx;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    ctx = uacpi_kernel_alloc(sizeof(*ctx));
+    if (ctx == UACPI_NULL)
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    ctx->size = data->generic_info.length;
+
+    // FIXME: this really shouldn't try to map everything at once
+    ctx->phys = data->generic_info.base;
+    ctx->virt = uacpi_kernel_map(ctx->phys, ctx->size);
+
+    if (uacpi_unlikely(ctx->virt == UACPI_NULL)) {
+        ret = UACPI_STATUS_MAPPING_FAILED;
+        uacpi_trace_region_error(data->region_node, "unable to map", ret);
+        uacpi_free(ctx, sizeof(*ctx));
+        goto out;
+    }
+
+    data->out_region_context = ctx;
+out:
+    return ret;
+}
+
+static uacpi_status memory_region_detach(uacpi_region_detach_data *data)
+{
+    struct memory_region_ctx *ctx = data->region_context;
+
+    uacpi_kernel_unmap(ctx->virt, ctx->size);
+    uacpi_free(ctx, sizeof(*ctx));
+    return UACPI_STATUS_OK;
+}
+
+struct io_region_ctx {
+    uacpi_io_addr base;
+    uacpi_handle handle;
+};
+
+static uacpi_status io_region_attach(uacpi_region_attach_data *data)
+{
+    struct io_region_ctx *ctx;
+    uacpi_generic_region_info *info = &data->generic_info;
+    uacpi_status ret;
+
+    ctx = uacpi_kernel_alloc(sizeof(*ctx));
+    if (ctx == UACPI_NULL)
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    ctx->base = info->base;
+
+    ret = uacpi_kernel_io_map(ctx->base, info->length, &ctx->handle);
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_trace_region_error(
+            data->region_node, "unable to map an IO", ret
+        );
+        uacpi_free(ctx, sizeof(*ctx));
+        return ret;
+    }
+
+    data->out_region_context = ctx;
+    return ret;
+}
+
+static uacpi_status io_region_detach(uacpi_region_detach_data *data)
+{
+    struct io_region_ctx *ctx = data->region_context;
+
+    uacpi_kernel_io_unmap(ctx->handle);
+    uacpi_free(ctx, sizeof(*ctx));
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status memory_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    struct memory_region_ctx *ctx = data->region_context;
+    uacpi_size offset;
+
+    offset = data->address - ctx->phys;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_system_memory_read(ctx->virt, offset, data->byte_width, &data->value) :
+        uacpi_system_memory_write(ctx->virt, offset, data->byte_width, data->value);
+}
+
+static uacpi_status handle_memory_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return memory_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return memory_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return memory_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+static uacpi_status table_data_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    void *addr = UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)data->offset);
+
+    return op == UACPI_REGION_OP_READ ?
+       uacpi_system_memory_read(addr, 0, data->byte_width, &data->value) :
+       uacpi_system_memory_write(addr, 0, data->byte_width, data->value);
+}
+
+static uacpi_status handle_table_data_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+    case UACPI_REGION_OP_DETACH:
+        return UACPI_STATUS_OK;
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return table_data_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+static uacpi_status io_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    struct io_region_ctx *ctx = data->region_context;
+    uacpi_u8 width;
+    uacpi_size offset;
+
+    offset = data->offset - ctx->base;
+    width = data->byte_width;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_system_io_read(ctx->handle, offset, width, &data->value) :
+        uacpi_system_io_write(ctx->handle, offset, width, data->value);
+}
+
+static uacpi_status handle_io_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return io_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return io_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return io_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+void uacpi_install_default_address_space_handlers(void)
+{
+    uacpi_namespace_node *root;
+
+    root = uacpi_namespace_root();
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_SYSTEM_MEMORY,
+        handle_memory_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_SYSTEM_IO,
+        handle_io_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_PCI_CONFIG,
+        handle_pci_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_TABLE_DATA,
+        handle_table_data_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+}
+
+#endif // !UACPI_BAREBONES_MODE

kernel/uACPI/source/files.cmake

@@ -0,0 +1,21 @@
+uacpi_add_sources(
+    tables.c
+    types.c
+    uacpi.c
+    utilities.c
+    interpreter.c
+    opcodes.c
+    namespace.c
+    stdlib.c
+    shareable.c
+    opregion.c
+    default_handlers.c
+    io.c
+    notify.c
+    sleep.c
+    registers.c
+    resources.c
+    event.c
+    mutex.c
+    osi.c
+)

kernel/uACPI/source/mutex.c

@@ -0,0 +1,396 @@
+#include <uacpi/platform/atomic.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/internal/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+
+#define GLOBAL_LOCK_PENDING (1 << 0)
+
+#define GLOBAL_LOCK_OWNED_BIT 1
+#define GLOBAL_LOCK_OWNED (1 << GLOBAL_LOCK_OWNED_BIT)
+
+#define GLOBAL_LOCK_MASK 3u
+
+static uacpi_bool try_acquire_global_lock_from_firmware(uacpi_u32 *lock)
+{
+    uacpi_u32 value, new_value;
+    uacpi_bool was_owned;
+
+    value = *(volatile uacpi_u32*)lock;
+    do {
+        was_owned = (value & GLOBAL_LOCK_OWNED) >> GLOBAL_LOCK_OWNED_BIT;
+
+        // Clear both owned & pending bits.
+        new_value = value & ~GLOBAL_LOCK_MASK;
+
+        // Set owned unconditionally
+        new_value |= GLOBAL_LOCK_OWNED;
+
+        // Set pending iff the lock was owned at the time of reading
+        if (was_owned)
+            new_value |= GLOBAL_LOCK_PENDING;
+    } while (!uacpi_atomic_cmpxchg32(lock, &value, new_value));
+
+    return !was_owned;
+}
+
+static uacpi_bool do_release_global_lock_to_firmware(uacpi_u32 *lock)
+{
+    uacpi_u32 value, new_value;
+
+    value = *(volatile uacpi_u32*)lock;
+    do {
+        new_value = value & ~GLOBAL_LOCK_MASK;
+    } while (!uacpi_atomic_cmpxchg32(lock, &value, new_value));
+
+    return value & GLOBAL_LOCK_PENDING;
+}
+
+static uacpi_status uacpi_acquire_global_lock_from_firmware(void)
+{
+    uacpi_cpu_flags flags;
+    uacpi_u16 spins = 0;
+    uacpi_bool success;
+
+    if (!g_uacpi_rt_ctx.has_global_lock)
+        return UACPI_STATUS_OK;
+
+    flags = uacpi_kernel_lock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+    for (;;) {
+        spins++;
+        uacpi_trace(
+            "trying to acquire the global lock from firmware... (attempt %u)\n",
+            spins
+        );
+
+        success = try_acquire_global_lock_from_firmware(
+            &g_uacpi_rt_ctx.facs->global_lock
+        );
+        if (success)
+            break;
+
+        if (uacpi_unlikely(spins == 0xFFFF))
+            break;
+
+        g_uacpi_rt_ctx.global_lock_pending = UACPI_TRUE;
+        uacpi_trace(
+            "global lock is owned by firmware, waiting for a release "
+            "notification...\n"
+        );
+        uacpi_kernel_unlock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock, flags);
+
+        uacpi_kernel_wait_for_event(g_uacpi_rt_ctx.global_lock_event, 0xFFFF);
+        flags = uacpi_kernel_lock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+    }
+
+    g_uacpi_rt_ctx.global_lock_pending = UACPI_FALSE;
+    uacpi_kernel_unlock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock, flags);
+
+    if (uacpi_unlikely(!success)) {
+        uacpi_error("unable to acquire global lock after %u attempts\n", spins);
+        return UACPI_STATUS_HARDWARE_TIMEOUT;
+    }
+
+    uacpi_trace("global lock successfully acquired after %u attempt%s\n",
+                spins, spins > 1 ? "s" : "");
+    return UACPI_STATUS_OK;
+}
+
+static void uacpi_release_global_lock_to_firmware(void)
+{
+    if (!g_uacpi_rt_ctx.has_global_lock)
+        return;
+
+    uacpi_trace("releasing the global lock to firmware...\n");
+    if (do_release_global_lock_to_firmware(&g_uacpi_rt_ctx.facs->global_lock)) {
+        uacpi_trace("notifying firmware of the global lock release since the "
+                    "pending bit was set\n");
+        uacpi_write_register_field(UACPI_REGISTER_FIELD_GBL_RLS, 1);
+    }
+}
+#endif
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_acquire_global_lock_from_firmware(void)
+)
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_release_global_lock_to_firmware(void)
+)
+
+uacpi_status uacpi_acquire_native_mutex_with_timeout(
+    uacpi_handle mtx, uacpi_u16 timeout
+)
+{
+    uacpi_status ret;
+
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_kernel_acquire_mutex(mtx, timeout);
+    if (uacpi_likely_success(ret))
+        return ret;
+
+    if (uacpi_unlikely(ret != UACPI_STATUS_TIMEOUT || timeout == 0xFFFF)) {
+        uacpi_error(
+            "unexpected status %08X (%s) while acquiring %p (timeout=%04X)\n",
+            ret, uacpi_status_to_string(ret), mtx, timeout
+        );
+    }
+
+    return ret;
+}
+
+uacpi_status uacpi_acquire_global_lock(uacpi_u16 timeout, uacpi_u32 *out_seq)
+{
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(out_seq == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_acquire_native_mutex_with_timeout(
+        g_uacpi_rt_ctx.global_lock_mutex->handle, timeout
+    );
+    if (ret != UACPI_STATUS_OK)
+        return ret;
+
+    ret = uacpi_acquire_global_lock_from_firmware();
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_release_native_mutex(g_uacpi_rt_ctx.global_lock_mutex->handle);
+        return ret;
+    }
+
+    if (uacpi_unlikely(g_uacpi_rt_ctx.global_lock_seq_num == 0xFFFFFFFF))
+        g_uacpi_rt_ctx.global_lock_seq_num = 0;
+
+    *out_seq = g_uacpi_rt_ctx.global_lock_seq_num++;
+    g_uacpi_rt_ctx.global_lock_acquired = UACPI_TRUE;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_release_global_lock(uacpi_u32 seq)
+{
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(!g_uacpi_rt_ctx.global_lock_acquired ||
+                       seq != g_uacpi_rt_ctx.global_lock_seq_num))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    g_uacpi_rt_ctx.global_lock_acquired = UACPI_FALSE;
+    uacpi_release_global_lock_to_firmware();
+    uacpi_release_native_mutex(g_uacpi_rt_ctx.global_lock_mutex->handle);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_bool uacpi_this_thread_owns_aml_mutex(uacpi_mutex *mutex)
+{
+    uacpi_thread_id id;
+
+    id = UACPI_ATOMIC_LOAD_THREAD_ID(&mutex->owner);
+    return id == uacpi_kernel_get_thread_id();
+}
+
+uacpi_status uacpi_acquire_aml_mutex(uacpi_mutex *mutex, uacpi_u16 timeout)
+{
+    uacpi_thread_id this_id;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    this_id = uacpi_kernel_get_thread_id();
+    if (UACPI_ATOMIC_LOAD_THREAD_ID(&mutex->owner) == this_id) {
+        if (uacpi_unlikely(mutex->depth == 0xFFFF)) {
+            uacpi_warn(
+                "failing an attempt to acquire mutex @%p, too many recursive "
+                "acquires\n", mutex
+            );
+            return UACPI_STATUS_DENIED;
+        }
+
+        mutex->depth++;
+        return ret;
+    }
+
+    uacpi_namespace_write_unlock();
+    ret = uacpi_acquire_native_mutex_with_timeout(mutex->handle, timeout);
+    if (ret != UACPI_STATUS_OK)
+        goto out;
+
+    if (mutex->handle == g_uacpi_rt_ctx.global_lock_mutex->handle) {
+        ret = uacpi_acquire_global_lock_from_firmware();
+        if (uacpi_unlikely_error(ret)) {
+            uacpi_release_native_mutex(mutex->handle);
+            goto out;
+        }
+    }
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&mutex->owner, this_id);
+    mutex->depth = 1;
+
+out:
+    uacpi_namespace_write_lock();
+    return ret;
+}
+
+uacpi_status uacpi_release_aml_mutex(uacpi_mutex *mutex)
+{
+    if (mutex->depth-- > 1)
+        return UACPI_STATUS_OK;
+
+    if (mutex->handle == g_uacpi_rt_ctx.global_lock_mutex->handle)
+        uacpi_release_global_lock_to_firmware();
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&mutex->owner, UACPI_THREAD_ID_NONE);
+    uacpi_release_native_mutex(mutex->handle);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_init(struct uacpi_recursive_lock *lock)
+{
+    lock->mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    lock->owner = UACPI_THREAD_ID_NONE;
+    lock->depth = 0;
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_deinit(struct uacpi_recursive_lock *lock)
+{
+    if (uacpi_unlikely(lock->depth)) {
+        uacpi_warn(
+            "de-initializing active recursive lock %p with depth=%zu\n",
+            lock, lock->depth
+        );
+        lock->depth = 0;
+    }
+
+    lock->owner = UACPI_THREAD_ID_NONE;
+
+    if (lock->mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->mutex);
+        lock->mutex = UACPI_NULL;
+    }
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_acquire(struct uacpi_recursive_lock *lock)
+{
+    uacpi_thread_id this_id;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    this_id = uacpi_kernel_get_thread_id();
+    if (UACPI_ATOMIC_LOAD_THREAD_ID(&lock->owner) == this_id) {
+        lock->depth++;
+        return ret;
+    }
+
+    ret = uacpi_acquire_native_mutex(lock->mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&lock->owner, this_id);
+    lock->depth = 1;
+    return ret;
+}
+
+uacpi_status uacpi_recursive_lock_release(struct uacpi_recursive_lock *lock)
+{
+    if (lock->depth-- > 1)
+        return UACPI_STATUS_OK;
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&lock->owner, UACPI_THREAD_ID_NONE);
+    return uacpi_release_native_mutex(lock->mutex);
+}
+
+uacpi_status uacpi_rw_lock_init(struct uacpi_rw_lock *lock)
+{
+    lock->read_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->read_mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    lock->write_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->write_mutex == UACPI_NULL)) {
+        uacpi_kernel_free_mutex(lock->read_mutex);
+        lock->read_mutex = UACPI_NULL;
+        return UACPI_STATUS_OUT_OF_MEMORY;
+    }
+
+    lock->num_readers = 0;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_rw_lock_deinit(struct uacpi_rw_lock *lock)
+{
+    if (uacpi_unlikely(lock->num_readers)) {
+        uacpi_warn("de-initializing rw_lock %p with %zu active readers\n",
+                   lock, lock->num_readers);
+        lock->num_readers = 0;
+    }
+
+    if (lock->read_mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->read_mutex);
+        lock->read_mutex = UACPI_NULL;
+    }
+    if (lock->write_mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->write_mutex);
+        lock->write_mutex = UACPI_NULL;
+    }
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_rw_lock_read(struct uacpi_rw_lock *lock)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex(lock->read_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (lock->num_readers++ == 0) {
+        ret = uacpi_acquire_native_mutex(lock->write_mutex);
+        if (uacpi_unlikely_error(ret))
+            lock->num_readers = 0;
+    }
+
+    uacpi_kernel_release_mutex(lock->read_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_rw_unlock_read(struct uacpi_rw_lock *lock)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex(lock->read_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (lock->num_readers-- == 1)
+        uacpi_release_native_mutex(lock->write_mutex);
+
+    uacpi_kernel_release_mutex(lock->read_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_rw_lock_write(struct uacpi_rw_lock *lock)
+{
+    return uacpi_acquire_native_mutex(lock->write_mutex);
+}
+
+uacpi_status uacpi_rw_unlock_write(struct uacpi_rw_lock *lock)
+{
+    return uacpi_release_native_mutex(lock->write_mutex);
+}
+
+#endif // !UACPI_BAREBONES_MODE