Обновление системных функций

include/mod.h

@@ -7,6 +7,8 @@
  *
  */
 
+#include <sys.h>
+
 #ifndef MOD_H
 #define MOD_H
 
@@ -14,8 +16,26 @@
 // сейчас для прототипа это не так важно
 #define MOD_MAX 16
 
+// Структуры соответствующие ELF заголовкам
+typedef struct {
+	unsigned char e_ident[16];
+	uint16_t e_type;
+	uint16_t e_machine;
+	uint32_t e_version;
+	uint64_t e_entry;
+	uint64_t e_phoff;
+	uint64_t e_shoff;
+	uint32_t e_flags;
+	uint16_t e_ehsize;
+	uint16_t e_phentsize;
+	uint16_t e_phnum;
+	uint16_t e_shentsize;
+	uint16_t e_shnum;
+	uint16_t e_shstrndx;
+} elf64_header_t;
+
 void mod_init( );
 void mod_list_show( );
-void mod_find(char *name);
+module_info_t *mod_find(char *tag);
 
 #endif // mod.h

include/sys.h

@@ -34,6 +34,8 @@ typedef struct {
 	char *name;
 	char *message;
 	uint64_t type;
+	uint64_t data_size;
+	void *data;
 	int64_t err_code;
 	uint64_t module_id;
 } module_info_t;
