置换调度队列结构

Author: xiaoyi1212

src/core/cpu/cpuid.c

@@ -14,29 +14,34 @@ void cpuid(uint32_t code, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d) {
 static void get_vendor_name() {
     int cpuid_level;
     static char x86_vendor_id[16] = {0};
-    cpuid(0x00000000, (unsigned int *) &cpuid_level,
-          (unsigned int *) &x86_vendor_id[0],
-          (unsigned int *) &x86_vendor_id[8],
-          (unsigned int *) &x86_vendor_id[4]);
+    cpuid(0x00000000, (uint32_t *) &cpuid_level,
+          (uint32_t *) &x86_vendor_id[0],
+          (uint32_t *) &x86_vendor_id[8],
+          (uint32_t *) &x86_vendor_id[4]);
     cpu.vendor = x86_vendor_id;
 }
 
 static void get_model_name() {
-    unsigned int *v = (unsigned int *) cpu.model_name;
+    uint32_t *v = (uint32_t *) cpu.model_name;
     cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
     cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
     cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
     cpu.model_name[48] = 0;
 }
 
 static void get_cpu_address_sizes() {
-    unsigned int eax, ebx, ecx, edx;
+    uint32_t eax, ebx, ecx, edx;
     cpuid(0x80000008, &eax, &ebx, &ecx, &edx);
-
     cpu.virt_bits = (eax >> 8) & 0xff;
     cpu.phys_bits = eax & 0xff;
 }
 
+bool cpuid_has_sse(){
+    uint32_t eax, ebx, ecx, edx;
+    cpuid(1, &eax, &ebx, &ecx, &edx);
+    return edx & (1 << 25);
+}
+
 cpu_t get_cpu_info() {
     return cpu;
 }

src/core/cpu/empty_interrupt.c

@@ -7,7 +7,7 @@
 #include "krlibc.h"
 #include "io.h"
 
-#define INTERRUPT_HANDLE(id) void empty_handler_##id(interrupt_frame_t *frame){ UNUSED(frame); close_interrupt; send_eoi(); printk("Interrupt empty %d\n",id); update_terminal(); cpu_hlt; }
+#define INTERRUPT_HANDLE(id) void empty_handler_##id(interrupt_frame_t *frame){ UNUSED(frame); close_interrupt; send_eoi(); printk("Interrupt empty "#id"\n"); update_terminal(); cpu_hlt; }
 
 INTERRUPT_HANDLE(0)
 INTERRUPT_HANDLE(1)

src/core/cpu/smp.c

@@ -19,7 +19,7 @@ extern bool x2apic_mode; //apic.c
 ticketlock apu_lock;
 
 smp_cpu_t cpus[MAX_CPU];
-
+uint32_t bsp_lapic_id;
 uint64_t cpu_count = 0;
 
 uint64_t cpu_num(){
@@ -118,21 +118,53 @@ void apu_entry(){
     sprintf(name,"CP_IDLE_CPU%lu",get_current_cpuid());
     memcpy(apu_idle->name, name, strlen(name));
     apu_idle->next = kernel_head_task;
-    add_task(apu_idle);
+    smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+    if(cpu == NULL){
+        return;
+    }
+    apu_idle->queue_index = queue_enqueue(cpu->scheduler_queue,apu_idle);
+    if(apu_idle->queue_index == -1){
+        logkf("Error: scheduler null %d\n",get_current_cpuid());
+    }
     pivfs_update(kernel_head_task);
     ticket_unlock(&apu_lock);
     cpu_hlt;
 }
 
+smp_cpu_t *get_cpu_smp(uint32_t processor_id){
+    if(processor_id == bsp_lapic_id) return &cpus[MAX_CPU - 1];
+    smp_cpu_t cpu = cpus[processor_id];
+    if(cpu.flags == 1){
+        return &cpus[processor_id];
+    } else return NULL;
+}
+
 void apu_startup(struct limine_smp_request smp_request){
     struct limine_smp_response *response = smp_request.response;
     cpu_count = response->cpu_count;
-    for (uint64_t i = 0; i < cpu_count && i < MAX_CPU; i++){
+    bsp_lapic_id = response->bsp_lapic_id;
+    for (uint64_t i = 0; i < cpu_count && i < MAX_CPU - 1; i++){
         struct limine_smp_info *info = response->cpus[i];
-        if(info->lapic_id == response->bsp_lapic_id) continue;
+        if(info->lapic_id == response->bsp_lapic_id) {
+            cpus[MAX_CPU - 1].lapic_id = response->bsp_lapic_id;
+            cpus[MAX_CPU - 1].flags = 1;
+            cpus[MAX_CPU - 1].scheduler_queue = queue_init();
+            cpus[MAX_CPU - 1].iter_node = NULL;
+            continue;
+        }
+        cpus[info->processor_id].scheduler_queue = queue_init();
         cpus[info->processor_id].lapic_id = info->lapic_id;
         cpus[info->processor_id].flags = 1;
+        cpus[info->processor_id].iter_node = NULL;
         info->goto_address = (void*)apu_entry;
     }
+    smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+    if(cpu == NULL){
+        return;
+    }
+    kernel_head_task->queue_index = queue_enqueue(cpu->scheduler_queue,kernel_head_task);
+    if(kernel_head_task->queue_index == -1){
+        logkf("Error: scheduler null %d\n",get_current_cpuid());
+    }
     kinfo("%d processors have been enabled.",cpu_count);
 }

src/core/module.c

@@ -25,7 +25,7 @@ void module_setup() {
         return;
     }
 
-    for (int i = 0; i < module.response->module_count; i++) {
+    for (size_t i = 0; i < module.response->module_count; i++) {
         struct limine_file *file = module.response->modules[i];
         logkf("Module %d: %s\n", i, file->path);
         if(!strcmp(file->path,"/sys/sysfont.ttf")){

src/core/task/pcb.c

@@ -59,20 +59,11 @@ void kill_proc(pcb_t task){
     disable_scheduler(); // 终止调度器, 防止释放被杀进程时候调度到该进程发生错误
     free_tty(task->tty);
 
-    pcb_t head = kernel_head_task;
-    pcb_t last = NULL;
-    while (1) {
-        if (head->pid == task->pid) {
-            last->next = task->next;
-            free(task);
-            enable_scheduler();
-            open_interrupt;
-            ticket_unlock(&pcb_lock);
-            return;
-        }
-        last = head;
-        head = head->next;
-    }
+    remove_task(task);
+
+    enable_scheduler();
+    open_interrupt;
+    ticket_unlock(&pcb_lock);
 }
 
 pcb_t found_pcb(int pid) {
@@ -146,5 +137,6 @@ void init_pcb(){
     memcpy(current_task->name, name, strlen(name));
     current_task->next = kernel_head_task;
     pivfs_update(kernel_head_task);
+
     kinfo("Load task schedule. | KernelProcessName: %s PID: %d", current_task->name, current_task->pid);
 }

src/core/task/scheduler.c

@@ -5,6 +5,7 @@
 #include "pivfs.h"
 #include "smp.h"
 #include "lock.h"
+#include "lock_queue.h"
 
 pcb_t current_task = NULL;
 pcb_t kernel_head_task = NULL;
@@ -25,15 +26,39 @@ void disable_scheduler(){
     is_scheduler = false;
 }
 
-void add_task(pcb_t new_task) {
-    if (new_task == NULL) return;
+int add_task(pcb_t new_task) {
+    if (new_task == NULL) return -1;
     ticket_lock(&scheduler_lock);
-    pcb_t tailt = kernel_head_task;
-    while (tailt->next != kernel_head_task) {
-        if (tailt->next == NULL) break;
-        tailt = tailt->next;
+
+    smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+    if(cpu == NULL){
+        ticket_unlock(&scheduler_lock);
+        return -1;
+    }
+    new_task->queue_index = queue_enqueue(cpu->scheduler_queue,new_task);
+    if(new_task->queue_index == -1){
+        logkf("Error: scheduler null %d\n",get_current_cpuid());
+        return -1;
+    }
+
+    if(new_task->pid == kernel_head_task->pid) goto ret;
+
+    pivfs_update(kernel_head_task);
+    ret:
+    ticket_unlock(&scheduler_lock);
+    return new_task->queue_index;
+}
+
+void remove_task(pcb_t task){
+    if(task == NULL) return;
+    ticket_lock(&scheduler_lock);
+
+    smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+    if(cpu == NULL){
+        ticket_unlock(&scheduler_lock);
+        return;
     }
-    tailt->next = new_task;
+    queue_remove_at(cpu->scheduler_queue,task->queue_index);
     pivfs_update(kernel_head_task);
     ticket_unlock(&scheduler_lock);
 }
@@ -95,17 +120,28 @@ void change_proccess(registers_t *reg,pcb_t taget){
 }
 
 /**
- * CP_Kernel 默认调度器 - 循环调度
- * TODO 只适用于单核调度所以做了进程的CPU归属判断
+ * CP_Kernel 默认单核调度器 - 循环调度
  * @param reg 当前进程上下文
  */
 void scheduler(registers_t *reg){
     if(is_scheduler){
         if(current_task != NULL){
-            pcb_t next = current_task->next;
-            while (next->cpu_id != get_current_cpuid()){
-                next = next->next;
+            smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+            if (cpu->iter_node == NULL) {
+                iter_head:
+                cpu->iter_node = cpu->scheduler_queue->head;
+            } else {
+                cpu->iter_node = cpu->iter_node->next;
+                if(cpu->iter_node == NULL) goto iter_head;
             }
+            void *data = NULL;
+            if (cpu->iter_node != NULL) {
+                data = cpu->iter_node->data;
+            }
+
+            pcb_t next = (pcb_t)data;
+           // logkf("p: %p\n",next);
+
             current_task->cpu_clock++;
             if(current_task->time_buf != NULL){
                 current_task->cpu_timer += get_time(current_task->time_buf);

src/driver/iic/pca9685.c

@@ -56,6 +56,7 @@ void pca9685_write(uint8_t reg, uint8_t data){
 uint8_t pca9685_read(uint8_t reg){
     //读取兼容性
     UNUSED(reg);
+    return 0;
 }
 
 /**

src/driver/input/keyboard.c

@@ -4,7 +4,7 @@
 #include "krlibc.h"
 #include "io.h"
 #include "kprint.h"
-#include "acpi.h"
+#include "smp.h"
 #include "pcb.h"
 #include "terminal.h"
 
@@ -26,6 +26,12 @@ char keytable1[0x54] = { // 未按下Shift
         ',', '.', '/', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1', '2', '3', '0', '.'};
 
+static void key_callback(void *pcb_handle,void* scan_handle){
+    pcb_t cur = (pcb_t)pcb_handle;
+    uint8_t scancode = *((uint8_t*)scan_handle);
+    atom_push(cur->tty->keyboard_buffer, scancode);
+}
+
 __IRQHANDLER void keyboard_handler(interrupt_frame_t *frame) {
     UNUSED(frame);
     io_out8(0x61, 0x20);
@@ -53,14 +59,12 @@ __IRQHANDLER void keyboard_handler(interrupt_frame_t *frame) {
     }
 
     if (scancode < 0x80) {
-        if (kernel_head_task != NULL) {
-            pcb_t cur = kernel_head_task;
-            do {
-                cur = cur->next;
-                atom_push(cur->tty->keyboard_buffer, scancode);
-            } while (cur->pid != kernel_head_task->pid);
-        } else
-            printk("Keyboard scancode: %x\n", scancode);
+        smp_cpu_t *cpu = get_cpu_smp(get_current_cpuid());
+        if(cpu == NULL){
+            logkf("Error: keyboard cannot iteration scheduler queue.\n");
+            return;
+        }
+        queue_iterate(cpu->scheduler_queue,key_callback,&scancode);
     }
 }
 

src/include/cpuid.h

@@ -10,5 +10,5 @@ typedef struct {
 } cpu_t;
 
 void init_cpuid();
-
+bool cpuid_has_sse();
 cpu_t get_cpu_info();

src/include/lock_queue.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "lock.h"
+
+typedef struct LockNode {
+    void *data;
+    struct LockNode *next;
+    int index;
+} lock_node;
+
+typedef struct {
+    lock_node *head;
+    lock_node *tail;
+    ticketlock lock;
+    ticketlock iter_lock;
+    int size;
+    int next_index;
+} lock_queue;
+
+/**
+ * 初始化一个有锁可迭代队列
+ * @return 队列
+ */
+lock_queue *queue_init();
+
+/**
+ * 入队操作
+ * @param q 队列
+ * @param data 存储的句柄
+ * @return 该节点的索引
+ */
+int queue_enqueue(lock_queue *q, void *data);
+
+/**
+ * 删除指定索引的节点
+ * @param q 队列
+ * @param index 索引
+ * @return 被删除节点的句柄
+ */
+void *queue_remove_at(lock_queue *q, int index);
+
+/**
+ * 出队操作
+ * @param q 队列
+ * @return 该节点存储的句柄
+ */
+void *queue_dequeue(lock_queue *q);
+
+/**
+ * 销毁队列
+ * @param q 队列
+ */
+void queue_destroy(lock_queue *q);
+
+/**
+ * 传入回调函数迭代指定队列
+ * @param q 队列
+ * @param callback 回调函数
+ * @param argument 回调函数传入的参数
+ */
+void queue_iterate(lock_queue *q, void (*callback)(void *,void*), void* argument);