tailix/kernel
1
0
Fork 0
mirror of https://github.com/tailix/kernel.git synced 2025-07-31 22:00:58 -04:00
Code Releases Activity

Use new drivers

Browse source
This commit is contained in:
Alex Kotov 2022-12-03 20:32:32 +04:00
parent 6e7bb02546
commit 676fe25b6c
Signed by: kotovalexarian
GPG key ID: 553C0EBBEB5D5F08
9 changed files with 57 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/Makefile
View file

@ -1,6 +1,7 @@
CCPREFIX = /home/kotovalexarian/repos/global/tailix/cross/root/bin/i386-elf- CCPREFIX = /home/kotovalexarian/repos/global/tailix/cross/root/bin/i386-elf-
LIBKERNAUX_PREFIX = /opt/libkernaux/i386 LIBKERNAUX_PREFIX = /opt/libkernaux/i386
DRIVERS_PREFIX = /opt/drivers/i386
AS = $(CCPREFIX)as AS = $(CCPREFIX)as
CC = $(CCPREFIX)gcc CC = $(CCPREFIX)gcc
@ -16,7 +17,8 @@ CFLAGS = \
-ffreestanding \ -ffreestanding \
-fno-builtin \ -fno-builtin \
-fno-stack-protector \ -fno-stack-protector \
-I$(LIBKERNAUX_PREFIX)/include -I$(LIBKERNAUX_PREFIX)/include \
-I$(DRIVERS_PREFIX)/include
CPPFLAGS = \ CPPFLAGS = \
-DKERNAUX_ENABLE_ASSERT \ -DKERNAUX_ENABLE_ASSERT \
@ -47,7 +49,7 @@ clean:
rm -f $(KERNEL) $(OBJS) rm -f $(KERNEL) $(OBJS)
$(KERNEL): $(OBJS) $(KERNEL): $(OBJS)
$(CC) -T linker.ld -o $@ $^ -ffreestanding -nostdlib -lkernaux -lgcc -Wl,-L$(LIBKERNAUX_PREFIX)/lib $(CC) -T linker.ld -o $@ $^ -ffreestanding -nostdlib -ldrivers -lkernaux -lgcc -Wl,-L$(LIBKERNAUX_PREFIX)/lib -Wl,-L$(DRIVERS_PREFIX)/lib
grub-file --is-x86-multiboot2 $@ grub-file --is-x86-multiboot2 $@
%.c.o: %.c %.c.o: %.c

32
src/info.c
View file

@ -1,8 +1,8 @@
#include "info.h" #include "info.h"
#include "panic.h" #include "panic.h"
#include <drivers/console.h>
#include <kernaux/assert.h> #include <kernaux/assert.h>
#include <kernaux/drivers/console.h>
#include <string.h> #include <string.h>
@ -156,21 +156,21 @@ void kernel_info_print(const struct Kernel_Info *const kinfo)
{ {
KERNAUX_ASSERT(kinfo); KERNAUX_ASSERT(kinfo);
kernaux_drivers_console_printf("Kernel info\n"); drivers_console_printf("Kernel info\n");
kernaux_drivers_console_printf(" cmdline: %s\n", kinfo->cmdline); drivers_console_printf(" cmdline: %s\n", kinfo->cmdline);
kernaux_drivers_console_printf(" modules: %lu\n", kinfo->modules_count); drivers_console_printf(" modules: %lu\n", kinfo->modules_count);
kernaux_drivers_console_printf(" areas: %lu\n", kinfo->areas_count); drivers_console_printf(" areas: %lu\n", kinfo->areas_count);
kernaux_drivers_console_printf("\n"); drivers_console_printf("\n");
kernaux_drivers_console_printf(" offset: %lu\n", kinfo->kernel_offset); drivers_console_printf(" offset: %lu\n", kinfo->kernel_offset);
kernaux_drivers_console_printf(" size: %lu\n", kinfo->kernel_size); drivers_console_printf(" size: %lu\n", kinfo->kernel_size);
kernaux_drivers_console_printf(" phys base: %lu\n", kinfo->kernel_phys_base); drivers_console_printf(" phys base: %lu\n", kinfo->kernel_phys_base);
kernaux_drivers_console_printf(" virt base: %lu\n", kinfo->kernel_virt_base); drivers_console_printf(" virt base: %lu\n", kinfo->kernel_virt_base);
kernaux_drivers_console_printf("\n"); drivers_console_printf("\n");
kernaux_drivers_console_printf(" modules size: %lu\n", kinfo->modules_total_size); drivers_console_printf(" modules size: %lu\n", kinfo->modules_total_size);
kernaux_drivers_console_printf(" kernel & modules size: %lu\n", kinfo->kernel_and_modules_total_size); drivers_console_printf(" kernel & modules size: %lu\n", kinfo->kernel_and_modules_total_size);
kernaux_drivers_console_printf("\n"); drivers_console_printf("\n");
kernaux_drivers_console_printf(" stack start: %lu\n", kinfo->kernel_stack_start); drivers_console_printf(" stack start: %lu\n", kinfo->kernel_stack_start);
kernaux_drivers_console_printf(" stack size: %lu\n", kinfo->kernel_stack_size); drivers_console_printf(" stack size: %lu\n", kinfo->kernel_stack_size);
} }
bool kernel_info_is_valid(const struct Kernel_Info *const kinfo) bool kernel_info_is_valid(const struct Kernel_Info *const kinfo)