@@ -59,7 +61,18 @@ typedef struct {
 typedef struct {
 	uint64_t offset;
 	module_info_t *info;
-	void (*fb_printf)(char *str, ...);
+	void (*fb_printf)(char *str, ...); // Временная функция
+	framebuffer_t *(*alloc_framebuffer)( );
+	void (*free_framebuffer)(framebuffer_t *frame);
+	void (*exit)(int code);
+	int (*get_error)( );
+	sys_info_t *(*get_info)( );
+	module_info_t *(*get_module)(char *module_id);
+	uint64_t (*new_thread)(uint64_t func);
+	int (*delete_thread)(uint64_t thread_id);
+	time_t (*get_time)( );
 } env_t;
 
+env_t sys_install(env_t module);
+
 #endif // sys.h

include/version.h

@@ -1,3 +1,3 @@
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 1
-#define VERSION_BUILD 438
+#define VERSION_BUILD 502

kernel/fb.c

@@ -123,7 +123,6 @@ void scroll_fb( ) {
 
 // Вывод одного символа
 static void fb_putchar(char c) {
-	pause( );
 	if (c == '\t') {
 		pos_x += FONT_6X8_SLIM_CHAR_WIDTH * 4;
 	} else if (c == '\n') {

kernel/mod.c

@@ -13,47 +13,6 @@
 #include <sys.h>
 #include <tool.h>
 
-// Структуры соответствующие ELF заголовкам
-typedef struct {
-	unsigned char e_ident[16];
-	uint16_t e_type;
-	uint16_t e_machine;
-	uint32_t e_version;
-	uint64_t e_entry;
-	uint64_t e_phoff;
-	uint64_t e_shoff;
-	uint32_t e_flags;
-	uint16_t e_ehsize;
-	uint16_t e_phentsize;
-	uint16_t e_phnum;
-	uint16_t e_shentsize;
-	uint16_t e_shnum;
-	uint16_t e_shstrndx;
-} elf64_header_t;
-
-static env_t main_env;
-
-void *bootpng_ptr;
-uint64_t bootpng_size;
-
-static void *elf_entry(void *module_bin) {
-	// Приводим заголовок ELF файла к типу elf64_header_t
-	elf64_header_t *elf_header = (elf64_header_t *)module_bin;
-
-#if 0
-	LOG("  Класс:       ELF64\n");
-	LOG("  Версия:      %u\n", elf_header->e_ident[6]);
-	LOG("  ОС/ABI:      %u\n", elf_header->e_ident[7]);
-	LOG("  Тип:         %u\n", elf_header->e_type);
-	LOG("  Машина:      %u\n", elf_header->e_machine);
-	LOG("  Версия:      %u\n", elf_header->e_version);
-	LOG("  Точка входа: 0x%x\n", elf_header->e_entry);
-#endif
-
-	// Возвращаем указатель на точку входа
-	return (void *)((uint64_t)elf_header->e_entry + (uint64_t)module_bin);
-}
-
 static volatile struct limine_module_request module_request = {
 	.id = LIMINE_MODULE_REQUEST,
 	.revision = 0,
@@ -66,15 +25,39 @@ module_info_t module_list[MOD_MAX];
 static char *graphics_module_message = "Графический модуль-объект";
 static char *other_module_message = "Неизвестный тип модуля";
 
+static env_t main_env;
+
+void *bootpng_ptr;
+uint64_t bootpng_size;
+
+static void *elf_entry(elf64_header_t *module_bin) {
+	// Приводим заголовок ELF файла к типу elf64_header_t
+	elf64_header_t *elf_header = (elf64_header_t *)module_bin;
+
+	// Возвращаем указатель на точку входа
+	return (void *)((uint64_t)elf_header->e_entry + (uint64_t)module_bin);
+}
+
 void mod_list_show( ) {
 	for (uint64_t i = 0; i < modules_count; i++) {
 		fb_printf("Имя: %s\n", module_list[i].name);
 		fb_printf("Описание модуля: %s\n", module_list[i].message);
 		fb_printf("Тип модуля: %u\n", module_list[i].type);
 		fb_printf("Код ошибки модуля: %u\n", module_list[i].err_code);
+		fb_printf("Размер данных: %u\n", module_list[i].data_size);
+		fb_printf("Адрес данных: 0x%x\n", module_list[i].data);
 	}
 }
 
+module_info_t *mod_find(char *tag) {
+	for (uint64_t i = 0; i < modules_count; i++) {
+		if (!tool_starts_with(module_list[i].name, tag)) {
+			return &module_list[i];
+		}
+	}
+	return (module_info_t *)NULL;
+}
+
 void mod_init( ) {
 	module_response = module_request.response;
 	uint64_t module_count = module_response->module_count;
@@ -95,6 +78,8 @@ void mod_init( ) {
 		module_list[modules_count].message = other_module_message;
 
 		if (tool_starts_with(module_ptr->cmdline, "[BOOTIMG]")) {
+			module_list[modules_count].data_size = module_ptr->size;
+			module_list[modules_count].data = module_ptr->address;
 			bootpng_ptr = module_ptr->address;
 			bootpng_size = module_ptr->size;
 			module_list[modules_count].type = 1; // Графика
@@ -108,16 +93,29 @@ void mod_init( ) {
 			modules_count++;
 			continue;
 		}
+
 		module_info_t (*module_init)(env_t * env) =
-		    (module_info_t(*)(env_t * env)) elf_entry(module_ptr->address);
+		    (module_info_t(*)(env_t * env))
+		        elf_entry((elf64_header_t *)module_ptr->address);
 
 		LOG("\t->Точка входа: 0x%x\n", module_init);
 
 		main_env.offset = (uint64_t)module_ptr->address;
 		main_env.info = (module_info_t *)0;
+
+		sys_install(main_env);
+
 		main_env.fb_printf = &fb_printf;
+
 		module_info_t ret = module_init(&main_env);
+
 		module_list[modules_count].message = ret.message;
+		module_list[modules_count].data_size = ret.data_size;
+
+		if (ret.data_size != 0) {
+			module_list[modules_count].data =
+			    (&(ret.data) + (uint64_t)module_ptr->address);
+		}
 
 		modules_count++;
 	}

kernel/sys.c

@@ -5,6 +5,8 @@
  * Этот файл содержит имплементацию функций для управления системой
  */
 
+#include <fb.h>
+#include <mod.h>
 #include <stdint.h>
 #include <sys.h>
 
@@ -12,40 +14,55 @@ module_info_t *current_module;
 
 void sys_init( ) {}
 
-framebuffer_t *sys_alloc_framebuffer( ) {
+static framebuffer_t *sys_alloc_framebuffer( ) {
 	return (framebuffer_t *)0;
 }
 
-void sys_free_framebuffer(framebuffer_t *frame) {
+static void sys_free_framebuffer(framebuffer_t *frame) {
 	frame->reserved = 0;
 }
 
-void sys_exit(int code) {
+static void sys_exit(int code) {
 	current_module->err_code = code;
 }
 
-int sys_get_error( ) {
+static int sys_get_error( ) {
 	return current_module->err_code;
 }
 
-sys_info_t *sys_get_info( ) {
+static sys_info_t *sys_get_info( ) {
 	return &(sys_info_t){ .reserved = 0 };
 }
 
-module_info_t *sys_get_module(uint64_t module_id) {
+static module_info_t *sys_get_module(char *module_id) {
-	return (module_info_t *)module_id;
+	return (module_info_t *)mod_find(module_id);
 }
 
-uint64_t sys_new_thread(uint64_t func) {
+static uint64_t sys_new_thread(uint64_t func) {
 	return func;
 }
 
-int sys_delete_thread(uint64_t thread_id) {
+static int sys_delete_thread(uint64_t thread_id) {
 	return thread_id;
 }
 
-time_t sys_get_time( ) {
+static time_t sys_get_time( ) {
 	return (time_t){ .year = 2023, .month = 10, .day = 31, .second = 1 };
 }
 
+env_t sys_install(env_t module) {
+	module.fb_printf = &fb_printf;
+	module.alloc_framebuffer = &sys_alloc_framebuffer;
+	module.free_framebuffer = &sys_free_framebuffer;
+	module.exit = &sys_exit;
+	module.get_error = &sys_get_error;
+	module.get_info = &sys_get_info;
+	module.get_module = &sys_get_module;
+	module.new_thread = &sys_new_thread;
+	module.delete_thread = &sys_delete_thread;
+	module.get_time = &sys_get_time;
+
+	return module;
+}
+
 // void sys_set_alarm(time_t time, func_t func) {}

modlib/system.h

@@ -31,8 +31,11 @@ typedef struct {
 typedef struct {
 	char *name;
 	char *message;
-	int err_code;
+	uint64_t type;
-	uint64_t func_count;
+	uint64_t data_size;
+	void *data;
+	int64_t err_code;
+	uint64_t module_id;
 } module_info_t;
 
 typedef struct {
@@ -56,14 +59,25 @@ typedef struct {
 typedef struct {
 	uint64_t offset;
 	module_info_t *info;
-	void (*fb_printf)(char *str, ...);
+	void (*fb_printf)(char *str, ...); // Временная функция
+	framebuffer_t *(*alloc_framebuffer)( );
+	void (*free_framebuffer)(framebuffer_t *frame);
+	void (*exit)(int code);
+	void (*get_error)( );
+	sys_info_t *(*get_info)( );
+	module_info_t *(*get_module)(char *module_id);
+	uint64_t (*new_thread)(uint64_t func);
+	int (*delete_thread)(uint64_t thread_id);
+	time_t (*get_time)( );
 } env_t;
 
 extern module_info_t static_info;
 static void (*fb_printf)(char *str, ...);
+static uint64_t offset;
 
 static inline void init_env(env_t *loader_env) {
-	loader_env->info = (module_info_t *)&static_info + loader_env->offset;
+	offset = loader_env->offset;
+	loader_env->info = (module_info_t *)&static_info + offset;
 	fb_printf = loader_env->fb_printf;
 }
 

modules/cpubench/main.c

@@ -56,6 +56,5 @@ module_info_t init(env_t *env) {
 		.name = (char *)"CPUBENCH",
 		.message = (char *)"Дополнительная информация о процессоре",
 		.err_code = 0,
-		.func_count = 1
 	};
 }

modules/helloworld/main.c

@@ -6,8 +6,9 @@ static const char message[] = "Привет из модуля!";
 module_info_t init(env_t *env) {
 	init_env(env);
 	fb_printf("[%s]\n", message);
-	return (module_info_t){ .name = (char *)&name,
+	return (module_info_t){
-		                    .message = (char *)&message,
+		.name = (char *)&name,
-		                    .err_code = 2023,
+		.message = (char *)&message,
-		                    .func_count = 1 };
+		.err_code = 2023,
+	};
 }

modules/music/main.c

@@ -38,11 +38,11 @@ static void nosound( ) {
 module_info_t init(env_t *env) {
 	init_env(env);
 	fb_printf("Программа инициализирована!\n");
-	return (module_info_t){ .name = (char *)"Мелодия",
+	return (module_info_t){
-		                    .message =
+		.name = (char *)"Мелодия",
-		                        (char *)"Надеюсь скоро тут будет тетрис!",
+		.message = (char *)"Надеюсь скоро тут будет тетрис!",
-		                    .err_code = 404,
+		.err_code = 404,
-		                    .func_count = 1 };
+	};
 
 	// Массив с нотами
 	unsigned int tetris_notes[] = { 0 };

modules/pci/main.c

@@ -1,5 +1,10 @@
 #include <system.h>
 
+typedef struct {
+	char *name;
+	uint16_t id;
+} vendor_t;
+
 static inline uint32_t inl(uint16_t port) {
 	uint32_t data;
 	asm volatile("inl %1, %0" : "=a"(data) : "Nd"(port));
@@ -53,12 +58,15 @@ static void scan( ) {
 		for (uint32_t slot = 0; slot < 32; slot++) {
 			for (uint32_t function = 0; function < 8; function++) {
 				uint16_t vendor = get_vendor_id(bus, slot, function);
+
 				if (vendor == 0xFFFF) { continue; }
+
 				uint16_t device_id = get_device_id(bus, slot, function);
 				uint16_t class_id = get_class_id(bus, slot, function);
 
-				fb_printf("[%u] vendor: %x, device: %x, class: %u\n", devices,
+				fb_printf("[%u] vendor: 0x%x, device: 0x%x, class: %u\n",
-				          vendor, device_id, class_id);
+				          devices, vendor, device_id, class_id);
+
 				devices++;
 			}
 		}
@@ -68,8 +76,9 @@ static void scan( ) {
 module_info_t init(env_t *env) {
 	init_env(env);
 	scan( );
-	return (module_info_t){ .name = (char *)"[PCI]",
+	return (module_info_t){
-		                    .message = (char *)"PCI драйвер",
+		.name = (char *)"[PCI]",
-		                    .err_code = 0,
+		.message = (char *)"PCI драйвер",
-		                    .func_count = 1 };
+		.err_code = 0,
+	};
 }

modules/simd/main.c

@@ -27,8 +27,9 @@ module_info_t init(env_t *env) {
 
 	if ((ecx >> 28) & 1) { env->fb_printf("AVX поддерживается!\n"); }
 
-	return (module_info_t){ .name = (char *)"SIMD",
+	return (module_info_t){
-		                    .message = (char *)"SIMD инструкции",
+		.name = (char *)"SIMD",
-		                    .err_code = 0,
+		.message = (char *)"SIMD инструкции",
-		                    .func_count = 1 };
+		.err_code = 0,
+	};
 }