thomas/mittos65
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Formating tweaks overall

Browse Source
This commit is contained in:
Thomas Lovén 2022-01-18 13:42:01 +01:00
parent 8dd5e81399
commit ba85d9337d
30 changed files with 930 additions and 825 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/settings.json vendored
View File

@ -10,6 +10,6 @@
"**/*.d": true,
},
"C_Cpp.default.includePath": ["src/kernel/include"],
"C_Cpp.default.cStandard": "c2x",
"C_Cpp.default.includePath": ["src/kernel/include", "sysroot/usr/include"],
"C_Cpp.default.cStandard": "c17",
}

67
src/kernel/boot/TEMP-test_scheduler.c
View File

@ -9,42 +9,51 @@ extern gfx_context kernel_fb;
int *position = (void *)0x20000;
void thread1() {
int a = 1;
gfx_context *ctx = framebuffer_make_subcontext(&kernel_fb, 700, 300, 100, 100);
while(1) {
putCharacter(term_fb, *position, *position, RGB(255,255,0), RGB(0,0,0), '0'+(a++%10));
flip(term_fb);
draw_line(ctx, 0, 100, 50, ((a-1)%100), RGB(0,0,0));
draw_line(ctx, 0, 100, 50, (a%100), RGB(255,0,0));
flip(ctx);
sched_yield();
}
int a = 1;
gfx_context *ctx =
framebuffer_make_subcontext(&kernel_fb, 700, 300, 100, 100);
while(1) {
putCharacter(term_fb,
*position, *position,
RGB(255,255,0), RGB(0,0,0),
'0'+(a++%10)
);
flip(term_fb);
draw_line(ctx, 0, 100, 50, ((a-1)%100), RGB(0,0,0));
draw_line(ctx, 0, 100, 50, (a%100), RGB(255,0,0));
flip(ctx);
sched_yield();
}
}
void thread2() {
int a = 0;
while(1) {
putCharacter(term_fb, *position, *position, RGB(0,255,255), RGB(0,0,0), 'A'+(a++%10));
flip(term_fb);
sched_yield();
}
int a = 0;
while(1) {
putCharacter(term_fb,
*position, *position,
RGB(0,255,255), RGB(0,0,0),
'A'+(a++%10)
);
flip(term_fb);
sched_yield();
}
}
void TEMP_test_scheduler() {
struct process *th1 = new_process(thread1);
scheduler_insert(th1);
struct process *th1 = new_process(thread1);
scheduler_insert(th1);
struct process *th2 = new_process(thread2);
scheduler_insert(th2);
struct process *th2 = new_process(thread2);
scheduler_insert(th2);
uint64_t p1 = pmm_alloc();
uint64_t p2 = pmm_alloc();
vmm_set_page(th1->P4, 0x20000, p1, PAGE_PRESENT);
vmm_set_page(th2->P4, 0x20000, p2, PAGE_PRESENT);
// Write different values into the position variable for the two processes
int *a = P2V(p1);
*a = 20;
a = P2V(p2);
*a = 70;
uint64_t p1 = pmm_alloc();
uint64_t p2 = pmm_alloc();
vmm_set_page(th1->P4, 0x20000, p1, PAGE_PRESENT);
vmm_set_page(th2->P4, 0x20000, p2, PAGE_PRESENT);
// Write different values into the position variable for the two processes
int *a = P2V(p1);
*a = 20;
a = P2V(p2);
*a = 70;
}

55
src/kernel/boot/kmain.c
View File

@ -15,45 +15,46 @@ struct kernel_boot_data_st kernel_boot_data;
registers *kbd_handler(registers *r)
{
while(inb(0x64) & 0x2);
uint8_t scancode = inb(0x60);
debug("Keyboard: %x\n", scancode);
irq_ack();
return r;
while(inb(0x64) & 0x2);
uint8_t scancode = inb(0x60);
debug("Keyboard: %x\n", scancode);
irq_ack();
return r;
}
void kmain(uint64_t multiboot_magic, void *multiboot_data) {
musl_init();
debug_info("Started kernel\n");
multiboot_init(multiboot_magic, P2V(multiboot_data));
debug_info("Kernel loaded with command line: \"%s\" by <%s>\n",
kernel_boot_data.commandline,
kernel_boot_data.bootloader);
musl_init();
debug_info("Started kernel\n");
multiboot_init(multiboot_magic, P2V(multiboot_data));
debug_info("Kernel loaded with command line: \"%s\" by <%s>\n",
kernel_boot_data.commandline,
kernel_boot_data.bootloader
);
early_cpu_init();
debug_info("Set up boot CPU\n");
memory_init();
debug_info("Set up memory management\n");
early_cpu_init();
debug_info("Set up boot CPU\n");
memory_init();
debug_info("Set up memory management\n");
terminal_init();
debug_info("Set up debug terminal\n");
terminal_init();
debug_info("Set up debug terminal\n");
cpu_init();
cpu_init();
__asm__("sti");
__asm__("sti");
debug_info("Boot complete\n");
debug_info("Boot complete\n");
bind_interrupt(IRQ_INTERRUPT(IRQ_PS2_KBD), kbd_handler);
irq_unmask(IRQ_PS2_KBD);
TEMP_test_scheduler();
bind_interrupt(IRQ_INTERRUPT(IRQ_PS2_KBD), kbd_handler);
irq_unmask(IRQ_PS2_KBD);
TEMP_test_scheduler();
start_scheduler();
start_scheduler();
PANIC("End of kernel function!");
PANIC("End of kernel function!");
debug_info("Broke out of panic");
for(;;);
debug_info("Broke out of panic");
for(;;);
}

165
src/kernel/boot/multiboot.c
View File

