added acpi dump module

Author: Glowman554

mckrnl/Makefile

@@ -8,13 +8,14 @@ all:
 	make -C driver/ac97
 	make -C driver/ata
 	make -C driver/ps2
-	make -C driver/ahci
 
 	make -C network/am79C973
 	make -C network/e1000
 	make -C network/ne2k
 	make -C network/rtl8139
 
+	make -C feature/acpi_dump
+
 
 clean:
 	make -C core clean
@@ -25,13 +26,14 @@ clean:
 	make -C driver/ac97 clean
 	make -C driver/ata clean
 	make -C driver/ps2 clean
-	make -C driver/ahci clean
 
 	make -C network/am79C973 clean
 	make -C network/e1000 clean
 	make -C network/ne2k clean
 	make -C network/rtl8139 clean
 
+	make -C feature/acpi_dump clean
+
 compile_flags.txt:
 	make -C core compile_flags.txt 
 
@@ -41,9 +43,10 @@ compile_flags.txt:
 	make -C driver/ac97 compile_flags.txt
 	make -C driver/ata compile_flags.txt
 	make -C driver/ps2 compile_flags.txt
-	make -C driver/ahci compile_flags.txt
 
 	make -C network/am79C973 compile_flags.txt
 	make -C network/e1000 compile_flags.txt
 	make -C network/ne2k compile_flags.txt
-	make -C network/rtl8139 compile_flags.txt
+	make -C network/rtl8139 compile_flags.txt
+
+	make -C feature/acpi_dump compile_flags.txt

mckrnl/core/driver/acpi/rsdp.c

