improve memory allocators methods, improve paging, update readme

Author: alexeev-prog

CHANGELOG.md

@@ -1,3 +1,9 @@
+commit 1257a001f3ade050a2d997495921417e27a880d4
+Author: Alexeev Bronislav <[email protected]>
+Date:   Mon Aug 25 03:18:16 2025 +0700
+
+    improve kklibc stdlib and stdio, add kernel panic red screen
+
 commit f1d82ba66c77d46c2b727a6af6c8ce7e559b3c07
 Author: Alexeev Bronislav <[email protected]>
 Date:   Mon Aug 25 02:42:53 2025 +0700

image.png

@@ -13,6 +13,8 @@
 #include "../kklibc/paging.h"
 #include "../kklibc/kklibc.h"
 
+#define MAX_ARGS 32
+
 int shell_cursor_offset = 0;
 int shell_prompt_offset = 0;
 
@@ -38,12 +40,17 @@ void kmain() {
 
 char** get_args(char *input) {
 	char *token = strtok(input, " ");
-	char** args;
+	static char* args[MAX_ARGS + 1];
 	int arg_counter = 0;
 
     while(token) {
         token = strtok(NULL, " ");
 
+		if (arg_counter + 1 > MAX_ARGS + 1) {
+			printf_colored("Error when parsing args: %d args exceed the limit %d\n", RED_ON_BLACK_CLR_CODE, arg_counter + 1, MAX_ARGS + 1);
+			break;
+		}
+
 		args[arg_counter] = token;
 		arg_counter++;
     }

src/kernel/kernel/kernel.c

@@ -10,11 +10,13 @@
 #include "ctypes.h"
 #include "stdio.h"
 #include "stdlib.h"
+#include "paging.h"
 
 u32 free_mem_addr_guard1 = 0xDEADBEEF;
 u32 free_mem_addr = HEAP_START;
 u32 free_mem_addr_guard2 = 0xCAFEBABE;
 static mem_block_t *free_blocks = NULL;
+u32 heap_current_end = HEAP_START + HEAP_SIZE;
 
 // Инициализация памяти heap
 void heap_init() {
@@ -24,13 +26,57 @@ void heap_init() {
     free_blocks->next = NULL;
     free_blocks->is_free = 1;
 
+    // Обновим текущий конец кучи
+    heap_current_end = HEAP_START + HEAP_SIZE;
+
     kprint("Heap initialized at ");
     char buf[32] = "";
     hex_to_ascii(HEAP_START, buf);
     kprint(buf);
     kprint("\n");
 }
 
+int expand_heap(u32 size) {
+    // Выравниваем размер вверх до границы страницы
+    u32 num_pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
+    u32 expand_size = num_pages * PAGE_SIZE;
+
+    printf("Expanding heap by %d bytes (%d pages)\n", expand_size, num_pages);
+
+    // Мы будем расширять кучу начиная с адреса heap_current_end
+    u32 virtual_address = heap_current_end;
+
+    for (u32 i = 0; i < num_pages; i++) {
+        // Запрашиваем физический фрейм
+        page_t *page = get_page(virtual_address, 1, kernel_directory);
+        if (!page) {
+            kprint("Failed to get page for heap expansion!\n");
+            return 0;
+        }
+
+        // Выделяем фрейм для страницы (с флагами ядра и записи)
+        alloc_frame(page, 0, 1);
+
+        // Обновляем виртуальный адрес для следующей страницы
+        virtual_address += PAGE_SIZE;
+    }
+
+    // Теперь нам нужно добавить новую область памяти в список свободных блоков
+    mem_block_t *new_block = (mem_block_t *)heap_current_end;
+    new_block->size = expand_size - sizeof(mem_block_t); // Учитываем заголовок
+    new_block->is_free = 1;
+    new_block->next = free_blocks; // Добавляем в начало списка
+
+    // Обновляем глобальный список свободных блоков
+    free_blocks = new_block;
+
+    // Обновляем текущий конец кучи
+    heap_current_end += expand_size;
+
+    printf("Heap expanded successfully. New end: %x\n", heap_current_end);
+    return 1;
+}
+
 void *kmalloc(u32 size) {
     // Выравниваем размер до границы BLOCK_SIZE
     if (size % BLOCK_SIZE != 0) {
@@ -47,13 +93,9 @@ void *kmalloc(u32 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) +
+                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->size = current->size - size - sizeof(mem_block_t); // размер текущего - выделяемый - размер структуры
                 new_block->is_free = 1; // свободен
                 new_block->next = current->next;
 
@@ -70,20 +112,68 @@ void *kmalloc(u32 size) {
         current = current->next;
     }
 
-    kprint("No free blocks found\n");
-    return NULL;
+    // Если дошли сюда, значит, подходящего блока не найдено -> пробуем расширить кучу
+    printf("No free block found for size %d. Trying to expand heap...\n", size);
+    if (expand_heap(size)) {
+        // После расширения кучи пробуем аллоцировать снова (рекурсивно)
+        return kmalloc(size);
+    } else {
+        kprint("Heap expansion failed!\n");
+        return NULL;
+    }
 }
 
 void *krealloc(void *ptr, u32 size) {
-    if (!ptr) return kmalloc(size); // если нет указателя то просто аллоцируем память
-    if (size == 0) { kfree(ptr); return NULL; } // если размер нулевой освобождаем поинтер
+    if (!ptr)
+        return kmalloc(size);
+
+    if (size == 0) {
+        kfree(ptr);
+        return NULL;
+    }
+
+    // Получаем заголовок блока
+    mem_block_t *block = (mem_block_t *)((u32)ptr - sizeof(mem_block_t));
+
+    // Если текущий блок достаточно большой
+    if (block->size >= size) {
+        // Можно ли разделить блок?
+        if (block->size - size >= sizeof(mem_block_t) + BLOCK_SIZE) {
+            mem_block_t *new_block = (mem_block_t *)((u32)block + sizeof(mem_block_t) + size);
+            new_block->size = block->size - size - sizeof(mem_block_t);
+            new_block->is_free = 1;
+            new_block->next = block->next;
+
+            block->size = size;
+            block->next = new_block;
+        }
+        return ptr;
+    }
+
+    // Пытаемся объединить с последующим свободным блоком
+    if (block->next && block->next->is_free) {
+        u32 total_size = block->size + sizeof(mem_block_t) + block->next->size;
+        if (total_size >= size) {
+            block->size = total_size;
+            block->next = block->next->next;
 
-    mem_block_t *block = (mem_block_t*)((u32)ptr - sizeof(mem_block_t)); // создаем блок
-    if (block->size >= size) return ptr; // если текущий блок достаточно большой
+            // Разделяем блок, если осталось место
+            if (total_size - size >= sizeof(mem_block_t) + BLOCK_SIZE) {
+                mem_block_t *new_block = (mem_block_t *)((u32)block + sizeof(mem_block_t) + size);
+                new_block->size = total_size - size - sizeof(mem_block_t);
+                new_block->is_free = 1;
+                new_block->next = block->next;
+                block->next = new_block;
+                block->size = size;
+            }
+            return ptr;
+        }
+    }
 
-    void *new_ptr = kmalloc(size); // новый поинтер
-    if (new_ptr) { // если все ок то копируем память и освобождаем старый поинтер
-        memory_copy(ptr, new_ptr, block->size);
+    // Если не можем расширить, выделяем новый блок и копируем данные
+    void *new_ptr = kmalloc(size);
+    if (new_ptr) {
+        memcpy(new_ptr, ptr, block->size);
         kfree(ptr);
     }
     return new_ptr;
@@ -93,25 +183,64 @@ void kfree(void *ptr) {
     if (!ptr)
         return;
 
-    // получаем указатель на заголовок блока
+    // Получаем указатель на заголовок блока
     mem_block_t *block = (mem_block_t *)((u32)ptr - sizeof(mem_block_t));
 
-    if (block->is_free) { // блок уже освобожден
+    if (block->is_free) {
         kprint("Double free detected!\n");
         return;
     }
 
     block->is_free = 1;
 
-    /* попробуем объединить с соседними свободными блоками*/
+    // Попробуем объединить с соседними свободными блоками
     mem_block_t *current = free_blocks;
+    mem_block_t *prev = NULL;
+
     while (current) {
         if (current->is_free && current->next && current->next->is_free) {
-            // соединим текущий блок со следующим
+            // Объединяем текущий блок со следующим
             current->size += sizeof(mem_block_t) + current->next->size;
             current->next = current->next->next;
-            free_mem_addr -= current->size;
         }
+
+        // Проверяем, можно ли освободить страницы
+        if (current->is_free) {
+            u32 block_start = (u32)current;
+            u32 block_end = block_start + sizeof(mem_block_t) + current->size;
+
+            // Выравниваем границы блока по границам страниц
+            u32 start_page = block_start & ~(PAGE_SIZE - 1);
+            u32 end_page = (block_end + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+
+            // Проверяем, полностью ли свободны страницы в этом блоке
+            for (u32 page = start_page; page < end_page; page += PAGE_SIZE) {
+                page_t *page_entry = get_page(page, 0, kernel_directory);
+                if (page_entry && page_entry->present) {
+                    // Проверяем, нет ли занятых блоков в этой странице
+                    int page_is_free = 1;
+                    mem_block_t *check = free_blocks;
+                    while (check) {
+                        u32 check_start = (u32)check;
+                        u32 check_end = check_start + sizeof(mem_block_t) + check->size;
+
+                        if (!check->is_free && check_start < page + PAGE_SIZE && check_end > page) {
+                            page_is_free = 0;
+                            break;
+                        }
+                        check = check->next;
+                    }
+
+                    if (page_is_free) {
+                        // Освобождаем фрейм и страницу
+                        free_frame(page_entry);
+                        page_entry->present = 0;
+                    }
+                }
+            }
+        }
+
+        prev = current;
         current = current->next;
     }
 }
@@ -153,14 +282,44 @@ void kmemdump() {
     u32 counter = 0;
 
     printf("Heap: %x - %x (%d bytes)\n", info.heap_start,
-                    info.heap_start + info.heap_size, info.heap_size);
+                    info.heap_current_end, info.heap_current_end - info.heap_start);
     printf("Block size: %d bytes\n", info.block_size);
     printf("Total: USED=%d bytes, FREE=%d bytes, in %d blocks\n\n",
                     info.total_used, info.total_free, info.block_count);
 
+    // Вывод информации о страницах хипа
+
+    int present_pages_count = 0;
+    int not_present_pages_count = 0;
+    for (u32 addr = info.heap_start; addr < info.heap_current_end; addr += PAGE_SIZE) {
+        page_t *page = get_page(addr, 0, kernel_directory);
+        if (page && page->present) {
+            present_pages_count += 1;
+        } else {
+            not_present_pages_count += 1;
+        }
+    }
+
+    printf("Heap pages: PRESENT=%d  |  NOT PRESENT=%d", present_pages_count, not_present_pages_count);
+
+    printf("\nMemory blocks:\n");
     while (current) {
         printf("Block %d: %x, Size=%d, %s\n", counter++, (u32)current,
                         current->size, current->is_free ? "FREE" : "USED");
+
+        // Дополнительная информация о страницах этого блока
+        u32 block_start = (u32)current;
+        u32 block_end = block_start + sizeof(mem_block_t) + current->size;
+        u32 start_page = block_start & ~(PAGE_SIZE - 1);
+        u32 end_page = (block_end + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+
+        for (u32 page_addr = start_page; page_addr < end_page; page_addr += PAGE_SIZE) {
+            page_t *page = get_page(page_addr, 0, kernel_directory);
+            if (page && page->present) {
+                printf("    Page %x -> Frame %x\n", page_addr, page->frame * PAGE_SIZE);
+            }
+        }
+
         current = current->next;
     }
 }

src/kernel/kklibc/mem.c

@@ -23,6 +23,7 @@ typedef struct mem_block {
 typedef struct meminfo {
     u32 heap_start;
     u32 heap_size;
+    u32 heap_current_end;
     u32 block_size;
     mem_block_t* free_blocks;
     u32 total_used;
@@ -33,9 +34,10 @@ typedef struct meminfo {
 meminfo_t get_meminfo();
 void get_freememaddr();
 
-// Новые функции
+int expand_heap(u32 size);
 void heap_init();
 void* kmalloc(u32 size);
+void *krealloc(void *ptr, u32 size);
 void kfree(void* ptr);
 void kmemdump();
 

src/kernel/kklibc/mem.h

@@ -90,8 +90,7 @@ static u32 first_frame() {
 }
 
 /* Выделение фрейма для страницы */
-void alloc_frame(page_t *page, int is_kernel, int is_writeable)
-{
+void alloc_frame(page_t *page, int is_kernel, int is_writeable) {
     if (page->frame != 0) {
         return; // Фрейм уже выделен
     } else {

src/kernel/kklibc/paging.c

@@ -4,6 +4,12 @@
 #include "ctypes.h"
 #include "../cpu/isr.h"
 
+/* Макросы для работы с битовыми массивами */
+#define INDEX_FROM_BIT(a) (a/(8*4))
+#define OFFSET_FROM_BIT(a) (a%(8*4))
+
+#define PAGE_SIZE 0x1000
+
 /* Внутренняя функция выделения памяти */
 u32 pkmalloc_internal(u32 sz, int align, u32 *phys);
 
@@ -19,10 +25,6 @@ u32 pkmalloc_ap(u32 sz, u32 *phys);
 /* Обычное выделение памяти */
 u32 pkmalloc(u32 sz);
 
-/* Макросы для работы с битовыми массивами */
-#define INDEX_FROM_BIT(a) (a/(8*4))
-#define OFFSET_FROM_BIT(a) (a%(8*4))
-
 /* Внешняя переменная текущего адреса свободной памяти */
 extern u32 free_mem_addr;
 
@@ -89,4 +91,7 @@ page_t *get_page(u32 address, int make, page_directory_t *dir);
 **/
 void page_fault(registers_t regs);
 
+void alloc_frame(page_t *page, int is_kernel, int is_writeable);
+void free_frame(page_t *page);
+
 #endif