@ -8,106 +8,119 @@
// https://www.gnu.org/software/grub/manual/multiboot2/multiboot.html
struct taglist {
uint32_t total_size;
uint32_t reserved;
uint32_t total_size;
uint32_t reserved;
}__attribute__((packed));
struct tag {
uint32_t type;
uint32_t size;
uint8_t data[];
uint32_t type;
uint32_t size;
uint8_t data[];
}__attribute__((packed));
struct mmap_entry {
uint64_t base;
uint64_t len;
uint32_t type;
uint32_t reserved;
uint64_t base;
uint64_t len;
uint32_t type;
uint32_t reserved;
}__attribute__((packed));
struct mmap {
uint32_t entry_size;
uint32_t entry_version;
struct mmap_entry entries[];
uint32_t entry_size;
uint32_t entry_version;
struct mmap_entry entries[];
}__attribute__((packed));
static int parse_multiboot2(struct taglist *tags) {
struct mmap *mmap;
struct mmap *mmap;
struct tag *tag = incptr(tags, sizeof(struct taglist));
kernel_boot_data.mboot_tags = tag;
kernel_boot_data.tags_length = tags->total_size;
while(tag->type) {
switch(tag->type) {
case MBOOT2_TAG_BOOTLOADER:
kernel_boot_data.bootloader = (char *)tag->data;
break;
case MBOOT2_TAG_CMDLINE:
kernel_boot_data.commandline = (char *)tag->data;
break;
case MBOOT2_TAG_MMAP:
mmap = kernel_boot_data.mmap = (void *)tag->data;
kernel_boot_data.mmap_len = (tag->size - 8)/mmap->entry_size;
kernel_boot_data.mmap_size = (tag->size - 8);
break;
case MBOOT2_TAG_FBINFO:
kernel_boot_data.fbinfo = (void *)tag->data;
break;
case MBOOT2_TAG_OLD_RSDP:
case MBOOT2_TAG_NEW_RSDP:
kernel_boot_data.rsdp = (void *)tag->data;
break;
}
// Tags are 8 byte alligned, so make sure we look for the next one in the right place
int padded_size = tag->size + ((tag->size % 8)?(8-(tag->size%8)):0);
tag = incptr(tag, padded_size);
struct tag *tag = incptr(tags, sizeof(struct taglist));
kernel_boot_data.mboot_tags = tag;
kernel_boot_data.tags_length = tags->total_size;
while(tag->type) {
switch(tag->type) {
case MBOOT2_TAG_BOOTLOADER:
kernel_boot_data.bootloader = (char *)tag->data;
break;
case MBOOT2_TAG_CMDLINE:
kernel_boot_data.commandline = (char *)tag->data;
break;
case MBOOT2_TAG_MMAP:
mmap = kernel_boot_data.mmap = (void *)tag->data;
kernel_boot_data.mmap_len = (tag->size - 8)/mmap->entry_size;
kernel_boot_data.mmap_size = (tag->size - 8);
break;
case MBOOT2_TAG_FBINFO:
kernel_boot_data.fbinfo = (void *)tag->data;
break;
case MBOOT2_TAG_OLD_RSDP:
case MBOOT2_TAG_NEW_RSDP:
kernel_boot_data.rsdp = (void *)tag->data;
break;
}
return 0;
// Tags are 8 byte alligned, so make sure we look for the next one
// in the right place
int padded_size = tag->size + ((tag->size % 8)?(8-(tag->size%8)):0);
tag = incptr(tag, padded_size);
}
return 0;
}
int multiboot_init(uint64_t magic, void *mboot_info) {
if(magic == MBOOT2_REPLY) {
kernel_boot_data.multiboot_version = 2;
parse_multiboot2(mboot_info);
} else {
return 1;
}
if(magic == MBOOT2_REPLY) {
kernel_boot_data.multiboot_version = 2;
parse_multiboot2(mboot_info);
} else {
return 1;
}
return 0;
return 0;
}
int multiboot_get_memory_area(size_t index, uintptr_t *start, uintptr_t *end, uint32_t *type) {
if(index >= kernel_boot_data.mmap_len) return 1;
int multiboot_get_memory_area(
size_t index,
uintptr_t *start,
uintptr_t *end,
uint32_t *type
) {
if(index >= kernel_boot_data.mmap_len) return 1;
struct mmap *mmap = kernel_boot_data.mmap;
struct mmap_entry *entry = mmap->entries;
entry = incptr(entry, index*mmap->entry_size);
struct mmap *mmap = kernel_boot_data.mmap;
struct mmap_entry *entry = mmap->entries;
entry = incptr(entry, index*mmap->entry_size);
*start = entry->base;
*end = entry->base + entry->len;
*type = entry->type;
return 0;
*start = entry->base;
*end = entry->base + entry->len;
*type = entry->type;
return 0;
}
int multiboot_page_used(uintptr_t page) {
#define within_page(st, l) (((uintptr_t)st + l) > page && (uintptr_t)st < (page + PAGE_SIZE))
#define within_page(st, l) (((uintptr_t)st + l) > page && \
(uintptr_t)st < (page + PAGE_SIZE))
size_t fb_size = 0;
uintptr_t fb_start = 0;
if(kernel_boot_data.fbinfo) {
fb_start = kernel_boot_data.fbinfo->framebuffer_addr;
fb_size = kernel_boot_data.fbinfo->framebuffer_pitch*(kernel_boot_data.fbinfo->framebuffer_height + 1);
}
if(
within_page(kernel_boot_data.mboot_tags, kernel_boot_data.tags_length) ||
within_page(kernel_boot_data.bootloader, strlen(kernel_boot_data.bootloader)) ||
within_page(kernel_boot_data.commandline, strlen(kernel_boot_data.commandline)) ||
within_page(kernel_boot_data.mmap, kernel_boot_data.mmap_size) ||
within_page(fb_start, fb_size) ||
0
) {
return 1;
}
return 0;
size_t fb_size = 0;
uintptr_t fb_start = 0;
if(kernel_boot_data.fbinfo) {
fb_start = kernel_boot_data.fbinfo->framebuffer_addr;
fb_size = kernel_boot_data.fbinfo->framebuffer_pitch *
(kernel_boot_data.fbinfo->framebuffer_height + 1);
}
if(
within_page(kernel_boot_data.mboot_tags,
kernel_boot_data.tags_length
) ||
within_page(kernel_boot_data.bootloader,
strlen(kernel_boot_data.bootloader)
) ||
within_page(kernel_boot_data.commandline,
strlen(kernel_boot_data.commandline)
) ||
within_page(kernel_boot_data.mmap, kernel_boot_data.mmap_size) ||
within_page(fb_start, fb_size) ||
0) {
return 1;
}
return 0;
}

145
src/kernel/cpu/acpi.c
View File

@ -4,22 +4,23 @@
#include <string.h>
#include <debug.h>
// ACPI Specification https://uefi.org/sites/default/files/resources/ACPI_6_3_final_Jan30.pdf
// ACPI Specification:
// https://uefi.org/sites/default/files/resources/ACPI_6_3_final_Jan30.pdf
struct rsdp { // 5.2.5.3
char signature[8];
uint8_t checksum;
char OEMID[6];
uint8_t revision;
uint32_t rsdt_p;
uint8_t _[14]; // Fields for revision >= 2
char signature[8];
uint8_t checksum;
char OEMID[6];
uint8_t revision;
uint32_t rsdt_p;
uint8_t _[14]; // Fields for revision >= 2
}__attribute__((packed));
struct sdt {
char signature[4];
uint32_t length;
uint8_t _[28];
uint32_t data[];
char signature[4];
uint32_t length;
uint8_t _[28];
uint32_t data[];
}__attribute__((packed));
@ -29,83 +30,79 @@ struct sdt {
#define MADT_TYPE_ISO 2
struct madt_field {
uint8_t type;
uint8_t length;
union {
// Processor Local APIC (5.2.12.2)
struct {
uint8_t id;
uint8_t apic;
uint32_t flags;
}__attribute__((packed)) lapic;
// I/O APIC (5.2.12.3)
struct {
uint8_t id;
uint8_t reserved;
uint32_t address;
uint32_t base;
}__attribute__((packed)) ioapic;
// Interrupt source override (5.2.12.5)
struct {
uint8_t bus;
uint8_t source;
uint32_t interrupt;
uint16_t flags;
}__attribute__((packed)) iso;
};
uint8_t type;
uint8_t length;
union {
struct { // Processor Local APIC (5.2.12.2)
uint8_t id;
uint8_t apic;
uint32_t flags;
}__attribute__((packed)) lapic;
struct { // I/O APIC (5.2.12.3)
uint8_t id;
uint8_t reserved;
uint32_t address;
uint32_t base;
}__attribute__((packed)) ioapic;
struct { // Interrupt source override (5.2.12.5)
uint8_t bus;
uint8_t source;
uint32_t interrupt;
uint16_t flags;
}__attribute__((packed)) iso;
};
}__attribute__((packed));
struct madt_header {
uint32_t controllerAddress;
uint32_t flags;
struct madt_field fields[];
uint32_t controllerAddress;
uint32_t flags;
struct madt_field fields[];
}__attribute__((packed));
static void madt_parse(struct madt_header *madt, size_t length)
{
int cpu_i=0;
for(
struct madt_field *f = madt->fields;
(size_t)f <= (size_t)madt + length;
f = incptr(f, f->length)
) {
switch(f->type) {
case MADT_TYPE_LAPIC: {
struct cpu *cpu = P2V(pmm_alloc());
cpus[cpu_i++] = cpu;
cpu->id = f->lapic.id;
cpu->apic_id = f->lapic.apic;
cpu->flags = f->lapic.flags;
break;
}
case MADT_TYPE_IOAPIC: {
ioapic.id = f->ioapic.id;
ioapic.addr = f->ioapic.address;
ioapic.base = f->ioapic.base;
break;
}
case MADT_TYPE_ISO: {
irq_redirects[f->iso.source] = f->iso.interrupt;
break;
}
default:
}
int cpu_i=0;
for(struct madt_field *f = madt->fields;
(size_t)f <= (size_t)madt + length;
f = incptr(f, f->length)
) {
switch(f->type) {
case MADT_TYPE_LAPIC: {
struct cpu *cpu = P2V(pmm_alloc());
cpus[cpu_i++] = cpu;
cpu->id = f->lapic.id;
cpu->apic_id = f->lapic.apic;
cpu->flags = f->lapic.flags;
break;
}
case MADT_TYPE_IOAPIC: {
ioapic.id = f->ioapic.id;
ioapic.addr = f->ioapic.address;
ioapic.base = f->ioapic.base;
break;
}
case MADT_TYPE_ISO: {
irq_redirects[f->iso.source] = f->iso.interrupt;
break;
}
default:
}
}
}
void acpi_parse(void *_rsdp) {
struct rsdp *rsdp = _rsdp;
struct rsdp *rsdp = _rsdp;
struct sdt *rsdt = P2V(rsdp->rsdt_p);
int rsdt_entries = (rsdt->length - sizeof(struct sdt))/sizeof(uint32_t);
struct sdt *rsdt = P2V(rsdp->rsdt_p);
int rsdt_entries = (rsdt->length - sizeof(struct sdt))/sizeof(uint32_t);
for(int i = 0; i < rsdt_entries; i++) {
struct sdt *h = P2V(rsdt->data[i]);
if(h->length == 0) continue;
for(int i = 0; i < rsdt_entries; i++) {
struct sdt *h = P2V(rsdt->data[i]);
if(h->length == 0) continue;
if(!strncmp(h->signature, "APIC", 4)) { // 5.2.12
madt_parse(P2V(h->data), h->length - sizeof(struct sdt));
}
if(!strncmp(h->signature, "APIC", 4)) { // 5.2.12
madt_parse(P2V(h->data), h->length - sizeof(struct sdt));
}
}
}

112
src/kernel/cpu/apic.c
View File

@ -14,82 +14,90 @@
#define IOREDTBL(irq) (0x10 + (irq)*2)
union iored {
struct {
uint8_t vector;
uint8_t flags;
uint8_t mask;
uint32_t reserved;
uint8_t target;
}__attribute__((packed));
struct {
uint32_t l;
uint32_t h;
}__attribute__((packed));
uint64_t val;
struct {
uint8_t vector;
uint8_t flags;
uint8_t mask;
uint32_t reserved;
uint8_t target;
}__attribute__((packed));
struct {
uint32_t l;
uint32_t h;
}__attribute__((packed));
uint64_t val;
};
static uint32_t ioapic_read(int reg) {
uint32_t volatile *ioregsel = P2V(ioapic.addr);
uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
*ioregsel = reg;
return *iowin;
uint32_t volatile *ioregsel = P2V(ioapic.addr);
uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
*ioregsel = reg;
return *iowin;
}
static void ioapic_write(int reg, uint32_t value) {
uint32_t volatile *ioregsel = P2V(ioapic.addr);
uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
*ioregsel = reg;
*iowin = value;
uint32_t volatile *ioregsel = P2V(ioapic.addr);
uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
*ioregsel = reg;
*iowin = value;
}
static uint64_t ioapic_read_redirection(int irq) {
union iored retval;
retval.l = ioapic_read(IOREDTBL(irq));
retval.h = ioapic_read(IOREDTBL(irq)+1);
return retval.val;
union iored retval;
retval.l = ioapic_read(IOREDTBL(irq));
retval.h = ioapic_read(IOREDTBL(irq)+1);
return retval.val;
}
static void ioapic_write_redirection(int irq, uint64_t val) {
union iored value;
value.val = val;
ioapic_write(IOREDTBL(irq), value.l);
ioapic_write(IOREDTBL(irq) + 1, value.h);
union iored value;
value.val = val;
ioapic_write(IOREDTBL(irq), value.l);
ioapic_write(IOREDTBL(irq) + 1, value.h);
}
void irq_ack() {
APIC_REG(APIC_EOI) = 0;
APIC_REG(APIC_EOI) = 0;
}
void irq_mask(int irq) {
union iored iored;
iored.val = ioapic_read_redirection(irq_redirects[irq]);
iored.mask |= 0x1;
ioapic_write_redirection(irq_redirects[irq], iored.val);
union iored iored;
iored.val = ioapic_read_redirection(irq_redirects[irq]);
iored.mask |= 0x1;
ioapic_write_redirection(irq_redirects[irq], iored.val);
}
void irq_unmask(int irq) {
union iored iored;
iored.val = ioapic_read_redirection(irq_redirects[irq]);
iored.mask &= ~0x1;
ioapic_write_redirection(irq_redirects[irq], iored.val);
union iored iored;
iored.val = ioapic_read_redirection(irq_redirects[irq]);
iored.mask &= ~0x1;
ioapic_write_redirection(irq_redirects[irq], iored.val);
}
void ioapic_init() {
// Map ioapic offset into kernel memory
vmm_set_page(kernel_P4, (uintptr_t)P2V(ioapic.addr), ioapic.addr, PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL);
// Map ioapic offset into kernel memory
vmm_set_page(kernel_P4,
(uintptr_t)P2V(ioapic.addr),
ioapic.addr,
PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL
);
union iored iored;
for(int i = 0; i < 24; i++) {
iored.val = ioapic_read_redirection(i);
iored.vector = IRQ_BASE+i;
iored.flags = 0x0;
iored.mask |= 1;
iored.target = 0x0;
ioapic_write_redirection(i, iored.val);
}
union iored iored;
for(int i = 0; i < 24; i++) {
iored.val = ioapic_read_redirection(i);
iored.vector = IRQ_BASE+i;
iored.flags = 0x0;
iored.mask |= 1;
iored.target = 0x0;
ioapic_write_redirection(i, iored.val);
}
}
void apic_init() {
// Map apic offset into kernel memory
vmm_set_page(kernel_P4, (uintptr_t)P2V(APIC_BASE), APIC_BASE, PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL);
// Map apic offset into kernel memory
vmm_set_page(kernel_P4,
(uintptr_t)P2V(APIC_BASE),
APIC_BASE,
PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL
);
// Allow LAPIC to receive interrupts
APIC_REG(APIC_SPURIOUS) = APIC_REG(APIC_SPURIOUS) | 0x100 | IRQ_SPURIOUS;
// Allow LAPIC to receive interrupts
APIC_REG(APIC_SPURIOUS) = APIC_REG(APIC_SPURIOUS) | 0x100 | IRQ_SPURIOUS;
}

22
src/kernel/cpu/cpu.c
View File

@ -4,24 +4,26 @@
struct cpu *cpus[16];
struct ioapic ioapic = {0,0,0};
uint8_t irq_redirects[MAX_IRQS] = \
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
uint8_t irq_redirects[MAX_IRQS] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
};
#define PIC1_ADDR 0x20
#define PIC2_ADDR 0xA0
static void pic_disable() {
// Mask all interrupts
outb(PIC1_ADDR | 1, 0xFF);
outb(PIC2_ADDR | 1, 0xFF);
// Mask all interrupts
outb(PIC1_ADDR | 1, 0xFF);
outb(PIC2_ADDR | 1, 0xFF);
}
void early_cpu_init() {
interrupt_init();
interrupt_init();
}
void cpu_init() {
acpi_parse(kernel_boot_data.rsdp);
pic_disable();
apic_init();
ioapic_init();
acpi_parse(kernel_boot_data.rsdp);
pic_disable();
apic_init();
ioapic_init();
}

12
src/kernel/cpu/gdt.c
View File

@ -6,18 +6,18 @@
#define GDT_LONG (1<<21)
struct gdt {
uint32_t _;
uint32_t flags;
uint32_t _;
uint32_t flags;
}__attribute__((packed));
struct gdtp {
uint16_t len;
struct gdt *gdt;
uint16_t len;
struct gdt *gdt;
}__attribute__((packed));
struct gdt BootGDT[] = {
{0, 0},
{0, GDT_PRESENT | GDT_DPL(0) | GDT_CODE | GDT_LONG}
{0, 0},
{0, GDT_PRESENT | GDT_DPL(0) | GDT_CODE | GDT_LONG}
};
struct gdtp GDTp = {2*8-1, BootGDT};

95
src/kernel/cpu/interrupts.c
View File

@ -11,67 +11,70 @@
#define NUM_INTERRUPTS 256
struct idt {
uint16_t base_l;
uint16_t cs;
uint8_t ist;
uint8_t flags;
uint16_t base_m;
uint32_t base_h;
uint32_t _;
uint16_t base_l;
uint16_t cs;
uint8_t ist;
uint8_t flags;
uint16_t base_m;
uint32_t base_h;
uint32_t _;
}__attribute__((packed)) idt[NUM_INTERRUPTS];
struct {
uint16_t len;
struct idt *addr;
uint16_t len;
struct idt *addr;
}__attribute__((packed)) idtr;
extern uintptr_t isr_table[];
int_handler_t int_handlers[NUM_INTERRUPTS];
void interrupt_init() {
memset(idt, 0, sizeof(idt));
for(int i=0; i < NUM_INTERRUPTS; i++) {
idt[i].base_l = isr_table[i] & 0xFFFF;
idt[i].base_m = (isr_table[i] >> 16) & 0xFFFF;
idt[i].base_h = (isr_table[i] >> 32) & 0xFFFFFFFF;
idt[i].cs = 0x8;
idt[i].ist = 0;
idt[i].flags = IDT_PRESENT | IDT_DPL0 | IDT_INTERRUPT;
}
memset(idt, 0, sizeof(idt));
for(int i=0; i < NUM_INTERRUPTS; i++) {
idt[i].base_l = isr_table[i] & 0xFFFF;
idt[i].base_m = (isr_table[i] >> 16) & 0xFFFF;
idt[i].base_h = (isr_table[i] >> 32) & 0xFFFFFFFF;
idt[i].cs = 0x8;
idt[i].ist = 0;
idt[i].flags = IDT_PRESENT | IDT_DPL0 | IDT_INTERRUPT;
}
idtr.addr = idt;
idtr.len = sizeof(idt)-1;
load_idt(&idtr); // cpu/registers.S
idtr.addr = idt;
idtr.len = sizeof(idt)-1;
load_idt(&idtr); // cpu/registers.S
}
int_handler_t bind_interrupt(uint32_t num, int_handler_t fn) {
int_handler_t old = int_handlers[num];
int_handlers[num] = fn;
return old;
int_handler_t old = int_handlers[num];
int_handlers[num] = fn;
return old;
}
registers *int_handler(registers *r) {
if(int_handlers[r->int_no])
return int_handlers[r->int_no](r);
if(r->int_no < IRQ_BASE) {
debug_error("UNHANDLED EXCEPTION\n");
switch(r->int_no) {
case 14:
debug_error("Page fault\n");
break;
case 6:
debug_error("Invalid opcode\n");
}
debug_error("Interrupt number: %d, Error code: %d\n", r->int_no, r->err_code);
PANIC("Unhandled interrupt\n");
} else if(r->int_no < IRQ_BASE + MAX_IRQS) {
debug_error("UNHANDLED IRQ\n");
debug_error("IRQ: %d", r->int_no - IRQ_BASE);
PANIC("Unhandled IRQ\n");
} else {
debug_error("UNKNOWN INTERRUPT\n");
debug_error("Interrupt number: %d\n", r->int_no);
PANIC("Unknown interrupt\n");
if(int_handlers[r->int_no])
return int_handlers[r->int_no](r);
if(r->int_no < IRQ_BASE) {
debug_error("UNHANDLED EXCEPTION\n");
switch(r->int_no) {
case 14:
debug_error("Page fault\n");
break;
case 6:
debug_error("Invalid opcode\n");
}
return r;
debug_error("Interrupt number: %d, Error code: %d\n",
r->int_no,
r->err_code
);
PANIC("Unhandled interrupt\n");
} else if(r->int_no < IRQ_BASE + MAX_IRQS) {
debug_error("UNHANDLED IRQ\n");
debug_error("IRQ: %d", r->int_no - IRQ_BASE);
PANIC("Unhandled IRQ\n");
} else {
debug_error("UNKNOWN INTERRUPT\n");
debug_error("Interrupt number: %d\n", r->int_no);
PANIC("Unknown interrupt\n");
}
return r;
}

82
src/kernel/drivers/terminal/fbterm.c
View File

@ -8,47 +8,63 @@ gfx_context *term_fb;
static int setup = 0;
void fbterm_movecursor(unsigned int cursor) {
(void) cursor;
(void) cursor;
}
void fbterm_flush(struct vga_cell *buffer) {
if(!setup) return;
int i = 0;
for(int row = 0; row < VGA_ROWS; row++) {
for(int col=0; col < VGA_COLS; col++) {
putCharacter(term_fb, col*8, row*16, 0xebdbb2, 0x282828, (char)buffer[i++].c);
}
if(!setup) return;
int i = 0;
for(int row = 0; row < VGA_ROWS; row++) {
for(int col=0; col < VGA_COLS; col++) {
putCharacter(term_fb,
col*8, row*16,
0xebdbb2, 0x282828,
(char)buffer[i++].c
);
}
flip(term_fb);
}
flip(term_fb);
}
void fbterm_init(struct fbinfo *fbinfo) {
kernel_fb.width = fbinfo->framebuffer_width;
kernel_fb.height = fbinfo->framebuffer_height;
kernel_fb.bpp = fbinfo->framebuffer_bpp/8;
kernel_fb.pitch = fbinfo->framebuffer_pitch/kernel_fb.bpp;
kernel_fb.addr = P2V(fbinfo->framebuffer_addr);
kernel_fb.size = fbinfo->framebuffer_pitch * (kernel_fb.height);
kernel_fb.buffer = calloc(1, kernel_fb.size);
kernel_fb = (gfx_context){
.width = fbinfo->framebuffer_width,
.height = fbinfo->framebuffer_height,
.bpp = fbinfo->framebuffer_bpp/8,
.pitch = fbinfo->framebuffer_pitch/(fbinfo->framebuffer_bpp/8),
.addr = P2V(fbinfo->framebuffer_addr),
.size = fbinfo->framebuffer_pitch * (fbinfo->framebuffer_height),
};
kernel_fb.buffer = calloc(1, kernel_fb.size);
for(
uintptr_t p = (uintptr_t)kernel_fb.addr;
p < ((uintptr_t)kernel_fb.addr + kernel_fb.size);
p += PAGE_SIZE
) {
vmm_set_page(kernel_P4, p, V2P(p), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
}
for(uintptr_t p = (uintptr_t)kernel_fb.addr;
p < ((uintptr_t)kernel_fb.addr + kernel_fb.size);
p += PAGE_SIZE
) {
vmm_set_page(kernel_P4,
p,
V2P(p),
PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
);
}
draw_rect(&kernel_fb, 20, 20, 8*VGA_COLS+8, 16*VGA_ROWS+8, RGB(255, 0, 0));
flip(&kernel_fb);
term_fb = framebuffer_make_subcontext(&kernel_fb, 24, 24, 8*VGA_COLS, 16*VGA_ROWS);
flip(term_fb);
setup = 1;
draw_rect(&kernel_fb,
20, 20,
8*VGA_COLS+8, 16*VGA_ROWS+8,
RGB(255, 0, 0)
);
flip(&kernel_fb);
term_fb = framebuffer_make_subcontext(&kernel_fb,
24, 24,
8*VGA_COLS, 16*VGA_ROWS
);
flip(term_fb);
setup = 1;
draw_line(&kernel_fb, 750, 850, 120, 120, RGB(255,0,0));
draw_line(&kernel_fb, 750, 750, 120, 220, RGB(0,255,0));
draw_line(&kernel_fb, 750, 850, 120, 220, RGB(0,0,255));
draw_line(&kernel_fb, 750, 800, 120, 220, RGB(255,0,255));
draw_line(&kernel_fb, 750, 850, 120, 170, RGB(255,255,0));
flip(&kernel_fb);
draw_line(&kernel_fb, 750, 850, 120, 120, RGB(255,0,0));
draw_line(&kernel_fb, 750, 750, 120, 220, RGB(0,255,0));
draw_line(&kernel_fb, 750, 850, 120, 220, RGB(0,0,255));
draw_line(&kernel_fb, 750, 800, 120, 220, RGB(255,0,255));
draw_line(&kernel_fb, 750, 850, 120, 170, RGB(255,255,0));
flip(&kernel_fb);
}

135
src/kernel/drivers/terminal/terminal.c
View File

@ -20,86 +20,91 @@ uint8_t format = 0x7;
static int terminal_type;
static void scroll() {
while(cursor >= VGA_SIZE) {
memmove(buffer, &buffer[VGA_POS(1,0)], VGA_COLS*(VGA_ROWS-1)*sizeof(struct vga_cell));
memset(&buffer[VGA_POS(VGA_ROWS-1, 0)], 0, VGA_COLS*sizeof(struct vga_cell));
cursor -= VGA_COLS;
}
while(cursor >= VGA_SIZE) {
memmove(buffer,
&buffer[VGA_POS(1,0)],
VGA_COLS*(VGA_ROWS-1)*sizeof(struct vga_cell)
);
memset(&buffer[VGA_POS(VGA_ROWS-1, 0)],
0,
VGA_COLS*sizeof(struct vga_cell)
);
cursor -= VGA_COLS;
}
}
static void terminal_write(char c) {
int doflush = 0;
switch(c) {
case '\n':
cursor += VGA_COLS - VGA_COL(cursor);
doflush = 1;
break;
default:
buffer[cursor++] = (struct vga_cell){.c = c, .f = format};
}
scroll();
switch(terminal_type) {
case FRAMEBUFFER:
if(doflush)
fbterm_flush(buffer);
fbterm_movecursor(cursor);
break;
case EGA_TEXT:
if(doflush)
vga_flush(buffer);
vga_movecursor(cursor);
break;
}
int doflush = 0;
switch(c) {
case '\n':
cursor += VGA_COLS - VGA_COL(cursor);
doflush = 1;
break;
default:
buffer[cursor++] = (struct vga_cell){.c = c, .f = format};
}
scroll();
switch(terminal_type) {
case FRAMEBUFFER:
if(doflush)
fbterm_flush(buffer);
fbterm_movecursor(cursor);
break;
case EGA_TEXT:
if(doflush)
vga_flush(buffer);
vga_movecursor(cursor);
break;
}
}
static void terminal_putsn(char *s, size_t n) {
while(n--)
terminal_write(*s++);
while(n--)
terminal_write(*s++);
}
long k_ioctl(long fd, long cmd, long arg3, long, long, long) {
if(fd == 1 && cmd == 0x5413) {
struct {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xp;
unsigned short ws_yp;
} *wsz = (void *)arg3;
wsz->ws_row = 24;
wsz->ws_col = 80;
return 0;
}
long retval = -1;
PANIC("Unknown IOCTL request: fd: %d, command: %x\n", fd, cmd);
return retval;
if(fd == 1 && cmd == 0x5413) {
struct {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xp;
unsigned short ws_yp;
} *wsz = (void *)arg3;
wsz->ws_row = 24;
wsz->ws_col = 80;
return 0;
}
long retval = -1;
PANIC("Unknown IOCTL request: fd: %d, command: %x\n", fd, cmd);
return retval;
}
long k_writev(long fd, long iov, long iovcnt, long, long, long) {
if(fd == 1)
{
size_t len = 0;
struct iovec *v = (void *) iov;
for(int i = 0; i < iovcnt; i++) {
terminal_putsn(v[i].iov_base, v[i].iov_len);
len += v[i].iov_len;
}
return len;
if(fd == 1) {
size_t len = 0;
struct iovec *v = (void *) iov;
for(int i = 0; i < iovcnt; i++) {
terminal_putsn(v[i].iov_base, v[i].iov_len);
len += v[i].iov_len;
}
long retval = 0;
PANIC("Unknown writev request: fd: %d\n", fd);
return retval;
return len;
}
long retval = 0;
PANIC("Unknown writev request: fd: %d\n", fd);
return retval;
}
void terminal_init() {
struct fbinfo *fbinfo = kernel_boot_data.fbinfo;
terminal_type = fbinfo->framebuffer_type;
struct fbinfo *fbinfo = kernel_boot_data.fbinfo;
terminal_type = fbinfo->framebuffer_type;
switch(terminal_type) {
case FRAMEBUFFER:
fbterm_init(fbinfo);
break;
case EGA_TEXT:
vga_init(fbinfo);
break;
}
switch(terminal_type) {
case FRAMEBUFFER:
fbterm_init(fbinfo);
break;
case EGA_TEXT:
vga_init(fbinfo);
break;
}
}

22
src/kernel/drivers/terminal/vga.c
View File

@ -16,21 +16,21 @@ static void *vidmem;
static int setup = 0;
void vga_init(struct fbinfo *fbinfo) {
(void) fbinfo;
vidmem = VGA_MEMORY;
memset(vidmem, 0, VGA_SIZE*sizeof(struct vga_cell));
setup = 1;
(void) fbinfo;
vidmem = VGA_MEMORY;
memset(vidmem, 0, VGA_SIZE*sizeof(struct vga_cell));
setup = 1;
}
void vga_movecursor(unsigned int cursor) {
if(!setup) return;
outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_LOW);
outb(VGA_DATA_PORT, (uint8_t)(cursor & 0xFF));
outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_HIGH);
outb(VGA_DATA_PORT, (uint8_t)((cursor >> 8) & 0xFF));
if(!setup) return;
outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_LOW);
outb(VGA_DATA_PORT, (uint8_t)(cursor & 0xFF));
outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_HIGH);
outb(VGA_DATA_PORT, (uint8_t)((cursor >> 8) & 0xFF));
}
void vga_flush(struct vga_cell *buffer) {
if(!setup) return;
memcpy(vidmem, buffer, VGA_SIZE*2);
if(!setup) return;
memcpy(vidmem, buffer, VGA_SIZE*2);
}

56
src/kernel/include/cpu.h
View File

@ -13,43 +13,43 @@
#define IRQ_SPURIOUS 0xFF
typedef struct {
uint64_t rax;
uint64_t rbx;
uint64_t rcx;
uint64_t rdx;
uint64_t rsi;
uint64_t rdi;
uint64_t rbp;
uint64_t r8;
uint64_t r9;
uint64_t r10;
uint64_t r11;
uint64_t r12;
uint64_t r13;
uint64_t r14;
uint64_t r15;
uint64_t rax;
uint64_t rbx;
uint64_t rcx;
uint64_t rdx;
uint64_t rsi;
uint64_t rdi;
uint64_t rbp;
uint64_t r8;
uint64_t r9;
uint64_t r10;
uint64_t r11;
uint64_t r12;
uint64_t r13;
uint64_t r14;
uint64_t r15;
uint64_t int_no;
uint64_t err_code;
uint64_t int_no;
uint64_t err_code;
uint64_t rip;
uint64_t cs;
uint64_t rflags;
uint64_t rsp;
uint64_t ss;
uint64_t rip;
uint64_t cs;
uint64_t rflags;
uint64_t rsp;
uint64_t ss;
} registers;
typedef registers *(*int_handler_t)(registers *);
struct cpu {
uint8_t id;
uint8_t apic_id;
uint32_t flags;
uint8_t id;
uint8_t apic_id;
uint32_t flags;
};
struct ioapic {
uint8_t id;
uint32_t addr;
uint32_t base;
uint8_t id;
uint32_t addr;
uint32_t base;
};
extern struct cpu *cpus[MAX_CPUS];

16
src/kernel/include/debug.h
View File

@ -26,12 +26,12 @@
#define PANIC(...) \
do { \
debug("\n\nKERNEL PANIC!\n%s:%d\n", __FILE__, __LINE__); \
debug(__VA_ARGS__); \
debug("\n"); \
volatile int _override = 0; \
while(1) { \
__asm__("panic_breakpoint_" S__LINE__ ":"); \
if(_override) break; \
} \
debug("\n\nKERNEL PANIC!\n%s:%d\n", __FILE__, __LINE__); \
debug(__VA_ARGS__); \
debug("\n"); \
volatile int _override = 0; \
while(1) { \
__asm__("panic_breakpoint_" S__LINE__ ":"); \
if(_override) break; \
} \
}while(0)

54
src/kernel/include/memory.h
View File

@ -12,40 +12,40 @@
#define ENTRIES_PER_PT 512
#ifdef __ASSEMBLER__
#define V2P(a) ((a) - KERNEL_OFFSET)
#define P2V(a) ((a) + KERNEL_OFFSET)
#define V2P(a) ((a) - KERNEL_OFFSET)
#define P2V(a) ((a) + KERNEL_OFFSET)
#else
#include <stdint.h>
#include <stddef.h>
#define V2P(a) ((uintptr_t)(a) &~KERNEL_OFFSET)
#define P2V(a) ((void *)((uintptr_t)(a) | KERNEL_OFFSET))
#include <stdint.h>
#include <stddef.h>
#define V2P(a) ((uintptr_t)(a) &~KERNEL_OFFSET)
#define P2V(a) ((void *)((uintptr_t)(a) | KERNEL_OFFSET))
#define incptr(p, n) ((void *)(((uintptr_t)(p)) + (n)))
#define incptr(p, n) ((void *)(((uintptr_t)(p)) + (n)))
#define P1_OFFSET(a) (((a)>>12) & 0x1FF)
#define P2_OFFSET(a) (((a)>>21) & 0x1FF)
#define P3_OFFSET(a) (((a)>>30) & 0x1FF)
#define P4_OFFSET(a) (((a)>>39) & 0x1FF)
#define P1_OFFSET(a) (((a)>>12) & 0x1FF)
#define P2_OFFSET(a) (((a)>>21) & 0x1FF)
#define P3_OFFSET(a) (((a)>>30) & 0x1FF)
#define P4_OFFSET(a) (((a)>>39) & 0x1FF)
// memory/memory.c
void memory_init();
extern uint64_t kernel_P4;
// memory/memory.c
void memory_init();
extern uint64_t kernel_P4;
// memory/vmm.c
uint64_t new_P4();
uint64_t vmm_get_page(uint64_t P4, uint64_t addr);
int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags);
void vmm_clear_page(uint64_t P4, uint64_t addr, int free);
// memory/vmm.c
uint64_t new_P4();
uint64_t vmm_get_page(uint64_t P4, uint64_t addr);
int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags);
void vmm_clear_page(uint64_t P4, uint64_t addr, int free);
// memory/pmm.c
void pmm_free(uint64_t page);
uint64_t pmm_alloc();
uint64_t pmm_calloc();
// memory/pmm.c
void pmm_free(uint64_t page);
uint64_t pmm_alloc();
uint64_t pmm_calloc();
// Link.ld
extern int kernel_start, kernel_end;
// Link.ld
extern int kernel_start, kernel_end;
// boot/boot_PT.s
extern uint64_t BootP4;
// boot/boot_PT.s
extern uint64_t BootP4;
#endif

36
src/kernel/include/multiboot.h
View File

@ -18,27 +18,27 @@
#include <stdint.h>
struct fbinfo {
uint64_t framebuffer_addr;
uint32_t framebuffer_pitch;
uint32_t framebuffer_width;
uint32_t framebuffer_height;
uint8_t framebuffer_bpp;
uint8_t framebuffer_type;
uint8_t reserved;
uint8_t color_info[];
uint64_t framebuffer_addr;
uint32_t framebuffer_pitch;
uint32_t framebuffer_width;
uint32_t framebuffer_height;
uint8_t framebuffer_bpp;
uint8_t framebuffer_type;
uint8_t reserved;
uint8_t color_info[];
}__attribute__((packed));
struct kernel_boot_data_st {
int multiboot_version;
void *mboot_tags;
size_t tags_length;
char *bootloader;
char *commandline;
size_t mmap_size;
unsigned int mmap_len;
void *mmap;
struct fbinfo *fbinfo;
void *rsdp;
int multiboot_version;
void *mboot_tags;
size_t tags_length;
char *bootloader;
char *commandline;
size_t mmap_size;
unsigned int mmap_len;
void *mmap;
struct fbinfo *fbinfo;
void *rsdp;
};
#define MMAP_FREE 1

28
src/kernel/include/musl-glue.h
View File

@ -26,23 +26,23 @@ long k_sched_yield(long, long, long, long, long, long);
struct __locale_struct {
const struct __locale_map *cat[6];
const struct __locale_map *cat[6];
};
struct tls_module {
struct tls_module *next;
void *image;
size_t len, size, align, offset;
struct tls_module *next;
void *image;
size_t len, size, align, offset;
};
struct __libc {
char can_do_threads;
char threaded;
char secure;
volatile signed char need_locks;
int threads_minus_1;
size_t *auxv;
struct tls_module *tls_head;
size_t tls_size, tls_align, tls_cnt;
size_t page_size;
struct __locale_struct global_locale;
char can_do_threads;
char threaded;
char secure;
volatile signed char need_locks;
int threads_minus_1;
size_t *auxv;
struct tls_module *tls_head;
size_t tls_size, tls_align, tls_cnt;
size_t page_size;
struct __locale_struct global_locale;
};
extern struct __libc __libc;

8
src/kernel/include/ports.h
View File

@ -2,13 +2,13 @@
#include <stdint.h>
static __inline void _outb(uint16_t port, uint8_t value) {
__asm__ volatile("outb %1, %0" : : "dN" (port), "a" (value));
__asm__ volatile("outb %1, %0" : : "dN" (port), "a" (value));
}
static __inline uint8_t _inb(uint16_t port) {
uint8_t ret;
__asm__ volatile("inb %1, %0" : "=a" (ret) : "dN" (port));
return ret;
uint8_t ret;
__asm__ volatile("inb %1, %0" : "=a" (ret) : "dN" (port));
return ret;
}
#define outb _outb

12
src/kernel/include/proc.h
View File

@ -2,12 +2,12 @@
#include <stdint.h>
struct process {
uint64_t pid;
void *stack_ptr;
uint64_t state;
uint64_t P4;
struct process *q_next;
uint8_t stack[];
uint64_t pid;
void *stack_ptr;
uint64_t state;
uint64_t P4;
struct process *q_next;
uint8_t stack[];
};
// proc/process.c

4
src/kernel/include/terminal.h
View File

@ -8,8 +8,8 @@
#define VGA_MEMORY P2V(0xB8000)
struct vga_cell {
uint8_t c;
uint8_t f;
uint8_t c;
uint8_t f;
}__attribute__((packed));

106
src/kernel/lib/musl-glue.c
View File

@ -2,85 +2,89 @@
#include <debug.h>
syscall_handler syscall_handlers[440] = {
[SYSCALL_BRK] = k_brk,
[SYSCALL_IOCTL] = k_ioctl,
[SYSCALL_WRITEV] = k_writev,
[SYSCALL_SCHED_YIELD] = k_sched_yield,
[SYSCALL_MMAP] = k_mmap,
[SYSCALL_BRK] = k_brk,
[SYSCALL_IOCTL] = k_ioctl,
[SYSCALL_WRITEV] = k_writev,
[SYSCALL_SCHED_YIELD] = k_sched_yield,
[SYSCALL_MMAP] = k_mmap,
};
syscall_handler set_syscall_handler(long num, syscall_handler handler) {
syscall_handler old = syscall_handlers[num];
syscall_handlers[num] = handler;
return old;
syscall_handler old = syscall_handlers[num];
syscall_handlers[num] = handler;
return old;
}
long syscall0(long num) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](0, 0, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d()\n", num);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](0, 0, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d()\n", num);
return retval;
}
long syscall1(long num, long a1) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, 0, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x)\n", num, a1);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, 0, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x)\n", num, a1);
return retval;
}
long syscall2(long num, long a1, long a2) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x)\n", num, a1, a2);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, 0, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x)\n", num, a1, a2);
return retval;
}
long syscall3(long num, long a1, long a2, long a3) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x)\n", num, a1, a2, a3);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, 0, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x)\n", num, a1, a2, a3);
return retval;
}
long syscall4(long num, long a1, long a2, long a3, long a4) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x)\n", num, a1, a2, a3, a4);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, 0, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x)\n", num, a1, a2, a3, a4);
return retval;
}
long syscall5(long num, long a1, long a2, long a3, long a4, long a5) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, a5, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x)\n", num, a1, a2, a3, a4, a5);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, a5, 0);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x)\n",
num, a1, a2, a3, a4, a5
);
return retval;
}
long syscall6(long num, long a1, long a2, long a3, long a4, long a5, long a6) {
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, a5, a6);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x, %x)\n", num, a1, a2, a3, a4, a5, a6);
return retval;
long retval = 0;
if(syscall_handlers[num])
retval = syscall_handlers[num](a1, a2, a3, a4, a5, a6);
else
PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x, %x)\n",
num, a1, a2, a3, a4, a5, a6
);
return retval;
}
size_t auxv[] = {0};
void musl_init() {
__libc.auxv = auxv;
__libc.auxv = auxv;
}

