增加新的内核模块加载机制, 补充版权信息.

Author: xiaoyi1212

module/all_include/driver_subsystem.h

@@ -301,3 +301,4 @@ int  usb_interrupt_transfer(usb_device_t *device, uint8_t endpoint, void *data,
                             usb_transfer_callback_t callback, void *user_data);
 usb_hcd_t *usb_register_hcd(const char *name, usb_hcd_ops_t *ops, void *regs, void *data);
 void       usb_unregister_hcd(usb_hcd_t *hcd);
+int usb_enumerate_device(usb_hcd_t *hcd, uint8_t port_id, uint8_t speed);

module/e1000/e1000.c

@@ -304,6 +304,10 @@ errno_t e1000_receive(void *dev_desc, void *buffer, uint32_t buffer_size) {
     return have_data ? packet_len : 0;
 }
 
+__attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
+    return EOK;
+}
+
 __attribute__((used)) __attribute__((visibility("default"))) int dlmain(void) {
     pci_device_t *device = pci_find_vid_did(0x8086, 0x100e);
     if (device == NULL) {

module/extfs/ext.c

@@ -378,6 +378,10 @@ static struct vfs_callback callbacks = {
     .dup      = (vfs_dup_t)ext_dup,
 };
 
+__attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
+    return EOK;
+}
+
 __attribute__((used)) __attribute__((visibility("default"))) int dlmain(void) {
     ext_fsid = vfs_regist("ext3", &callbacks, 0, 0xef53);
     if (ext_fsid == -1) {

module/hid/hid.c

@@ -1,6 +1,10 @@
-// Copyright (C) 2025  lihanrui2913
+/**
+ * NeoAetherOS XHCI HID Driver
+ * Copyright (C) 2025  lihanrui2913
+ */
 #include "hid.h"
 #include "proc_subsystem.h"
+#include "errno.h"
 
 static bool ctrlPressed  = false;
 static bool shiftPressed = false;
@@ -476,6 +480,10 @@ usb_driver_t hid_driver = {
     .remove   = hid_remove,
 };
 
+__attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
+    return EOK;
+}
+
 __attribute__((visibility("default"))) int dlmain() {
     register_usb_driver(&hid_driver);
 

module/nvme/nvme.c

@@ -463,6 +463,10 @@ NVME_CONTROLLER *nvme_driver_init(uint64_t bar0, uint64_t bar_size) {
     return ctrl;
 }
 
+__attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
+    return EOK;
+}
+
 __attribute__((used)) __attribute__((visibility("default"))) int dlmain(void) {
     pci_device_t *device = pci_find_class(0x10802);
     if (device == NULL) { return -ENODEV; }

module/xhci/xhci_hcd.c

@@ -1,4 +1,7 @@
-// Copyright (C) 2025  lihanrui2913
+/**
+ * NeoAetherOS XHCI Driver
+ * Copyright (C) 2025 lihanrui2913
+ */
 #include "xhci_hcd.h"
 #include "errno.h"
 #include "int_subsystem.h"
@@ -1261,7 +1264,7 @@ void xhci_device_enumerater(enumerater_arg_t *arg) {
     spin_lock(enumerate_lock);
     usb_hcd_t *hcd = arg->hcd;
     if (hcd) {
-        int ret = 0; //TODO usb_enumerate_device(hcd, arg->port_id, arg->speed);
+        int ret = usb_enumerate_device(hcd, arg->port_id, arg->speed);
         if (ret == 1) {
             printk("XHCI: Device on port %d enumerated successfully\n", arg->port_id);
         } else {
@@ -1379,6 +1382,15 @@ void xhci_shutdown(usb_hcd_t *hcd) {
 
 //oid xhci_hcd_driver_shutdown(pci_device_t *dev) { xhci_shutdown(dev->desc); }
 
+void *mmio_vaddr = NULL;
+pci_device_t *deviceA = NULL;
+
+__attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
+    usb_hcd_t *xhci_hcd = xhci_init(mmio_vaddr, deviceA);
+    printk("xhci: %s inited - port:%d\n", xhci_hcd->name, xhci_hcd->devices->port);
+    return EOK;
+}
+
 __attribute__((visibility("default"))) int dlmain() {
     pci_device_t *device = pci_find_class(0x000C0330);
     if (device == NULL) {
@@ -1400,10 +1412,9 @@ __attribute__((visibility("default"))) int dlmain() {
         return -1;
     }
 
-    void *mmio_vaddr = (void *)phys_to_virt(mmio_base);
+    mmio_vaddr = (void *)phys_to_virt(mmio_base);
     page_map_range(get_current_directory(), (uint64_t)mmio_vaddr, mmio_base, mmio_size,
                    PTE_PRESENT | PTE_WRITEABLE | PTE_DIS_CACHE);
-    usb_hcd_t *xhci_hcd = xhci_init(mmio_vaddr, device);
-    printk("xhci: %s inited - port:%d\n", xhci_hcd->name, xhci_hcd->devices->port);
+    deviceA = device;
     return EOK;
 }

src/arch/x86_64/include/dlinker.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#define MAX_KERNEL_MODULE 256
+
 #include "krlibc.h"
 #include "module.h"
 
@@ -18,11 +20,18 @@ typedef struct {
     void *addr;
 } dlfunc_t;
 
+typedef struct kernel_mode {
+    cp_module_t *module;
+    dlinit_t entry;
+    dlinit_t task_entry;
+}kernel_mode_t;
+
 /**
  * 加载一个内核模块
+ * @param kmod 内核模块管理单元
  * @param module 文件句柄
  */
-void dlinker_load(cp_module_t *module);
+void dlinker_load(kernel_mode_t *kmod,cp_module_t *module);
 
 dlfunc_t *find_func(const char *name);
 
@@ -33,3 +42,5 @@ void dlinker_init();
 void module_setup();
 
 void load_all_kernel_module();
+
+void start_all_kernel_module();

src/arch/x86_64/kmod/dlinker.c

@@ -77,7 +77,7 @@ void *find_symbol_address(const char *symbol_name, Elf64_Ehdr *ehdr, uint64_t of
     return NULL;
 }
 
-dlinit_t load_dynamic(Elf64_Phdr *phdrs, Elf64_Ehdr *ehdr, uint64_t offset) {
+dlinit_t load_dynamic(kernel_mode_t *kmod,Elf64_Phdr *phdrs, Elf64_Ehdr *ehdr, uint64_t offset) {
     Elf64_Dyn *dyn_entry = NULL;
     for (size_t i = 0; i < ehdr->e_phnum; i++) {
         if (phdrs[i].p_type == PT_DYNAMIC) {
@@ -142,12 +142,17 @@ dlinit_t load_dynamic(Elf64_Phdr *phdrs, Elf64_Ehdr *ehdr, uint64_t offset) {
 
     void *entry = find_symbol_address("dlmain", ehdr, offset);
     if (entry == NULL) { entry = find_symbol_address("_dlmain", ehdr, offset); }
+    kmod->entry = entry;
+
+    void *tentry = find_symbol_address("dlstart", ehdr, offset);
+    if (tentry == NULL) { tentry = find_symbol_address("_dlstart", ehdr, offset); }
+    kmod->task_entry = tentry;
 
     dlinit_t dlinit_func = (dlinit_t)entry;
     return dlinit_func;
 }
 
-void dlinker_load(cp_module_t *module) {
+void dlinker_load(kernel_mode_t *kmod,cp_module_t *module) {
     if (module == NULL) return;
 
     Elf64_Ehdr *ehdr = (Elf64_Ehdr *)module->data;
@@ -173,7 +178,7 @@ void dlinker_load(cp_module_t *module) {
     }
 
     dlinit_t dlinit =
-        load_dynamic(phdrs, ehdr, KERNEL_MOD_SPACE_START + kernel_modules_load_offset);
+        load_dynamic(kmod,phdrs, ehdr, KERNEL_MOD_SPACE_START + kernel_modules_load_offset);
     if (dlinit == NULL) {
         dlinit = (dlinit_t)ehdr->e_entry;
         if (dlinit == NULL) {
@@ -184,7 +189,6 @@ void dlinker_load(cp_module_t *module) {
 
     kinfo("Loaded module %s at %#018lx", module->module_name,
           KERNEL_MOD_SPACE_START + kernel_modules_load_offset);
-
     int ret = dlinit();
 
     (void)ret;

src/arch/x86_64/kmod/interface.c

@@ -123,6 +123,7 @@ EXPORT_SYMBOL(usb_interrupt_transfer);
 EXPORT_SYMBOL(register_usb_driver);
 EXPORT_SYMBOL(usb_register_hcd);
 EXPORT_SYMBOL(usb_unregister_hcd);
+EXPORT_SYMBOL(usb_enumerate_device);
 
 /**
  * 网络子系统接口导出

src/arch/x86_64/kmod/module.c

@@ -1,13 +1,17 @@
 #include "dlinker.h"
 #include "klog.h"
 #include "limine.h"
+#include "id_alloc.h"
+#include "heap.h"
 
 cp_module_t module_ls[256];
 size_t      module_count = 0;
 
 LIMINE_REQUEST struct limine_module_request module = {.id = LIMINE_MODULE_REQUEST, .revision = 0};
 LIMINE_REQUEST struct limine_kernel_file_request kfile = {.id       = LIMINE_KERNEL_FILE_REQUEST,
                                                           .response = 0};
+id_allocator_t *kmod_allocator = NULL;
+kernel_mode_t *kmods[MAX_KERNEL_MODULE];
 
 void extract_name(const char *input, char *output, size_t output_size) {
     const char *name = strrchr(input, '/');
@@ -64,14 +68,28 @@ static bool ends_with_km(const char *str) {
     return strcmp(str + len - 3, ".km") == 0;
 }
 
+void start_all_kernel_module() {
+    for (size_t i = 0; i < MAX_KERNEL_MODULE; i++) {
+        kernel_mode_t *kmod = kmods[i];
+        if(kmod == NULL) continue;
+        if(kmod->task_entry == NULL) continue;
+        int ret = kmod->task_entry();
+    }
+}
+
 void load_all_kernel_module() {
+    kmod_allocator = id_allocator_create(MAX_KERNEL_MODULE);
     for (size_t i = 0; i < module_count; i++) {
         if (module_ls[i].is_use) {
             if (ends_with_km(module_ls[i].raw_name)) {
                 logkf("kmod: loading module %s raw: %s\n", module_ls[i].module_name,
                       module_ls[i].raw_name);
                 cp_module_t *mod = get_module(module_ls[i].module_name);
-                if (mod) { dlinker_load(mod); }
+                if (mod) {
+                    int id = id_alloc(kmod_allocator);
+                    kmods[id] = calloc(1,sizeof(kernel_mode_t));
+                    dlinker_load(kmods[id],mod);
+                }
             }
         }
     }