diff options
| author | Aleksa Vuckovic <aleksa@vuckovic.cc> | 2023-02-25 06:56:01 +0100 |
|---|---|---|
| committer | Aleksa Vuckovic <aleksa@vuckovic.cc> | 2023-02-25 08:45:09 +0100 |
| commit | 239900af293f192931391dc5579afab39a43e6c6 (patch) | |
| tree | 72d7f87ee6adf5aa84b78436197e03e61fba8d97 /kernel/src | |
| parent | aaa23fffd02fb49cdbc56a480dbb5a8fa95bff38 (diff) | |
clang-format
Diffstat (limited to 'kernel/src')
38 files changed, 743 insertions, 596 deletions
diff --git a/kernel/src/apic/apic.c b/kernel/src/apic/apic.c index 06c0661..2b650b0 100644 --- a/kernel/src/apic/apic.c +++ b/kernel/src/apic/apic.c @@ -16,7 +16,10 @@ uint8_t cpu_apic_ids[256]; uint8_t curr_cpu_apic_id() { - return (uint8_t)(((*((__volatile__ uint32_t*)((uint64_t)lapic_addr + 0x20))) >> 24) & 0xFF); + return (uint8_t)(((*((__volatile__ uint32_t *)((uint64_t)lapic_addr + + 0x20))) >> + 24) & + 0xFF); } void init_ap_cpus() @@ -26,43 +29,75 @@ void init_ap_cpus() init_mutex(&cnt_lock); map_addr(lapic_addr, lapic_addr, FLAG_PRESENT); - for(size_t i = 0; i < numcores; i++) { + for (size_t i = 0; i < numcores; i++) { // do not start BSP, that's already running this code - if(cpu_apic_ids[i] == bspid) + if (cpu_apic_ids[i] == bspid) continue; // send INIT IPI // clear APIC errors - *((__volatile__ uint32_t*)(lapic_addr + 0x280)) = 0; + *((__volatile__ uint32_t *)(lapic_addr + 0x280)) = 0; // select AP - *((__volatile__ uint32_t*)(lapic_addr + 0x310)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x310)) & 0x00ffffff) | ((uint32_t)cpu_apic_ids[i] << 24); + *((__volatile__ uint32_t *)(lapic_addr + 0x310)) = + (*((__volatile__ uint32_t *)(lapic_addr + 0x310)) & + 0x00ffffff) | + ((uint32_t)cpu_apic_ids[i] << 24); // trigger INIT IPI - *((__volatile__ uint32_t*)(lapic_addr + 0x300)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x300)) & 0xfff00000) | 0x00C500; + *((__volatile__ uint32_t *)(lapic_addr + 0x300)) = + (*((__volatile__ uint32_t *)(lapic_addr + 0x300)) & + 0xfff00000) | + 0x00C500; // wait for delivery - do { __asm__ __volatile__ ("pause" : : : "memory"); }while(*((__volatile__ uint32_t*)(uint64_t)(lapic_addr + 0x300)) & (1 << 12)); + do { + __asm__ __volatile__("pause" : : : "memory"); + } while (*((__volatile__ uint32_t *)(uint64_t)(lapic_addr + + 0x300)) & + (1 << 12)); // select AP - *((__volatile__ uint32_t*)(lapic_addr + 0x310)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x310)) & 0x00ffffff) | ((uint32_t)cpu_apic_ids[i] << 24); + *((__volatile__ uint32_t *)(lapic_addr + 0x310)) = + (*((__volatile__ uint32_t *)(lapic_addr + 0x310)) & + 0x00ffffff) | + ((uint32_t)cpu_apic_ids[i] << 24); // deassert - *((__volatile__ uint32_t*)(lapic_addr + 0x300)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x300)) & 0xfff00000) | 0x008500; + *((__volatile__ uint32_t *)(lapic_addr + 0x300)) = + (*((__volatile__ uint32_t *)(lapic_addr + 0x300)) & + 0xfff00000) | + 0x008500; // wait for delivery - do { __asm__ __volatile__ ("pause" : : : "memory"); }while(*((__volatile__ uint32_t*)(uint64_t)(lapic_addr + 0x300)) & (1 << 12)); + do { + __asm__ __volatile__("pause" : : : "memory"); + } while (*((__volatile__ uint32_t *)(uint64_t)(lapic_addr + + 0x300)) & + (1 << 12)); // wait 10 msec wait(10); // send STARTUP IPI (twice) - for(size_t j = 0; j < 2; j++) { + for (size_t j = 0; j < 2; j++) { // clear APIC errors - *((__volatile__ uint32_t*)(lapic_addr + 0x280)) = 0; + *((__volatile__ uint32_t *)(lapic_addr + 0x280)) = 0; // select AP - *((__volatile__ uint32_t*)(lapic_addr + 0x310)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x310)) & 0x00ffffff) | ((uint32_t)cpu_apic_ids[i] << 24); + *((__volatile__ uint32_t *)(lapic_addr + 0x310)) = + (*((__volatile__ uint32_t *)(lapic_addr + + 0x310)) & + 0x00ffffff) | + ((uint32_t)cpu_apic_ids[i] << 24); // trigger STARTUP IPI for 0800:0000 - *((__volatile__ uint32_t*)(lapic_addr + 0x300)) = (*((__volatile__ uint32_t*)(lapic_addr + 0x300)) & 0xfff0f800) | 0x000608; + *((__volatile__ uint32_t *)(lapic_addr + 0x300)) = + (*((__volatile__ uint32_t *)(lapic_addr + + 0x300)) & + 0xfff0f800) | + 0x000608; // wait 200 usec wait(1); // wait for delivery - do { __asm__ __volatile__ ("pause" : : : "memory"); }while(*((__volatile__ uint32_t*)(uint64_t)(lapic_addr + 0x300)) & (1 << 12)); + do { + __asm__ __volatile__("pause" : : : "memory"); + } while (*((__volatile__ uint32_t + *)(uint64_t)(lapic_addr + 0x300)) & + (1 << 12)); } } diff --git a/kernel/src/apic/ioapic.c b/kernel/src/apic/ioapic.c index bcd5a4d..cfda8be 100644 --- a/kernel/src/apic/ioapic.c +++ b/kernel/src/apic/ioapic.c @@ -7,29 +7,29 @@ void ioapic_eoi() { - *((__volatile__ uint32_t*)((uint64_t)lapic_addr + 0xB0)) = 0; + *((__volatile__ uint32_t *)((uint64_t)lapic_addr + 0xB0)) = 0; } uint32_t ioapic_read(const uint8_t offset) { - /* tell IOREGSEL where we want to read from */ - *(__volatile__ uint32_t*)(uint64_t)ioapic_addr = offset; - /* return the data from IOWIN */ - return *(__volatile__ uint32_t*)((uint64_t)ioapic_addr + 0x10); + /* tell IOREGSEL where we want to read from */ + *(__volatile__ uint32_t *)(uint64_t)ioapic_addr = offset; + /* return the data from IOWIN */ + return *(__volatile__ uint32_t *)((uint64_t)ioapic_addr + 0x10); } void ioapic_write(const uint8_t offset, const uint32_t val) { - /* tell IOREGSEL where we want to write to */ - *(__volatile__ uint32_t*)(uint64_t)ioapic_addr = offset; - /* write the value to IOWIN */ - *(__volatile__ uint32_t*)((uint64_t)ioapic_addr + 0x10) = val; + /* tell IOREGSEL where we want to write to */ + *(__volatile__ uint32_t *)(uint64_t)ioapic_addr = offset; + /* write the value to IOWIN */ + *(__volatile__ uint32_t *)((uint64_t)ioapic_addr + 0x10) = val; } void ioapic_set_irq(uint8_t irq, uint64_t apic_id, uint8_t vector) { - const uint32_t low_index = (uint32_t)0x10 + irq*2; - const uint32_t high_index = (uint32_t)0x10 + irq*2 + 1; + const uint32_t low_index = (uint32_t)0x10 + irq * 2; + const uint32_t high_index = (uint32_t)0x10 + irq * 2 + 1; uint32_t high = ioapic_read((uint8_t)high_index); // set APIC ID @@ -40,10 +40,10 @@ void ioapic_set_irq(uint8_t irq, uint64_t apic_id, uint8_t vector) uint32_t low = ioapic_read((uint8_t)low_index); // unmask the IRQ - low &= (uint32_t)~(1<<16); + low &= (uint32_t) ~(1 << 16); // set to physical delivery mode - low &= (uint32_t)~(1<<11); + low &= (uint32_t) ~(1 << 11); // set to fixed delivery mode low &= (uint32_t)~0x700; @@ -66,6 +66,7 @@ void apic_remap_interrupts() ioapic_set_irq(0x2, bspid, 0x20); // timer ioapic_set_irq(0x1, bspid, 0x21); // keyboard - write_msr(APIC_BASE_MSR, read_msr(APIC_BASE_MSR) | (1<<11)); - *((__volatile__ uint32_t*)(lapic_addr + 0xF0)) = (*(__volatile__ uint32_t*)(lapic_addr + 0xF0) | 0x1FF ); + write_msr(APIC_BASE_MSR, read_msr(APIC_BASE_MSR) | (1 << 11)); + *((__volatile__ uint32_t *)(lapic_addr + 0xF0)) = + (*(__volatile__ uint32_t *)(lapic_addr + 0xF0) | 0x1FF); } diff --git a/kernel/src/apic/madt.c b/kernel/src/apic/madt.c index f69887d..5a6e914 100644 --- a/kernel/src/apic/madt.c +++ b/kernel/src/apic/madt.c @@ -6,28 +6,37 @@ void parse_madt() { - uint64_t* madt_addr = find_sys_table_addr("APIC"); + uint64_t *madt_addr = find_sys_table_addr("APIC"); if (madt_addr == NULL) { printf("MADT NOT FOUND\n"); return; } - struct MADT* madt = (struct MADT*)kalloc(sizeof(struct MADT)); + struct MADT *madt = (struct MADT *)kalloc(sizeof(struct MADT)); memcpy(madt, madt_addr, sizeof(struct MADT)); lapic_addr = madt->lapic_addr; - for (size_t curr_size = sizeof(struct MADT); curr_size < madt->h.Length;) { - struct MADT_type_header* m = (struct MADT_type_header*)kalloc(sizeof(struct MADT_type_header)); - memcpy(m, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_type_header)); + for (size_t curr_size = sizeof(struct MADT); + curr_size < madt->h.Length;) { + struct MADT_type_header *m = (struct MADT_type_header *)kalloc( + sizeof(struct MADT_type_header)); + memcpy(m, + (uint64_t *)((uint64_t)madt_addr + (uint64_t)curr_size), + sizeof(struct MADT_type_header)); uint8_t type = m->type; uint8_t len = m->len; kfree(m); if (type == 0) { // Processor Local APIC - struct MADT_cpu_local_apic* cpu = (struct MADT_cpu_local_apic*)kalloc(sizeof(struct MADT_cpu_local_apic)); - memcpy(cpu, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_cpu_local_apic)); + struct MADT_cpu_local_apic *cpu = + (struct MADT_cpu_local_apic *)kalloc( + sizeof(struct MADT_cpu_local_apic)); + memcpy(cpu, + (uint64_t *)((uint64_t)madt_addr + + (uint64_t)curr_size), + sizeof(struct MADT_cpu_local_apic)); if (cpu->flags & 0x1) { cpu_apic_ids[numcores] = cpu->apic_id; @@ -38,8 +47,12 @@ void parse_madt() kfree(cpu); } else if (type == 1) { // I/O APIC - struct MADT_io_apic* io = (struct MADT_io_apic*)kalloc(sizeof(struct MADT_io_apic)); - memcpy(io, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_io_apic)); + struct MADT_io_apic *io = (struct MADT_io_apic *)kalloc( + sizeof(struct MADT_io_apic)); + memcpy(io, + (uint64_t *)((uint64_t)madt_addr + + (uint64_t)curr_size), + sizeof(struct MADT_io_apic)); ioapic_addr = io->io_apic_addr; @@ -47,8 +60,13 @@ void parse_madt() kfree(io); } else if (type == 2) { // IO/APIC Interrupt Source Override - struct MADT_io_apic_int* io_apic_int = (struct MADT_io_apic_int*)kalloc(sizeof(struct MADT_io_apic_int)); - memcpy(io_apic_int, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_io_apic_int)); + struct MADT_io_apic_int *io_apic_int = + (struct MADT_io_apic_int *)kalloc( + sizeof(struct MADT_io_apic_int)); + memcpy(io_apic_int, + (uint64_t *)((uint64_t)madt_addr + + (uint64_t)curr_size), + sizeof(struct MADT_io_apic_int)); // printf("found io_apic_int: bus: 0x%x, irq_source: 0x%x, global_sys_int: 0x%x, flags: 0x%x\n", io_apic_int->bus_source, io_apic_int->irq_source, io_apic_int->global_sys_int, io_apic_int->flags); kfree(io_apic_int); @@ -57,15 +75,25 @@ void parse_madt() printf("MADT entry of type %d\n", type); } else if (type == 4) { // Local APIC Non-maskable interrupts - struct MADT_lapic_nmi* lapic_nmi = (struct MADT_lapic_nmi*)kalloc(sizeof(struct MADT_lapic_nmi)); - memcpy(lapic_nmi, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_lapic_nmi)); + struct MADT_lapic_nmi *lapic_nmi = + (struct MADT_lapic_nmi *)kalloc( + sizeof(struct MADT_lapic_nmi)); + memcpy(lapic_nmi, + (uint64_t *)((uint64_t)madt_addr + + (uint64_t)curr_size), + sizeof(struct MADT_lapic_nmi)); // printf("found lapic_nmi: acpi_cpu_id: 0x%x, flags: 0x%x, lint: 0x%x\n", lapic_nmi->acpi_cpu_id, lapic_nmi->flags, lapic_nmi->lint); kfree(lapic_nmi); } else if (type == 5) { // Local APIC Address Override - struct MADT_lapic_addr* lapic_addr_ovr = (struct MADT_lapic_addr*)kalloc(sizeof(struct MADT_lapic_addr)); - memcpy(lapic_addr_ovr, (uint64_t*)((uint64_t)madt_addr + (uint64_t)curr_size), sizeof(struct MADT_lapic_addr)); + struct MADT_lapic_addr *lapic_addr_ovr = + (struct MADT_lapic_addr *)kalloc( + sizeof(struct MADT_lapic_addr)); + memcpy(lapic_addr_ovr, + (uint64_t *)((uint64_t)madt_addr + + (uint64_t)curr_size), + sizeof(struct MADT_lapic_addr)); // printf("found lapic: addr: 0x%x\n", lapic_addr_ovr->phys_addr); kfree(lapic_addr_ovr); diff --git a/kernel/src/apic/rsdp.c b/kernel/src/apic/rsdp.c index e0127aa..c12b63f 100644 --- a/kernel/src/apic/rsdp.c +++ b/kernel/src/apic/rsdp.c @@ -4,12 +4,12 @@ #include <libk/string.h> #include <libk/stdio.h> -uint64_t* find_rsdp() +uint64_t *find_rsdp() { map_addr(0x0, 0x0, FLAG_PRESENT); - const char* rsdp_cs = "RSD PTR "; + const char *rsdp_cs = "RSD PTR "; for (uint64_t i = 0x10; i < 0x100000; i += 0x10) { - char *x = (char*)i; + char *x = (char *)i; uint8_t ind = 1; for (size_t j = 0; j < strlen(rsdp_cs); j++) { if (rsdp_cs[j] != x[j]) { @@ -18,7 +18,7 @@ uint64_t* find_rsdp() } } if (ind) { - return (uint64_t*)i; + return (uint64_t *)i; } } return NULL; @@ -26,28 +26,35 @@ uint64_t* find_rsdp() void list_sys_tables(void) { - uint64_t* rsdp = find_rsdp(); + uint64_t *rsdp = find_rsdp(); if (rsdp == NULL) { printf("RSDP NOT FOUND\n"); return; } - struct RSDP_descriptor* rsdp_desc = (struct RSDP_descriptor*)rsdp; + struct RSDP_descriptor *rsdp_desc = (struct RSDP_descriptor *)rsdp; map_addr(rsdp_desc->RsdtAddress, rsdp_desc->RsdtAddress, FLAG_PRESENT); - struct ACPI_header* rsdt = (struct ACPI_header*)kalloc(sizeof(struct ACPI_header)); - memcpy(rsdt, (uint64_t*)(uint64_t)rsdp_desc->RsdtAddress, sizeof(struct ACPI_header)); + struct ACPI_header *rsdt = + (struct ACPI_header *)kalloc(sizeof(struct ACPI_header)); + memcpy(rsdt, (uint64_t *)(uint64_t)rsdp_desc->RsdtAddress, + sizeof(struct ACPI_header)); - uint32_t entries = (rsdt->Length - (uint32_t)sizeof(struct ACPI_header)) / 4; + uint32_t entries = + (rsdt->Length - (uint32_t)sizeof(struct ACPI_header)) / 4; for (size_t i = 0; i < entries; i++) { - uint32_t na_addr = (uint32_t)rsdp_desc->RsdtAddress + (uint32_t)sizeof(struct ACPI_header) + (uint32_t)i * 4; + uint32_t na_addr = (uint32_t)rsdp_desc->RsdtAddress + + (uint32_t)sizeof(struct ACPI_header) + + (uint32_t)i * 4; uint32_t addr; - memcpy(&addr, (uint64_t*)(uint64_t)na_addr, 4); + memcpy(&addr, (uint64_t *)(uint64_t)na_addr, 4); - struct ACPI_header* t = (struct ACPI_header*)kalloc(sizeof(struct ACPI_header)); - memcpy(t, (uint64_t*)(uint64_t)addr, sizeof(struct ACPI_header)); + struct ACPI_header *t = (struct ACPI_header *)kalloc( + sizeof(struct ACPI_header)); + memcpy(t, (uint64_t *)(uint64_t)addr, + sizeof(struct ACPI_header)); for (size_t j = 0; j < 4; j++) { printf("%c", t->Signature[j]); @@ -61,30 +68,37 @@ void list_sys_tables(void) kfree(rsdt); } -uint64_t* find_sys_table_addr(const char* signature) +uint64_t *find_sys_table_addr(const char *signature) { - uint64_t* rsdp = find_rsdp(); + uint64_t *rsdp = find_rsdp(); if (rsdp == NULL) { printf("RSDP NOT FOUND\n"); return NULL; } - struct RSDP_descriptor* rsdp_desc = (struct RSDP_descriptor*)rsdp; + struct RSDP_descriptor *rsdp_desc = (struct RSDP_descriptor *)rsdp; map_addr(rsdp_desc->RsdtAddress, rsdp_desc->RsdtAddress, FLAG_PRESENT); - struct ACPI_header* rsdt = (struct ACPI_header*)kalloc(sizeof(struct ACPI_header)); - memcpy(rsdt, (uint64_t*)(uint64_t)rsdp_desc->RsdtAddress, sizeof(struct ACPI_header)); + struct ACPI_header *rsdt = + (struct ACPI_header *)kalloc(sizeof(struct ACPI_header)); + memcpy(rsdt, (uint64_t *)(uint64_t)rsdp_desc->RsdtAddress, + sizeof(struct ACPI_header)); - uint32_t entries = (rsdt->Length - (uint32_t)sizeof(struct ACPI_header)) / 4; + uint32_t entries = + (rsdt->Length - (uint32_t)sizeof(struct ACPI_header)) / 4; for (size_t i = 0; i < entries; i++) { - uint32_t na_addr = (uint32_t)rsdp_desc->RsdtAddress + (uint32_t)sizeof(struct ACPI_header) + (uint32_t)i * 4; + uint32_t na_addr = (uint32_t)rsdp_desc->RsdtAddress + + (uint32_t)sizeof(struct ACPI_header) + + (uint32_t)i * 4; uint32_t addr; - memcpy(&addr, (uint64_t*)(uint64_t)na_addr, 4); + memcpy(&addr, (uint64_t *)(uint64_t)na_addr, 4); - struct ACPI_header* t = (struct ACPI_header*)kalloc(sizeof(struct ACPI_header)); - memcpy(t, (uint64_t*)(uint64_t)addr, sizeof(struct ACPI_header)); + struct ACPI_header *t = (struct ACPI_header *)kalloc( + sizeof(struct ACPI_header)); + memcpy(t, (uint64_t *)(uint64_t)addr, + sizeof(struct ACPI_header)); int ind = 1; for (size_t j = 0; j < 4; j++) { @@ -94,7 +108,7 @@ uint64_t* find_sys_table_addr(const char* signature) if (ind) { kfree(t); kfree(rsdt); - return (uint64_t*)(uint64_t)addr; + return (uint64_t *)(uint64_t)addr; } kfree(t); diff --git a/kernel/src/boot/multiboot2.c b/kernel/src/boot/multiboot2.c index dd3ab78..8a7d0d6 100644 --- a/kernel/src/boot/multiboot2.c +++ b/kernel/src/boot/multiboot2.c @@ -1,9 +1,7 @@ #include <types.h> #include <multiboot2.h> - #include <graphics.h> #include <paging.h> - #include <libk/serial_stdio.h> #include <libk/string.h> #include <libk/list.h> @@ -12,11 +10,11 @@ /* https://www.gnu.org/software/grub/manual/multiboot2/html_node/Boot-information-format.html */ -mb2_tag_module* ext2_module; +mb2_tag_module *ext2_module; mmap_t mmap; -void init_fb(mb2_tag_fb* tag_fb) +void init_fb(mb2_tag_fb *tag_fb) { main_fb.addr = tag_fb->framebuffer_addr; main_fb.width = tag_fb->framebuffer_width; @@ -28,62 +26,70 @@ void init_fb(mb2_tag_fb* tag_fb) // identity map framebuffer address map_addr(main_fb.addr, main_fb.addr, FLAG_PRESENT | FLAG_WRITABLE); - map_addr(main_fb.addr + PAGE_SIZE, main_fb.addr + PAGE_SIZE, FLAG_PRESENT | FLAG_WRITABLE); + map_addr(main_fb.addr + PAGE_SIZE, main_fb.addr + PAGE_SIZE, + FLAG_PRESENT | FLAG_WRITABLE); } -void init_mmap(mb2_tag_mmap* tag_mmap) +void init_mmap(mb2_tag_mmap *tag_mmap) { INIT_LIST(mmap.list) // get data and store it into list - for (size_t i = sizeof(mb2_tag_mmap); i < tag_mmap->size; i += sizeof(mb2_tag_mmap_entry)) { - mmap_t* curr_mmap_entry = (mmap_t*)kalloc(sizeof(mmap_t)); - memcpy(&curr_mmap_entry->mmap_entry, (char*)tag_mmap + i, sizeof(mb2_tag_mmap_entry)); + for (size_t i = sizeof(mb2_tag_mmap); i < tag_mmap->size; + i += sizeof(mb2_tag_mmap_entry)) { + mmap_t *curr_mmap_entry = (mmap_t *)kalloc(sizeof(mmap_t)); + memcpy(&curr_mmap_entry->mmap_entry, (char *)tag_mmap + i, + sizeof(mb2_tag_mmap_entry)); add_to_list(&curr_mmap_entry->list, &mmap.list, mmap.list.next); } } -void init_module(mb2_tag_module* tag_module) +void init_module(mb2_tag_module *tag_module) { // name is utf-8 encoded string! - uint32_t name_size = tag_module->size - sizeof(tag_module) + sizeof(char*); - tag_module->name = (char*)kalloc(name_size); - memcpy(tag_module->name, tag_module + tag_module->size - name_size, name_size); + uint32_t name_size = + tag_module->size - sizeof(tag_module) + sizeof(char *); + tag_module->name = (char *)kalloc(name_size); + memcpy(tag_module->name, tag_module + tag_module->size - name_size, + name_size); kfree(tag_module->name); } -void read_mb2(mb2_tag_header* multiboot_bootinfo, uint32_t multiboot_magic) +void read_mb2(mb2_tag_header *multiboot_bootinfo, uint32_t multiboot_magic) { if (multiboot_magic != MB2_MAGIC) { // not loaded by multiboot2 bootloader - __asm__ __volatile__ ("hlt;"); + __asm__ __volatile__("hlt;"); } // we will store framebuffer information here - static mb2_tag_fb* tag_fb; - static mb2_tag_mmap* tag_mmap; + static mb2_tag_fb *tag_fb; + static mb2_tag_mmap *tag_mmap; // skip first 8 bytes (total_size + reserved) - mb2_tag_header* tag_header = (mb2_tag_header*)((uint64_t)multiboot_bootinfo + 8 + KERNEL_VMA); + mb2_tag_header *tag_header = + (mb2_tag_header *)((uint64_t)multiboot_bootinfo + 8 + + KERNEL_VMA); while (tag_header->type != MB2_TAG_END) { // process tag_type - switch(tag_header->type) { - case MB2_TAG_FB: - tag_fb = (mb2_tag_fb*)tag_header; - break; - case MB2_TAG_MMAP: - tag_mmap = (mb2_tag_mmap*)tag_header; - break; - case MB2_TAG_MODULE: - ext2_module = (mb2_tag_module*)tag_header; - break; - default: - break; + switch (tag_header->type) { + case MB2_TAG_FB: + tag_fb = (mb2_tag_fb *)tag_header; + break; + case MB2_TAG_MMAP: + tag_mmap = (mb2_tag_mmap *)tag_header; + break; + case MB2_TAG_MODULE: + ext2_module = (mb2_tag_module *)tag_header; + break; + default: + break; } // next mb2_tag - tag_header += tag_header->size / 8 + ((tag_header->size % 8) > 0); + tag_header += + tag_header->size / 8 + ((tag_header->size % 8) > 0); } init_fb(tag_fb); diff --git a/kernel/src/check/panic.c b/kernel/src/check/panic.c index 894f22f..7cfaa56 100644 --- a/kernel/src/check/panic.c +++ b/kernel/src/check/panic.c @@ -5,12 +5,11 @@ uint64_t panic_rsp; -__attribute__((noreturn)) -void panic(const char *s, ...) +__attribute__((noreturn)) void panic(const char *s, ...) { set_color(&main_fb, RED, BLACK); printf("KERNEL PANIC\n"); -// set_color(&main_fb, WHITE, BLACK); + // set_color(&main_fb, WHITE, BLACK); va_list list; va_start(list, s); vprintf(s, list); @@ -19,34 +18,38 @@ void panic(const char *s, ...) if (panic_rsp != 0) { printf("info:\n"); uint64_t i = 0; - printf("ss: 0x%x ", (uint16_t)*((uint64_t*)panic_rsp + i++)); - printf("ds: 0x%x ", (uint16_t)*((uint64_t*)panic_rsp + i++)); - printf("es: 0x%x ", (uint16_t)*((uint64_t*)panic_rsp + i++)); - printf("r15: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r14: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r13: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r12: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r11: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r10: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r9: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("r8: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rdi: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rsi: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rdx: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rcx: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rbx: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rax: 0x%x ", *((uint64_t*)panic_rsp + i++)); - if (*((uint64_t*)panic_rsp + i) <= 0xffffffff) - printf("err code: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rip: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("cs: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rflags: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("rsp: 0x%x ", *((uint64_t*)panic_rsp + i++)); - printf("ss: 0x%x ", *((uint64_t*)panic_rsp + i++)); + printf("ss: 0x%x ", + (uint16_t) * ((uint64_t *)panic_rsp + i++)); + printf("ds: 0x%x ", + (uint16_t) * ((uint64_t *)panic_rsp + i++)); + printf("es: 0x%x ", + (uint16_t) * ((uint64_t *)panic_rsp + i++)); + printf("r15: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r14: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r13: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r12: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r11: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r10: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r9: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("r8: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rdi: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rsi: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rdx: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rcx: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rbx: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rax: 0x%x ", *((uint64_t *)panic_rsp + i++)); + if (*((uint64_t *)panic_rsp + i) <= 0xffffffff) + printf("err code: 0x%x ", + *((uint64_t *)panic_rsp + i++)); + printf("rip: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("cs: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rflags: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("rsp: 0x%x ", *((uint64_t *)panic_rsp + i++)); + printf("ss: 0x%x ", *((uint64_t *)panic_rsp + i++)); } disable_interrupts(); - for(;;) { - __asm__ __volatile__ ("hlt;"); + for (;;) { + __asm__ __volatile__("hlt;"); } } diff --git a/kernel/src/check/ssp.c b/kernel/src/check/ssp.c index 86288b1..65271eb 100644 --- a/kernel/src/check/ssp.c +++ b/kernel/src/check/ssp.c @@ -6,8 +6,8 @@ uintptr_t __stack_chk_guard = STACK_CHK_GUARD; -__attribute__((noreturn)) -void __stack_chk_fail(void) +__attribute__((noreturn)) void __stack_chk_fail(void); +__attribute__((noreturn)) void __stack_chk_fail(void) { panic("Stack smashing detected"); } diff --git a/kernel/src/check/ubsan.c b/kernel/src/check/ubsan.c index c3933da..dc6c4b4 100644 --- a/kernel/src/check/ubsan.c +++ b/kernel/src/check/ubsan.c @@ -23,15 +23,13 @@ #include <ubsan.h> #include <panic.h> -struct ubsan_source_location -{ - const char* filename; +struct ubsan_source_location { + const char *filename; uint32_t line; uint32_t column; }; -struct ubsan_type_descriptor -{ +struct ubsan_type_descriptor { uint16_t type_kind; uint16_t type_info; char type_name[]; @@ -39,348 +37,320 @@ struct ubsan_type_descriptor typedef uintptr_t ubsan_value_handle_t; -static const struct ubsan_source_location unknown_location = -{ +static const struct ubsan_source_location unknown_location = { "<unknown file>", 0, 0, }; -__attribute__((noreturn)) -static void ubsan_abort(const struct ubsan_source_location* location, - const char* violation) +__attribute__((noreturn)) static void +ubsan_abort(const struct ubsan_source_location *location, const char *violation) { - if ( !location || !location->filename ) + if (!location || !location->filename) location = &unknown_location; panic_rsp = 0; - panic( - "filename = %s; line = %d; column = %d; violation = %s;\n", - location->filename, location->line, location->column, violation); + panic("filename = %s; line = %d; column = %d; violation = %s;\n", + location->filename, location->line, location->column, violation); } -#define ABORT_VARIANT(name, params, call) \ -__attribute__((noreturn)) \ -void __ubsan_handle_##name##_abort params \ -{ \ - __ubsan_handle_##name call; \ - __builtin_unreachable(); \ -} +#define ABORT_VARIANT(name, params, call) \ + __attribute__((noreturn)) void __ubsan_handle_##name##_abort params \ + { \ + __ubsan_handle_##name call; \ + __builtin_unreachable(); \ + } -#define ABORT_VARIANT_VP(name) \ -ABORT_VARIANT(name, (void* a), (a)) +#define ABORT_VARIANT_VP(name) ABORT_VARIANT(name, (void *a), (a)) #define ABORT_VARIANT_VP_VP(name) \ -ABORT_VARIANT(name, (void* a, void* b), (a, b)) + ABORT_VARIANT(name, (void *a, void *b), (a, b)) #define ABORT_VARIANT_VP_IP(name) \ -ABORT_VARIANT(name, (void* a, intptr_t b), (a, b)) + ABORT_VARIANT(name, (void *a, intptr_t b), (a, b)) #define ABORT_VARIANT_VP_VP_VP(name) \ -ABORT_VARIANT(name, (void* a, void* b, void* c), (a, b, c)) + ABORT_VARIANT(name, (void *a, void *b, void *c), (a, b, c)) -struct ubsan_type_mismatch_v1_data -{ +struct ubsan_type_mismatch_v1_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; uintptr_t alignment; unsigned char type_check_kind; }; -void __ubsan_handle_type_mismatch_v1(void* data_raw, - void* pointer_raw) +void __ubsan_handle_type_mismatch_v1(void *data_raw, void *pointer_raw) { - struct ubsan_type_mismatch_v1_data* data = - (struct ubsan_type_mismatch_v1_data*) data_raw; - ubsan_value_handle_t pointer = (ubsan_value_handle_t) pointer_raw; - const char* violation = "type mismatch"; - if ( !pointer ) + struct ubsan_type_mismatch_v1_data *data = + (struct ubsan_type_mismatch_v1_data *)data_raw; + ubsan_value_handle_t pointer = (ubsan_value_handle_t)pointer_raw; + const char *violation = "type mismatch"; + if (!pointer) violation = "null pointer access"; - else if ( data->alignment && (pointer & (data->alignment - 1)) ) + else if (data->alignment && (pointer & (data->alignment - 1))) violation = "unaligned access"; ubsan_abort(&data->location, violation); } ABORT_VARIANT_VP_VP(type_mismatch_v1); -struct ubsan_overflow_data -{ +struct ubsan_overflow_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; }; -void __ubsan_handle_pointer_overflow(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_pointer_overflow(void *data_raw, void *lhs_raw, + void *rhs_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "pointer overflow"); } ABORT_VARIANT_VP_VP_VP(pointer_overflow); -void __ubsan_handle_add_overflow(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_add_overflow(void *data_raw, void *lhs_raw, void *rhs_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "addition overflow"); } ABORT_VARIANT_VP_VP_VP(add_overflow); -void __ubsan_handle_sub_overflow(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_sub_overflow(void *data_raw, void *lhs_raw, void *rhs_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "subtraction overflow"); } ABORT_VARIANT_VP_VP_VP(sub_overflow); -void __ubsan_handle_mul_overflow(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_mul_overflow(void *data_raw, void *lhs_raw, void *rhs_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "multiplication overflow"); } ABORT_VARIANT_VP_VP_VP(mul_overflow); -void __ubsan_handle_negate_overflow(void* data_raw, - void* old_value_raw) +void __ubsan_handle_negate_overflow(void *data_raw, void *old_value_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t old_value = (ubsan_value_handle_t) old_value_raw; - (void) old_value; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t old_value = (ubsan_value_handle_t)old_value_raw; + (void)old_value; ubsan_abort(&data->location, "negation overflow"); } ABORT_VARIANT_VP_VP(negate_overflow); -void __ubsan_handle_divrem_overflow(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_divrem_overflow(void *data_raw, void *lhs_raw, + void *rhs_raw) { - struct ubsan_overflow_data* data = (struct ubsan_overflow_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_overflow_data *data = + (struct ubsan_overflow_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "division remainder overflow"); } ABORT_VARIANT_VP_VP_VP(divrem_overflow); -struct ubsan_shift_out_of_bounds_data -{ +struct ubsan_shift_out_of_bounds_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* lhs_type; - struct ubsan_type_descriptor* rhs_type; + struct ubsan_type_descriptor *lhs_type; + struct ubsan_type_descriptor *rhs_type; }; -void __ubsan_handle_shift_out_of_bounds(void* data_raw, - void* lhs_raw, - void* rhs_raw) +void __ubsan_handle_shift_out_of_bounds(void *data_raw, void *lhs_raw, + void *rhs_raw) { - struct ubsan_shift_out_of_bounds_data* data = - (struct ubsan_shift_out_of_bounds_data*) data_raw; - ubsan_value_handle_t lhs = (ubsan_value_handle_t) lhs_raw; - ubsan_value_handle_t rhs = (ubsan_value_handle_t) rhs_raw; - (void) lhs; - (void) rhs; + struct ubsan_shift_out_of_bounds_data *data = + (struct ubsan_shift_out_of_bounds_data *)data_raw; + ubsan_value_handle_t lhs = (ubsan_value_handle_t)lhs_raw; + ubsan_value_handle_t rhs = (ubsan_value_handle_t)rhs_raw; + (void)lhs; + (void)rhs; ubsan_abort(&data->location, "shift out of bounds"); } ABORT_VARIANT_VP_VP_VP(shift_out_of_bounds); -struct ubsan_out_of_bounds_data -{ +struct ubsan_out_of_bounds_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* array_type; - struct ubsan_type_descriptor* index_type; + struct ubsan_type_descriptor *array_type; + struct ubsan_type_descriptor *index_type; }; -void __ubsan_handle_out_of_bounds(void* data_raw, - void* index_raw) +void __ubsan_handle_out_of_bounds(void *data_raw, void *index_raw) { - struct ubsan_out_of_bounds_data* data = - (struct ubsan_out_of_bounds_data*) data_raw; - ubsan_value_handle_t index = (ubsan_value_handle_t) index_raw; - (void) index; + struct ubsan_out_of_bounds_data *data = + (struct ubsan_out_of_bounds_data *)data_raw; + ubsan_value_handle_t index = (ubsan_value_handle_t)index_raw; + (void)index; ubsan_abort(&data->location, "out of bounds"); } ABORT_VARIANT_VP_VP(out_of_bounds); -struct ubsan_unreachable_data -{ +struct ubsan_unreachable_data { struct ubsan_source_location location; }; -__attribute__((noreturn)) -void __ubsan_handle_builtin_unreachable(void* data_raw) +__attribute__((noreturn)) void +__ubsan_handle_builtin_unreachable(void *data_raw) { - struct ubsan_unreachable_data* data = - (struct ubsan_unreachable_data*) data_raw; + struct ubsan_unreachable_data *data = + (struct ubsan_unreachable_data *)data_raw; ubsan_abort(&data->location, "reached unreachable"); } -__attribute__((noreturn)) -void __ubsan_handle_missing_return(void* data_raw) +__attribute__((noreturn)) void __ubsan_handle_missing_return(void *data_raw) { - struct ubsan_unreachable_data* data = - (struct ubsan_unreachable_data*) data_raw; + struct ubsan_unreachable_data *data = + (struct ubsan_unreachable_data *)data_raw; ubsan_abort(&data->location, "missing return"); } -struct ubsan_vla_bound_data -{ +struct ubsan_vla_bound_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; }; -void __ubsan_handle_vla_bound_not_positive(void* data_raw, - void* bound_raw) +void __ubsan_handle_vla_bound_not_positive(void *data_raw, void *bound_raw) { - struct ubsan_vla_bound_data* data = (struct ubsan_vla_bound_data*) data_raw; - ubsan_value_handle_t bound = (ubsan_value_handle_t) bound_raw; - (void) bound; + struct ubsan_vla_bound_data *data = + (struct ubsan_vla_bound_data *)data_raw; + ubsan_value_handle_t bound = (ubsan_value_handle_t)bound_raw; + (void)bound; ubsan_abort(&data->location, "negative variable array length"); } ABORT_VARIANT_VP_VP(vla_bound_not_positive); -struct ubsan_float_cast_overflow_data -{ +struct ubsan_float_cast_overflow_data { // TODO: Remove this GCC 5.x compatibility after switching to GCC 6.x. The // GCC developers accidentally forgot the source location. Their // libubsan probes to see if it looks like a path, but we don't need // to maintain compatibility with multiple gcc releases. See below. -#if !(defined(__GNUC__) && __GNUC__< 6) +#if !(defined(__GNUC__) && __GNUC__ < 6) struct ubsan_source_location location; #endif - struct ubsan_type_descriptor* from_type; - struct ubsan_type_descriptor* to_type; + struct ubsan_type_descriptor *from_type; + struct ubsan_type_descriptor *to_type; }; -void __ubsan_handle_float_cast_overflow(void* data_raw, - void* from_raw) +void __ubsan_handle_float_cast_overflow(void *data_raw, void *from_raw) { - struct ubsan_float_cast_overflow_data* data = - (struct ubsan_float_cast_overflow_data*) data_raw; - ubsan_value_handle_t from = (ubsan_value_handle_t) from_raw; - (void) from; -#if !(defined(__GNUC__) && __GNUC__< 6) + struct ubsan_float_cast_overflow_data *data = + (struct ubsan_float_cast_overflow_data *)data_raw; + ubsan_value_handle_t from = (ubsan_value_handle_t)from_raw; + (void)from; +#if !(defined(__GNUC__) && __GNUC__ < 6) ubsan_abort(&data->location, "float cast overflow"); #else - ubsan_abort(((void) data, &unknown_location), "float cast overflow"); + ubsan_abort(((void)data, &unknown_location), "float cast overflow"); #endif } ABORT_VARIANT_VP_VP(float_cast_overflow); -struct ubsan_invalid_value_data -{ +struct ubsan_invalid_value_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; }; -void __ubsan_handle_load_invalid_value(void* data_raw, - void* value_raw) +void __ubsan_handle_load_invalid_value(void *data_raw, void *value_raw) { - struct ubsan_invalid_value_data* data = - (struct ubsan_invalid_value_data*) data_raw; - ubsan_value_handle_t value = (ubsan_value_handle_t) value_raw; - (void) value; + struct ubsan_invalid_value_data *data = + (struct ubsan_invalid_value_data *)data_raw; + ubsan_value_handle_t value = (ubsan_value_handle_t)value_raw; + (void)value; ubsan_abort(&data->location, "invalid value load"); } ABORT_VARIANT_VP_VP(load_invalid_value); -struct ubsan_function_type_mismatch_v1_data -{ +struct ubsan_function_type_mismatch_v1_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; }; -void __ubsan_handle_function_type_mismatch_v1(void* data_raw, - void* value_raw) +void __ubsan_handle_function_type_mismatch_v1(void *data_raw, void *value_raw) { - struct ubsan_function_type_mismatch_v1_data* data = - (struct ubsan_function_type_mismatch_v1_data*) data_raw; - ubsan_value_handle_t value = (ubsan_value_handle_t) value_raw; - (void) value; + struct ubsan_function_type_mismatch_v1_data *data = + (struct ubsan_function_type_mismatch_v1_data *)data_raw; + ubsan_value_handle_t value = (ubsan_value_handle_t)value_raw; + (void)value; ubsan_abort(&data->location, "function type mismatch"); } ABORT_VARIANT_VP_VP(function_type_mismatch_v1); -struct ubsan_nonnull_return_data -{ +struct ubsan_nonnull_return_data { struct ubsan_source_location location; struct ubsan_source_location attr_location; }; -void __ubsan_handle_nonnull_return(void* data_raw) +void __ubsan_handle_nonnull_return(void *data_raw) { - struct ubsan_nonnull_return_data* data = - (struct ubsan_nonnull_return_data*) data_raw; + struct ubsan_nonnull_return_data *data = + (struct ubsan_nonnull_return_data *)data_raw; ubsan_abort(&data->location, "null return"); } ABORT_VARIANT_VP(nonnull_return); -struct ubsan_nonnull_arg_data -{ +struct ubsan_nonnull_arg_data { struct ubsan_source_location location; struct ubsan_source_location attr_location; }; // TODO: GCC's libubsan does not have the second parameter, but its builtin // somehow has it and conflict if we don't match it. -void __ubsan_handle_nonnull_arg(void* data_raw, - intptr_t index_raw) +void __ubsan_handle_nonnull_arg(void *data_raw, intptr_t index_raw) { - struct ubsan_nonnull_arg_data* data = - (struct ubsan_nonnull_arg_data*) data_raw; - ubsan_value_handle_t index = (ubsan_value_handle_t) index_raw; - (void) index; + struct ubsan_nonnull_arg_data *data = + (struct ubsan_nonnull_arg_data *)data_raw; + ubsan_value_handle_t index = (ubsan_value_handle_t)index_raw; + (void)index; ubsan_abort(&data->location, "null argument"); } ABORT_VARIANT_VP_IP(nonnull_arg); -struct ubsan_cfi_bad_icall_data -{ +struct ubsan_cfi_bad_icall_data { struct ubsan_source_location location; - struct ubsan_type_descriptor* type; + struct ubsan_type_descriptor *type; }; -void __ubsan_handle_cfi_bad_icall(void* data_raw, - void* value_raw) +void __ubsan_handle_cfi_bad_icall(void *data_raw, void *value_raw) { - struct ubsan_cfi_bad_icall_data* data = - (struct ubsan_cfi_bad_icall_data*) data_raw; - ubsan_value_handle_t value = (ubsan_value_handle_t) value_raw; - (void) value; - ubsan_abort(&data->location, - "control flow integrity check failure during indirect call"); + struct ubsan_cfi_bad_icall_data *data = + (struct ubsan_cfi_bad_icall_data *)data_raw; + ubsan_value_handle_t value = (ubsan_value_handle_t)value_raw; + (void)value; + ubsan_abort( + &data->location, + "control flow integrity check failure during indirect call"); } ABORT_VARIANT_VP_VP(cfi_bad_icall); diff --git a/kernel/src/cpu/gdt.c b/kernel/src/cpu/gdt.c index 58db962..7460474 100644 --- a/kernel/src/cpu/gdt.c +++ b/kernel/src/cpu/gdt.c @@ -4,7 +4,8 @@ gdt_seg_entry gdt[7]; gdt_p gdt_pointer; -void add_gdt_entry(uint32_t num, uint32_t offset, uint32_t limit, uint8_t access, uint8_t flags) +void add_gdt_entry(uint32_t num, uint32_t offset, uint32_t limit, + uint8_t access, uint8_t flags) { gdt[num].offset1 = offset & 0xffff; gdt[num].offset2 = (offset >> 16) & 0xff; @@ -15,31 +16,31 @@ void add_gdt_entry(uint32_t num, uint32_t offset, uint32_t limit, uint8_t access gdt[num].limitflags = (uint8_t)(flags << 4); } -void add_gdt_tss(uint32_t num, uint64_t offset, uint32_t limit, uint8_t access, uint8_t flags) +void add_gdt_tss(uint32_t num, uint64_t offset, uint32_t limit, uint8_t access, + uint8_t flags) { uint32_t offset_low = (offset & 0xffffffff); uint32_t offset_high = (uint32_t)(offset >> 32); add_gdt_entry(num, offset_low, limit, access, flags); - gdt[num+1].limit = (offset_high & 0xffff); - gdt[num+1].offset1 = (uint16_t)(offset_high >> 16); + gdt[num + 1].limit = (offset_high & 0xffff); + gdt[num + 1].offset1 = (uint16_t)(offset_high >> 16); } void reload_gdt() { - __asm__ __volatile__ ( - // reload segment registers - "mov $0x10, %ax;" - "mov %ax, %ds;" - "mov %ax, %es;" - "mov %ax, %ss;" - "mov %ax, %fs;" - "mov %ax, %gs;" - ); + __asm__ __volatile__( + // reload segment registers + "mov $0x10, %ax;" + "mov %ax, %ds;" + "mov %ax, %es;" + "mov %ax, %ss;" + "mov %ax, %fs;" + "mov %ax, %gs;"); } -void load_gdt(gdt_p* pointer) +void load_gdt(gdt_p *pointer) { - __asm__ __volatile__ ("lgdt (%0);" : : "r"(pointer) : ); + __asm__ __volatile__("lgdt (%0);" : : "r"(pointer) :); reload_gdt(); } diff --git a/kernel/src/cpu/idt.c b/kernel/src/cpu/idt.c index 1b0fffb..9134d84 100644 --- a/kernel/src/cpu/idt.c +++ b/kernel/src/cpu/idt.c @@ -1,5 +1,4 @@ #include <idt.h> - #include <irq.h> #include <pic.h> @@ -8,17 +7,17 @@ idtp idt_pointer; void enable_interrupts(void) { - __asm__ __volatile__ ("sti;"); + __asm__ __volatile__("sti;"); } void disable_interrupts(void) { - __asm__ __volatile__ ("cli;"); + __asm__ __volatile__("cli;"); } -void load_idt(idtp* pointer) +void load_idt(idtp *pointer) { - __asm__ __volatile__ ("lidt (%0);" : : "r"(pointer) : ); + __asm__ __volatile__("lidt (%0);" : : "r"(pointer) :); } void add_to_idt(uint16_t num, uint64_t offset, uint16_t selector, uint8_t type) @@ -72,7 +71,8 @@ void init_idt_table(void) add_to_idt(32, (uint64_t)irq0, GDT_CODE_SEG, INTERRUPT_GATE); add_to_idt(33, (uint64_t)irq1, GDT_CODE_SEG, INTERRUPT_GATE); for (size_t i = 34; i < 256; i++) { - add_to_idt((uint16_t)i, (uint64_t)irq2, GDT_CODE_SEG, INTERRUPT_GATE); + add_to_idt((uint16_t)i, (uint64_t)irq2, GDT_CODE_SEG, + INTERRUPT_GATE); } } diff --git a/kernel/src/cpu/io.c b/kernel/src/cpu/io.c index 4b5e5ac..e638ae7 100644 --- a/kernel/src/cpu/io.c +++ b/kernel/src/cpu/io.c @@ -4,13 +4,13 @@ uint8_t inb(uint32_t port) { uint8_t ret; - __asm__ __volatile__ ("inb %%dx, %%al;" : "=a"(ret) : "d"(port)); + __asm__ __volatile__("inb %%dx, %%al;" : "=a"(ret) : "d"(port)); return ret; } void outb(uint32_t port, uint8_t value) { - __asm__ __volatile__ ("outb %%al, %%dx;" : : "d"(port), "a"(value)); + __asm__ __volatile__("outb %%al, %%dx;" : : "d"(port), "a"(value)); } void io_wait(void) diff --git a/kernel/src/cpu/irq.c b/kernel/src/cpu/irq.c index e5f811c..5eadd39 100644 --- a/kernel/src/cpu/irq.c +++ b/kernel/src/cpu/irq.c @@ -1,6 +1,5 @@ #include <types.h> #include <irq_handler.h> - #include <pic.h> #include <io.h> #include <keyboard.h> @@ -13,7 +12,7 @@ #define PIT 0 -const char* const exception_name[] = { +const char *const exception_name[] = { "Divide-by-zero Error", "Debug", "Non-maskable Interrupt", @@ -50,13 +49,13 @@ const char* const exception_name[] = { void isr_def_handler(uint64_t number, uint64_t error) { - switch(number) { - case 14: - printf("%s, error: 0x%x\n", exception_name[14], error); - page_fault(error); - break; - default: - panic("%s, error: 0x%x\n", exception_name[number], error); + switch (number) { + case 14: + printf("%s, error: 0x%x\n", exception_name[14], error); + page_fault(error); + break; + default: + panic("%s, error: 0x%x\n", exception_name[number], error); } } @@ -76,17 +75,16 @@ void eoi(uint64_t number) void irq_def_handler(uint64_t number) { - switch(number) - { - case 0: - timer_handler(); - break; - case 1: - keyboard_handler(); - break; - default: - printf("spurious interrupt\n"); - break; + switch (number) { + case 0: + timer_handler(); + break; + case 1: + keyboard_handler(); + break; + default: + printf("spurious interrupt\n"); + break; } eoi(number); } diff --git a/kernel/src/cpu/kcpuid.c b/kernel/src/cpu/kcpuid.c index 30a4d3e..c400be4 100644 --- a/kernel/src/cpu/kcpuid.c +++ b/kernel/src/cpu/kcpuid.c @@ -1,7 +1,11 @@ #include <types.h> #include <kcpuid.h> -void kcpuid(uint32_t func, uint32_t subfunc, CPUIDinfo* info) +void kcpuid(uint32_t func, uint32_t subfunc, CPUIDinfo *info) { - __asm__ __volatile__ ( "cpuid" : "=a"(info->EAX), "=b"(info->EBX), "=c"(info->ECX), "=d"(info->EDX) : "a"(func), "c"(subfunc) : ); + __asm__ __volatile__("cpuid" + : "=a"(info->EAX), "=b"(info->EBX), + "=c"(info->ECX), "=d"(info->EDX) + : "a"(func), "c"(subfunc) + :); } diff --git a/kernel/src/cpu/msr.c b/kernel/src/cpu/msr.c index e904d5f..d61b218 100644 --- a/kernel/src/cpu/msr.c +++ b/kernel/src/cpu/msr.c @@ -6,7 +6,7 @@ uint64_t read_msr(uint32_t addr) uint64_t edx; uint64_t ecx = addr; - __asm__ __volatile__ ("rdmsr;" : "=a"(eax), "=d"(edx) : "c"(ecx) :); + __asm__ __volatile__("rdmsr;" : "=a"(eax), "=d"(edx) : "c"(ecx) :); return (edx << 32) | eax; } @@ -17,5 +17,5 @@ void write_msr(uint32_t addr, uint64_t value) uint64_t edx = value >> 32; uint64_t ecx = addr; - __asm__ __volatile__ ("wrmsr;" : : "a"(eax), "d"(edx), "c"(ecx) :); + __asm__ __volatile__("wrmsr;" : : "a"(eax), "d"(edx), "c"(ecx) :); } diff --git a/kernel/src/cpu/pic.c b/kernel/src/cpu/pic.c index 83bb524..cfcc4d5 100644 --- a/kernel/src/cpu/pic.c +++ b/kernel/src/cpu/pic.c @@ -6,10 +6,12 @@ void remap_pic(void) // starts the initialization sequence (in cascade mode) outb(PIC1_COMMAND, ICW1_INIT | ICW1_ICW4); outb(PIC2_COMMAND, ICW1_INIT | ICW1_ICW4); - outb(PIC1_DATA, 0xe0); // ICW2: Master PIC vector offset - outb(PIC2_DATA, 0xe8); // ICW2: Slave PIC vector offset - outb(PIC1_DATA, 4); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100) - outb(PIC2_DATA, 2); // ICW3: tell Slave PIC its cascade identity (0000 0010) + outb(PIC1_DATA, 0xe0); // ICW2: Master PIC vector offset + outb(PIC2_DATA, 0xe8); // ICW2: Slave PIC vector offset + outb(PIC1_DATA, + 4); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100) + outb(PIC2_DATA, + 2); // ICW3: tell Slave PIC its cascade identity (0000 0010) outb(PIC1_DATA, ICW4_8086); outb(PIC2_DATA, ICW4_8086); diff --git a/kernel/src/cpu/tss.c b/kernel/src/cpu/tss.c index 03b3475..cdfe2cc 100644 --- a/kernel/src/cpu/tss.c +++ b/kernel/src/cpu/tss.c @@ -7,14 +7,14 @@ tss_type tss; void load_tss() { - __asm__ __volatile__ ("push %rax; mov $0x28, %ax; ltr %ax; pop %rax;"); + __asm__ __volatile__("push %rax; mov $0x28, %ax; ltr %ax; pop %rax;"); } void init_tss() { memset(&tss, 0, sizeof(tss_type)); tss.iopb = sizeof(tss_type); - uint32_t stack_size = 4096*4; + uint32_t stack_size = 4096 * 4; uint64_t stack = (uint64_t)kalloc(stack_size) + stack_size - 8; tss.rsp0_low = (uint32_t)stack; tss.rsp0_high = (uint32_t)(stack >> 32); diff --git a/kernel/src/devices/disc.c b/kernel/src/devices/disc.c index b378fc1..75ed1ef 100644 --- a/kernel/src/devices/disc.c +++ b/kernel/src/devices/disc.c @@ -4,25 +4,24 @@ #include <paging.h> #include <libk/math.h> #include <kernel_vma.h> +#include <libk/stdio.h> -#include <libk/serial_stdio.h> - -disc_sector_t* disc; +disc_sector_t *disc; void disc_init() { - disc = (disc_sector_t*)((uint64_t)ext2_module->mod_start + KERNEL_VMA); + disc = (disc_sector_t *)((uint64_t)ext2_module->mod_start + KERNEL_VMA); if (disc == NULL) { printf("Error opening disc\n"); } } -void read_sector(size_t sector_num, disc_sector_t* disc_sector) +void read_sector(size_t sector_num, disc_sector_t *disc_sector) { memcpy(disc_sector, disc + sector_num, SECTOR_SIZE); } -void write_sector(size_t sector_num, disc_sector_t* disc_sector) +void write_sector(size_t sector_num, disc_sector_t *disc_sector) { memcpy(disc + sector_num, disc_sector, SECTOR_SIZE); } diff --git a/kernel/src/devices/keyboard.c b/kernel/src/devices/keyboard.c index 549a0ca..67c2f19 100644 --- a/kernel/src/devices/keyboard.c +++ b/kernel/src/devices/keyboard.c @@ -7,23 +7,23 @@ #include <libk/stdio.h> #include <libk/math.h> #include <libk/string.h> +#include <stdbuff.h> +#include <heap.h> bool is_pressed[128]; -#include <stdbuff.h> -#include <heap.h> #define BUFFER_SIZE 10000 -stdbuff* keyboard_buffer; +stdbuff *keyboard_buffer; void init_keyboard() { -// outb(KEYBOARD_CMD_PORT, 0xF3); -// io_wait(); -// outb(KEYBOARD_DATA_PORT, 0x00); -// io_wait(); -// while (!(inb(KEYBOARD_STATUS_PORT) & 1)) {} -// if (inb(KEYBOARD_DATA_PORT) == 0xFA) -// printf("[keyboard init]\n"); + // outb(KEYBOARD_CMD_PORT, 0xF3); + // io_wait(); + // outb(KEYBOARD_DATA_PORT, 0x00); + // io_wait(); + // while (!(inb(KEYBOARD_STATUS_PORT) & 1)) {} + // if (inb(KEYBOARD_DATA_PORT) == 0xFA) + // printf("[keyboard init]\n"); } void keyboard_handler() @@ -48,13 +48,14 @@ void keyboard_handler() if (main_fb.x != 0) write_buff(keyboard_buffer, "\b \b", 3); } else if (keycode == KEY_ENTER) { - char* output = kalloc(sizeof(char) + 1); + char *output = kalloc(sizeof(char) + 1); output[0] = keymap[keycode]; write_buff(keyboard_buffer, output, 1); kfree(output); } else { - char* output = kalloc(sizeof(char) + 1); - if (keymap[keycode] == ' ') return; + char *output = kalloc(sizeof(char) + 1); + if (keymap[keycode] == ' ') + return; if (is_pressed[KEY_LSHIFT] || is_pressed[KEY_RSHIFT]) output[0] = shift_keymap[keycode]; else @@ -66,8 +67,13 @@ void keyboard_handler() is_pressed[keycode - 128] = false; } - uint32_t len = (uint32_t)(keyboard_buffer->head >= keyboard_buffer->tail ? keyboard_buffer->head - keyboard_buffer->tail : BUFFER_SIZE + keyboard_buffer->head - keyboard_buffer->tail); - char* print_buff = kalloc(len + 1); + uint32_t len = + (uint32_t)(keyboard_buffer->head >= keyboard_buffer->tail ? + keyboard_buffer->head - + keyboard_buffer->tail : + BUFFER_SIZE + keyboard_buffer->head - + keyboard_buffer->tail); + char *print_buff = kalloc(len + 1); read_buff(keyboard_buffer, print_buff, len); printf("%s", print_buff); kfree(print_buff); diff --git a/kernel/src/devices/serial.c b/kernel/src/devices/serial.c index 76bc71a..2d2da51 100644 --- a/kernel/src/devices/serial.c +++ b/kernel/src/devices/serial.c @@ -3,13 +3,13 @@ void init_serial() { - outb(PORT + 1, 0x00); // Disable all interrupts - outb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor) - outb(PORT + 0, 0x03); // Set divisor to 3 (lo byte) 38400 baud - outb(PORT + 1, 0x00); // (hi byte) - outb(PORT + 3, 0x03); // 8 bits, no parity, one stop bit - outb(PORT + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold - outb(PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set + outb(PORT + 1, 0x00); // Disable all interrupts + outb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor) + outb(PORT + 0, 0x03); // Set divisor to 3 (lo byte) 38400 baud + outb(PORT + 1, 0x00); // (hi byte) + outb(PORT + 3, 0x03); // 8 bits, no parity, one stop bit + outb(PORT + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold + outb(PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set } uint8_t serial_received() @@ -19,7 +19,8 @@ uint8_t serial_received() char read_serial() { - while (serial_received() == 0); + while (serial_received() == 0) + ; return (char)inb(PORT); } @@ -31,7 +32,8 @@ uint8_t is_transmit_empty() void write_serial(char c) { - while (is_transmit_empty() == 0); + while (is_transmit_empty() == 0) + ; outb(PORT, (uint8_t)c); } diff --git a/kernel/src/devices/timer.c b/kernel/src/devices/timer.c index c2fa887..f6463ab 100644 --- a/kernel/src/devices/timer.c +++ b/kernel/src/devices/timer.c @@ -18,7 +18,7 @@ wait_queue timer_queue; void timer_handler() { - wait_queue* pos; + wait_queue *pos; list_for_each_entry(pos, (&timer_queue.list), list) { pos->ticks--; } @@ -33,12 +33,13 @@ void timer_handler() void wait(uint64_t ms) { disable_interrupts(); - wait_queue* queue = (wait_queue*)kalloc(sizeof(wait_queue)); + wait_queue *queue = (wait_queue *)kalloc(sizeof(wait_queue)); queue->ticks = (int64_t)ms; add_to_list(&queue->list, &timer_queue.list, timer_queue.list.next); enable_interrupts(); - while (queue->ticks > 0) ; + while (queue->ticks > 0) + ; kfree(queue); free_node(&queue->list); @@ -52,7 +53,7 @@ void init_timer(uint32_t frequency) outb(0x43, 0x36); uint8_t l = (uint8_t)(divisor & 0xFF); - uint8_t h = (uint8_t)((divisor>>8) & 0xFF); + uint8_t h = (uint8_t)((divisor >> 8) & 0xFF); outb(0x40, l); outb(0x40, h); diff --git a/kernel/src/fs/ext2.c b/kernel/src/fs/ext2.c index 72eb776..7750a50 100644 --- a/kernel/src/fs/ext2.c +++ b/kernel/src/fs/ext2.c @@ -5,32 +5,34 @@ #include <disc.h> #include <ext2.h> -ext2_superblock_t* ext2_superblock; +ext2_superblock_t *ext2_superblock; -void read_block(uint32_t block_num, void* block_ptr) +void read_block(uint32_t block_num, void *block_ptr) { uint32_t sectors_per_block = BLOCK_SIZE / SECTOR_SIZE; for (size_t i = 0; i < sectors_per_block; i++) { - read_sector(block_num * sectors_per_block + i, (disc_sector_t*)block_ptr + i); + read_sector(block_num * sectors_per_block + i, + (disc_sector_t *)block_ptr + i); } } -void read_superblock(ext2_superblock_t* superblock) +void read_superblock(ext2_superblock_t *superblock) { char block[1024]; - read_sector(2, (disc_sector_t*)block); - read_sector(3, (disc_sector_t*)block + 1); + read_sector(2, (disc_sector_t *)block); + read_sector(3, (disc_sector_t *)block + 1); memcpy(superblock, block, sizeof(ext2_superblock_t)); } void ext2_init() { - ext2_superblock = (ext2_superblock_t*)kalloc(sizeof(ext2_superblock_t)); + ext2_superblock = + (ext2_superblock_t *)kalloc(sizeof(ext2_superblock_t)); read_superblock(ext2_superblock); } -void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t* ext2_bg_desc) +void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t *ext2_bg_desc) { uint32_t starting_block_num = BLOCK_SIZE == 1024 ? 2 : 1; uint32_t bg_descs_per_block = BLOCK_SIZE / BG_DESC_SIZE; @@ -39,40 +41,44 @@ void read_bg_desc(uint32_t bg_desc, ext2_bg_desc_t* ext2_bg_desc) char block[BLOCK_SIZE]; read_block(block_num, block); - memcpy(ext2_bg_desc, (char*)block + BG_DESC_SIZE * block_index, sizeof(ext2_bg_desc_t)); + memcpy(ext2_bg_desc, (char *)block + BG_DESC_SIZE * block_index, + sizeof(ext2_bg_desc_t)); } -void read_inode(uint32_t starting_block_num, uint32_t inode_index, ext2_inode_t* ext2_inode) +void read_inode(uint32_t starting_block_num, uint32_t inode_index, + ext2_inode_t *ext2_inode) { - uint32_t block_num = starting_block_num + inode_index / INODES_PER_BLOCK; + uint32_t block_num = + starting_block_num + inode_index / INODES_PER_BLOCK; uint32_t block_index = inode_index % INODES_PER_BLOCK; char block[BLOCK_SIZE]; read_block(block_num, block); - memcpy(ext2_inode, (char*)block + block_index * INODE_SIZE, sizeof(ext2_inode_t)); + memcpy(ext2_inode, (char *)block + block_index * INODE_SIZE, + sizeof(ext2_inode_t)); } -dentry_list_t* directory_to_entries(uint32_t inode) +dentry_list_t *directory_to_entries(uint32_t inode) { - dentry_list_t* dentry_list = (dentry_list_t*)kalloc(sizeof(dentry_list_t)); + dentry_list_t *dentry_list = + (dentry_list_t *)kalloc(sizeof(dentry_list_t)); INIT_LIST(dentry_list->list); if (inode < 2) { return dentry_list; } - uint32_t bg_desc = (inode - 1) / ext2_superblock->inodes_per_group; uint32_t inode_index = (inode - 1) % ext2_superblock->inodes_per_group; // block group descriptor - ext2_bg_desc_t* ext2_bg_desc; - ext2_bg_desc = (ext2_bg_desc_t*)kalloc(sizeof(ext2_bg_desc_t)); + ext2_bg_desc_t *ext2_bg_desc; + ext2_bg_desc = (ext2_bg_desc_t *)kalloc(sizeof(ext2_bg_desc_t)); read_bg_desc(bg_desc, ext2_bg_desc); // inode table - ext2_inode_t* ext2_inode; - ext2_inode = (ext2_inode_t*)kalloc(sizeof(ext2_inode_t)); + ext2_inode_t *ext2_inode; + ext2_inode = (ext2_inode_t *)kalloc(sizeof(ext2_inode_t)); read_inode(ext2_bg_desc->inode_block_address, inode_index, ext2_inode); // if it is not directory @@ -91,8 +97,11 @@ dentry_list_t* directory_to_entries(uint32_t inode) // parse block for (size_t block_offset = 0; block_offset < BLOCK_SIZE;) { // get dentry header - dentry_list_t* ext2_dentry_list = (dentry_list_t*)kalloc(sizeof(dentry_list_t)); - memcpy(&ext2_dentry_list->ext2_dentry, (char*)block + block_offset, sizeof(ext2_dentry_t) - sizeof(char*)); + dentry_list_t *ext2_dentry_list = + (dentry_list_t *)kalloc(sizeof(dentry_list_t)); + memcpy(&ext2_dentry_list->ext2_dentry, + (char *)block + block_offset, + sizeof(ext2_dentry_t) - sizeof(char *)); // dentry is unused if (ext2_dentry_list->ext2_dentry.inode == 0) { @@ -101,26 +110,33 @@ dentry_list_t* directory_to_entries(uint32_t inode) } // get dentry name - ext2_dentry_list->ext2_dentry.name = (char*)kalloc(ext2_dentry_list->ext2_dentry.name_length_lower + 1); - memcpy(ext2_dentry_list->ext2_dentry.name, (char*)block + block_offset + sizeof(ext2_dentry_t) - sizeof(char*), ext2_dentry_list->ext2_dentry.name_length_lower); - ext2_dentry_list->ext2_dentry.name[ext2_dentry_list->ext2_dentry.name_length_lower] = '\0'; + ext2_dentry_list->ext2_dentry.name = (char *)kalloc( + ext2_dentry_list->ext2_dentry.name_length_lower + + 1); + memcpy(ext2_dentry_list->ext2_dentry.name, + (char *)block + block_offset + + sizeof(ext2_dentry_t) - sizeof(char *), + ext2_dentry_list->ext2_dentry.name_length_lower); + ext2_dentry_list->ext2_dentry + .name[ext2_dentry_list->ext2_dentry + .name_length_lower] = '\0'; // put dentry in list - add_to_list(&ext2_dentry_list->list, &dentry_list->list, dentry_list->list.next); + add_to_list(&ext2_dentry_list->list, &dentry_list->list, + dentry_list->list.next); // offset block_offset += ext2_dentry_list->ext2_dentry.size; } } - kfree(ext2_bg_desc); kfree(ext2_inode); return dentry_list; } -char* files_to_buffer(uint32_t inode) +char *files_to_buffer(uint32_t inode) { if (inode < 2) { return NULL; @@ -130,13 +146,13 @@ char* files_to_buffer(uint32_t inode) uint32_t inode_index = (inode - 1) % ext2_superblock->inodes_per_group; // block group descriptor - ext2_bg_desc_t* ext2_bg_desc; - ext2_bg_desc = (ext2_bg_desc_t*)kalloc(sizeof(ext2_bg_desc_t)); + ext2_bg_desc_t *ext2_bg_desc; + ext2_bg_desc = (ext2_bg_desc_t *)kalloc(sizeof(ext2_bg_desc_t)); read_bg_desc(bg_desc, ext2_bg_desc); // inode table - ext2_inode_t* ext2_inode; - ext2_inode = (ext2_inode_t*)kalloc(sizeof(ext2_inode_t)); + ext2_inode_t *ext2_inode; + ext2_inode = (ext2_inode_t *)kalloc(sizeof(ext2_inode_t)); read_inode(ext2_bg_desc->inode_block_address, inode_index, ext2_inode); if (ext2_inode->type_perms & TYPE_DIR) { @@ -146,16 +162,18 @@ char* files_to_buffer(uint32_t inode) return NULL; } - char* data; + char *data; uint32_t size = ext2_inode->size_lower; - data = (char*)kalloc(size + 1); + data = (char *)kalloc(size + 1); uint32_t block_num = upper_div(size, BLOCK_SIZE); for (size_t i = 0; i < min(block_num, 12); i++) { char block[BLOCK_SIZE]; read_block(ext2_inode->dbp[i], block); - memcpy(data + i * BLOCK_SIZE, block, size >= (i + 1) * BLOCK_SIZE ? BLOCK_SIZE : size % BLOCK_SIZE); + memcpy(data + i * BLOCK_SIZE, block, + size >= (i + 1) * BLOCK_SIZE ? BLOCK_SIZE : + size % BLOCK_SIZE); } data[size] = '\0'; @@ -165,10 +183,10 @@ char* files_to_buffer(uint32_t inode) return data; } -path_t* path_to_list(const char* path) +path_t *path_to_list(const char *path) { size_t i, j; - path_t* divided_path = (path_t*)kalloc(sizeof(path_t)); + path_t *divided_path = (path_t *)kalloc(sizeof(path_t)); INIT_LIST(divided_path->list) size_t n = strlen(path); @@ -176,19 +194,27 @@ path_t* path_to_list(const char* path) if (i == n || path[i] == '/') { // add data before slash if (i != j) { - path_t* curr_path = (path_t*)kalloc(sizeof(path_t)); - curr_path->name = (char*)kalloc(sizeof(char) * (uint32_t)(i - j + 1)); + path_t *curr_path = + (path_t *)kalloc(sizeof(path_t)); + curr_path->name = (char *)kalloc( + sizeof(char) * (uint32_t)(i - j + 1)); memcpy(curr_path->name, path + j, i - j); curr_path->name[i - j] = '\0'; - add_to_list(&curr_path->list, ÷d_path->list, divided_path->list.next); + add_to_list(&curr_path->list, + ÷d_path->list, + divided_path->list.next); } // add slash if (i != n) { - path_t* curr_path = (path_t*)kalloc(sizeof(path_t)); - curr_path->name = (char*)kalloc(sizeof(char) * 2); + path_t *curr_path = + (path_t *)kalloc(sizeof(path_t)); + curr_path->name = + (char *)kalloc(sizeof(char) * 2); curr_path->name[0] = '/'; curr_path->name[1] = '\0'; - add_to_list(&curr_path->list, ÷d_path->list, divided_path->list.next); + add_to_list(&curr_path->list, + ÷d_path->list, + divided_path->list.next); j = i + 1; } } @@ -197,19 +223,19 @@ path_t* path_to_list(const char* path) return divided_path; } -uint32_t path_to_inode(const char* path) +uint32_t path_to_inode(const char *path) { uint32_t inode = 0; - path_t* divided_path = path_to_list(path); + path_t *divided_path = path_to_list(path); // first entry is / - path_t* curr_path = list_prev_entry(divided_path, list); + path_t *curr_path = list_prev_entry(divided_path, list); curr_path = list_prev_entry(curr_path, list); inode = 2; while (curr_path != divided_path) { // list of dentry - dentry_list_t* dentry_list = directory_to_entries(inode); + dentry_list_t *dentry_list = directory_to_entries(inode); // check if inode is actually a dir if (list_is_empty((&dentry_list->list))) { @@ -219,9 +245,10 @@ uint32_t path_to_inode(const char* path) // iterate through all direntries uint8_t ind = 1; - dentry_list_t* curr_dir; - list_for_each_entry_prev (curr_dir, (&dentry_list->list), list) { - if (!memcmp(curr_dir->ext2_dentry.name, curr_path->name)) { + dentry_list_t *curr_dir; + list_for_each_entry_prev(curr_dir, (&dentry_list->list), list) { + if (!memcmp(curr_dir->ext2_dentry.name, + curr_path->name)) { ind = 0; inode = curr_dir->ext2_dentry.inode; break; @@ -240,7 +267,7 @@ uint32_t path_to_inode(const char* path) curr_path = list_prev_entry(curr_path, list); } - path_t* pos; + path_t *pos; list_for_each_entry_del(pos, (÷d_path->list), list) { kfree(pos->name); kfree(pos); @@ -252,15 +279,16 @@ uint32_t path_to_inode(const char* path) void ls(uint32_t inode) { - dentry_list_t* dir = directory_to_entries(inode); + dentry_list_t *dir = directory_to_entries(inode); if (list_is_empty((&dir->list))) { return; } printf("ls dir with inode %d:\n", inode); - dentry_list_t* pos; + dentry_list_t *pos; list_for_each_entry(pos, (&dir->list), list) { - printf("inode: %d, name: %s\n", pos->ext2_dentry.inode, pos->ext2_dentry.name); + printf("inode: %d, name: %s\n", pos->ext2_dentry.inode, + pos->ext2_dentry.name); } list_for_each_entry_del(pos, (&dir->list), list) { diff --git a/kernel/src/libk/list.c b/kernel/src/libk/list.c index 21dac16..fb7e20d 100644 --- a/kernel/src/libk/list.c +++ b/kernel/src/libk/list.c @@ -1,7 +1,7 @@ #include <libk/list.h> #include <heap.h> -void add_to_list(list_t* head, list_t* prev, list_t* next) +void add_to_list(list_t *head, list_t *prev, list_t *next) { head->prev = prev; head->next = next; @@ -9,7 +9,7 @@ void add_to_list(list_t* head, list_t* prev, list_t* next) next->prev = head; } -void free_node(list_t* head) +void free_node(list_t *head) { if (list_is_empty(head)) { head = NULL; diff --git a/kernel/src/libk/math.c b/kernel/src/libk/math.c index f625fb5..7e0046f 100644 --- a/kernel/src/libk/math.c +++ b/kernel/src/libk/math.c @@ -3,6 +3,7 @@ int64_t abs(int64_t val) { - if (val < 0) return -val; + if (val < 0) + return -val; return val; } diff --git a/kernel/src/libk/mem.c b/kernel/src/libk/mem.c deleted file mode 100644 index e69de29..0000000 --- a/kernel/src/libk/mem.c +++ /dev/null diff --git a/kernel/src/libk/serial_stdio.c b/kernel/src/libk/serial_stdio.c index 8c0c527..002eb9e 100644 --- a/kernel/src/libk/serial_stdio.c +++ b/kernel/src/libk/serial_stdio.c @@ -12,7 +12,7 @@ void serial_print_char(char c) write_serial(c); } -void serial_print_string(const char* s) +void serial_print_string(const char *s) { for (size_t i = 0; i < strlen(s); i++) { serial_print_char(s[i]); @@ -47,24 +47,30 @@ void serial_vprintf(const char *s, va_list list) { lock(serial_stdio_lock); size_t count = 0; - for(size_t i = 0; i < strlen(s); i++) if(s[i] == '%') count++; + for (size_t i = 0; i < strlen(s); i++) + if (s[i] == '%') + count++; - for(size_t i = 0; i < strlen(s); i++) - { - if(s[i] == '%') - { + for (size_t i = 0; i < strlen(s); i++) { + if (s[i] == '%') { i++; - if(s[i] == 'c') serial_print_char((char)va_arg(list, uint32_t)); - else if(s[i] == 's') serial_print_string(va_arg(list, char*)); - else if(s[i] == 'd') serial_print_int((uint64_t)va_arg(list, uint64_t)); - else if(s[i] == 'x') serial_print_hex((uint64_t)va_arg(list, uint64_t)); - else - { - serial_print_string("Wrong format using printf\n"); + if (s[i] == 'c') + serial_print_char((char)va_arg(list, uint32_t)); + else if (s[i] == 's') + serial_print_string(va_arg(list, char *)); + else if (s[i] == 'd') + serial_print_int( + (uint64_t)va_arg(list, uint64_t)); + else if (s[i] == 'x') + serial_print_hex( + (uint64_t)va_arg(list, uint64_t)); + else { + serial_print_string( + "Wrong format using printf\n"); return; } - } - else serial_print_char(s[i]); + } else + serial_print_char(s[i]); } unlock(serial_stdio_lock); } diff --git a/kernel/src/libk/stdio.c b/kernel/src/libk/stdio.c index 18f3d3f..f410ccd 100644 --- a/kernel/src/libk/stdio.c +++ b/kernel/src/libk/stdio.c @@ -27,13 +27,14 @@ void print_char(char c) } return; } - fb_draw_character(main_fb, c, (int32_t)main_fb.x * 8, (int32_t)main_fb.y * 16); + fb_draw_character(main_fb, c, (int32_t)main_fb.x * 8, + (int32_t)main_fb.y * 16); main_fb.x++; write_serial(c); } -void print_string(const char* s) +void print_string(const char *s) { for (size_t i = 0; i < strlen(s); i++) { print_char(s[i]); @@ -68,24 +69,27 @@ void vprintf(const char *s, va_list list) { lock(stdio_lock); size_t count = 0; - for(size_t i = 0; i < strlen(s); i++) if(s[i] == '%') count++; + for (size_t i = 0; i < strlen(s); i++) + if (s[i] == '%') + count++; - for(size_t i = 0; i < strlen(s); i++) - { - if(s[i] == '%') - { + for (size_t i = 0; i < strlen(s); i++) { + if (s[i] == '%') { i++; - if(s[i] == 'c') print_char((char)va_arg(list, uint32_t)); - else if(s[i] == 's') print_string(va_arg(list, char*)); - else if(s[i] == 'd') print_int((uint64_t)va_arg(list, uint64_t)); - else if(s[i] == 'x') print_hex((uint64_t)va_arg(list, uint64_t)); - else - { + if (s[i] == 'c') + print_char((char)va_arg(list, uint32_t)); + else if (s[i] == 's') + print_string(va_arg(list, char *)); + else if (s[i] == 'd') + print_int((uint64_t)va_arg(list, uint64_t)); + else if (s[i] == 'x') + print_hex((uint64_t)va_arg(list, uint64_t)); + else { print_string("Wrong format using printf\n"); return; } - } - else print_char(s[i]); + } else + print_char(s[i]); } unlock(stdio_lock); } diff --git a/kernel/src/libk/string.c b/kernel/src/libk/string.c index 8b2b2c6..b8fd659 100644 --- a/kernel/src/libk/string.c +++ b/kernel/src/libk/string.c @@ -1,13 +1,14 @@ #include <types.h> #include <libk/string.h> -size_t strlen(const char* s) +size_t strlen(const char *s) { if (s == NULL) return 0; - char *p = (char*)s; - while (*p) p++; + char *p = (char *)s; + while (*p) + p++; return (size_t)(p - s); } @@ -36,7 +37,7 @@ void strrev(char *s) } } -void itos(uint64_t num, char* s) +void itos(uint64_t num, char *s) { if (num == 0) { s[0] = '0'; @@ -52,7 +53,7 @@ void itos(uint64_t num, char* s) strrev(s); } -void itoh(uint64_t num, char* s) +void itoh(uint64_t num, char *s) { if (num == 0) { s[0] = '0'; @@ -71,35 +72,35 @@ void itoh(uint64_t num, char* s) strrev(s); } -void memcpy(const void* destptr, const void* srcptr, size_t n) +void memcpy(const void *destptr, const void *srcptr, size_t n) { if (destptr == NULL || srcptr == NULL) return; - uint8_t* dest = (uint8_t*)destptr; - const uint8_t* src = (const uint8_t*)srcptr; + uint8_t *dest = (uint8_t *)destptr; + const uint8_t *src = (const uint8_t *)srcptr; - for(size_t i = 0; i < n; i++) { + for (size_t i = 0; i < n; i++) { dest[i] = src[i]; } } -void memset(const void* destptr, uint8_t value, size_t n) +void memset(const void *destptr, uint8_t value, size_t n) { - uint8_t* dest = (uint8_t*)destptr; + uint8_t *dest = (uint8_t *)destptr; for (size_t i = 0; i < n; i++) { dest[i] = value; } } -int32_t memcmp(const void* aptr, const void* bptr) +int32_t memcmp(const void *aptr, const void *bptr) { - const uint8_t* a = (const uint8_t*)aptr; - const uint8_t* b = (const uint8_t*)bptr; + const uint8_t *a = (const uint8_t *)aptr; + const uint8_t *b = (const uint8_t *)bptr; - const size_t len_a = strlen((char*)a); - const size_t len_b = strlen((char*)b); + const size_t len_a = strlen((char *)a); + const size_t len_b = strlen((char *)b); for (size_t i = 0; i < len_a && i < len_b; i++) { if (a[i] != b[i]) diff --git a/kernel/src/main.c b/kernel/src/main.c index 106576f..037c43e 100644 --- a/kernel/src/main.c +++ b/kernel/src/main.c @@ -24,11 +24,11 @@ #include <atomic.h> #include <pmm.h> -int kernel_main(mb2_tag_header* multiboot_bootinfo, uint32_t multiboot_magic); -int kernel_main(mb2_tag_header* multiboot_bootinfo, uint32_t multiboot_magic) +int kernel_main(mb2_tag_header *multiboot_bootinfo, uint32_t multiboot_magic); +int kernel_main(mb2_tag_header *multiboot_bootinfo, uint32_t multiboot_magic) { init_serial(); -// serial is enabled from this point + // serial is enabled from this point init_gdt(); init_paging(); init_heap(); @@ -36,7 +36,7 @@ int kernel_main(mb2_tag_header* multiboot_bootinfo, uint32_t multiboot_magic) clear_screen(main_fb); init_mutex(&stdio_lock); init_mutex(&serial_stdio_lock); -// framebuffer is enabled from this point + // framebuffer is enabled from this point init_pmm(); memory_usage(); init_keyboard(); @@ -52,8 +52,8 @@ int kernel_main(mb2_tag_header* multiboot_bootinfo, uint32_t multiboot_magic) init_ap_cpus(); jump_userspace(); - for(;;) { - __asm__ __volatile__ ("hlt;"); + for (;;) { + __asm__ __volatile__("hlt;"); } return 0; } diff --git a/kernel/src/mem/heap.c b/kernel/src/mem/heap.c index b49eefb..537a2fe 100644 --- a/kernel/src/mem/heap.c +++ b/kernel/src/mem/heap.c @@ -1,6 +1,5 @@ #include <types.h> #include <heap.h> - #include <libk/math.h> #include <paging.h> #include <libk/serial_stdio.h> @@ -8,17 +7,18 @@ kheap_t main_kheap; -void kheap_init(kheap_t* kheap) +void kheap_init(kheap_t *kheap) { kheap->fblock = NULL; } -void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsize) +void kheap_add_block(kheap_t *kheap, uint64_t addr, uint32_t size, + uint32_t bsize) { kheapblock_t *kheapblock; // store size & bsize into kheapblock - kheapblock = (kheapblock_t*)addr; + kheapblock = (kheapblock_t *)addr; kheapblock->size = size - (uint32_t)sizeof(kheapblock_t); kheapblock->bsize = bsize; @@ -28,14 +28,15 @@ void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsiz // block count & bitmap uint32_t bcnt = kheapblock->size / kheapblock->bsize; - uint8_t* bm = (uint8_t*)&kheapblock[1]; + uint8_t *bm = (uint8_t *)&kheapblock[1]; // clear bitmap for (size_t i = 0; i < bcnt; i++) { bm[i] = 0; } - uint32_t bcnt_used = upper_div((bcnt + (uint32_t)sizeof(kheapblock_t)), bsize); + uint32_t bcnt_used = + upper_div((bcnt + (uint32_t)sizeof(kheapblock_t)), bsize); for (size_t i = 0; i < bcnt_used; i++) { bm[i] = 5; } @@ -43,13 +44,15 @@ void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsiz kheapblock->used = bcnt_used; } -void* kheap_alloc(kheap_t* kheap, uint32_t size) +void *kheap_alloc(kheap_t *kheap, uint32_t size) { - kheapblock_t* kheapblock; + kheapblock_t *kheapblock; // find kheapblock that has enough space - for (kheapblock = kheap->fblock; kheapblock; kheapblock = kheapblock->next) { - if (kheapblock->size - (kheapblock->used * kheapblock->bsize) < size) { + for (kheapblock = kheap->fblock; kheapblock; + kheapblock = kheapblock->next) { + if (kheapblock->size - (kheapblock->used * kheapblock->bsize) < + size) { continue; } @@ -57,12 +60,12 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size) bool ind1 = ((size % 4096) == 0); bool ind2 = (kheapblock->bsize == 4096); if (ind1 + ind2 == 1) { - continue; + continue; } uint32_t bcnt = kheapblock->size / kheapblock->bsize; uint32_t bneed = upper_div(size, kheapblock->bsize); - uint8_t* bm = (uint8_t*)&kheapblock[1]; + uint8_t *bm = (uint8_t *)&kheapblock[1]; // find empty block for (size_t i = 0; i < bcnt; i++) { @@ -72,7 +75,9 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size) // find bneed consecutive empty blocks size_t j; - for (j = 0; bm[i + j] == 0 && j < bneed && i + j < bcnt; j++); + for (j = 0; bm[i + j] == 0 && j < bneed && i + j < bcnt; + j++) + ; if (j != bneed) { i += j - 1; continue; @@ -80,7 +85,8 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size) // using id for the block that is different from previous or next block uint8_t idp = bm[i - 1], idn = bm[i + j], id; - for (id = idp + 1; id == idn || id == 0; id++); + for (id = idp + 1; id == idn || id == 0; id++) + ; // mark blocks as used for (j = 0; j < bneed; j++) { @@ -89,24 +95,31 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size) kheapblock->used += bneed; - return (void*)(i * kheapblock->bsize + (uintptr_t)&kheapblock[0]); + return (void *)(i * kheapblock->bsize + + (uintptr_t)&kheapblock[0]); } } printf("Error: there is no remaining memory in kheap\n"); return NULL; } -void kheap_free(kheap_t* kheap, void* pointer) +void kheap_free(kheap_t *kheap, void *pointer) { - kheapblock_t* kheapblock; - for (kheapblock = kheap->fblock; kheapblock; kheapblock = kheapblock->next) { - if ((uintptr_t)(pointer) > (uintptr_t)kheapblock && (uintptr_t)(pointer) < (uintptr_t)kheapblock + sizeof(kheapblock_t) + kheapblock->size) { + kheapblock_t *kheapblock; + for (kheapblock = kheap->fblock; kheapblock; + kheapblock = kheapblock->next) { + if ((uintptr_t)(pointer) > (uintptr_t)kheapblock && + (uintptr_t)(pointer) < (uintptr_t)kheapblock + + sizeof(kheapblock_t) + + kheapblock->size) { // found block // get index of bitmap entry - uintptr_t pointer_offset = (uintptr_t)pointer - (uintptr_t)&kheapblock[0]; - uint32_t bi = (uint32_t)pointer_offset / kheapblock->bsize; - uint8_t* bm = (uint8_t*)&kheapblock[1]; + uintptr_t pointer_offset = + (uintptr_t)pointer - (uintptr_t)&kheapblock[0]; + uint32_t bi = + (uint32_t)pointer_offset / kheapblock->bsize; + uint8_t *bm = (uint8_t *)&kheapblock[1]; uint8_t id = bm[bi]; uint32_t max = kheapblock->size / kheapblock->bsize; @@ -126,6 +139,8 @@ void kheap_free(kheap_t* kheap, void* pointer) void init_heap() { kheap_init(&main_kheap); - kheap_add_block(&main_kheap, HEAP1_VMEM_ADDR, HEAP1_SIZE, HEAP1_BLOCK_SIZE); - kheap_add_block(&main_kheap, HEAP2_VMEM_ADDR, HEAP2_SIZE, HEAP2_BLOCK_SIZE); + kheap_add_block(&main_kheap, HEAP1_VMEM_ADDR, HEAP1_SIZE, + HEAP1_BLOCK_SIZE); + kheap_add_block(&main_kheap, HEAP2_VMEM_ADDR, HEAP2_SIZE, + HEAP2_BLOCK_SIZE); } diff --git a/kernel/src/mem/paging.c b/kernel/src/mem/paging.c index b8c44c0..aa61c5d 100644 --- a/kernel/src/mem/paging.c +++ b/kernel/src/mem/paging.c @@ -1,7 +1,6 @@ #include <types.h> #include <paging.h> #include <panic.h> - #include <heap.h> #include <libk/serial_stdio.h> #include <libk/stdio.h> @@ -21,24 +20,28 @@ void map_addr(uint64_t virt, uint64_t phys, uint32_t flags) size_t pt_lvl4_i = (virt >> 39) % 0x200; // 512gb entry size_t pt_lvl3_i = (virt >> 30) % 0x200; // 1gb entry size_t pt_lvl2_i = (virt >> 21) % 0x200; // 2mb entry -// size_t pt_lvl1_i = (virt >> 12) % 0x200; // 4kb entry + // size_t pt_lvl1_i = (virt >> 12) % 0x200; // 4kb entry - uint64_t* pt_lvl3 = (uint64_t*)(page_table_lvl4[pt_lvl4_i] + KERNEL_VMA); + uint64_t *pt_lvl3 = + (uint64_t *)(page_table_lvl4[pt_lvl4_i] + KERNEL_VMA); if (!((uint64_t)pt_lvl3 & FLAG_PRESENT)) { - pt_lvl3 = (uint64_t*)kalloc(4096); + pt_lvl3 = (uint64_t *)kalloc(4096); memset(pt_lvl3, 0, 4096); - page_table_lvl4[pt_lvl4_i] = ((uint64_t)pt_lvl3 - KERNEL_VMA) | flags; + page_table_lvl4[pt_lvl4_i] = ((uint64_t)pt_lvl3 - KERNEL_VMA) | + flags; } else { - pt_lvl3 = (uint64_t*)((uint64_t)pt_lvl3 - (uint64_t)pt_lvl3 % 4096); + pt_lvl3 = (uint64_t *)((uint64_t)pt_lvl3 - + (uint64_t)pt_lvl3 % 4096); } - uint64_t* pt_lvl2 = (uint64_t*)(pt_lvl3[pt_lvl3_i] + KERNEL_VMA); + uint64_t *pt_lvl2 = (uint64_t *)(pt_lvl3[pt_lvl3_i] + KERNEL_VMA); if (!((uint64_t)pt_lvl2 & FLAG_PRESENT)) { - pt_lvl2 = (uint64_t*)kalloc(4096); + pt_lvl2 = (uint64_t *)kalloc(4096); memset(pt_lvl2, 0, 4096); pt_lvl3[pt_lvl3_i] = ((uint64_t)pt_lvl2 - KERNEL_VMA) | flags; } else { - pt_lvl2 = (uint64_t*)((uint64_t)pt_lvl2 - (uint64_t)pt_lvl2 % 4096); + pt_lvl2 = (uint64_t *)((uint64_t)pt_lvl2 - + (uint64_t)pt_lvl2 % 4096); } pt_lvl2[pt_lvl2_i] = phys | flags | FLAG_HUGE; @@ -46,11 +49,15 @@ void map_addr(uint64_t virt, uint64_t phys, uint32_t flags) void init_paging(void) { - page_table_lvl4[511] = (uint64_t)page_table_lvl3 - KERNEL_VMA + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER); - page_table_lvl3[510] = (uint64_t)page_table_lvl2 - KERNEL_VMA + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER); + page_table_lvl4[511] = (uint64_t)page_table_lvl3 - KERNEL_VMA + + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER); + page_table_lvl3[510] = (uint64_t)page_table_lvl2 - KERNEL_VMA + + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER); // 16mb kernel + 32mb heap + 2mb (32kb stack * 64 threads) = first 50mb for (size_t i = 0; i < 25; i++) { - page_table_lvl2[i] = (uint64_t)0x0 + PAGE_SIZE * i + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER | FLAG_HUGE); + page_table_lvl2[i] = + (uint64_t)0x0 + PAGE_SIZE * i + + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER | FLAG_HUGE); } load_pt_lvl4(page_table_lvl4); @@ -59,7 +66,7 @@ void init_paging(void) void page_fault(uint64_t error) { uint64_t addr; - __asm__ __volatile__ ("mov %%cr2, %0;" : "=r"(addr) : : "memory"); + __asm__ __volatile__("mov %%cr2, %0;" : "=r"(addr) : : "memory"); printf("address: 0x%x, error code: 0x%x\n", addr, error); diff --git a/kernel/src/mem/pmm.c b/kernel/src/mem/pmm.c index f0b4884..043043c 100644 --- a/kernel/src/mem/pmm.c +++ b/kernel/src/mem/pmm.c @@ -6,7 +6,7 @@ #include <multiboot2.h> #include <pmm.h> -#define MEM_USED_BELOW 50*1024*1024 +#define MEM_USED_BELOW 50 * 1024 * 1024 uint64_t free_mem_cnt; uint64_t all_mem_cnt; @@ -16,17 +16,23 @@ void init_pmm() { INIT_LIST(pmm_list); - mmap_t* pos; + mmap_t *pos; list_for_each_entry_prev(pos, (&mmap.list), list) { mb2_tag_mmap_entry entry = pos->mmap_entry; if (entry.type != 1) continue; - uint64_t base = entry.base_addr & (PAGE_SIZE - 1) ? (entry.base_addr & (uint64_t)~(PAGE_SIZE - 1)) + PAGE_SIZE : entry.base_addr; - for (uint64_t i = base; i + PAGE_SIZE <= entry.base_addr + entry.length; i += PAGE_SIZE) { + uint64_t base = entry.base_addr & (PAGE_SIZE - 1) ? + (entry.base_addr & + (uint64_t) ~(PAGE_SIZE - 1)) + + PAGE_SIZE : + entry.base_addr; + for (uint64_t i = base; + i + PAGE_SIZE <= entry.base_addr + entry.length; + i += PAGE_SIZE) { if (i >= MEM_USED_BELOW) { free_mem_cnt++; map_addr(i, i, FLAG_PRESENT); - list_t* list = (list_t*)i; + list_t *list = (list_t *)i; add_to_list(list, &pmm_list, pmm_list.next); } } @@ -36,6 +42,8 @@ void init_pmm() void memory_usage() { - printf("memory used: %dMB\n", (MEM_USED_BELOW + (all_mem_cnt - free_mem_cnt) * PAGE_SIZE) / 1024 / 1024); + printf("memory used: %dMB\n", + (MEM_USED_BELOW + (all_mem_cnt - free_mem_cnt) * PAGE_SIZE) / + 1024 / 1024); printf("memory free: %dMB\n", free_mem_cnt * PAGE_SIZE / 1024 / 1024); } diff --git a/kernel/src/misc/graphics.c b/kernel/src/misc/graphics.c index 7ab67f3..f595146 100644 --- a/kernel/src/misc/graphics.c +++ b/kernel/src/misc/graphics.c @@ -1,6 +1,5 @@ #include <types.h> #include <graphics.h> - #include <multiboot2.h> #include <font.h> #include <libk/string.h> @@ -10,15 +9,17 @@ fb_t main_fb; void fb_draw_pixel(fb_t fb, int32_t x, int32_t y, uint32_t col) { - if (x < 0 || y < 0) return; - if (x >= (int32_t)fb.width || y >= (int32_t)fb.height) return; + if (x < 0 || y < 0) + return; + if (x >= (int32_t)fb.width || y >= (int32_t)fb.height) + return; uint32_t fb_offset = (uint32_t)y * fb.pitch + (uint32_t)x * fb.bpp / 8; - __volatile__ uint32_t* fb_buff = (uint32_t*)fb.addr; + __volatile__ uint32_t *fb_buff = (uint32_t *)fb.addr; fb_buff[fb_offset / 4] = col; } -void set_color(fb_t* fb, uint32_t char_col, uint32_t bg_col) +void set_color(fb_t *fb, uint32_t char_col, uint32_t bg_col) { fb->char_col = char_col; fb->bg_col = bg_col; @@ -37,7 +38,8 @@ void clear_screen(fb_t fb) /* https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm */ -void fb_draw_line_low(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t col) +void fb_draw_line_low(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, + uint32_t col) { int32_t dx = x1 - x0; int32_t dy = y1 - y0; @@ -58,10 +60,10 @@ void fb_draw_line_low(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, u D = D + 2 * dy; } } - } -void fb_draw_line_high(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t col) +void fb_draw_line_high(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, + uint32_t col) { int32_t dx = x1 - x0; int32_t dy = y1 - y0; @@ -84,7 +86,8 @@ void fb_draw_line_high(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, } } -void fb_draw_line(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t col) +void fb_draw_line(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, + uint32_t col) { if (abs(y1 - y0) < abs(x1 - x0)) { if (x0 > x1) @@ -101,13 +104,12 @@ void fb_draw_line(fb_t fb, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint3 void fb_draw_character(fb_t fb, char c, int32_t x, int32_t y) { - if (c < 0) return; + if (c < 0) + return; int32_t offset = 32 + c * 16; - for (int32_t i = 0 ; i < 16; i++) - { - for (int32_t j = 0 ; j < 8; j++) - { + for (int32_t i = 0; i < 16; i++) { + for (int32_t j = 0; j < 8; j++) { if (font[offset + i] & (1 << (7 - j))) { fb_draw_pixel(fb, x + j, y + i, fb.char_col); } else { diff --git a/kernel/src/misc/stdbuff.c b/kernel/src/misc/stdbuff.c index cca58d6..4362882 100644 --- a/kernel/src/misc/stdbuff.c +++ b/kernel/src/misc/stdbuff.c @@ -2,9 +2,9 @@ #include <heap.h> #include <stdbuff.h> -stdbuff* init_buff(uint32_t buff_size) +stdbuff *init_buff(uint32_t buff_size) { - stdbuff* buffer = kalloc(sizeof(stdbuff)); + stdbuff *buffer = kalloc(sizeof(stdbuff)); buffer->head = 0; buffer->tail = 0; buffer->size = buff_size; @@ -12,19 +12,21 @@ stdbuff* init_buff(uint32_t buff_size) return buffer; } -void read_buff(stdbuff* buffer, char* dest_ptr, size_t read_size) +void read_buff(stdbuff *buffer, char *dest_ptr, size_t read_size) { for (size_t i = 0; i < read_size; i++) { - memcpy(dest_ptr + i, buffer->data + ((buffer->tail + i) % buffer->size), 1); + memcpy(dest_ptr + i, + buffer->data + ((buffer->tail + i) % buffer->size), 1); } dest_ptr[read_size] = '\0'; buffer->tail = (buffer->tail + read_size) % buffer->size; } -void write_buff(stdbuff* buffer, const char* src_ptr, size_t write_size) +void write_buff(stdbuff *buffer, const char *src_ptr, size_t write_size) { for (size_t i = 0; i < write_size; i++) { - memcpy(buffer->data + ((buffer->head + i) % buffer->size), src_ptr + i, 1); + memcpy(buffer->data + ((buffer->head + i) % buffer->size), + src_ptr + i, 1); } buffer->head = (buffer->head + write_size) % buffer->size; } diff --git a/kernel/src/scheduler/ap_startup.c b/kernel/src/scheduler/ap_startup.c index f4a2055..92fc51c 100644 --- a/kernel/src/scheduler/ap_startup.c +++ b/kernel/src/scheduler/ap_startup.c @@ -5,13 +5,14 @@ #include <gdt.h> #include <paging.h> -void ap_startup(void) { +void ap_startup(void) +{ load_idt(&idt_pointer); load_gdt(&gdt_pointer); load_pt_lvl4(page_table_lvl4); - while (bspdone) { - __asm__ __volatile__ ("pause;"); + while (!bspdone) { + __asm__ __volatile__("pause;"); } printf("curr_cpu_apic_id: 0x%x\n", curr_cpu_apic_id()); @@ -19,7 +20,7 @@ void ap_startup(void) { ap_cnt++; unlock(cnt_lock); - for(;;) { - __asm__ __volatile__ ("hlt;"); + for (;;) { + __asm__ __volatile__("hlt;"); } } diff --git a/kernel/src/scheduler/atomic.c b/kernel/src/scheduler/atomic.c index c466f0b..d5ae02f 100644 --- a/kernel/src/scheduler/atomic.c +++ b/kernel/src/scheduler/atomic.c @@ -3,22 +3,25 @@ #include <libk/stdio.h> #include <heap.h> -void init_mutex(mutex_t* mutex) +void init_mutex(mutex_t *mutex) { - mutex->addr = (uint64_t*)kalloc(sizeof(uint64_t)); + mutex->addr = (uint64_t *)kalloc(sizeof(uint64_t)); *(mutex->addr) = 0; } bool test_and_set(mutex_t mutex, bool value) { bool rax; - __asm__ __volatile__ ("lock xchg %%rax, (%%rbx);" : "=a"(rax) : "b"(mutex.addr), "a"(value)); + __asm__ __volatile__("lock xchg %%rax, (%%rbx);" + : "=a"(rax) + : "b"(mutex.addr), "a"(value)); return rax; } void lock(mutex_t mutex) { - while (test_and_set(mutex, 1)) ; + while (test_and_set(mutex, 1)) + ; } void unlock(mutex_t mutex) diff --git a/kernel/src/scheduler/scheduler.c b/kernel/src/scheduler/scheduler.c index 000d20c..b8f3dab 100644 --- a/kernel/src/scheduler/scheduler.c +++ b/kernel/src/scheduler/scheduler.c @@ -3,5 +3,4 @@ void schedule(void) { - } diff --git a/kernel/src/sys/syscall.c b/kernel/src/sys/syscall.c index debd70f..bd3c52c 100644 --- a/kernel/src/sys/syscall.c +++ b/kernel/src/sys/syscall.c @@ -8,18 +8,18 @@ void syscall_handler() uint64_t rax; uint64_t rdi; uint64_t rsi; - __asm__ __volatile__ ("mov %%rax, %0;" : "=r"(rax) : :); - __asm__ __volatile__ ("mov %%rdi, %0;" : "=r"(rdi) : :); - __asm__ __volatile__ ("mov %%rsi, %0;" : "=r"(rsi) : :); - switch(rax) { - case SYSCALL_READ: - syscall_read(); - break; - case SYSCALL_WRITE: - syscall_write((char*)rdi, rsi); - break; - default: - printf("invalid syscall (%d)\n", rax); + __asm__ __volatile__("mov %%rax, %0;" : "=r"(rax) : :); + __asm__ __volatile__("mov %%rdi, %0;" : "=r"(rdi) : :); + __asm__ __volatile__("mov %%rsi, %0;" : "=r"(rsi) : :); + switch (rax) { + case SYSCALL_READ: + syscall_read(); + break; + case SYSCALL_WRITE: + syscall_write((char *)rdi, rsi); + break; + default: + printf("invalid syscall (%d)\n", rax); } } @@ -28,7 +28,7 @@ void syscall_read() printf("syscall_read()\n"); } -void syscall_write(char* buff, size_t count) +void syscall_write(char *buff, size_t count) { printf("syscall_write()\n"); printf("buff = 0x%x, count = %d\n", buff, count); diff --git a/kernel/src/sys/userspace.c b/kernel/src/sys/userspace.c index 00cd758..7091a3f 100644 --- a/kernel/src/sys/userspace.c +++ b/kernel/src/sys/userspace.c @@ -6,10 +6,10 @@ void begin_userspace() { // read - __asm__ __volatile__ ("mov $0x0, %rax; syscall;"); + __asm__ __volatile__("mov $0x0, %rax; syscall;"); // write - __asm__ __volatile__ ("mov $0x1, %rax; syscall;"); + __asm__ __volatile__("mov $0x1, %rax; syscall;"); - while(true) { + while (true) { } } |