55
src/kernel/memory/kbrk.c
View File

@ -5,27 +5,42 @@ static long _brk = KERNEL_BRK0;
static long _mmap = KERNEL_MMAP;
long k_brk(long brk, long, long, long, long, long) {
if(brk) {
while(_brk < brk) {
vmm_set_page(kernel_P4, _brk, pmm_alloc(), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
_brk += PAGE_SIZE;
}
if(brk) {
while(_brk < brk) {
vmm_set_page(kernel_P4,
_brk,
pmm_alloc(),
PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
);
_brk += PAGE_SIZE;
}
return _brk;
}
return _brk;
}
long k_mmap(long addr, long length, long prot, long flags, long fd, long offset) {
(void)addr;
(void)prot;
(void)flags;
(void)offset;
if(fd != -1)
PANIC("Unknown mmap request\n");
long retval = _mmap;
while(length > 0) {
vmm_set_page(kernel_P4, _mmap, pmm_alloc(), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
_mmap += PAGE_SIZE;
length -= PAGE_SIZE;
}
return retval;
long k_mmap(
long addr,
long length,
long prot,
long flags,
long fd,
long offset
) {
(void)addr;
(void)prot;
(void)flags;
(void)offset;
if(fd != -1)
PANIC("Unknown mmap request\n");
long retval = _mmap;
while(length > 0) {
vmm_set_page(kernel_P4,
_mmap, pmm_alloc(),
PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
);
_mmap += PAGE_SIZE;
length -= PAGE_SIZE;
}
return retval;
}

38
src/kernel/memory/memory.c
View File

@ -7,27 +7,27 @@
uint64_t kernel_P4;
void memory_init() {
kernel_P4 = (uint64_t)&BootP4;
kernel_P4 = (uint64_t)&BootP4;
uint64_t start, end;
uint32_t type, i = 0;
while(!multiboot_get_memory_area(i++, &start, &end, &type)) {
for(uint64_t p = start; p < end; p += PAGE_SIZE) {
uint64_t vaddr = (uint64_t)P2V(p);
uint64_t page = vmm_get_page(kernel_P4, vaddr);
if(page == (uint64_t)-1 || !(page & PAGE_PRESENT)) {
uint16_t flags = PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT;
vmm_set_page(kernel_P4, vaddr, p, flags);
}
uint64_t start, end;
uint32_t type, i = 0;
while(!multiboot_get_memory_area(i++, &start, &end, &type)) {
for(uint64_t p = start; p < end; p += PAGE_SIZE) {
uint64_t vaddr = (uint64_t)P2V(p);
uint64_t page = vmm_get_page(kernel_P4, vaddr);
if(page == (uint64_t)-1 || !(page & PAGE_PRESENT)) {
uint16_t flags = PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT;
vmm_set_page(kernel_P4, vaddr, p, flags);
}
if(type != MMAP_FREE)
continue;
if(p >= V2P(&kernel_start) && p < V2P(&kernel_end))
continue;
if(multiboot_page_used((uintptr_t)P2V(p)))
continue;
if(type != MMAP_FREE)
continue;
if(p >= V2P(&kernel_start) && p < V2P(&kernel_end))
continue;
if(multiboot_page_used((uintptr_t)P2V(p)))
continue;
pmm_free(p);
}
pmm_free(p);
}
}
}

18
src/kernel/memory/pmm.c
View File

@ -6,19 +6,19 @@
uint64_t next = 0;
void pmm_free(uint64_t page) {
*(uint64_t *)P2V(page) = next;
next = page;
*(uint64_t *)P2V(page) = next;
next = page;
}
uint64_t pmm_alloc() {
if(!next) return 0;
uint64_t page = next;
next = *(uint64_t *)P2V(page);
return page;
if(!next) return 0;
uint64_t page = next;
next = *(uint64_t *)P2V(page);
return page;
}
uint64_t pmm_calloc() {
uint64_t page = pmm_alloc();
memset(P2V(page), 0, PAGE_SIZE);
return page;
uint64_t page = pmm_alloc();
memset(P2V(page), 0, PAGE_SIZE);
return page;
}

99
src/kernel/memory/vmm.c
View File

@ -17,80 +17,79 @@
static int P1_exists(uint64_t P4, uint64_t addr) {
if (P4 && PRESENT(P4E(P4, addr)) && PRESENT(P3E(P4, addr)) && PRESENT(P2E(P4, addr)))
return 1;
return 0;
if (P4 && PRESENT(P4E(P4, addr)) && PRESENT(P3E(P4, addr)) && PRESENT(P2E(P4, addr)))
return 1;
return 0;
}
static int touch_P1(uint64_t P4, uint64_t addr, uint16_t flags) {
if (!P4) return -1;
if (!P4) return -1;
if(!PRESENT(P4E(P4, addr)) && (!(P4E(P4,addr) = pmm_calloc())))
return -1;
P4E(P4, addr) |= flags | PAGE_PRESENT;
if(!PRESENT(P4E(P4, addr)) && (!(P4E(P4,addr) = pmm_calloc())))
return -1;
P4E(P4, addr) |= flags | PAGE_PRESENT;
if(!PRESENT(P3E(P4, addr)) && (!(P3E(P4, addr) = pmm_calloc())))
return -1;
P3E(P4, addr) |= flags | PAGE_PRESENT;
if(!PRESENT(P3E(P4, addr)) && (!(P3E(P4, addr) = pmm_calloc())))
return -1;
P3E(P4, addr) |= flags | PAGE_PRESENT;
if(!PRESENT(P2E(P4, addr)) && (!(P2E(P4, addr) = pmm_calloc())))
return -1;
P2E(P4, addr) |= flags | PAGE_PRESENT;
if(!PRESENT(P2E(P4, addr)) && (!(P2E(P4, addr) = pmm_calloc())))
return -1;
P2E(P4, addr) |= flags | PAGE_PRESENT;
return 0;
return 0;
}
uint64_t new_P4() {
uint64_t p4 = pmm_alloc();
memcpy(P2V(p4), (void *)kernel_P4, PAGE_SIZE);
return p4;
uint64_t p4 = pmm_alloc();
memcpy(P2V(p4), (void *)kernel_P4, PAGE_SIZE);
return p4;
}
uint64_t vmm_get_page(uint64_t P4, uint64_t addr) {
if(P1_exists(P4, addr))
return P1E(P4, addr);
return -1;
if(P1_exists(P4, addr))
return P1E(P4, addr);
return -1;
}
int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags) {
if(!P1_exists(P4, addr))
if(touch_P1(P4, addr, flags))
return -1;
if(!P1_exists(P4, addr))
if(touch_P1(P4, addr, flags))
return -1;
P1E(P4, addr) = page | flags;
return 0;
P1E(P4, addr) = page | flags;
return 0;
}
void vmm_clear_page(uint64_t P4, uint64_t addr, int free) {
if(!P1_exists(P4, addr))
return;
if(!P1_exists(P4, addr))
return;
uint64_t *pt;
uint64_t *pt;
P1E(P4, addr) = 0;
P1E(P4, addr) = 0;
if(!free)
return;
if(!free)
return;
pt = PT(P2E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P2E(P4, addr)));
P2E(P4, addr) = 0;
pt = PT(P2E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P2E(P4, addr)));
P2E(P4, addr) = 0;
pt = PT(P3E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P3E(P4, addr)));
P3E(P4, addr) = 0;
pt = PT(P3E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P3E(P4, addr)));
P3E(P4, addr) = 0;
pt = PT(P4E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P4E(P4, addr)));
P4E(P4, addr) = 0;
pt = PT(P4E(P4, addr));
for(int i = 0; i < ENTRIES_PER_PT; i++)
if(pt[i])
return;
pmm_free(MASK_FLAGS(P4E(P4, addr)));
P4E(P4, addr) = 0;
}

