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

include/version.h

@@ -1,3 +1,3 @@
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 1
-#define VERSION_BUILD 198
+#define VERSION_BUILD 227

kernel/arch/cpu.cpp

@@ -58,16 +58,13 @@ void l2_cache( ) {
 	unsigned int eax, ebx, ecx, edx;
 	unsigned int lsize, assoc, cache;
 
-	cpuid(0x80000005, &eax, &ebx, &ecx, &edx);
-	lsize = ecx & 0xFF;
-	fb::printf("Кэш L1: %d KB\n", lsize);
-
 	cpuid(0x80000006, &eax, &ebx, &ecx, &edx);
 	lsize = ecx & 0xFF;
-	assoc = (ecx >> 12) & 0x0F;
-	cache = (ecx >> 16) & 0xFF;
+	assoc = (ecx >> 12) & 0x07;
+	cache = (ecx >> 16) & 0xFFFF;
 
-	fb::printf("Кэш L2: %d KB\n", lsize);
+	fb::printf("Размер строки: %u B, Тип ассоциации: %u, Размер кэша: %u КБ\n",
+	           lsize, assoc, cache);
 }
 
 void do_amd( ) {
@@ -157,12 +154,70 @@ void init( ) {
 		fb::printf("RDRND подерживается!\n");
 	}
 
+	cpuid(0x80000000, &eax, &ebx, &ecx, &edx);
+	fb::printf("0x80000000 [EAX] = 0x%x (%u)\n", eax, eax);
+
 	cpuid(0x80000001, &eax, &ebx, &ecx, &edx);
 
-	if ((edx >> 11) & 1) { fb::printf("SYSCALL подерживается!\n"); }
+	if ((edx >> 5) & 1) { fb::printf("Регистры MSR подерживаются!\n"); }
+
+	if ((edx >> 6) & 1) {
+		fb::printf("Расширение физического адреса подерживается!\n");
+	}
+
+	if ((edx >> 7) & 1) {
+		fb::printf("Исключение проверки компьютера (MCE) подерживается!\n");
+	}
+
+	if ((edx >> 9) & 1) {
+		fb::printf("Усовершенствованный программируемый контроллер прерываний "
+		           "подерживаются!\n");
+	}
+
+	if ((edx >> 10) & 1) {
+		fb::printf(
+		    "SYSCALL/SYSRET(для AMD семейства 5 линейки 7) подерживаются!\n");
+	}
+	if ((edx >> 11) & 1) { fb::printf("SYSCALL/SYSRET подерживаются!\n"); }
+
+	if ((edx >> 26) & 1) {
+		fb::printf("Гигабайтные страницы подерживаются!\n");
+	}
+
 	if ((edx >> 29) & 1) { fb::printf("AMD64 подерживается!\n"); }
+	if ((edx >> 30) & 1) { fb::printf("\"3DNow!\" подерживается!\n"); }
+	if ((edx >> 31) & 1) { fb::printf("\"Extended 3DNow!\" подерживается!\n"); }
+	if ((ecx >> 6) & 1) { fb::printf("SSE4a подерживается!\n"); }
+	if ((ecx >> 7) & 1) { fb::printf("Смещенный режим SSE подерживается!\n"); }
+
+	cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
+	if ((ebx >> 0) & 1) {
+		fb::printf("Восстановление после переполнения MCA подерживается!\n");
+	}
+	if ((ebx >> 1) & 1) {
+		fb::printf("Возможность локализации и восстановления неисправимых "
+		           "программных ошибок подерживается!\n");
+	}
+	if ((edx >> 0) & 1) { fb::printf("Датчик температуры подерживается!\n"); }
+	if ((edx >> 3) & 1) { fb::printf("Терморегулятор подерживается!\n"); }
+	if ((edx >> 4) & 1) {
+		fb::printf("Аппаратный терморегулятор (HTC) подерживается!\n");
+	}
+	if ((edx >> 5) & 1) {
+		fb::printf("Программный терморегулятор (STC) подерживается!\n");
+	}
+	if ((edx >> 6) & 1) {
+		fb::printf("Управление множителем 100 МГц подерживается!\n");
+	}
+
+	fb::printf("0x80000007[ECX] = 0x%x (%u)\n", ecx, ecx);
+
+	cpuid(0xC0000000, &eax, &ebx, &ecx, &edx);
+	if (eax > 0xC0000000) {
+		fb::printf("0xC0000000 [EAX] = 0x%x (%u)\n", eax, eax);
+	}
 
 	brandname( );
-	// l2_cache( );
+	l2_cache( );
 }
 } // namespace cpu