4
src/interrupts/exception.c
View file

@ -1,7 +1,7 @@
#include "main.h" #include "main.h"
#include "../panic.h" #include "../panic.h"
#include <kernaux/drivers/console.h> #include <drivers/console.h>
static const char *const messages[] = { static const char *const messages[] = {
"0 #DE - Divide Error Exception", "0 #DE - Divide Error Exception",
@ -42,7 +42,7 @@ void exception_handler(struct IsrRegisters regs)
{ {
if (regs.int_no > INT_EXCEPTION_LAST) return; if (regs.int_no > INT_EXCEPTION_LAST) return;
kernaux_drivers_console_printf( drivers_console_printf(
"[FAIL] exception: Unhandled protected-mode exception: %s\n", "[FAIL] exception: Unhandled protected-mode exception: %s\n",
messages[regs.int_no] messages[regs.int_no]
); );

12
src/interrupts/hwint.c
View file

@ -1,7 +1,7 @@
#include "main.h" #include "main.h"
#include <kernaux/drivers/console.h> #include <drivers/console.h>
#include <kernaux/drivers/intel_8259_pic.h> #include <drivers/intel_8259_pic.h>
static hwint_handler_t handlers[INT_HWINT_COUNT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; static hwint_handler_t handlers[INT_HWINT_COUNT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
@ -14,12 +14,12 @@ void hwint_handler(struct IsrRegisters regs)
const hwint_handler_t handler = handlers[hwint_no]; const hwint_handler_t handler = handlers[hwint_no];
if (!handler) { if (!handler) {
kernaux_drivers_console_printf("[WARN] hwint: Unhandled hardware interrupt: %u\n", hwint_no); drivers_console_printf("[WARN] hwint: Unhandled hardware interrupt: %u\n", hwint_no);
return; return;
} }
handler(); handler();
kernaux_drivers_intel_8259_pic_eoi(regs.int_no); drivers_intel_8259_pic_eoi(regs.int_no);
} }
void hwint_register_handler(unsigned int int_no, hwint_handler_t handler) void hwint_register_handler(unsigned int int_no, hwint_handler_t handler)
@ -29,7 +29,7 @@ void hwint_register_handler(unsigned int int_no, hwint_handler_t handler)
} }
handlers[int_no] = handler; handlers[int_no] = handler;
kernaux_drivers_intel_8259_pic_enable(int_no); drivers_intel_8259_pic_enable(int_no);
} }
void hwint_unregister_handler(unsigned int int_no) void hwint_unregister_handler(unsigned int int_no)
@ -38,6 +38,6 @@ void hwint_unregister_handler(unsigned int int_no)
return; return;
} }
kernaux_drivers_intel_8259_pic_disable(int_no); drivers_intel_8259_pic_disable(int_no);
handlers[int_no] = 0; handlers[int_no] = 0;
} }

6
src/interrupts/syscall.c
View file