36
src/kernel/proc/process.c
View File

@ -3,14 +3,14 @@
#include <memory.h>
struct swtch_stack {
uint64_t RBP;
uint64_t RBX;
uint64_t R12;
uint64_t R13;
uint64_t R14;
uint64_t R15;
uint64_t RBP2;
uint64_t ret;
uint64_t RBP;
uint64_t RBX;
uint64_t R12;
uint64_t R13;
uint64_t R14;
uint64_t R15;
uint64_t RBP2;
uint64_t ret;
};
static uint64_t next_pid = 1;
@ -18,19 +18,19 @@ static uint64_t next_pid = 1;
struct process *current_proc;
struct process *new_process(void (*function)(void)) {
struct process *p = P2V(pmm_calloc());
p->pid = next_pid++;
p->stack_ptr = incptr(p, PAGE_SIZE - sizeof(struct swtch_stack));
p->q_next = 0;
p->P4 = new_P4();
struct process *p = P2V(pmm_calloc());
p->pid = next_pid++;
p->stack_ptr = incptr(p, PAGE_SIZE - sizeof(struct swtch_stack));
p->q_next = 0;
p->P4 = new_P4();
struct swtch_stack *stck = p->stack_ptr;
stck->RBP = (uint64_t)&stck->RBP2;
stck->ret = (uint64_t)function;
struct swtch_stack *stck = p->stack_ptr;
stck->RBP = (uint64_t)&stck->RBP2;
stck->ret = (uint64_t)function;
return p;
return p;
}
struct process *proc() {
return current_proc;
return current_proc;
}