@@ -67,7 +67,8 @@ void map_sdt(sdt_header_t* header) {
 
 void* find_SDT(const char *signature) {
 	if(xsdt != NULL) {
-		for(uint64_t i = 0; i < (xsdt->header.length - sizeof(sdt_header_t)); i++) {
+        int entries = (xsdt->header.length - sizeof(sdt_header_t)) / 8;
+		for(uint64_t i = 0; i < entries; i++) {
 			sdt_header_t* acpihdr = (sdt_header_t*) (uint32_t) xsdt->acpiptr[i];
 			map_sdt(acpihdr);
 			if(memcmp(acpihdr->signature, signature, 4) == 0) {
@@ -78,7 +79,8 @@ void* find_SDT(const char *signature) {
 	} 
 
 	if(rsdt != NULL) {
-		for(uint64_t i = 0; i < (rsdt->header.length - sizeof(sdt_header_t)); i++) {
+		int entries = (rsdt->header.length - sizeof(sdt_header_t)) / 4;
+		for(uint64_t i = 0; i < entries; i++) {
 			sdt_header_t* acpihdr = (sdt_header_t*) (rsdt->acpiptr[i]);
 			map_sdt(acpihdr);
 			if(memcmp(acpihdr->signature, signature, 4) == 0) {

mckrnl/core/include/driver/acpi/rsdp.h

@@ -23,4 +23,6 @@ extern xsdt_t* xsdt;
 
 rsdp2_t* scan_for_rsdp(char* start, uint32_t length);
 void rsdp_init();
-void* find_SDT(const char *signature);
+void* find_SDT(const char *signature);
+
+void map_sdt(sdt_header_t* header);

mckrnl/core/module.c

@@ -264,13 +264,14 @@ void initrd_load_modules(void* saf_image, char* path) {
 		debugf("initrd: loading module %s (%d bytes)", child->name, file_node->size);
 		module_t* module = load_object_file(module_data);
 
+        loaded_modules[loaded_module_count++] = module;
+
         debugf("Loaded module %s", module->name);
 
 		if (module->init) {
 			module->init();
 		}
 
-		loaded_modules[loaded_module_count++] = module;
 	}
 }
 

mckrnl/feature/acpi_dump/Makefile

@@ -0,0 +1,2 @@
+MODULE = acpi_dump.o
+include ../../module.mk

mckrnl/feature/acpi_dump/acpi_vfs.c

@@ -0,0 +1,116 @@
+#include <acpi_vfs.h>
+#include <driver/disk_driver.h>
+#include <memory/vmm.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+acpi_vfs_mount_data_t create_acpi_vfs_mount_data() {
+    int entriesXSDT = xsdt ? (xsdt->header.length - sizeof(sdt_header_t)) / 8 : 0;
+	int entriesRSDT = rsdt ? (rsdt->header.length - sizeof(sdt_header_t)) / 4 : 0;
+
+	acpi_vfs_mount_data_t mount_data;
+	mount_data.table_count = entriesXSDT + entriesRSDT;
+	mount_data.tables = (sdt_header_t**) vmm_alloc(sizeof(sdt_header_t*) * mount_data.table_count);
+
+	if(xsdt != NULL) {
+		for(uint64_t i = 0; i < entriesXSDT; i++) {
+			sdt_header_t* acpihdr = (sdt_header_t*) (uint32_t) xsdt->acpiptr[i];
+            debugf("[XSDT] Found ACPI table: %c%c%c%c", acpihdr->signature[0], acpihdr->signature[1], acpihdr->signature[2], acpihdr->signature[3]);
+			mount_data.tables[i] = acpihdr;
+        }
+	} 
+
+	if(rsdt != NULL) {
+		for(uint64_t i = 0; i < entriesRSDT; i++) {
+			sdt_header_t* acpihdr = (sdt_header_t*) (rsdt->acpiptr[i]);
+            debugf("[RSDT] Found ACPI table: %c%c%c%c", acpihdr->signature[0], acpihdr->signature[1], acpihdr->signature[2], acpihdr->signature[3]);
+			mount_data.tables[entriesXSDT + i] = acpihdr;
+		}
+	} 
+
+	return mount_data;
+}
+
+char* acpi_vfs_name(vfs_mount_t* mount) {
+    return "acpi";
+}
+
+file_t* acpi_vfs_open(vfs_mount_t* mount, char* path, int flags) {
+	acpi_vfs_mount_data_t* data = (acpi_vfs_mount_data_t*) mount->driver_specific_data;
+
+    char file[0xff] = { 0 };
+    while (*(path = copy_until('/', path, file)));
+    debugf("file: %s", file);
+
+	for (size_t i = 0; i < data->table_count; i++) {
+		sdt_header_t* table = data->tables[i];
+		char expected_name[0xff] = { 0 };
+		sprintf(expected_name, "%d.%c%c%c%c", i, table->signature[0], table->signature[1], table->signature[2], table->signature[3]);
+	
+		if (strcmp(file, expected_name) == 0) {
+			file_t* file = (file_t*) vmm_alloc(1);
+            memset(file, 0, sizeof(file_t));
+
+            file->mount = mount;
+            file->size = table->length;
+			file->driver_specific_data = table;
+
+			return file;
+		}
+	}
+
+    return NULL;
+}
+
+void acpi_vfs_close(vfs_mount_t* mount, file_t* f) {
+	vmm_free(f, 1);
+}
+
+void acpi_vfs_read(vfs_mount_t* mount, file_t* f, void* buffer, size_t size, size_t offset) {
+	if (offset + size > f->size) {
+		abortf(true, "Attempted to read beyond end of ACPI table file");
+	}
+	memcpy(buffer, &((char*) f->driver_specific_data)[offset], size);
+}
+
+
+dir_t acpi_vfs_dir_at(vfs_mount_t* mount, int idx, char* path) {
+	acpi_vfs_mount_data_t* mount_data = (acpi_vfs_mount_data_t*) mount->driver_specific_data;
+	if(idx >= mount_data->table_count) {
+		dir_t empty = {
+			.is_none = true
+		};
+		return empty;
+	}
+
+	sdt_header_t* table = mount_data->tables[idx];
+	dir_t entry = {
+		.idx = idx,
+		.is_none = false,
+		.type = ENTRY_FILE
+	};
+	sprintf(entry.name, "%d.%c%c%c%c", idx, table->signature[0], table->signature[1], table->signature[2], table->signature[3]);
+
+	return entry;
+}
+
+vfs_mount_t* acpi_vfs_mount() {
+    vfs_mount_t* mount = (vfs_mount_t*) vmm_alloc(1);
+	memset(mount, 0, 0x1000);
+
+    assert((sizeof(vfs_mount_t) + sizeof(acpi_vfs_mount_data_t)) <= 0x1000);
+
+	acpi_vfs_mount_data_t* mount_data = (acpi_vfs_mount_data_t*) &mount[1];
+	mount->driver_specific_data = mount_data;
+
+	*mount_data = create_acpi_vfs_mount_data();
+
+	mount->name = acpi_vfs_name;
+	mount->open = acpi_vfs_open;
+	mount->close = acpi_vfs_close;
+	mount->read = acpi_vfs_read;
+	mount->dir_at = acpi_vfs_dir_at;
+
+	return mount;
+}

mckrnl/feature/acpi_dump/include/acpi_vfs.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <fs/vfs.h>
+#include <driver/acpi/rsdp.h>
+
+typedef struct {
+    sdt_header_t** tables;
+    size_t table_count;
+} acpi_vfs_mount_data_t;
+
+vfs_mount_t* acpi_vfs_mount();

mckrnl/feature/acpi_dump/main.c

@@ -0,0 +1,15 @@
+#include <module.h>
+#include <stddef.h>
+#include <acpi_vfs.h>
+
+#include <driver/acpi/rsdp.h>
+#include <stdio.h>
+
+void main() {
+}
+
+void stage_mount() {
+    vfs_mount(acpi_vfs_mount());
+}
+
+define_module("acpi_dump", main, NULL, stage_mount);

user/cp/main.c

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
+#include <assert.h>
 #include <sys/file.h>
 
 void copy_file(char* src_dir, char* dest_dir, char* file_name, bool verbose) {
@@ -99,17 +100,17 @@ int main(int argc, char** argv) {
 		}
 	}
 
-	char real_dest[512] = { 0 };
-	resolve(dest, real_dest);
-
-	char real_src[512] = { 0 };
-	resolve(src, real_src);
-
 	if (src == NULL || dest == NULL) {
 		printf("Usage: cp [-r][-v] <src> <dest>\n");
 		return 1;
 	}
 
+	char real_dest[512] = { 0 };
+	assert(resolve(dest, real_dest));
+
+	char real_src[512] = { 0 };
+	assert(resolve(src, real_src));
+
 	if (recursive) {
 		recursive_dir_copy(real_src, real_dest, verbose);
 	} else {