realize paging memory, add kmalloc aligned; todo: realize kmemdump fully

Author: alexeev-prog

CHANGELOG.md

@@ -1,10 +1,13 @@
 <<<<<<< HEAD
+<<<<<<< HEAD
 commit 5c5167c783467a1441565edfd12b130a741e999c
 Author: Alexeev Bronislav <[email protected]>
 Date:   Sun Aug 24 06:05:27 2025 +0700
 
     feat: realize paging, add page, frame allocator and change kfree, kmalloc, krealloc
 
+=======
+>>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
 =======
 >>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
 commit ffe676bbcd462e3e7d7c8bd82ca1683361ba3bf6

Makefile

@@ -18,10 +18,14 @@ LDFLAGS = -Ttext 0x1000 --oformat binary
 KERNEL_ENTRY = $(BIN_DIR)/bootloader/kernel_entry.o
 INTERRUPT_OBJ = $(BIN_DIR)/kernel/cpu/interrupt.o
 <<<<<<< HEAD
+<<<<<<< HEAD
 PAGING_OBJ = $(BIN_DIR)/bootloader/paging.o
 =======
 PAGING_OBJ = $(BIN_DIR)/kernel/paging_asm.o
 >>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
+=======
+PAGING_OBJ = $(BIN_DIR)/kernel/paging_asm.o
+>>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
 
 C_SOURCES = $(shell find $(SRC_DIR) -name '*.c')
 C_OBJS = $(C_SOURCES:$(SRC_DIR)/%.c=$(BIN_DIR)/%.o)

src/kernel/kernel/kernel.c