56
src/kernel/proc/scheduler.c
View File

@ -2,52 +2,52 @@
#include <cpu.h>
static struct {
struct process *first;
struct process *last;
struct process *first;
struct process *last;
} run_q = {0,0};
static struct process *scheduler_proc;
static struct process *scheduler_next() {
struct process *ret = run_q.first;
if(run_q.first && !(run_q.first = run_q.first->q_next))
run_q.last = 0;
return ret;
struct process *ret = run_q.first;
if(run_q.first && !(run_q.first = run_q.first->q_next))
run_q.last = 0;
return ret;
}
void scheduler_insert(struct process *new) {
if(run_q.last) {
run_q.last->q_next = new;
run_q.last = new;
} else {
run_q.first = run_q.last = new;
}
new->q_next = 0;
if(run_q.last) {
run_q.last->q_next = new;
run_q.last = new;
} else {
run_q.first = run_q.last = new;
}
new->q_next = 0;
}
void scheduler() {
while(1) {
struct process *new = 0;
while(!(new = scheduler_next()));
while(1) {
struct process *new = 0;
while(!(new = scheduler_next()));
current_proc = new;
write_cr3(new->P4);
switch_stack(&scheduler_proc->stack_ptr, &new->stack_ptr);
current_proc = new;
write_cr3(new->P4);
switch_stack(&scheduler_proc->stack_ptr, &new->stack_ptr);
scheduler_insert(current_proc);
current_proc = 0;
}
scheduler_insert(current_proc);
current_proc = 0;
}
}
long k_sched_yield(long, long, long, long, long, long) {
switch_stack(&current_proc->stack_ptr, &scheduler_proc->stack_ptr);
return 0;
switch_stack(&current_proc->stack_ptr, &scheduler_proc->stack_ptr);
return 0;
}
void start_scheduler() {
scheduler_proc = new_process(scheduler);
scheduler_proc->pid = (uint64_t)-1;
scheduler_proc = new_process(scheduler);
scheduler_proc->pid = (uint64_t)-1;
uint64_t stack;
switch_stack(&stack, &scheduler_proc->stack_ptr);
uint64_t stack;
switch_stack(&stack, &scheduler_proc->stack_ptr);
}