@ -1,6 +1,6 @@
#include "main.h" #include "main.h"
#include <kernaux/drivers/console.h> #include <drivers/console.h>
static void syscall_do_exit(struct IsrRegisters regs); static void syscall_do_exit(struct IsrRegisters regs);
@ -8,7 +8,7 @@ void syscall_handler(const struct IsrRegisters regs)
{ {
const unsigned int id = regs.eax << 16 >> 16; const unsigned int id = regs.eax << 16 >> 16;
kernaux_drivers_console_printf("[INFO] syscall: number %u\n", id); drivers_console_printf("[INFO] syscall: number %u\n", id);
switch (id) { switch (id) {
case KERNEL_SYSCALL_EXIT: syscall_do_exit(regs); break; case KERNEL_SYSCALL_EXIT: syscall_do_exit(regs); break;
@ -19,5 +19,5 @@ void syscall_do_exit(const struct IsrRegisters regs)
{ {
const unsigned int exit_code = regs.ebx << 16 >> 16; const unsigned int exit_code = regs.ebx << 16 >> 16;
kernaux_drivers_console_printf("[WARN] syscall: process try to exit with error code %u, haha\n", exit_code); drivers_console_printf("[WARN] syscall: process try to exit with error code %u, haha\n", exit_code);
} }

7
src/main.c
View file

@ -5,7 +5,7 @@
#include "panic.h" #include "panic.h"
#include "protected.h" #include "protected.h"
#include <kernaux/drivers/console.h> #include <drivers/console.h>
#include <kernaux/multiboot2.h> #include <kernaux/multiboot2.h>
#include <kernaux/pfa.h> #include <kernaux/pfa.h>
@ -33,8 +33,7 @@ void main(
panic("Multiboot 2 info magic number is invalid."); panic("Multiboot 2 info magic number is invalid.");
} }
KernAux_Multiboot2_Info_print(multiboot2_info, KernAux_Multiboot2_Info_print(multiboot2_info, drivers_console_printf);
kernaux_drivers_console_printf);
if (!KernAux_Multiboot2_Info_is_valid(multiboot2_info)) { if (!KernAux_Multiboot2_Info_is_valid(multiboot2_info)) {
panic("Multiboot 2 info is invalid."); panic("Multiboot 2 info is invalid.");
@ -68,5 +67,5 @@ void main(
protected_initialize(&kinfo); protected_initialize(&kinfo);
kernaux_drivers_console_puts("[INFO] main: Finished."); drivers_console_puts("[INFO] main: Finished.");
} }

13
src/panic.c
View file

@ -1,14 +1,13 @@
#include "panic.h" #include "panic.h"
#include <drivers/console.h>
#include <drivers/shutdown.h>
#include <kernaux/asm/i386.h> #include <kernaux/asm/i386.h>
#include <kernaux/drivers/console.h>
#include <kernaux/drivers/shutdown.h>
#include <kernaux/drivers/qemu.h>
void panic(const char *const s) void panic(const char *const s)
{ {
kernaux_drivers_console_printf("[FAIL] panic: %s\n", s); drivers_console_printf("[FAIL] panic: %s\n", s);
kernaux_drivers_shutdown_poweroff(); drivers_shutdown_poweroff();
} }
void halt() void halt()
@ -21,7 +20,7 @@ void kernaux_assert_fn(
const int line, const int line,
const char *const str const char *const str
) { ) {
kernaux_drivers_console_printf("[FAIL] assertion failed: %s:%u: \"%s\"\n", drivers_console_printf("[FAIL] assertion failed: %s:%u: \"%s\"\n",
file, line, str); file, line, str);
kernaux_drivers_shutdown_poweroff(); drivers_shutdown_poweroff();
} }

24
src/protected.c
View file

@ -4,10 +4,10 @@
#include "info.h" #include "info.h"
#include "interrupts/main.h" #include "interrupts/main.h"
#include <drivers/console.h>
#include <drivers/intel_8259_pic.h>
#include <kernaux/arch/i386.h> #include <kernaux/arch/i386.h>
#include <kernaux/asm/i386.h> #include <kernaux/asm/i386.h>
#include <kernaux/drivers/console.h>
#include <kernaux/drivers/intel_8259_pic.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@ -27,21 +27,21 @@ static void idt_set_gate(uint8_t num, uint32_t base, uint16_t sel, uint8_t flags
void protected_initialize(const struct Kernel_Info *const kinfo) void protected_initialize(const struct Kernel_Info *const kinfo)
{ {
kernaux_drivers_intel_8259_pic_remap(32, 40); drivers_intel_8259_pic_remap(32, 40);
kernaux_drivers_intel_8259_pic_disable_all(); drivers_intel_8259_pic_disable_all();
kernaux_drivers_console_puts("[INFO] protected: Setup GDT."); drivers_console_puts("[INFO] protected: Setup GDT.");
gdt_set_gates(); gdt_set_gates();
kernaux_drivers_console_puts("[INFO] protected: Setup IDT."); drivers_console_puts("[INFO] protected: Setup IDT.");
idt_set_gates(); idt_set_gates();
kernaux_drivers_console_puts("[INFO] protected: Setup TSS."); drivers_console_puts("[INFO] protected: Setup TSS.");
memset(&tss, 0, sizeof(tss)); memset(&tss, 0, sizeof(tss));
tss.ss0 = GDT_KERNEL_DS_SELECTOR; tss.ss0 = GDT_KERNEL_DS_SELECTOR;
tss.esp0 = kinfo->kernel_stack_start + kinfo->kernel_stack_size; tss.esp0 = kinfo->kernel_stack_start + kinfo->kernel_stack_size;
kernaux_drivers_console_puts("[INFO] protected: Load GDT."); drivers_console_puts("[INFO] protected: Load GDT.");
gdt_pointer.size = sizeof(struct KernAux_Arch_I386_DTE) * GDT_SIZE - 1; gdt_pointer.size = sizeof(struct KernAux_Arch_I386_DTE) * GDT_SIZE - 1;
gdt_pointer.offset = (uint32_t)&gdt_entries; gdt_pointer.offset = (uint32_t)&gdt_entries;
kernaux_asm_i386_flush_gdt( kernaux_asm_i386_flush_gdt(
@ -50,18 +50,18 @@ void protected_initialize(const struct Kernel_Info *const kinfo)
GDT_KERNEL_CS_SELECTOR GDT_KERNEL_CS_SELECTOR
); );
kernaux_drivers_console_puts("[INFO] protected: Load IDT."); drivers_console_puts("[INFO] protected: Load IDT.");
idt_pointer.size = sizeof(struct KernAux_Arch_I386_IDTE) * IDT_SIZE - 1; idt_pointer.size = sizeof(struct KernAux_Arch_I386_IDTE) * IDT_SIZE - 1;
idt_pointer.offset = (uint32_t)&idt_entries; idt_pointer.offset = (uint32_t)&idt_entries;
kernaux_asm_i386_flush_idt((uint32_t)&idt_pointer); kernaux_asm_i386_flush_idt((uint32_t)&idt_pointer);
// kernaux_drivers_console_puts("[INFO] protected: Load TSS."); // drivers_console_puts("[INFO] protected: Load TSS.");
// kernaux_asm_i386_flush_tss(GDT_TSS_SELECTOR); // kernaux_asm_i386_flush_tss(GDT_TSS_SELECTOR);
kernaux_drivers_console_puts("[INFO] protected: Enable interrupts."); drivers_console_puts("[INFO] protected: Enable interrupts.");
asm volatile ("sti"); asm volatile ("sti");
kernaux_drivers_console_puts("[INFO] protected: Finished."); drivers_console_puts("[INFO] protected: Finished.");
} }
void gdt_set_gates() void gdt_set_gates()

8
src/timer.c
View file

@ -1,13 +1,13 @@
#include "timer.h" #include "timer.h"
#include <drivers/console.h>
#include <drivers/intel_8253_pit.h>
#include <kernaux/asm/i386.h> #include <kernaux/asm/i386.h>
#include <kernaux/drivers/console.h>
#include <kernaux/drivers/intel_8253_pit.h>
void timer_initialize(unsigned int frequency) void timer_initialize(unsigned int frequency)
{ {
kernaux_drivers_console_puts("[INFO] timer: Initialize timer."); drivers_console_puts("[INFO] timer: Initialize timer.");
kernaux_drivers_intel_8253_pit_initialize(frequency); drivers_intel_8253_pit_initialize(frequency);
} }
void timer_register_handler(timer_handler_t handler) void timer_register_handler(timer_handler_t handler)