kamkow1/mop3
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use clang-format

Browse Source
This commit is contained in:
Kamil Kowalczyk
2025-12-21 22:53:25 +01:00
parent 8794a61073
commit b2d8294b12
36 changed files with 925 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
.editorconfig Normal file
View File

@@ -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

5
Makefile
View File

@@ -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

57
kernel/.clang-format Normal file
View File

@@ -0,0 +1,57 @@
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: DontAlign
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignOperands: false
# Includes
SortIncludes: true
# Comments
ReflowComments: false
CommentPragmas: '^ IWYU pragma:'
# Misc
KeepEmptyLinesAtTheStartOfBlocks: false
MaxEmptyLinesToKeep: 1

11
kernel/Makefile
View File

@@ -23,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

27
kernel/amd64/bootmain.c
View File

@@ -1,23 +1,26 @@
#include <limine/limine.h>
#include <amd64/init.h>
#include <sys/debug.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>
#define UACPI_MEMORY_BUFFER_MAX 4096
__attribute__((aligned(16))) static uint8_t uacpi_memory_buffer[UACPI_MEMORY_BUFFER_MAX];
__attribute__ ((
aligned (16))) static uint8_t uacpi_memory_buffer[UACPI_MEMORY_BUFFER_MAX];
void bootmain(void) {
amd64_init();
pmm_init();
uacpi_setup_early_table_access((void *)uacpi_memory_buffer, sizeof(uacpi_memory_buffer));
void bootmain (void) {
amd64_init ();
pmm_init ();
int *a = malloc(sizeof(int));
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);
for (;;);
for (;;)
;
}

53
kernel/amd64/debug.c
View File