181
src/libmittos/graphics/graphics.c
View File

@ -11,96 +11,125 @@
#define STEP_X(ctx) 1
#define STEP_Y(ctx) (ctx)->pitch
void putpixel(gfx_context *ctx, uint64_t x, uint64_t y, uint32_t clr) {
if(x >= ctx->width || y >= ctx->height) return;
uint32_t *fb = (uint32_t *)ctx->buffer;
void putpixel(
gfx_context *ctx,
uint64_t x, uint64_t y,
uint32_t clr
) {
if(x >= ctx->width || y >= ctx->height) return;
uint32_t *fb = (uint32_t *)ctx->buffer;
fb[PXL(ctx, x, y)] = clr;
}
void draw_line(
gfx_context *ctx,
uint64_t x0, uint64_t x1,
uint64_t y0, uint64_t y1,
uint32_t clr
) {
int64_t dx = x1 > x0 ? x1 - x0 : x0 - x1;
int64_t dy = y1 > y0 ? y1 - y0 : y0 - y1;
int sx = x1 > x0 ? 1 : -1;
int sy = y1 > y0 ? 1 : -1;
uint64_t x = x0, y = y0;
int64_t diff = dx - dy;
uint32_t *fb = (uint32_t *)ctx->buffer;
while(1) {
fb[PXL(ctx, x, y)] = clr;
if(x == x1 && y == y1) break;
if((2*diff) > -dy) {
diff -= dy;
x += sx;
} else {
diff += dx;
y += sy;
}
}
}
void draw_line(gfx_context *ctx, uint64_t x0, uint64_t x1, uint64_t y0, uint64_t y1, uint32_t clr) {
int64_t dx = x1 > x0 ? x1 - x0 : x0 - x1;
int64_t dy = y1 > y0 ? y1 - y0 : y0 - y1;
int sx = x1 > x0 ? 1 : -1;
int sy = y1 > y0 ? 1 : -1;
uint64_t x = x0, y = y0;
int64_t diff = dx - dy;
uint32_t *fb = (uint32_t *)ctx->buffer;
while(1) {
fb[PXL(ctx, x, y)] = clr;
if(x == x1 && y == y1) break;
if((2*diff) > -dy) {
diff -= dy;
x += sx;
} else {
diff += dx;
y += sy;
}
}
void draw_rect(
gfx_context *ctx,
uint64_t x, uint64_t y,
uint64_t width, uint64_t height,
uint32_t clr
) {
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t l1 = PXL(ctx, x, y);
uint64_t l2 = PXL(ctx, x, y + height);
for(uint64_t _x = 0; _x <= width; _x++) {
fb[l1] = fb[l2] = clr;
l1 += STEP_X(ctx);
l2 += STEP_X(ctx);
}
l1 = PXL(ctx, x, y);
l2 = PXL(ctx, x + width, y);
for(uint64_t _y = 0; _y <= height; _y++) {
fb[l1] = fb[l2] = clr;
l1 += STEP_Y(ctx);
l2 += STEP_Y(ctx);
}
}
void draw_rect(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height, uint32_t clr) {
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t l1 = PXL(ctx, x, y);
uint64_t l2 = PXL(ctx, x, y + height);
for(uint64_t _x = 0; _x <= width; _x++) {
fb[l1] = fb[l2] = clr;
l1 += STEP_X(ctx);
l2 += STEP_X(ctx);
}
l1 = PXL(ctx, x, y);
l2 = PXL(ctx, x + width, y);
for(uint64_t _y = 0; _y <= height; _y++) {
fb[l1] = fb[l2] = clr;
l1 += STEP_Y(ctx);
l2 += STEP_Y(ctx);
void fill_rect(
gfx_context *ctx,
uint64_t x, uint64_t y,
uint64_t width, uint64_t height,
uint32_t clr
) {
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t loc = PXL(ctx, x, y);
for(uint64_t _y = 0; _y <= height; _y++) {
for(uint64_t _x = 0; _x <= width; _x += STEP_X(ctx)) {
fb[loc + _x] = clr;
}
loc += STEP_Y(ctx);
}
}
void fill_rect(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height, uint32_t clr) {
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t loc = PXL(ctx, x, y);
for(uint64_t _y = 0; _y <= height; _y++) {
for(uint64_t _x = 0; _x <= width; _x += STEP_X(ctx)) {
fb[loc + _x] = clr;
}
loc += STEP_Y(ctx);
}
}
void putCharacter(gfx_context *ctx, uint64_t x, uint64_t y, uint32_t clr_fg, uint32_t clr_bg, char c) {
unsigned char *chr = c ? font[(int)c-0x20]: font[0];
if(x >= ctx->width || y >= ctx->height) return;
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t loc = y * ctx->pitch + x;
for(int row = 0; row < 16; row++) {
for(int col = 0; col < 8; col++) {
fb[loc+col] = ((chr[row]>>(7-col))&0x1) ? clr_fg : clr_bg;
}
loc += ctx->pitch;
void putCharacter(
gfx_context *ctx,
uint64_t x, uint64_t y,
uint32_t clr_fg, uint32_t clr_bg,
char c
) {
unsigned char *chr = c ? font[(int)c-0x20]: font[0];
if(x >= ctx->width || y >= ctx->height) return;
uint32_t *fb = (uint32_t *)ctx->buffer;
uint64_t loc = y * ctx->pitch + x;
for(int row = 0; row < 16; row++) {
for(int col = 0; col < 8; col++) {
fb[loc+col] = ((chr[row]>>(7-col))&0x1) ? clr_fg : clr_bg;
}
loc += ctx->pitch;
}
}
void flip(gfx_context *ctx) {
for(uint64_t y = 0; y < ctx->height; y++) {
memcpy(
incptr(ctx->addr, y*ctx->pitch*ctx->bpp),
incptr(ctx->buffer, y*ctx->pitch*ctx->bpp),
ctx->width*ctx->bpp);
}
for(uint64_t y = 0; y < ctx->height; y++) {
memcpy(
incptr(ctx->addr, y*ctx->pitch*ctx->bpp),
incptr(ctx->buffer, y*ctx->pitch*ctx->bpp),
ctx->width*ctx->bpp
);
}
}
gfx_context *framebuffer_make_subcontext(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height) {
gfx_context *out = malloc(sizeof(gfx_context));
uint64_t loc = y * ctx->pitch + x;
gfx_context *framebuffer_make_subcontext(
gfx_context *ctx,
uint64_t x, uint64_t y,
uint64_t width, uint64_t height
) {
gfx_context *out = malloc(sizeof(gfx_context));
uint64_t loc = y * ctx->pitch + x;
out->width = width;
out->height = height;
out->bpp = ctx->bpp;
out->pitch = ctx->pitch;
out->addr = incptr(ctx->addr, loc*ctx->bpp);
out->size = ctx->pitch * height * ctx->bpp;
out->buffer = calloc(1, out->size);
out->width = width;
out->height = height;
out->bpp = ctx->bpp;
out->pitch = ctx->pitch;
out->addr = incptr(ctx->addr, loc*ctx->bpp);
out->size = ctx->pitch * height * ctx->bpp;
out->buffer = calloc(1, out->size);
return out;
return out;
}

14
src/libmittos/include/graphics.h
View File

@ -2,13 +2,13 @@
#include <stdlib.h>
typedef struct {
uint32_t width;
uint32_t height;
uint32_t bpp;
uint32_t pitch;
void *addr;
void *buffer;
size_t size;
uint32_t width;
uint32_t height;
uint32_t bpp;
uint32_t pitch;
void *addr;
void *buffer;
size_t size;
} gfx_context;
#define RGB(r, g, b) (((uint32_t) (r<<16) + (g<<8) + (b)))

22
src/patch-musl/arch/x86_64/syscall_arch.h
View File

@ -10,25 +10,29 @@ extern long syscall5(long, long, long, long, long, long);
extern long syscall6(long, long, long, long, long, long, long);
static __inline long __syscall0(long n) {
return syscall0(n);
return syscall0(n);
}
static __inline long __syscall1(long n, long a1) {
return syscall1(n, a1);
return syscall1(n, a1);
}
static __inline long __syscall2(long n, long a1, long a2) {
return syscall2(n, a1, a2);
return syscall2(n, a1, a2);
}
static __inline long __syscall3(long n, long a1, long a2, long a3) {
return syscall3(n, a1, a2, a3);
return syscall3(n, a1, a2, a3);
}
static __inline long __syscall4(long n, long a1, long a2, long a3, long a4) {
return syscall4(n, a1, a2, a3, a4);
return syscall4(n, a1, a2, a3, a4);
}
static __inline long __syscall5(long n, long a1, long a2, long a3, long a4, long a5) {
return syscall5(n, a1, a2, a3, a4, a5);
static __inline long __syscall5(long n, long a1, long a2, long a3, long a4,
long a5
) {
return syscall5(n, a1, a2, a3, a4, a5);
}
static __inline long __syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6) {
return syscall6(n, a1, a2, a3, a4, a5, a6);
static __inline long __syscall6(long n, long a1, long a2, long a3, long a4,
long a5, long a6
) {
return syscall6(n, a1, a2, a3, a4, a5, a6);
}
#define VDSO_USEFUL