rami/hazel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace tabs with spaces lol

Browse Source
This commit is contained in:
rami 2024-07-28 10:18:59 -04:00
parent 4ac1efd433
commit 352d51f610
7 changed files with 133 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
kernel/elf.c
View File

@ -5,11 +5,11 @@ section_t *elf_find_section(elf_t *elf, const char *name) {
section_t *str = (section_t *)((uint32_t)elf + elf->e_shoff + elf->e_shstrndx*elf->e_shentsize); section_t *str = (section_t *)((uint32_t)elf + elf->e_shoff + elf->e_shstrndx*elf->e_shentsize);
section_t *found = 0; section_t *found = 0;
for (int i = 0; i < elf->e_shnum; i++) { for (int i = 0; i < elf->e_shnum; i++) {
section_t *sec = (section_t *)((uint32_t)elf + elf->e_shoff + i*elf->e_shentsize); section_t *sec = (section_t *)((uint32_t)elf + elf->e_shoff + i*elf->e_shentsize);
const char *n = (char *)((uint32_t)elf + str->sh_offset + sec->sh_name); const char *n = (char *)((uint32_t)elf + str->sh_offset + sec->sh_name);
if (!strcmp(n, name)) { if (!strcmp(n, name)) {
found = sec; found = sec;
} }
} }
return found; return found;

110
kernel/kernel.c
View File

@ -33,7 +33,7 @@ void syscall_write(stack_frame_t r) {
uint32_t fd = r.edi; uint32_t fd = r.edi;
uint8_t *buf = (uint8_t *)r.esi; uint8_t *buf = (uint8_t *)r.esi;
if (fd == FD_STDOUT) { if (fd == FD_STDOUT) {
LOG("%s", buf); LOG("%s", buf);
} }
} }
@ -42,14 +42,14 @@ void syscall_read(stack_frame_t r) {
uint8_t *buf = (uint8_t *)r.esi; uint8_t *buf = (uint8_t *)r.esi;
uint32_t len = r.edx; uint32_t len = r.edx;
if (fd == FD_STDOUT) { if (fd == FD_STDOUT) {
// Not yet // Not yet
} else if (fd == FD_STDIN) { } else if (fd == FD_STDIN) {
asm volatile ("sti" ::); asm volatile ("sti" ::);
while (ctx.current_task->stdin[ctx.current_task->stdin_len - 1] != '\n') cpu_relax; while (ctx.current_task->stdin[ctx.current_task->stdin_len - 1] != '\n') cpu_relax;
if (ctx.current_task->stdin_len > 0) ctx.current_task->stdin[--ctx.current_task->stdin_len] = 0; if (ctx.current_task->stdin_len > 0) ctx.current_task->stdin[--ctx.current_task->stdin_len] = 0;
memcpy(buf, ctx.current_task->stdin, len); memcpy(buf, ctx.current_task->stdin, len);
for (int i = 0; i < 0x1000; i++) ctx.current_task->stdin[i] = 0; for (int i = 0; i < 0x1000; i++) ctx.current_task->stdin[i] = 0;
ctx.current_task->stdin_len = 0; ctx.current_task->stdin_len = 0;
} }
} }
@ -69,7 +69,7 @@ void exception_handler(int_stack_frame_t r) {
void sleep(int delay) { void sleep(int delay) {
uint64_t end = ctx.ticks + delay; uint64_t end = ctx.ticks + delay;
while (ctx.ticks < end) while (ctx.ticks < end)
cpu_relax; cpu_relax;
} }
void idt_init(void) { void idt_init(void) {
@ -127,29 +127,29 @@ void kernel(multiboot_info_t *info) {
flush_tss(GDT_SEGMENT_SELECTOR(5, RING3)); flush_tss(GDT_SEGMENT_SELECTOR(5, RING3));
/* /*
task_t task1 = {0}; task_t task1 = {0};
task_t task2 = {0}; task_t task2 = {0};
task1.cr3 = (uint32_t)boot_page_dir - KERNEL_VMA; task1.cr3 = (uint32_t)boot_page_dir - KERNEL_VMA;
task1.next = (uint32_t *)&task2; task1.next = (uint32_t *)&task2;
ctx.current_task = &task1; ctx.current_task = &task1;
uint32_t *stack = mmap_find_first_free_block(); uint32_t *stack = mmap_find_first_free_block();
asm volatile ("mov %%esp, %0" : "=r" (task1.esp)); asm volatile ("mov %%esp, %0" : "=r" (task1.esp));
stack[1023] = 0x207; stack[1023] = 0x207;
stack[1022] = 0x8; stack[1022] = 0x8;
stack[1021] = (uint32_t)test; stack[1021] = (uint32_t)test;
stack[1020] = 0xDEADBEEF; stack[1020] = 0xDEADBEEF;
stack[1019] = 0xDEADBEEF; stack[1019] = 0xDEADBEEF;
stack[1018] = 0xDEADBEEF; stack[1018] = 0xDEADBEEF;
stack[1017] = 0xDEADBEEF; stack[1017] = 0xDEADBEEF;
stack[1016] = 0xDEADBEEF; stack[1016] = 0xDEADBEEF;
stack[1015] = 0xDEADBEEF; stack[1015] = 0xDEADBEEF;
stack[1014] = 0xDEADBEEF; stack[1014] = 0xDEADBEEF;
stack[1013] = 0xDEADBEEF; stack[1013] = 0xDEADBEEF;
task2.esp = (uint32_t)stack + (0x1000 - 44); task2.esp = (uint32_t)stack + (0x1000 - 44);
task2.cr3 = (uint32_t)boot_page_dir - KERNEL_VMA; task2.cr3 = (uint32_t)boot_page_dir - KERNEL_VMA;
task2.next = 0; task2.next = 0;
*/ */
multi_mod_t *init = (multi_mod_t *)(info->moduleaddress + KERNEL_VMA); multi_mod_t *init = (multi_mod_t *)(info->moduleaddress + KERNEL_VMA);
elf_t *elf = (elf_t *)(init->mod_start+KERNEL_VMA); elf_t *elf = (elf_t *)(init->mod_start+KERNEL_VMA);
@ -161,35 +161,35 @@ void kernel(multiboot_info_t *info) {
// Set the ring0 CS // Set the ring0 CS
asm volatile ( asm volatile (
"movl $0x174, %%ecx \n\t" "movl $0x174, %%ecx \n\t"
"movl %0, %%eax \n\t" "movl %0, %%eax \n\t"
"xor %%edx, %%edx \n\t" "xor %%edx, %%edx \n\t"
"wrmsr" "wrmsr"
: :
: "r"(GDT_SEGMENT_SELECTOR(GDT_KERNEL_CODE, RING0)) : "r"(GDT_SEGMENT_SELECTOR(GDT_KERNEL_CODE, RING0))
: "eax", "ecx", "edx" : "eax", "ecx", "edx"
); );
// Set the ring0 stack // Set the ring0 stack
uint32_t *k_stack = mmap_find_first_free_block(); uint32_t *k_stack = mmap_find_first_free_block();
asm volatile ( asm volatile (
"movl $0x175, %%ecx \n\t" "movl $0x175, %%ecx \n\t"
"movl %0, %%eax \n\t" "movl %0, %%eax \n\t"
"xor %%edx, %%edx \n\t" "xor %%edx, %%edx \n\t"
"wrmsr" "wrmsr"
: :
: "r"((uint32_t)k_stack + 0x1000) : "r"((uint32_t)k_stack + 0x1000)
: "eax", "ecx", "edx" : "eax", "ecx", "edx"
); );
// Set the ring0 syscall entry // Set the ring0 syscall entry
asm volatile ( asm volatile (
"movl $0x176, %%ecx \n\t" "movl $0x176, %%ecx \n\t"
"movl %0, %%eax \n\t" "movl %0, %%eax \n\t"
"xor %%edx, %%edx \n\t" "xor %%edx, %%edx \n\t"
"wrmsr" "wrmsr"
: :
: "r"(syscall) : "r"(syscall)
: "eax", "ecx", "edx" : "eax", "ecx", "edx"
); );
LOG("Switching to ring 3... EIP: 0x%08X ESP: 0x%08X\n", task.eip, task.esp); LOG("Switching to ring 3... EIP: 0x%08X ESP: 0x%08X\n", task.eip, task.esp);

20
kernel/log.c
View File

@ -6,20 +6,20 @@ extern kernel_ctx_t ctx;
void _putchar(char c) { void _putchar(char c) {
switch (ctx.log_method) { switch (ctx.log_method) {
case LOG_COM1: case LOG_COM1:
serial_putc(COM1, c); serial_putc(COM1, c);
break; break;
default: default:
break; break;
} }
} }
void logs(const char *str) { void logs(const char *str) {
switch (ctx.log_method) { switch (ctx.log_method) {
case LOG_COM1: case LOG_COM1:
serial_puts(COM1, str); serial_puts(COM1, str);
break; break;
default: default:
break; break;
} }
} }

18
kernel/mem.c
View File

@ -13,13 +13,13 @@ void *mmap_block_to_physical(int block) {
uint32_t len = (uint32_t)(entry.len); uint32_t len = (uint32_t)(entry.len);
uint32_t addr = (uint32_t)(entry.addr); uint32_t addr = (uint32_t)(entry.addr);
if (len > offset) { if (len > offset) {
uint32_t phys = (addr + offset); uint32_t phys = (addr + offset);
if (phys < 0x00400000) { if (phys < 0x00400000) {
return (void *)(phys + 0xC0000000); return (void *)(phys + 0xC0000000);
} }
return (void *)phys; return (void *)phys;
} }
} }
return 0; return 0;
@ -73,9 +73,9 @@ uint8_t mmap_init(void) {
struct multiboot_mmap_entry entry = ctx.multi_mmap[index]; struct multiboot_mmap_entry entry = ctx.multi_mmap[index];
//uint32_t addr = (uint32_t)(entry.addr_low | entry.addr_high); //uint32_t addr = (uint32_t)(entry.addr_low | entry.addr_high);
if ((uint32_t)(entry.addr & UINT32_MAX) < 0x00400000) if ((uint32_t)(entry.addr & UINT32_MAX) < 0x00400000)
ctx.mmap = (uint32_t *)((uint32_t)(entry.addr & UINT32_MAX) + 0xC0000000); ctx.mmap = (uint32_t *)((uint32_t)(entry.addr & UINT32_MAX) + 0xC0000000);
else else
ctx.mmap = (uint32_t *)(uint32_t)(entry.addr & 0xffffffff); ctx.mmap = (uint32_t *)(uint32_t)(entry.addr & 0xffffffff);
// Zero the map // Zero the map
memset(ctx.mmap, 0, ctx.mmap_size); memset(ctx.mmap, 0, ctx.mmap_size);
// Reserve the blocks that hold the memory map + 1 // Reserve the blocks that hold the memory map + 1

54
kernel/ps2.c
View File

@ -33,15 +33,15 @@ void ps2_init() {
if (result == 0x55) LOG("Passed PS/2 self test\n") if (result == 0x55) LOG("Passed PS/2 self test\n")
else LOG("Failed!\n") else LOG("Failed!\n")
// perform test // perform test
outb(PS2_8042_COMMAND, 0xAB); outb(PS2_8042_COMMAND, 0xAB);
while (!(inb(PS2_8042_STATUS) & 0x1)) cpu_relax; while (!(inb(PS2_8042_STATUS) & 0x1)) cpu_relax;
result = inb(PS2_8042_DATA); result = inb(PS2_8042_DATA);
if (!result) LOG("Passed PS/2 port 1 test\n") if (!result) LOG("Passed PS/2 port 1 test\n")
else LOG("Failed!\n") else LOG("Failed!\n")
// enable ps/2 // enable ps/2
outb(PS2_8042_COMMAND, 0xAE); outb(PS2_8042_COMMAND, 0xAE);
// enable IRQ 1 // enable IRQ 1
config = 0b01100101; config = 0b01100101;
@ -100,10 +100,10 @@ void ps2_handler() {
push_stdin('='); push_stdin('=');
break; break;
case KBD_BACKSPACE: case KBD_BACKSPACE:
/* /*
if (shell_index > 0) { if (shell_index > 0) {
//popchar(); //popchar();
shell_buffer[--shell_index] = 0; shell_buffer[--shell_index] = 0;
}*/ }*/
break; break;
case KBD_TAB: case KBD_TAB:
@ -146,25 +146,25 @@ void ps2_handler() {
break; break;
case KBD_ENTER: case KBD_ENTER:
/* /*
if (strcmp(shell_buffer, "PINGAS") == 0) { if (strcmp(shell_buffer, "PINGAS") == 0) {
printf("andew pingas detected"); printf("andew pingas detected");
} else if (strcmp(shell_buffer, "HELLO") == 0) { } else if (strcmp(shell_buffer, "HELLO") == 0) {
printf("hi"); printf("hi");
} else if (strcmp(shell_buffer, "READ") == 0) { } else if (strcmp(shell_buffer, "READ") == 0) {
uint8_t sector[512] = {0}; uint8_t sector[512] = {0};
ata_read_sector(ATA_PRIMARY, ATA_MASTER, 0, sector); ata_read_sector(ATA_PRIMARY, ATA_MASTER, 0, sector);
for (int i = 0; i < 512; i++) { for (int i = 0; i < 512; i++) {
push_stdin(sector[i]); push_stdin(sector[i]);
} }
} else { } else {
printf("unknown command '%s' idiot", shell_buffer); printf("unknown command '%s' idiot", shell_buffer);
} }
for (int i = 0; i < 512; i++) { for (int i = 0; i < 512; i++) {
shell_buffer[i] = 0; shell_buffer[i] = 0;
} }
shell_index = 0; shell_index = 0;
*/ */
push_stdin('\n'); push_stdin('\n');
break; break;
case KBD_LCTRL: case KBD_LCTRL:
// Handle left control key // Handle left control key

8
kernel/serial.c
View File

@ -7,7 +7,7 @@ uint8_t serial_port_init(int port) {
uint8_t old_scratch = inb(port + 7); uint8_t old_scratch = inb(port + 7);
outb(port + 7, old_scratch + 1); outb(port + 7, old_scratch + 1);
if (inb(port + 7) != old_scratch + 1) if (inb(port + 7) != old_scratch + 1)
return 0; return 0;
outb(port + 7, old_scratch); outb(port + 7, old_scratch);
outb(port + 1, 0x00); // Disable all interrupts outb(port + 1, 0x00); // Disable all interrupts
@ -22,7 +22,7 @@ uint8_t serial_port_init(int port) {
// Check if serial is faulty (i.e: not same byte as sent) // Check if serial is faulty (i.e: not same byte as sent)
if(inb(port + 0) != 0xAE) if(inb(port + 0) != 0xAE)
return 0; return 0;
// If serial is not faulty set it in normal operation mode // If serial is not faulty set it in normal operation mode
// (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled) // (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
@ -38,7 +38,7 @@ void serial_putc(int port, const char c) {
void serial_puts(int port, const char *str) { void serial_puts(int port, const char *str) {
while (*str) { while (*str) {
serial_putc(port, str[0]); serial_putc(port, str[0]);
str++; str++;
} }
} }

40
kernel/task.c
View File

@ -11,16 +11,16 @@ int task_init(task_t *task, elf_t *elf) {
if (!elf) return 0; if (!elf) return 0;
uint8_t *s = (uint8_t *)mmap_find_first_free_block(); uint8_t *s = (uint8_t *)mmap_find_first_free_block();
/* /*
memset(s, 0, 0x1000); memset(s, 0, 0x1000);
int idx = 0; int idx = 0;
// Loop section header to find ALLOC sections then allocate them // Loop section header to find ALLOC sections then allocate them
for (int i = 0; i < elf->e_shnum; i++) { for (int i = 0; i < elf->e_shnum; i++) {
section_t *sec = (section_t *)((uint32_t)elf + elf->e_shoff + i*elf->e_shentsize); section_t *sec = (section_t *)((uint32_t)elf + elf->e_shoff + i*elf->e_shentsize);
if (!(sec->sh_flags & 0x2)) continue; if (!(sec->sh_flags & 0x2)) continue;
if (!sec->sh_addr) continue; if (!sec->sh_addr) continue;
idx += sec->sh_offset; idx += sec->sh_offset;
memcpy(s + idx, (void *)((uint32_t)elf + sec->sh_offset), sec->sh_offset); memcpy(s + idx, (void *)((uint32_t)elf + sec->sh_offset), sec->sh_offset);
LOG("%d\n", sec->sh_offset); LOG("%d\n", sec->sh_offset);
} }
*/ */
memcpy(s, elf, 0x1000); memcpy(s, elf, 0x1000);
@ -39,12 +39,12 @@ int task_init(task_t *task, elf_t *elf) {
task->cr3 = (uint32_t)page_dir - KERNEL_VMA; task->cr3 = (uint32_t)page_dir - KERNEL_VMA;
uint32_t *page_tab = mmap_find_first_free_block(); uint32_t *page_tab = mmap_find_first_free_block();
for (int i = 0; i < 1024; i++) { for (int i = 0; i < 1024; i++) {
// Map kernel to 3GiB // Map kernel to 3GiB
if (i == 768) page_dir[i] = ((uint32_t)boot_page_tab - KERNEL_VMA) | 7; if (i == 768) page_dir[i] = ((uint32_t)boot_page_tab - KERNEL_VMA) | 7;
// Map 3.4GiB-4GiB as non-present kernel entries // Map 3.4GiB-4GiB as non-present kernel entries
else if (i > 768) page_dir[i] = 4; else if (i > 768) page_dir[i] = 4;
// Map remaining entries as non-present u/s // Map remaining entries as non-present u/s
else page_dir[i] = 6; else page_dir[i] = 6;
} }
// Map the ELF image to its specified entry // Map the ELF image to its specified entry
// This will cause problems if the ELF image is larger than 4 MiB so I need to fix this // This will cause problems if the ELF image is larger than 4 MiB so I need to fix this
@ -52,11 +52,11 @@ int task_init(task_t *task, elf_t *elf) {
page_dir[PAGE_DIR_INDEX(elf->e_entry)] = ((uint32_t)page_tab - KERNEL_VMA) | 7; page_dir[PAGE_DIR_INDEX(elf->e_entry)] = ((uint32_t)page_tab - KERNEL_VMA) | 7;
/* /*
uint32_t elf_phys = (uint32_t)s - KERNEL_VMA; uint32_t elf_phys = (uint32_t)s - KERNEL_VMA;
for (int i = 0; i < 1024; i++) { for (int i = 0; i < 1024; i++) {
page_tab[i] = (elf_phys + 0x1000*i) | 7; page_tab[i] = (elf_phys + 0x1000*i) | 7;
} }
*/ */
page_tab[PAGE_TAB_INDEX(elf->e_entry)] = ((uint32_t)s - KERNEL_VMA) | 7; page_tab[PAGE_TAB_INDEX(elf->e_entry)] = ((uint32_t)s - KERNEL_VMA) | 7;
return 1; return 1;
@ -69,7 +69,7 @@ void task_sort() {
task_t* temp = new_head; task_t* temp = new_head;
while (temp->next) { while (temp->next) {
temp = (task_t *)temp->next; temp = (task_t *)temp->next;
} }
temp->next = (uint32_t *)ctx.current_task; temp->next = (uint32_t *)ctx.current_task;