@@ -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 PORT_COM1 0x03F8
#define BUFFER_SIZE 1024
static bool amd64_debug_serial_tx_empty(void) {
return (bool)(amd64_io_inb(PORT_COM1 + 5) & 0x20);
static bool amd64_debug_serial_tx_empty (void) {
return (bool)(amd64_io_inb (PORT_COM1 + 5) & 0x20);
}
static void amd64_debug_serial_write(char x) {
while (!amd64_debug_serial_tx_empty());
amd64_io_outb(PORT_COM1, (uint8_t)x);
static void amd64_debug_serial_write (char x) {
while (!amd64_debug_serial_tx_empty ())
;
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);
vsnprintf(buffer, sizeof(buffer), fmt, ap);
va_end(ap);
va_start (ap, fmt);
vsnprintf (buffer, sizeof (buffer), fmt, 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) {
amd64_io_outb(PORT_COM1 + 1, 0x00);
amd64_io_outb(PORT_COM1 + 3, 0x80);
amd64_io_outb(PORT_COM1 + 0, 0x03);
amd64_io_outb(PORT_COM1 + 1, 0x00);
amd64_io_outb(PORT_COM1 + 3, 0x03);
amd64_io_outb(PORT_COM1 + 2, 0xC7);
amd64_io_outb(PORT_COM1 + 4, 0x0B);
void amd64_debug_init (void) {
amd64_io_outb (PORT_COM1 + 1, 0x00);
amd64_io_outb (PORT_COM1 + 3, 0x80);
amd64_io_outb (PORT_COM1 + 0, 0x03);
amd64_io_outb (PORT_COM1 + 1, 0x00);
amd64_io_outb (PORT_COM1 + 3, 0x03);
amd64_io_outb (PORT_COM1 + 2, 0xC7);
amd64_io_outb (PORT_COM1 + 4, 0x0B);
}

2
kernel/amd64/debug.h
View File

@@ -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

107
kernel/amd64/init.c
View File

@@ -1,20 +1,20 @@
#include <amd64/debug.h>
#include <amd64/init.h>
#include <amd64/intr.h>
#include <amd64/tss.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_KDATA 0x10
#define GDT_UCODE 0x18
#define GDT_UDATA 0x20
#define GDT_TSS 0x28
#define GDT_KCODE 0x08
#define GDT_KDATA 0x10
#define GDT_UCODE 0x18
#define GDT_UDATA 0x20
#define GDT_TSS 0x28
#define TSS 0x80
#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 +23,26 @@ struct gdt_entry {
uint8_t access;
uint8_t gran;
uint8_t basehigh;
} __attribute__((packed));
} __attribute__ ((packed));
struct gdt_ptr {
uint16_t limit;
uint64_t base;
} __attribute__((packed));
} __attribute__ ((packed));
struct gdt_extended {
struct gdt_entry old[5];
struct gdt_entry tsslow;
struct gdt_entry tsshigh;
} __attribute__((packed));
} __attribute__ ((packed));
__attribute__((aligned(16))) static volatile uint8_t kernel_stack[KSTACK_SIZE];
__attribute__((aligned(16))) static volatile struct gdt_extended gdt;
/* clang-format off */
__attribute__ ((aligned (16))) static volatile uint8_t kernel_stack[KSTACK_SIZE];
__attribute__ ((aligned (16))) static volatile struct gdt_extended gdt;
/* clang-format on */
static void amd64_gdt_set(volatile struct gdt_entry *ent, uint32_t base,
uint32_t limit, uint8_t acc, uint8_t gran) {
static void amd64_gdt_set (volatile struct gdt_entry* ent, uint32_t base,
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 +51,26 @@ static void amd64_gdt_set(volatile struct gdt_entry *ent, uint32_t base,
ent->access = acc;
}
static void amd64_gdt_init(void) {
volatile struct tss *tss = amd64_get_tss();
static void amd64_gdt_init (void) {
volatile struct tss* tss = amd64_get_tss ();
memset((void *)&gdt, 0, sizeof(gdt));
memset((void *)kernel_stack, 0, sizeof(kernel_stack));
memset((void *)tss, 0, sizeof(*tss));
memset ((void*)&gdt, 0, sizeof (gdt));
memset ((void*)kernel_stack, 0, sizeof (kernel_stack));
memset ((void*)tss, 0, sizeof (*tss));
tss->iopb_off = sizeof(*tss);
tss->rsp0 = (uint64_t)((uintptr_t)kernel_stack + sizeof(kernel_stack));
tss->iopb_off = sizeof (*tss);
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[1], 0, 0xFFFFF, 0x9A, 0xA0);
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[4], 0, 0xFFFFF, 0xF2, 0xC0);
amd64_gdt_set(&gdt.tsslow, (tssbase & 0xFFFFFFFF), tsslimit, TSS_PRESENT | TSS, 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[2], 0, 0xFFFFF, 0x92, 0xC0);
amd64_gdt_set (&gdt.old[3], 0, 0xFFFFF, 0xFA, 0xA0);
amd64_gdt_set (&gdt.old[4], 0, 0xFFFFF, 0xF2, 0xC0);
amd64_gdt_set (
&gdt.tsslow, (tssbase & 0xFFFFFFFF), tsslimit, TSS_PRESENT | TSS, 0);
uint32_t tssbasehigh = (tssbase >> 32);
gdt.tsshigh.limitlow = (tssbasehigh & 0xFFFF);
@@ -78,30 +81,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(
"pushq %[kcode]\n"
"lea 1f(%%rip), %%rax\n"
"pushq %%rax\n"
"lretq\n"
"1:\n"
"movw %[kdata], %%ax\n"
"movw %%ax, %%ds\n"
"movw %%ax, %%es\n"
"movw %%ax, %%ss\n"
:
: [kcode] "i"(GDT_KCODE), [kdata] "i"(GDT_KDATA)
: "rax", "memory"
);
__asm__ volatile ("pushq %[kcode]\n"
"lea 1f(%%rip), %%rax\n"
"pushq %%rax\n"
"lretq\n"
"1:\n"
"movw %[kdata], %%ax\n"
"movw %%ax, %%ds\n"
"movw %%ax, %%es\n"
"movw %%ax, %%ss\n"
:
: [kcode] "i"(GDT_KCODE), [kdata] "i"(GDT_KDATA)
: "rax", "memory");
__asm__ volatile("ltr %0" :: "r"((uint16_t)GDT_TSS));
__asm__ volatile ("ltr %0" ::"r"((uint16_t)GDT_TSS));
}
void amd64_init(void) {
amd64_gdt_init();
amd64_debug_init();
amd64_intr_init();
void amd64_init (void) {
amd64_gdt_init ();
amd64_debug_init ();
amd64_intr_init ();
}

2
kernel/amd64/init.h
View File

@@ -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

204
kernel/amd64/intr.c
View File

@@ -1,31 +1,31 @@
#include <amd64/intr.h>
#include <amd64/io.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 PIC2 0xA0
#define PIC1_CMD PIC1
#define PIC1_DATA (PIC1 + 1)
#define PIC2_CMD PIC2
#define PIC2_DATA (PIC2 + 1)
#define PIC_EOI 0x20
#define PIC1 0x20
#define PIC2 0xA0
#define PIC1_CMD PIC1
#define PIC1_DATA (PIC1 + 1)
#define PIC2_CMD PIC2
#define PIC2_DATA (PIC2 + 1)
#define PIC_EOI 0x20
#define ICW1_ICW4 0x01
#define ICW1_SINGLE 0x02
#define ICW1_INTVL4 0x04
#define ICW1_LEVEL 0x08
#define ICW1_INIT 0x10
#define ICW1_ICW4 0x01
#define ICW1_SINGLE 0x02
#define ICW1_INTVL4 0x04
#define ICW1_LEVEL 0x08
#define ICW1_INIT 0x10
#define ICW4_8086 0x01
#define ICW4_AUTO 0x02
#define ICW4_8086 0x01
#define ICW4_AUTO 0x02
#define ICW4_BUFSLAVE 0x08
#define ICW4_BUFMASER 0x0C
#define ICW4_SFNM 0x10
#define ICW4_SFNM 0x10
#define CASCADE_IRQ 2
#define CASCADE_IRQ 2
/* IDT defs. */
@@ -39,42 +39,46 @@ struct idt_entry {
uint16_t intrmid;
uint32_t intrhigh;
uint32_t resv;
} __attribute__((packed));
} __attribute__ ((packed));
struct idt {
uint16_t limit;
uint64_t base;
} __attribute__((packed));
} __attribute__ ((packed));
__attribute__((aligned(16))) static volatile struct idt_entry idt_entries[IDT_ENTRIES_MAX];
__attribute__ ((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) {
#define IO_OP(fn, ...) fn(__VA_ARGS__); amd64_io_wait()
static void amd64_init_pic (void) {
#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, PIC2_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, PIC1_DATA, 0x20);
IO_OP(amd64_io_outb, PIC2_DATA, 0x28);
IO_OP (amd64_io_outb, PIC1_DATA, 0x20);
IO_OP (amd64_io_outb, PIC2_DATA, 0x28);
IO_OP(amd64_io_outb, PIC1_DATA, (1 << CASCADE_IRQ));
IO_OP(amd64_io_outb, PIC2_DATA, 2);
IO_OP (amd64_io_outb, PIC1_DATA, (1 << CASCADE_IRQ));
IO_OP (amd64_io_outb, PIC2_DATA, 2);
IO_OP(amd64_io_outb, PIC1_DATA, ICW4_8086);
IO_OP(amd64_io_outb, PIC2_DATA, ICW4_8086);
IO_OP (amd64_io_outb, PIC1_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, PIC2_DATA, 0xFF);
IO_OP (amd64_io_outb, PIC1_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,104 @@ static void amd64_idt_set(volatile struct idt_entry *ent, uint64_t handler, uint
ent->resv = 0;
}
static void amd64_idt_init(void) {
memset((void *)idt_entries, 0, sizeof(idt_entries));
static void amd64_idt_init (void) {
memset ((void*)idt_entries, 0, sizeof (idt_entries));
#define IDT_ENTRY(n) \
extern void amd64_intr ## n(void); \
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(4); IDT_ENTRY(5); IDT_ENTRY(6); IDT_ENTRY(7);
IDT_ENTRY(8); IDT_ENTRY(9); IDT_ENTRY(10); 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);
#define IDT_ENTRY(n) \
extern void amd64_intr##n (void); \
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 (4);
IDT_ENTRY (5);
IDT_ENTRY (6);
IDT_ENTRY (7);
IDT_ENTRY (8);
IDT_ENTRY (9);
IDT_ENTRY (10);
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("sti");
__asm__ volatile ("lidt %0" ::"m"(idt));
__asm__ volatile ("sti");
}
static void amd64_intr_exception(struct saved_regs *regs) {
DEBUG("cpu exception %lu (%lu)\n", regs->trap, regs->error);
static void amd64_intr_exception (struct saved_regs* regs) {
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(
"r15=%016lx r14=%016lx r13=%016lx\n"
"r12=%016lx r11=%016lx r10=%016lx\n"
"r9 =%016lx r8 =%016lx rbp=%016lx\n"
"rdi=%016lx rsi=%016lx rdx=%016lx\n"
"rcx=%016lx rax=%016lx trp=%016lx\n"
"err=%016lx rip=%016lx cs =%016lx\n"
"rfl=%016lx rsp=%016lx ss =%016lx\n"
"cr2=%016lx cr3=%016lx rbx=%016lx\n",
regs->r15, regs->r14, regs->r13,
regs->r12, regs->r11, regs->r10,
regs->r9, regs->r8, regs->rbp,
regs->rdi, regs->rsi, regs->rdx,
regs->rcx, regs->rax, regs->trap,
regs->error, regs->rip, regs->cs,
regs->rflags, regs->rsp, regs->ss,
cr2, cr3, regs->rbx
);
debugprintf ("r15=%016lx r14=%016lx r13=%016lx\n"
"r12=%016lx r11=%016lx r10=%016lx\n"
"r9 =%016lx r8 =%016lx rbp=%016lx\n"
"rdi=%016lx rsi=%016lx rdx=%016lx\n"
"rcx=%016lx rax=%016lx trp=%016lx\n"
"err=%016lx rip=%016lx cs =%016lx\n"
"rfl=%016lx rsp=%016lx ss =%016lx\n"
"cr2=%016lx cr3=%016lx rbx=%016lx\n",
regs->r15, regs->r14, regs->r13, regs->r12, regs->r11, regs->r10,
regs->r9, regs->r8, regs->rbp, regs->rdi, regs->rsi, regs->rdx, 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) {
struct saved_regs *regs = stack_ptr;
void amd64_intr_handler (void* 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) {
amd64_init_pic();
amd64_idt_init();
void amd64_intr_init (void) {
amd64_init_pic ();
amd64_idt_init ();
}

4
kernel/amd64/intr.h
View File

@@ -28,8 +28,8 @@ struct saved_regs {
uint64_t rflags;
uint64_t rsp;
uint64_t ss;
} __attribute__((packed));
} __attribute__ ((packed));
void amd64_intr_init(void);
void amd64_intr_init (void);
#endif // _KERNEL_AMD64_INTR_H

54
kernel/amd64/io.c
View File

@@ -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) {
__asm__ volatile("outb %1, %0" :: "dN"(port), "a"(v));
void amd64_io_outb (uint16_t port, uint8_t v) {
__asm__ volatile ("outb %1, %0" ::"dN"(port), "a"(v));
}
void amd64_io_outw(uint16_t port, uint16_t v) {
__asm__ volatile("outw %%ax, %%dx" :: "a"(v), "d"(port));
void amd64_io_outw (uint16_t port, uint16_t v) {
__asm__ volatile ("outw %%ax, %%dx" ::"a"(v), "d"(port));
}
void amd64_io_outl(uint16_t port, uint32_t v) {
__asm__ volatile("outl %%eax, %%dx" :: "d"(port), "a"(v));
void amd64_io_outl (uint16_t port, uint32_t v) {
__asm__ volatile ("outl %%eax, %%dx" ::"d"(port), "a"(v));
}
void amd64_io_outsw(uint16_t port, const void *addr, int cnt) {
__asm__ volatile(
"cld; rep outsw"
: "+S"(addr), "+c"(cnt)
: "d"(port)
: "memory", "cc"
);
void amd64_io_outsw (uint16_t port, const void* addr, int cnt) {
__asm__ volatile ("cld; rep outsw"
: "+S"(addr), "+c"(cnt)
: "d"(port)
: "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) {
__asm__ volatile(
"cld; rep insw"
: "+D"(addr), "+c"(cnt)
: "d"(port)
: "memory", "cc"
);
void amd64_io_insw (uint16_t port, void* addr, int cnt) {
__asm__ volatile ("cld; rep insw"
: "+D"(addr), "+c"(cnt)
: "d"(port)
: "memory", "cc");
}
void amd64_io_wait(void) {
amd64_io_outb(0x80, 0);
}
void amd64_io_wait (void) { amd64_io_outb (0x80, 0); }

18
kernel/amd64/io.h
View File

@@ -3,14 +3,14 @@
#include <libk/std.h>
void amd64_io_outb(uint16_t port, uint8_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_outsw(uint16_t port, const void *addr, int cnt);
uint8_t amd64_io_inb(uint16_t port);
uint16_t amd64_io_inw(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_wait(void);
void amd64_io_outb (uint16_t port, uint8_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_outsw (uint16_t port, const void* addr, int cnt);
uint8_t amd64_io_inb (uint16_t port);
uint16_t amd64_io_inw (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_wait (void);
#endif // _KERNEL_AMD64_IO_H

2
kernel/amd64/mm.h
View File

@@ -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

4
kernel/amd64/spin_lock.c
View File

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

8
kernel/amd64/tss.c
View File

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

4
kernel/amd64/tss.h
View File

@@ -13,8 +13,8 @@ struct tss {
uint64_t resv2;
uint16_t resv3;
uint16_t iopb_off;
} __attribute__((packed));
} __attribute__ ((packed));
volatile struct tss *amd64_get_tss(void);
volatile struct tss* amd64_get_tss (void);
#endif // _KERNEL_AMD64_TSS_H

4
kernel/libk/align.h
View File

@@ -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_up(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
#define align_down(x, a) ((x) & ~((a) - 1))
#define align_up(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
#endif // _KERNEL_LIBK_ALIGN_H

34
kernel/libk/bm.c
View File

@@ -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;
}

16
kernel/libk/bm.h
View File

@@ -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_set(struct bm *bm, size_t k);
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_region(struct bm *bm, size_t k, size_t m);
bool bm_test(struct bm *bm, size_t k);
bool bm_test_region(struct bm *bm, size_t k, size_t m);
void bm_init (struct bm* bm, uint8_t* base, size_t nbits);
void bm_set (struct bm* bm, size_t k);
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_region (struct bm* bm, size_t k, size_t m);
bool bm_test (struct bm* bm, size_t k);
bool bm_test_region (struct bm* bm, size_t k, size_t m);
#endif // _KERNEL_LIBK_BM_H

3
kernel/libk/putchar_.c
View File

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

2
kernel/libk/std.h
View File

@@ -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

30
kernel/libk/string.c
View File

@@ -1,17 +1,17 @@
#include <libk/std.h>
#include <libk/string.h>
size_t memset(void *dst, uint8_t b, size_t n) {
uint8_t *dst1 = dst;
size_t memset (void* dst, uint8_t b, size_t n) {
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) {
uint8_t *dst1 = dst;
const uint8_t *src1 = src;
size_t memcpy (void* dst, const void* src, size_t n) {
uint8_t* dst1 = dst;
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) {
size_t i = 0;
while(i++ != n && (*dst++ = *src++));
void strncpy (char* dst, const char* src, size_t n) {
size_t i = 0;
while (i++ != n && (*dst++ = *src++))
;
}
size_t strlen(const char *str) {
const char *s;
for (s = str; *s; ++s);
size_t strlen (const char* str) {
const char* s;
for (s = str; *s; ++s)
;
return (s - str);
}
int memcmp(const void *s1, const void *s2, size_t n) {
unsigned char *p = (unsigned char *)s1;
unsigned char *q = (unsigned char *)s2;
int memcmp (const void* s1, const void* s2, size_t n) {
unsigned char* p = (unsigned char*)s1;
unsigned char* q = (unsigned char*)s2;
while (n--) {
if (*p != *q) {

10
kernel/libk/string.h
View File

@@ -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 memcpy(void *dst, const void *src, size_t n);
void strncpy(char* dst, const char* src, size_t n);
size_t strlen(const char *str);
int memcmp(const void *s1, const void *s2, 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);
void strncpy (char* dst, const char* src, size_t n);
size_t strlen (const char* str);
int memcmp (const void* s1, const void* s2, size_t n);
#endif // _KERNEL_LIBK_STRING_H

30
kernel/limine/requests.c
View File

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

10
kernel/limine/requests.h
View File

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

775
kernel/mm/liballoc.c
View File

@@ -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) {
spin_lock(&_liballoc_lock);
int liballoc_lock (void) {
spin_lock (&_liballoc_lock);
return 0;
}
int liballoc_unlock(void) {
spin_unlock(&_liballoc_lock);
int liballoc_unlock (void) {
spin_unlock (&_liballoc_lock);
return 0;
}
void *liballoc_alloc(int pages) {
physaddr_t p_addr = pmm_alloc(pages);
void* liballoc_alloc (int 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) {
struct limine_hhdm_response *hhdm = limine_hhdm_request.response;
int liballoc_free (void* ptr, int pages) {
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 MAXCOMPLETE 5
#define MAXEXP 32
#define MINEXP 8
#define LIBALLOC_MAGIC 0xc001c0de
#define MAXCOMPLETE 5
#define MAXEXP 32
#define MINEXP 8
#define MODE_BEST 0
#define MODE_INSTANT 1
#define MODE_BEST 0
#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
int l_completePages[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
#ifdef DEBUG
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_allocated = 0; //< The real amount of memory allocated.
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_pageSize = 4096; //< Individual page size
static int l_pageCount = 16; //< Minimum number of pages to allocate.
static int l_initialized = 0; //< Flag to indicate initialization.
static int l_pageSize = 4096; //< Individual page size
static int l_pageCount = 16; //< Minimum number of pages to allocate.
// *********** HELPER FUNCTIONS *******************************
@@ -81,495 +77,456 @@ 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 )
{
if ( size < (1<<MINEXP) )
{
#ifdef DEBUG
printf("getexp returns -1 for %i less than MINEXP\n", size );
#endif
return -1; // Smaller than the quantum.
}
int shift = MINEXP;
static inline int getexp (unsigned int size) {
if (size < (1 << MINEXP)) {
#ifdef DEBUG
printf ("getexp returns -1 for %i less than MINEXP\n", size);
#endif
return -1; // Smaller than the quantum.
}
while ( shift < MAXEXP )
{
if ( (1<<shift) > size ) break;
shift += 1;
}
int shift = MINEXP;
#ifdef DEBUG
printf("getexp returns %i (%i bytes) for %i size\n", shift - 1, (1<<(shift -1)), size );
#endif
while (shift < MAXEXP) {
if ((1 << shift) > size)
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)
{
size_t i;
for ( i = 0; i < n ; i++)
((char*)s)[i] = c;
return s;
return s;
}
static void* liballoc_memcpy(void* s1, const void* s2, size_t n)
{
char *cdest;
char *csrc;
unsigned int *ldest = (unsigned int*)s1;
unsigned int *lsrc = (unsigned int*)s2;
static void* liballoc_memcpy (void* s1, const void* s2, size_t n) {
char* cdest;
char* csrc;
unsigned int* ldest = (unsigned int*)s1;
unsigned int* lsrc = (unsigned int*)s2;
while ( n >= sizeof(unsigned int) )
{
*ldest++ = *lsrc++;
n -= sizeof(unsigned int);
while (n >= sizeof (unsigned int)) {
*ldest++ = *lsrc++;
n -= sizeof (unsigned int);
}
cdest = (char*)ldest;
csrc = (char*)lsrc;
while ( n > 0 )
{
*cdest++ = *csrc++;
n -= 1;
csrc = (char*)lsrc;
while (n > 0) {
*cdest++ = *csrc++;
n -= 1;
}
return s1;
}
#ifdef DEBUG
static void dump_array()
{
int i = 0;
struct boundary_tag *tag = NULL;
static void dump_array () {
int i = 0;
struct boundary_tag* tag = NULL;
printf("------ Free pages array ---------\n");
printf("System memory allocated: %i\n", l_allocated );
printf("Memory in used (malloc'ed): %i\n", l_inuse );
printf ("------ Free pages array ---------\n");
printf ("System memory allocated: %i\n", l_allocated);
printf ("Memory in used (malloc'ed): %i\n", l_inuse);
for ( i = 0; i < MAXEXP; 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");
}
for (i = 0; i < MAXEXP; i++) {
printf ("%.2i(%i): ", i, l_completePages[i]);
printf("'*' denotes a split to the left/right of a tag\n");
fflush( stdout );
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");
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 )
{
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 ];
}
tag->index = 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 )
{
if ( l_freePages[ tag->index ] == tag ) l_freePages[ tag->index ] = tag->next;
static inline void remove_tag (struct boundary_tag* tag) {
if (l_freePages[tag->index] == tag)
l_freePages[tag->index] = tag->next;
if ( tag->prev != NULL ) tag->prev->next = tag->next;
if ( tag->next != NULL ) tag->next->prev = tag->prev;
if (tag->prev != NULL)
tag->prev->next = tag->next;
if (tag->next != NULL)
tag->next->prev = tag->prev;
tag->next = NULL;
tag->prev = NULL;
tag->index = -1;
tag->next = NULL;
tag->prev = NULL;
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 )
{
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;
left->real_size += tag->real_size;
left->split_right = tag->split_right;
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 )
{
struct boundary_tag *right = tag->split_right;
remove_tag (right); // Remove right from free pages.
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;
if ( right->split_right != NULL )
right->split_right->split_left = tag;
return tag;
return tag;
}
static inline struct boundary_tag* split_tag( struct boundary_tag* tag )
{
unsigned int remainder = 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;
static inline struct boundary_tag* split_tag (struct boundary_tag* tag) {
unsigned int remainder =
tag->real_size - sizeof (struct boundary_tag) - tag->size;
new_tag->next = NULL;
new_tag->prev = NULL;
new_tag->split_left = tag;
new_tag->split_right = tag->split_right;
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;
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;
new_tag->prev = NULL;
new_tag->split_left = tag;
new_tag->split_right = tag->split_right;
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 )
{
unsigned int pages;
unsigned int usage;
struct boundary_tag *tag;
// Make sure it's >= the minimum size.
if (pages < (unsigned int)l_pageCount)
pages = l_pageCount;
// This is how much space is required.
usage = size + sizeof(struct boundary_tag);
tag = (struct boundary_tag*)liballoc_alloc (pages);
// Perfect amount of space
pages = usage / l_pageSize;
if ( (usage % l_pageSize) != 0 ) pages += 1;
if (tag == NULL)
return NULL; // uh oh, we ran out of memory.
// Make sure it's >= the minimum size.
if ( pages < (unsigned int)l_pageCount ) pages = l_pageCount;
tag->magic = LIBALLOC_MAGIC;
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.
tag->magic = LIBALLOC_MAGIC;
tag->size = size;
tag->real_size = pages * l_pageSize;
tag->index = -1;
#ifdef DEBUG
printf ("Resource allocated %x of %i pages (%i bytes) for %i size.\n", tag,
pages, pages * l_pageSize, size);
tag->next = NULL;
tag->prev = NULL;
tag->split_left = NULL;
tag->split_right = NULL;
l_allocated += pages * l_pageSize;
printf ("Total memory usage = %i KB\n", (int)((l_allocated / (1024))));
#endif
#ifdef DEBUG
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;
return tag;
}
void* malloc (size_t size) {
int index;
void* ptr;
struct boundary_tag* tag = NULL;
liballoc_lock ();
void *malloc(size_t size)
{
int index;
void *ptr;
struct boundary_tag *tag = NULL;
if (l_initialized == 0) {
#ifdef DEBUG
printf ("%s\n", "liballoc initializing.");
#endif
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 )
{
#ifdef DEBUG
printf("%s\n","liballoc initializing.");
#endif
for ( index = 0; index < MAXEXP; index++ )
{
l_freePages[index] = NULL;
l_completePages[index] = 0;
}
l_initialized = 1;
}
// Find one big enough.
tag = l_freePages[index]; // Start at the front of the list.
while (tag != NULL) {
// If there's enough space in this tag.
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;
}
index = getexp( size ) + MODE;
if ( index < MINEXP ) index = MINEXP;
tag = tag->next;
}
// Find one big enough.
tag = l_freePages[ index ]; // Start at the front of the list.
while ( tag != NULL )
{
// If there's enough space in this tag.
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;
}
// No page found. Make one.
if (tag == NULL) {
if ((tag = allocate_new_tag (size)) == NULL) {
liballoc_unlock ();
return NULL;
}
tag = tag->next;
}
index = getexp (tag->real_size - sizeof (struct boundary_tag));
} else {
remove_tag (tag);
// No page found. Make one.
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))
l_completePages[index] -= 1;
}
if ( (tag->split_left == NULL) && (tag->split_right == NULL) )
l_completePages[ index ] -= 1;
}
// We have a free page. Remove it from the free pages list.
tag->size = size;
// We have a free page. Remove it from the free pages list.
// Removed... see if we can re-use the excess space.
tag->size = size;
#ifdef DEBUG
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
// Removed... see if we can re-use the excess space.
if ( ((int)(remainder) > 0) /*&& ( (tag->real_size - remainder) >= (1<<MINEXP))*/ )
{
int childIndex = getexp( remainder );
if ( childIndex >= 0 )
{
#ifdef DEBUG
printf("Seems to be splittable: %i >= 2^%i .. %i\n", remainder, childIndex, (1<<childIndex) );
#endif
#ifdef DEBUG
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
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
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 );
#endif
}
}
if (childIndex >= 0) {
#ifdef DEBUG
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
l_inuse += size;
printf("malloc: %x, %i, %i\n", ptr, (int)l_inuse / 1024, (int)l_allocated / 1024 );
dump_array();
#endif
#ifdef DEBUG
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);
#endif
}
}
ptr = (void*)((uintptr_t)tag + sizeof (struct boundary_tag));
liballoc_unlock();
return ptr;
#ifdef DEBUG
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)
{
int index;
struct boundary_tag *tag;
if (tag->magic != LIBALLOC_MAGIC) {
liballoc_unlock (); // release the lock
return;
}
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 ));
if ( tag->magic != LIBALLOC_MAGIC )
{
liballoc_unlock(); // release the lock
return;
}
// MELT RIGHT...
while ((tag->split_right != NULL) && (tag->split_right->index >= 0)) {
#ifdef DEBUG
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
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
l_inuse -= tag->size;
printf("free: %x, %i, %i\n", ptr, (int)l_inuse / 1024, (int)l_allocated / 1024 );
#endif
if ((tag->real_size % l_pageSize) != 0)
pages += 1;
if (pages < (unsigned int)l_pageCount)
pages = l_pageCount;
// 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 );
}
liballoc_free (tag, pages);
// MELT RIGHT...
while ( (tag->split_right != NULL) && (tag->split_right->index >= 0) )
{
#ifdef DEBUG
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
tag = absorb_right( tag );
}
#ifdef DEBUG
l_allocated -= pages * l_pageSize;
printf ("Resource freeing %x of %i pages\n", tag, pages);
dump_array ();
#endif
// 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) )
{
liballoc_unlock ();
return;
}
if ( l_completePages[ index ] == MAXCOMPLETE )
{
// Too many standing by to keep. Free this one.
unsigned int pages = tag->real_size / l_pageSize;
l_completePages[index] += 1; // Increase the count of complete pages.
}
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
l_allocated -= pages * l_pageSize;
printf("Resource freeing %x of %i pages\n", tag, pages );
dump_array();
#endif
#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();
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();
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)
{
int real_size;
void *p;
liballoc_memset (p, 0, real_size);
real_size = nobj * size;
p = malloc( real_size );
liballoc_memset( p, 0, real_size );
return p;
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)
{
void *ptr;
struct boundary_tag *tag;
int real_size;
if ( size == 0 )
{
free( p );
return NULL;
}
if ( p == NULL ) return malloc( size );
if (&liballoc_lock != NULL)
liballoc_lock (); // lockit
tag = (struct boundary_tag*)((uintptr_t)p - sizeof (struct boundary_tag));
real_size = tag->size;
if (&liballoc_unlock != NULL)
liballoc_unlock ();
if ( &liballoc_lock != NULL ) liballoc_lock(); // lockit
tag = (struct boundary_tag*)((uintptr_t)p - sizeof( struct boundary_tag ));
real_size = tag->size;
if ( &liballoc_unlock != NULL ) liballoc_unlock();
if ((size_t)real_size > size)
real_size = size;
if ( (size_t)real_size > size ) real_size = size;
ptr = malloc (size);
liballoc_memcpy (ptr, p, real_size);
free (p);
ptr = malloc( size );
liballoc_memcpy( ptr, p, real_size );
free( p );
return ptr;
return ptr;
}

53
kernel/mm/liballoc.h
View File

@@ -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
#define NULL 0
#ifndef NULL
#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
{
unsigned int magic; //< It's a kind of ...
unsigned int size; //< Requested size.
unsigned int real_size; //< Actual size.
int index; //< Location in the page table.
struct boundary_tag {
unsigned int magic; //< It's a kind of ...
unsigned int size; //< Requested size.
unsigned int real_size; //< Actual size.
int index; //< Location in the page table.
struct boundary_tag *split_left; //< Linked-list info for broken pages.
struct boundary_tag *split_right; //< The same.
struct boundary_tag *next; //< Linked list info.
struct boundary_tag *prev; //< Linked list info.
struct boundary_tag* split_left; //< Linked-list info for broken pages.
struct boundary_tag* split_right; //< The same.
struct boundary_tag* next; //< 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);
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.
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.
#ifdef __cplusplus
}
#endif
#endif

97
kernel/mm/pmm.c
View File

@@ -1,52 +1,51 @@
#include <libk/std.h>
#include <libk/bm.h>
#include <libk/string.h>
#include <libk/align.h>
#include <sys/mm.h>
#include <sys/debug.h>
#include <sync/spin_lock.h>
#include <mm/types.h>
#include <mm/pmm.h>
#include <libk/bm.h>
#include <libk/std.h>
#include <libk/string.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) {
memset(&pmm, 0, sizeof(pmm));
void pmm_init (void) {
memset (&pmm, 0, sizeof (pmm));
struct limine_memmap_response *memmap = limine_memmap_request.response;
struct limine_hhdm_response *hhdm = limine_hhdm_request.response;
struct limine_memmap_response* memmap = limine_memmap_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];
static const char *entry_strings[] = {
"usable", "reserved", "acpi reclaimable", "acpi nvs",
"bad memory", "bootloader reclaimable", "executable and modules",
"framebuffer", "acpi tables"
};
struct limine_memmap_entry* entry = memmap->entries[i];
static const char* entry_strings[] = {"usable", "reserved",
"acpi reclaimable", "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);
physaddr_t start = align_up(entry->base, PAGE_SIZE);
size_t size = align_down (entry->length, 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 +56,22 @@ void pmm_init(void) {
if (final_pages < max_pages) {
bm_nbits = final_pages;
bm_size = align_up(bm_nbits, 8) / 8;
data_base = align_up(bm_base + bm_size, PAGE_SIZE);
bm_size = align_up (bm_nbits, 8) / 8;
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_clear_region(&pmm_region->bm, 0, bm_nbits);
bm_init (&pmm_region->bm, bm_base1, bm_nbits);
bm_clear_region (&pmm_region->bm, 0, bm_nbits);
pmm_region->flags |= PMM_REGION_ACTIVE; /* mark as active */
region++;
}
}
@@ -82,9 +81,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 +94,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);
spin_unlock(&pmm_region->lock);
bm_set_region (&pmm_region->bm, bit, nblks);
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);
bm_clear_region(&pmm_region->bm, bit, nblks);
spin_lock (&pmm_region->lock);
spin_unlock(&pmm_region->lock);
bm_clear_region (&pmm_region->bm, bit, nblks);
spin_unlock (&pmm_region->lock);
break;
}

14
kernel/mm/pmm.h
View File

@@ -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);
physaddr_t pmm_alloc(size_t nblks);
void pmm_free(physaddr_t p_addr, size_t nblks);
void pmm_init (void);
physaddr_t pmm_alloc (size_t nblks);
void pmm_free (physaddr_t p_addr, size_t nblks);
#endif // _KERNEL_MM_PMM_H

12
kernel/sync/spin_lock.c
View File

@@ -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) {
while (atomic_flag_test_and_set_explicit(sl, memory_order_acquire))
spin_lock_relax();
void spin_lock (spin_lock_t* sl) {
while (atomic_flag_test_and_set_explicit (sl, memory_order_acquire))
spin_lock_relax ();
}
void spin_unlock(spin_lock_t *sl) {
atomic_flag_clear_explicit(sl, memory_order_release);
void spin_unlock (spin_lock_t* sl) {
atomic_flag_clear_explicit (sl, memory_order_release);
}

6
kernel/sync/spin_lock.h
View File

@@ -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_unlock(spin_lock_t *sl);
void spin_lock (spin_lock_t* sl);
void spin_unlock (spin_lock_t* sl);
#endif // _KERNEL_SYNC_SPIN_LOCK_H

9
kernel/sys/debug.h
View File

@@ -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 { \
debugprintf("%s: " fmt, __func__, ##__VA_ARGS__); \
} while(0)
#define DEBUG(fmt, ...) \
do { \
debugprintf ("%s: " fmt, __func__, ##__VA_ARGS__); \
} while (0)
#endif // _KERNEL_SYS_DEBUG_H

2
kernel/sys/mm.h
View File

@@ -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

2
kernel/sys/spin_lock.h
View File

@@ -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

59
kernel/uACPI/platform_mop3.c
View File

@@ -1,49 +1,48 @@
#include <libk/std.h>
#include <sys/debug.h>
#include <mm/liballoc.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;
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);
*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* 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);
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_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;
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;
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);
DEBUG ("%s %s", prefix, msg);
}