@@ -25,7 +25,11 @@ void kmain() {
 	irq_install();
 	kprint("IRQ Installed\n");
 
+<<<<<<< HEAD
 	init_paging();
+=======
+	register_interrupt_handler(14, page_fault_handler);
+>>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
 
     heap_init();
 

src/kernel/kklibc/mem.c

@@ -11,113 +11,84 @@
 #include "stdio.h"
 #include "stdlib.h"
 
+u32 free_mem_addr_guard1 = 0xDEADBEEF;
+static u32 free_mem_addr = HEAP_VIRTUAL_START;  // Теперь виртуальный адрес
+u32 free_mem_addr_guard2 = 0xCAFEBABE;
 static mem_block_t *free_blocks = NULL;
 
-static page_header_t* page_list = NULL;
-static u32 next_virtual_addr = 0xC0000000; // Начинаем с 3GB для ядра
-
-// Инициализация аллокатора страниц
-void init_page_allocator() {
-    page_list = NULL;
-    kprint("Page allocator initialized\n");
-}
-
-// Выделение новой страницы
-page_header_t* alloc_page_struct(u32 size) {
-    page_header_t* new_page = (page_header_t*)kmalloc(sizeof(page_header_t));
-    if (!new_page) {
-        kprint("Failed to allocate page header\n");
-        return NULL;
-    }
-
-    // Выделяем физический кадр
-    u32 frame_addr = alloc_frame();
-    if (!frame_addr) {
-        kprint("Failed to allocate physical frame\n");
-        kfree(new_page);
-        return NULL;
-    }
-
-    // Назначаем виртуальный адрес
-    u32 virt_addr = next_virtual_addr;
-    next_virtual_addr += PAGE_SIZE;
-
-    // Настраиваем отображение виртуального адреса на физический
-    if (!map_page(virt_addr, frame_addr, 0x03)) { // Present + R/W
-        kprint("Failed to map page\n");
-        free_frame(frame_addr);
-        kfree(new_page);
-        return NULL;
-    }
-
-    // Инициализируем структуру страницы
-    new_page->physical_addr = frame_addr;
-    new_page->virtual_addr = virt_addr;
-    new_page->next = page_list;
-    new_page->ref_count = 1;
-
-    page_list = new_page;
-    return new_page;
-}
-
-// Освобождение страницы
-void free_page_struct(page_header_t* page) {
-    if (!page) return;
-
-    if (--page->ref_count == 0) {
-        // Удаляем отображение страницы
-        unmap_page(page->virtual_addr);
-
-        // Освобождаем физический кадр
-        free_frame(page->physical_addr);
-
-        // Удаляем из списка
-        if (page_list == page) {
-            page_list = page->next;
-        } else {
-            page_header_t* current = page_list;
-            while (current && current->next != page) {
-                current = current->next;
-            }
-            if (current) {
-                current->next = page->next;
-            }
-        }
-
-        // Освобождаем саму структуру
-        kfree(page);
-    }
-}
+static u32 heap_physical_start = 0;
 
 // Инициализация памяти heap
 void heap_init() {
-    // Инициализируем аллокатор страниц
-    init_page_allocator();
+    // Выделяем физическую память для кучи
+    heap_physical_start = 0x200000;  // Начинаем кучу с 2MB
+
+    // Отображаем виртуальные адреса кучи на физические
+    for (u32 i = 0; i < HEAP_SIZE; i += PAGE_SIZE) {
+        void *virtual_addr = (void*)(HEAP_VIRTUAL_START + i);
+        void *physical_addr = (void*)(heap_physical_start + i);
+        map_page(virtual_addr, physical_addr, PAGE_PRESENT | PAGE_WRITABLE);
+    }
 
-    // Остальная инициализация кучи
-    free_blocks = (mem_block_t*)HEAP_START;
+    // Инициализируем первый свободный блок
+    free_blocks = (mem_block_t *)HEAP_VIRTUAL_START;
     free_blocks->size = HEAP_SIZE - sizeof(mem_block_t);
     free_blocks->next = NULL;
     free_blocks->is_free = 1;
     free_blocks->is_page = 0;
     free_blocks->page = NULL;
 
+    kprint("Heap initialized at virtual: ");
     kprint("Heap initialized at virtual: ");
     char buf[32] = "";
     hex_to_ascii(HEAP_VIRTUAL_START, buf);
     kprint(buf);
     kprint(", physical: ");
     hex_to_ascii(heap_physical_start, buf);
+    hex_to_ascii(HEAP_VIRTUAL_START, buf);
+    kprint(buf);
+    kprint(", physical: ");
+    hex_to_ascii(heap_physical_start, buf);
     kprint(buf);
     kprint("\n");
 }
 
 
+
 // TODO: Paging is not implemented
 void *get_physaddr(void *virtualaddr) {
     return get_physical_address(virtualaddr);
 }
 
+void *kmalloc_a(u32 size) {
+    // Выравниваем размер до границы страницы
+    if (size % PAGE_SIZE != 0) {
+        size += PAGE_SIZE - (size % PAGE_SIZE);
+    }
+
+    // Ищем свободную физическую страницу
+    // (здесь должна быть реализация аллокатора физических страниц)
+    static u32 next_physical_page = 0x300000;  // Начинаем с 3MB
+
+    void *physical_addr = (void*)next_physical_page;
+    next_physical_page += size;
+
+    // Выделяем виртуальный адрес
+    static u32 next_virtual_addr = HEAP_VIRTUAL_START + HEAP_SIZE;
+    void *virtual_addr = (void*)next_virtual_addr;
+    next_virtual_addr += size;
+
+    // Отображаем виртуальный адрес на физический
+    for (u32 i = 0; i < size; i += PAGE_SIZE) {
+        map_page((void*)((u32)virtual_addr + i),
+                 (void*)((u32)physical_addr + i),
+                 PAGE_PRESENT | PAGE_WRITABLE);
+    }
+
+    return virtual_addr;
+    return get_physical_address(virtualaddr);
+}
+
 void *kmalloc_a(u32 size) {
     // Выравниваем размер до границы страницы
     if (size % PAGE_SIZE != 0) {
@@ -177,10 +148,10 @@ void *kmalloc(u32 size) {
 
     while (current) {
         if (current->is_free && current->size >= size) {
-            // Нашли подходящий блок
+            // Нашли подходящий свободный блок
             if (current->size > size + sizeof(mem_block_t) + BLOCK_SIZE) {
                 // Можем разделить блок
-                mem_block_t* new_block = (mem_block_t*)((u32)current + sizeof(mem_block_t) + size);
+                mem_block_t *new_block = (mem_block_t*)((u32)current + sizeof(mem_block_t) + size);
                 new_block->size = current->size - size - sizeof(mem_block_t);
                 new_block->is_free = 1;
                 new_block->next = current->next;
@@ -193,6 +164,7 @@ void *kmalloc(u32 size) {
 
             current->is_free = 0;
             return (void*)((u32)current + sizeof(mem_block_t));
+            return (void*)((u32)current + sizeof(mem_block_t));
         }
         prev = current;
         current = current->next;
@@ -310,6 +282,8 @@ meminfo_t get_meminfo() {
         current = current->next;
     }
 
+    meminfo.heap_virtual_start = HEAP_VIRTUAL_START;
+    meminfo.heap_physical_start = heap_physical_start;
     meminfo.heap_virtual_start = HEAP_VIRTUAL_START;
     meminfo.heap_physical_start = heap_physical_start;
     meminfo.heap_size = HEAP_SIZE;
@@ -325,15 +299,26 @@ meminfo_t get_meminfo() {
     meminfo.used_pages = 256;    // Примерное значение
     meminfo.free_pages = 768;    // Примерное значение
 
+    // Информация о страницах (заглушка)
+    meminfo.page_directory_phys = (u32)get_physical_address(get_current_page_directory());
+    meminfo.total_pages = 1024;  // Примерное значение
+    meminfo.used_pages = 256;    // Примерное значение
+    meminfo.free_pages = 768;    // Примерное значение
+
     return meminfo;
 }
 
+// Дамп информации о памяти
 // Дамп информации о памяти
 void kmemdump() {
     meminfo_t info = get_meminfo();
     mem_block_t *current = info.free_blocks;
     u32 counter = 0;
 
+    kprintf("Heap: virtual %x - %x (%d bytes)\n", info.heap_virtual_start,
+            info.heap_virtual_start + info.heap_size, info.heap_size);
+    kprintf("Heap: physical %x - %x\n", info.heap_physical_start,
+            info.heap_physical_start + info.heap_size);
     kprintf("Heap: virtual %x - %x (%d bytes)\n", info.heap_virtual_start,
             info.heap_virtual_start + info.heap_size, info.heap_size);
     kprintf("Heap: physical %x - %x\n", info.heap_physical_start,
@@ -343,8 +328,15 @@ void kmemdump() {
             info.total_used, info.total_free, info.block_count);
     kprintf("Pages: TOTAL=%d, USED=%d, FREE=%d\n\n",
             info.total_pages, info.used_pages, info.free_pages);
+    kprintf("Total: USED=%d bytes, FREE=%d bytes, in %d blocks\n",
+            info.total_used, info.total_free, info.block_count);
+    kprintf("Pages: TOTAL=%d, USED=%d, FREE=%d\n\n",
+            info.total_pages, info.used_pages, info.free_pages);
 
     while (current) {
+        kprintf("Block %d: virt=%x, phys=%x, Size=%d, %s\n", counter++,
+                (u32)current, (u32)get_physical_address(current),
+                current->size, current->is_free ? "FREE" : "USED");
         kprintf("Block %d: virt=%x, phys=%x, Size=%d, %s\n", counter++,
                 (u32)current, (u32)get_physical_address(current),
                 current->size, current->is_free ? "FREE" : "USED");

src/kernel/kklibc/mem.h

@@ -50,7 +50,11 @@ typedef struct meminfo {
 // Обновляем прототипы функций
 void *get_physaddr(void *virtualaddr);
 meminfo_t get_meminfo();
+<<<<<<< HEAD
 
+=======
+void get_freememaddr();
+>>>>>>> 3fe2ead (realize paging memory, add kmalloc aligned; todo: realize kmemdump fully)
 void heap_init();
 void* kmalloc(u32 size);
 void kfree(void* ptr);