kernel/arch/idt.cpp

@@ -145,7 +145,7 @@ void idt_init( ) {
 	}
 
 	idt_load( );
-	fb::printf("IDT инициализирован.\n");
+	fb::printf("IDT инициализирован\n");
 }
 
 void idt_set_ist(uint8_t vector, uint8_t ist) {

kernel/fb.cpp

@@ -25,6 +25,7 @@ static volatile struct limine_framebuffer_request framebuffer_request = {
 struct limine_framebuffer_response *framebuffer_response;
 struct limine_framebuffer *boot_framebuffer;
 
+uint32_t *fb_addr;
 uint32_t text_color = GREEN;
 uint32_t background = DARK_GREEN;
 uint64_t width;

kernel/main/main.cpp

@@ -159,6 +159,7 @@ unsigned int *tga_parse(unsigned char *ptr, int size) {
 	return data;
 }
 void main( ) {
+	for (uint64_t i = 512; i > 1; i--) { pause( ); }
 	fb::printf("Загрузка завершена! 1\n");
 	unsigned int *res = tga_parse((uint8_t *)bootpng_ptr, bootpng_size);
 	fb::printf("Загрузка завершена! 2 %x\n", res);

kernel/mem.cpp

@@ -58,8 +58,9 @@ void dump_memory( ) {
 	mem_entry_t *curr = first_node;
 
 	while (curr) {
-		fb::printf("->0x%x | %u kb | %u | 0x%x\n", &curr->data,
-		           curr->size / 1024, curr->free, curr->next);
+		fb::printf("->0x%x | %u.%u kb | %u | 0x%x\n", &curr->data,
+		           (curr->size) / 1024, (curr->size) % 1024, curr->free,
+		           curr->next);
 		curr = curr->next;
 	}
 }
@@ -111,6 +112,15 @@ void merge_blocks(mem_entry_t *start) {
 	}
 }
 
+void merge_all_blocks( ) {
+	mem_entry_t *curr = first_node;
+
+	while (curr) {
+		merge_blocks(curr);
+		curr = curr->next;
+	}
+}
+
 void add_block(void *addr, size_t size) {
 	mem_entry_t *new_entry = (mem_entry_t *)addr;
 
@@ -127,7 +137,6 @@ void add_block(void *addr, size_t size) {
 		curr->next = new_entry;
 		new_entry->next = NULL;
 	}
-	merge_blocks(first_node);
 }
 
 void alloc_init(void *address, size_t length) {
@@ -214,7 +223,7 @@ void init( ) {
 	mmmap_count = memmap_response->entry_count;
 	struct limine_memmap_entry **mmaps = memmap_response->entries;
 
-	fb::printf("В карте памяти: %u записей.\n", memmap_response->entry_count);
+	fb::printf("Записей в карте памяти: %u\n", memmap_response->entry_count);
 
 	// Обработка каждой записи в карте памяти
 	for (int i = 0; i < mmmap_count; i++) {
@@ -267,15 +276,14 @@ void init( ) {
 
 	fb::printf("%u / %u блоков доступно\n", bitmap_available, bitmap_limit);
 	fb::printf("Размер битовой карты: %u\n", bitmap_size);
-	alloc_init(frame_alloc(100), 1000 * BLOCK_SIZE);
-	for (uint64_t i = 0; i < 255; i++) {
-		add_block(frame_alloc(100), 1000 * BLOCK_SIZE);
+	alloc_init(frame_alloc(1), BLOCK_SIZE);
+	for (uint64_t i = 256 * 1024; i > 0; i -= BLOCK_SIZE) {
+		add_block(frame_alloc(1024), 1024 * BLOCK_SIZE);
 	}
-	mem::dump_memory( );
-	merge_blocks(first_node);
+	merge_all_blocks( );
 	mem::dump_memory( );
 	fb::printf("%u мегабайт выделено в динамичную память\n",
-	           (256 * 1000 * BLOCK_SIZE) / 1024 / 1024);
+	           (256 * 1024 * BLOCK_SIZE + BLOCK_SIZE) / 1024 / 1024);
 	fb::printf("%u МБ объем доступной памяти, %u МБ объем виртуальной памяти\n",
 	           (bitmap_available * BLOCK_SIZE) / 1024 / 1024,
 	           available / 1024 / 1024);

kernel/task.cpp

@@ -0,0 +1,9 @@
+
+
+void new_thread( ) {
+	return;
+}
+
+void delete_thread( ) {
+	return;
+}