修复 usb 部分分配地址不对齐问题, 修复调度器概率死锁问题.

撤掉内核模块输出的同步锁.

Co-authored-by: suhuajun-github <115517663+suhuajun-github@users.noreply.github.com>

Author: xiaoyi1212

module/all_include/mem_subsystem.h

@@ -19,6 +19,8 @@
 #define PAGE_MASK  (~(PAGE_SIZE - 1))
 #define ENTRY_MASK 0x1FF
 
+#define PADDING_REQ(size, to) ((size + (to) - 1) & ~((to) - 1) / (to))
+
 #include "cp_kernel.h"
 
 typedef struct page_table_entry {

module/hid/hid.c

@@ -486,6 +486,5 @@ __attribute__((used)) __attribute__((visibility("default"))) int dlstart(void) {
 
 __attribute__((visibility("default"))) int dlmain() {
     register_usb_driver(&hid_driver);
-
-    return 0;
+    return EOK;
 }

module/xhci/xhci_hcd.c

@@ -38,10 +38,14 @@ spin_t transfer_lock = SPIN_INIT;
 
 // 分配DMA内存（对齐到64字节）
 static void *xhci_alloc_dma(size_t size, uint64_t *phys_addr) {
-    void *ptr = malloc((size + 63) & ~63);
+    size_t aligned_bytes = (size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+    size_t required_pages = aligned_bytes / PAGE_SIZE;
+    uint64_t phys = alloc_frames(required_pages);
+    page_map_range_to(get_current_directory(),phys,aligned_bytes,KERNEL_PTE_FLAGS);
+    void *ptr = phys_to_virt(phys);
     if (ptr) {
         memset(ptr, 0, size);
-        if (phys_addr) { *phys_addr = page_virt_to_phys((uint64_t)ptr); }
+        if (phys_addr) { *phys_addr = phys; }
     }
     return ptr;
 }
@@ -70,7 +74,9 @@ xhci_ring_t *xhci_alloc_ring(uint32_t num_trbs) {
 void xhci_free_ring(xhci_ring_t *ring) {
     if (!ring) return;
 
-    if (ring->trbs) { free(ring->trbs); }
+    if (ring->trbs) {
+        unmap_page_range(get_current_directory(),(uint64_t)ring->trbs,ring->size);
+    }
     free(ring);
 }
 
@@ -317,15 +323,18 @@ static int xhci_hcd_init(usb_hcd_t *hcd) {
     if (xhci->num_scratchpads > 0) {
         xhci->scratchpad_array =
             (uint64_t *)xhci_alloc_dma(xhci->num_scratchpads * sizeof(uint64_t), NULL);
-        xhci->scratchpad_buffers = (void **)malloc(xhci->num_scratchpads * sizeof(void *));
+
+        uint64_t scphy = alloc_frames(PADDING_REQ(xhci->num_scratchpads * sizeof(void *),PAGE_SIZE));
+        page_map_range_to(get_current_directory(),scphy,xhci->num_scratchpads * sizeof(void *),KERNEL_PTE_FLAGS);
+        xhci->scratchpad_buffers = (void **)phys_to_virt(scphy);
 
         for (uint32_t i = 0; i < xhci->num_scratchpads; i++) {
             uint64_t phys;
             xhci->scratchpad_buffers[i] = xhci_alloc_dma(4096, &phys);
             xhci->scratchpad_array[i]   = phys;
         }
 
-        xhci->dcbaa[0] = page_virt_to_phys((uint64_t)xhci->scratchpad_array);
+        xhci->dcbaa[0] = (uint64_t)virt_to_phys((uint64_t)xhci->scratchpad_array);
     }
 
     // 设置DCBAA指针
@@ -559,7 +568,7 @@ int xhci_setup_default_endpoint(usb_hcd_t *hcd, usb_device_t *device) {
     return 0;
 }
 
-spin_t xhci_command_lock = {0};
+spin_t xhci_command_lock = SPIN_INIT;
 
 // 启用槽位 - 使用等待机制
 static int xhci_enable_slot(usb_hcd_t *hcd, usb_device_t *device) {
@@ -1026,7 +1035,7 @@ static int xhci_configure_endpoint(usb_hcd_t *hcd, usb_endpoint_t *endpoint) {
     return ret;
 }
 
-spin_t xhci_transfer_lock = {0};
+spin_t xhci_transfer_lock = SPIN_INIT;
 
 // 控制传输 - 使用等待机制
 static int xhci_control_transfer(usb_hcd_t *hcd, usb_transfer_t *transfer,
@@ -1258,7 +1267,7 @@ typedef struct enumerater_arg {
     uint8_t    speed;
 } enumerater_arg_t;
 
-spin_t enumerate_lock = {0};
+spin_t enumerate_lock = SPIN_INIT;
 
 void xhci_device_enumerater(enumerater_arg_t *arg) {
     spin_lock(enumerate_lock);
@@ -1387,7 +1396,7 @@ 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);
+    printk("xhci: %s inited。\n", xhci_hcd->name);
     return EOK;
 }
 

src/arch/x86_64/include/krlibc.h

@@ -42,6 +42,7 @@
 
 #define PADDING_DOWN(size, to) ((size_t)(size) / (size_t)(to) * (size_t)(to))
 #define PADDING_UP(size, to)   PADDING_DOWN((size_t)(size) + (size_t)(to) - (size_t)1, to)
+#define PADDING_REQ(size, to) ((size + (to) - 1) & ~((to) - 1) / (to))
 
 #define waitif(cond)                                                                               \
     ((void)({                                                                                      \

src/arch/x86_64/kmod/dlinker.c

@@ -189,6 +189,7 @@ void dlinker_load(kernel_mode_t *kmod,cp_module_t *module) {
 
     kinfo("Loaded module %s at %#018lx", module->module_name,
           KERNEL_MOD_SPACE_START + kernel_modules_load_offset);
+    logkf("kmod: loaded module %s at %#018lx\n", module->module_name, KERNEL_MOD_SPACE_START + kernel_modules_load_offset);
     int ret = dlinit();
 
     (void)ret;

src/arch/x86_64/kmod/module.c

@@ -82,8 +82,6 @@ void load_all_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) {
                     int id = id_alloc(kmod_allocator);

src/arch/x86_64/task/pcb.c

@@ -36,8 +36,9 @@ _Atomic volatile pid_t now_tid = 0;
 _Noreturn void process_exit() {
     uint64_t rax = 0;
     __asm__("movq %%rax,%0" ::"r"(rax) :);
-    printk("Kernel thread exit, Code: %d\n", rax);
+    logkf("Kernel thread exit, Code: %d\n", rax);
     kill_thread(get_current_task());
+    open_interrupt;
     loop __asm__ volatile("hlt");
 }
 

src/arch/x86_64/task/scheduler.c

@@ -68,6 +68,8 @@ void scheduler_nano_sleep(uint64_t nano) {
  */
 int add_task(tcb_t new_task) {
     if (new_task == NULL) return -1;
+    open_interrupt;
+    enable_scheduler();
     spin_lock(scheduler_lock);
 
     smp_cpu_t *cpu0  = get_cpu_smp(bsp_processor_id);

src/driver/usb/usb.c

@@ -1,8 +1,8 @@
 #include "usb.h"
-#include "../../../module/all_include/cp_kernel.h"
 #include "heap.h"
 #include "kprint.h"
 #include "krlibc.h"
+#include "klog.h"
 
 usb_driver_t *usb_drivers[MAX_USB_DRIVERS_NUM];
 

src/driver/usb/usb_enumeration.c

@@ -1,6 +1,7 @@
 #include "usb_enumeration.h"
 #include "heap.h"
 #include "kprint.h"
+#include "klog.h"
 
 // 全局地址分配计数器
 static uint8_t next_device_address = 1;
@@ -46,7 +47,7 @@ static void usb_free_enum_context(usb_enum_context_t *ctx) {
 // 解析配置描述符
 int usb_parse_config_descriptor(usb_device_t *device, uint8_t *buffer, uint32_t length) {
     if (length < sizeof(usb_config_descriptor_t)) {
-        printk("USB: Config descriptor too short\n");
+        logkf("USB: Config descriptor too short\n");
         return -1;
     }