Дополнительные функции библиотеки ядра

.vscode/settings.json

@@ -1,3 +1,10 @@
 {
-    "C_Cpp.errorSquiggles": "disabled"
+    "C_Cpp.errorSquiggles": "disabled",
+    "files.associations": {
+        "array": "cpp",
+        "bitset": "cpp",
+        "string_view": "cpp",
+        "initializer_list": "cpp",
+        "complex": "cpp"
+    }
 }

configs/limine.cfg

@@ -17,5 +17,5 @@ BACKGROUND_PATH=boot:///boot.png
     MODULE_PATH=boot:///mod/hello.so
     MODULE_CMDLINE=[MOD]hello.so
 
-    #MODULE_PATH=boot:///boot.png
-    #MODULE_CMDLINE=bootimage
+    MODULE_PATH=boot:///boot.png
+    MODULE_CMDLINE=[BOOTIMG]

include/mem.h

@@ -1,5 +1,8 @@
 namespace mem {
 void init( );
+void *alloc(size_t size);
+void free(void *addr);
+void *realloc(void *addr, size_t size);
 void *frame_alloc(uint64_t wanted_frames);
 void frame_free(void *ptr, uint64_t frames);
 void *frame_calloc(uint64_t frames);

include/tool.h

@@ -1,5 +1,7 @@
 #include <stdarg.h>
 
+#define abs(x) ((x) < 0 ? -(x) : (x))
+
 #define assert(check)                                                          \
 	({                                                                         \
 		if (!(check)) {                                                        \
@@ -18,8 +20,18 @@
 #define BIT_CLEAR(BIT) (bitmap[(BIT) / 8] &= ~(1 << ((BIT) % 8)))
 #define BIT_GET(BIT) ((bitmap[(BIT) / 8] >> ((BIT) % 8)) & 1)
 
+static inline void pause( ) {
+	for (uint64_t i = 0; i < 1024; i++) {
+		for (uint64_t j = 0; j < 1024; j++) {
+			for (uint64_t q = 0; q < 4; q++) { asm volatile("pause"); }
+		}
+	}
+}
+
 namespace tool {
 void memcpy(void *dest, void *src, uint64_t n);
 void *memset(void *ptr, uint8_t n, uint64_t size);
+uint64_t strlen(const char *str);
+uint64_t starts_with(const char *str, const char *prefix);
 void format(void (*putc)(char c), const char *format_string, va_list args);
 } // namespace tool

include/version.h

@@ -1,3 +1,3 @@
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 1
-#define VERSION_BUILD 100
+#define VERSION_BUILD 135

kernel/main.cpp

@@ -1,18 +0,0 @@
-#include <fb.h>
-#include <mem.h>
-#include <tool.h>
-
-void assert(int x) {
-	if (!x) {
-		fb::printf("assert(%d)\n", x);
-		while (1) { asm volatile("hlt"); }
-	}
-}
-
-void *malloc(int size) {}
-
-void *realloc(void *pointer, int new_size) {}
-
-void free(void *pointer) {}
-
-void main( ) {}

kernel/main/main.cpp

@@ -0,0 +1,80 @@
+#include <fb.h>
+#include <mem.h>
+#include <tool.h>
+extern void *bootpng_ptr;
+extern uint64_t bootpng_size;
+extern "C" {
+
+void *realloc(void *pointer, int new_size) {
+	return mem::realloc(pointer, new_size);
+}
+
+void free(void *pointer) {
+	free(pointer);
+}
+#define memcpy(x, y, z) tool::memcpy(x, y, z)
+#define memset(x, y, z) tool::memset(x, y, z)
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ASSERT(x) assert(x)
+#define malloc(sz)                                                             \
+	mem::alloc(sz);                                                            \
+	fb::printf("malloc(%uКБ) %s, %s, %u\n", sz / 1024, __FILE__, __FUNCTION__, \
+	           __LINE__);
+#define STBI_MALLOC(sz) malloc(sz)
+#define STBI_REALLOC(p, newsz) realloc(p, newsz)
+#define STBI_FREE(p) free(p)
+#define STBI_NO_STDIO
+#define STBI_NO_LINEAR
+#define STBI_NO_HDR
+#define STBI_NO_SIMD
+#define STBI_ONLYPNG
+#include "stb_image.h"
+
+unsigned int *png_parse(unsigned char *ptr, int size) {
+	int i, w, h, f;
+	unsigned char *img, *p;
+	stbi__context s;
+	stbi__result_info ri;
+	s.read_from_callbacks = 0;
+	s.img_buffer = s.img_buffer_original = ptr;
+	s.img_buffer_end = s.img_buffer_original_end = ptr + size;
+	ri.bits_per_channel = 8;
+	img = p = (unsigned char *)stbi__png_load(&s, (int *)&w, (int *)&h,
+	                                          (int *)&f, 1, &ri);
+	unsigned int *data =
+	    (unsigned int *)malloc((w * h + 2) * sizeof(unsigned int));
+	fb::printf("Выделено %u\n", (w * h + 2) * sizeof(unsigned int));
+	pause( );
+	pause( );
+	pause( );
+	pause( );
+	if (!data) {
+		// free(img);
+		return NULL;
+	}
+	for (i = 0; i < w * h; i++, p += f) switch (f) {
+			case 1:
+				data[2 + i] = 0xFF000000 | (p[0] << 16) | (p[0] << 8) | p[0];
+				break;
+			case 2:
+				data[2 + i] = (p[1] << 24) | (p[0] << 16) | (p[0] << 8) | p[0];
+				break;
+			case 3:
+				data[2 + i] = 0xFF000000 | (p[0] << 16) | (p[1] << 8) | p[2];
+				break;
+			case 4:
+				data[2 + i] = (p[3] << 24) | (p[0] << 16) | (p[1] << 8) | p[2];
+				break;
+		}
+	// free(img);
+	data[0] = w;
+	data[1] = h;
+	return data;
+}
+
+void main( ) {
+	fb::printf("Загрузка завершена! 1\n");
+	unsigned int *data = png_parse((unsigned char *)bootpng_ptr, bootpng_size);
+	fb::printf("Загрузка завершена! 2 %x\n", data);
+}
+}

kernel/mod.cpp

@@ -2,6 +2,7 @@
 #include <limine.h>
 #include <mod.h>
 #include <sys.h>
+#include <tool.h>
 
 // Структуры соответствующие ELF заголовкам
 typedef struct {
@@ -23,6 +24,10 @@ typedef struct {
 
 env_t main_env;
 
+extern "C" {
+void *bootpng_ptr;
+uint64_t bootpng_size;
+}
 void *elf_entry(void *module_bin, uint64_t size) {
 	// Приводим заголовок ELF файла к типу elf64_header_t
 	elf64_header_t *elf_header = (elf64_header_t *)module_bin;
@@ -83,16 +88,24 @@ void init( ) {
 		    module_ptr->mbr_disk_id, module_ptr->tftp_ip,
 		    module_ptr->tftp_port);
 
+		if (tool::starts_with(module_ptr->cmdline, "[BOOTIMG]")) {
+			fb::printf("\t\t[BOOTIMG]\n");
+			bootpng_ptr = module_ptr->address;
+			bootpng_size = module_ptr->size;
+			continue;
+		}
+		if (!tool::starts_with(module_ptr->cmdline, "[MOD]")) { continue; }
+
 		module_info_t *(*module_init)(env_t * env) =
 		    (module_info_t * (*)(env_t * env))
 		        elf_entry(module_ptr->address, module_ptr->size);
 
 		fb::printf("\t->Точка входа: 0x%x\n", module_init);
 
-		module_info_t *ret = module_init(&main_env);
+		// module_info_t *ret = module_init(&main_env);
 
-		fb::printf("Инициализированно с кодом: %u\n", ret->err_code);
-		fb::printf("Сообщение из модуля: %s\n\n", ret->message);
+		// fb::printf("Инициализированно с кодом: %u\n", ret->err_code);
+		// fb::printf("Сообщение из модуля: %s\n\n", ret->message);
 	}
 }
 } // namespace mod

kernel/start.cpp

@@ -9,14 +9,6 @@
 
 extern "C" void main( );
 
-static inline void pause( ) {
-	for (uint64_t i = 0; i < 1024; i++) {
-		for (uint64_t j = 0; j < 1024; j++) {
-			for (uint64_t q = 0; q < 1; q++) { asm volatile("pause"); }
-		}
-	}
-}
-
 // Точка входа
 extern "C" void _start( ) {
 	asm volatile("cli");
@@ -30,6 +22,8 @@ extern "C" void _start( ) {
 	           VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD);
 	fb::printf("\t\t\t\t *** Дата сборки: %s %s ***\n", __DATE__, __TIME__);
 	mod::init( );
-
+	fb::printf("Пауза...\n");
+	pause( );
+	main( );
 	for (;;) { asm volatile("hlt"); }
 }

kernel/tool.cpp

@@ -17,6 +17,28 @@ void *memset(void *ptr, uint8_t n, uint64_t size) {
 	return ptr;
 }
 
+uint64_t strlen(const char *str) {
+	uint64_t length = 0;
+	while (*str) {
+		length++;
+		str++;
+	}
+	return length;
+}
+
+uint64_t starts_with(const char *str, const char *prefix) {
+	uint64_t str_len = strlen(str);
+	uint64_t prefix_len = strlen(prefix);
+
+	if (prefix_len > str_len) { return 0; }
+
+	for (uint64_t i = 0; i < prefix_len; i++) {
+		if (str[i] != prefix[i]) { return 0; }
+	}
+
+	return 1;
+}
+
 // Функция для форматированного вывода
 void format(void (*putc)(char c), const char *format_string, va_list args) {
 	while (*format_string != '\0') {
@@ -28,7 +50,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 			if (*format_string == '%') {
 				putc('%'); // Вывод одного символа '%'
 			} else if (*format_string == 'd') {
-				int arg = va_arg(args, int);
+				int64_t arg = va_arg(args, int64_t);
 				// Преобразование целочисленного аргумента в строку и вывод
 				// каждого символа
 				if (arg < 0) {
@@ -40,7 +62,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 				} else {
 					char buffer[10]; // Предполагаем, что максимальное число из
 					                 // 10 цифр
-					int i = 0;
+					int64_t i = 0;
 
 					while (arg > 0) {
 						buffer[i++] = '0' + (arg % 10);
@@ -57,15 +79,15 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 					arg++;
 				}
 			} else if (*format_string == 'u') {
-				unsigned int arg = va_arg(args, unsigned int);
+				uint64_t arg = va_arg(args, uint64_t);
 				// Преобразование беззнакового целочисленного аргумента в строку
 				// и вывод каждого символа
 				if (arg == 0) {
 					putc('0');
 				} else {
-					char buffer[10]; // Предполагаем, что максимальное число из
+					char buffer[32]; // Предполагаем, что максимальное число из
 					                 // 10 цифр
-					int i = 0;
+					int64_t i = 0;
 
 					while (arg > 0) {
 						buffer[i++] = '0' + (arg % 10);
@@ -75,18 +97,18 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 					while (i > 0) { putc(buffer[--i]); }
 				}
 			} else if (*format_string == 'x') {
-				unsigned int arg = va_arg(args, unsigned int);
+				uint64_t arg = va_arg(args, uint64_t);
 				// Преобразование беззнакового целочисленного аргумента в
 				// шестнадцатеричную строку и вывод каждого символа
 				if (arg == 0) {
 					putc('0');
 				} else {
-					char buffer[9]; // Предполагаем, что максимальное число из 8
-					                // символов
-					int i = 0;
+					char buffer[32]; // Предполагаем, что максимальное число из
+					                 // 8 символов
+					int64_t i = 0;
 
 					while (arg > 0) {
-						int rem = arg % 16;
+						int64_t rem = arg % 16;
 						if (rem < 10) {
 							buffer[i++] = '0' + rem;
 						} else {
@@ -102,7 +124,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 				// Вывод символа
 				putc(arg);
 			} else if (*format_string == 'o') {
-				unsigned int arg = va_arg(args, unsigned int);
+				uint64_t arg = va_arg(args, uint64_t);
 				// Преобразование беззнакового целочисленного аргумента в
 				// восьмеричную строку и вывод каждого символа
 				if (arg == 0) {
@@ -110,7 +132,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 				} else {
 					char buffer[12]; // Предполагаем, что максимальное число из
 					                 // 11 символов
-					int i = 0;
+					int64_t i = 0;
 
 					while (arg > 0) {
 						buffer[i++] = '0' + (arg % 8);
@@ -120,7 +142,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 					while (i > 0) { putc(buffer[--i]); }
 				}
 			} else if (*format_string == 'b') {
-				unsigned int arg = va_arg(args, unsigned int);
+				uint64_t arg = va_arg(args, uint64_t);
 				// Преобразование беззнакового целочисленного аргумента в
 				// двоичную строку и вывод каждого символа
 				if (arg == 0) {
@@ -128,7 +150,7 @@ void format(void (*putc)(char c), const char *format_string, va_list args) {
 				} else {
 					char buffer[33]; // Предполагаем, что максимальное число из
 					                 // 32 символа
-					int i = 0;
+					int64_t i = 0;
 
 					while (arg > 0) {
 						buffer[i++] = '0' + (arg % 2);

modules/helloworld/build.sh

@@ -2,5 +2,5 @@
 echo "Название: Hello world"
 echo "Лицензия: Публичное достояние"
 gcc -I../../modlib -O0 -finput-charset=UTF-8 -fexec-charset=cp1251 -c -fPIC -nostdlib main.c -o hello.o
-gcc -shared -nostdlib hello.o -o hello.so -Wl,--entry=_start
+gcc -fPIC -shared -nostdlib hello.o -o hello.so -Wl,--entry=_start
 echo "Сборка завершена, файл: hello.so"

run.sh

@@ -1,2 +1,2 @@
 #!/bin/sh
-qemu-system-x86_64 -cpu max -m 256M -smp 1 -bios ovmf/OVMF.fd -hda bmosp.hdd
+qemu-system-x86_64 -cpu max -m 1G -smp 1 -bios ovmf/OVMF.fd -hda bmosp.hdd