diff --git a/Ubiquitous/XiZi_AIoT/softkernel/task/ipc.c b/Ubiquitous/XiZi_AIoT/softkernel/task/ipc.c deleted file mode 100644 index e69de29bb..000000000 diff --git a/Ubiquitous/XiZi_AIoT/softkernel/task/schedule.c b/Ubiquitous/XiZi_AIoT/softkernel/task/schedule.c deleted file mode 100644 index e69de29bb..000000000 diff --git a/Ubiquitous/XiZi_AIoT/softkernel/task/task.c b/Ubiquitous/XiZi_AIoT/softkernel/task/task.c index a053a61d5..bd955c1af 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/task/task.c +++ b/Ubiquitous/XiZi_AIoT/softkernel/task/task.c @@ -5,306 +5,347 @@ #include #include -// 创建线程 -static pid_t next_pid = 0; +#define DEF_STACK_SIZE (128 * 1024) +// 定义全局的任务调度器 +scheduler_t *scheduler; /******************************************************************************* -* 函 数 名: start_thread -* 功能描述: 启动线程 -* 形 参: 无 -* 返 回 值: 栈指针 +* 函 数 名: scheduler_init +* 功能描述: 初始化任务调度器 +* 形 参: num_cpus:cpu个数,num_tasks_per_cpu:每个CPU的任务数量 +* 返 回 值: 任务调度器结构体指针 *******************************************************************************/ -tcb_t *task_create(char *name, int pri, uint32_t stack_size, void (*entry)(void *arg), void *arg) { - tcb_t *tcb; - uint32_t stack_top; - uint32_t kstack_top; - int r; - - /* 分配任务控制块 */ - tcb = (tcb_t *)malloc(sizeof(tcb_t)); - if (tcb == NULL) { - return NULL; +scheduler_t *scheduler_init(int num_cpus, int num_tasks_per_cpu) { + // 分配并初始化任务调度器 + scheduler = malloc(sizeof(scheduler_t)); + scheduler->num_cpus = num_cpus; + scheduler->num_tasks_per_cpu = num_tasks_per_cpu; + scheduler->ready_queue = malloc(sizeof(task_t*) * num_cpus * num_tasks_per_cpu); + scheduler->interrupt_stack_ptr = NULL; + for (int i = 0; i < num_cpus * num_tasks_per_cpu; i++) { + scheduler->ready_queue[i] = NULL; } - - /* 分配任务栈 */ - tcb->stack_size = stack_size; - tcb->stack_top = (uint32_t)malloc(stack_size); - if (tcb->stack_top == 0) { - free(tcb); - return NULL; - } - - /* 分配内核栈 */ - tcb->kstack_size = K_STACK_SIZE; - tcb->kstack_top = (uint32_t)malloc(tcb->kstack_size); - if (tcb->kstack_top == 0) { - free((void *)tcb->stack_top); - free(tcb); - return NULL; - } - - /* 初始化任务控制块 */ - tcb->state.flags = 0; - tcb->state.exit_code = 0; - tcb->state.trap_type = 0; - tcb->priority = pri; - tcb->flags = 0; - tcb->message_queue.head = NULL; - tcb->message_queue.tail = NULL; - tcb->async_flags = 0; - tcb->cpu_affinity = 0; - tcb->private = NULL; - - /* 初始化任务上下文 */ - r = setup_context(&tcb->context, (void *)entry, arg, (void *)tcb->stack_top + tcb->stack_size, tcb->kstack_top + tcb->kstack_size); - if (r != 0) { - free((void *)tcb->kstack_top); - free((void *)tcb->stack_top); - free(tcb); - return NULL; - } - - /* 设置任务ID */ - tcb->pid = next_pid++; - - /* 向任务列表中添加任务 */ - r = add_task(tcb); - if (r != 0) { - free((void *)tcb->kstack_top); - free((void *)tcb->stack_top); - free(tcb); - return NULL; - } - - /* 设置任务名称 */ - strncpy(tcb->name, name, TASK_NAME_MAX_LENGTH); - - /* 返回任务控制块 */ - return tcb; -} - -void task_destroy(tcb_t *tcb) { - /* 从任务列表中移除任务 */ - remove_task(tcb); - - /* 释放任务栈和内核栈 */ - free((void *)tcb->stack_top); - free((void *)tcb->kstack_top); - - /* 释放任务控制块 */ - free(tcb); -} - -void task_suspend(tcb_t *tcb) { - /* 设置任务状态为挂起 */ - task_set_state(tcb, TASK_STATE_SUSPENDED); - - /* 将任务从调度队列中移除 */ - remove_from_schedule_queue(tcb); -} - -void task_resume(tcb_t *tcb) { - /* 设置任务状态为就绪 */ - task_set_state(tcb, TASK_STATE_READY); - - /* 将任务添加到调度队列中 */ - add_to_schedule_queue(tcb); -} - -void task_delay(uint32_t ticks) { - tcb_t *tcb; - - /* 获取当前任务的控制块 */ - tcb = get_current_task(); - - /* 设置任务的延迟计数器 */ - tcb->delay_ticks = ticks; - - /* 将任务从调度队列中移除 */ - remove_from_schedule_queue(tcb); - - /* 将任务添加到延迟队列中 */ - add_to_delay_queue(tcb); -} - -void task_notify_async(tcb_t *tcb, int flags) { - /* 设置任务的异步通知标志 */ - tcb->async_flags |= flags; - - /* 将该任务添加到等待列表中 */ - add_to_wait_queue(tcb, flags); -} - -int task_wait_async(int flags) { - tcb_t *tcb; - - /* 获取当前任务的控制块 */ - tcb = get_current_task(); - - /* 设置任务的等待标志 */ - tcb->wait_flags = flags; - - /* 将当前任务从调度队列中移除 */ - remove_from_schedule_queue(tcb); - - /* 将当前任务添加到等待列表中 */ - add_to_wait_queue(tcb, flags); - - /* 切换到下一个任务 */ - switch_to_next_task(); - - /* 被唤醒后，返回当前任务的异步通知标志 */ - return tcb->async_flags; + scheduler->current_task = NULL; + scheduler->current_cpu_id = 0; + return scheduler; } -int task_send_msg(tcb_t *tcb, void *msg, int len) { - int ret = 0; - msg_t *new_msg; +/******************************************************************************* +* 函 数 名: create_task +* 功能描述: 创建任务 +* 形 参: func:任务入口函数,arg:入口函数参数指针, + priority:任务优先级,stack_size:栈大小 +* 返 回 值: 任务的id +*******************************************************************************/ +int create_task(void (*func)(void *), void *arg, int priority, size_t stack_size) { + // 分配并初始化任务控制块 + tcb *task = malloc(sizeof(tcb)); + task->id = generate_task_id(); + task->priority = priority; + task->state = THREAD_READY; + task->stack_size = stack_size; + task->stack_bottom = malloc(stack_size); + task->stack_ptr = (uint32_t*)(task->stack_bottom + stack_size / sizeof(uint32_t)); + task->entry_point = func; + task->arg = arg; + task->cpu_id = get_current_cpu_id(); + // 初始化任务堆栈 + init_stack(task->stack_ptr, stack_size, func, arg,task); + // 添加任务到就绪队列 + add_task_to_ready_queue(task); + return task->id; +} - /* 如果目标任务的消息队列已满，则返回错误码 */ - if (is_msg_queue_full(tcb)) { + +/******************************************************************************* +* 函 数 名: destroy_task +* 功能描述: 销毁任务 +* 形 参: task_id:任务的id +* 返 回 值: 销毁成功返回0 +*******************************************************************************/ +int destroy_task(int task_id) { + // 获取要销毁的任务控制块 + tcb *task = get_task_by_id(task_id); + if (task == NULL) { return -1; } - - /* 分配新的消息结构体 */ - new_msg = alloc_msg(msg, len); - if (new_msg == NULL) { - return -1; + if (task->state == TASK_RUNNING) { + // 如果要销毁的任务正在运行，则直接切换到下一个任务 + switch_to_next_task(); } - - /* 将新的消息添加到目标任务的消息队列中 */ - add_msg_to_queue(tcb, new_msg); - - /* 如果目标任务正在等待消息，则唤醒该任务 */ - if (is_waiting_for_msg(tcb)) { - wake_up_task(tcb); - } - - return ret; + // 从就绪队列中移除任务 + remove_task_from_ready_queue(task); + // 释放任务堆栈 + free(task->stack_bottom); + // 释放任务控制块 + free(task); + return 0; } -int task_recv_msg(void *msg, int len) { - int ret = 0; - msg_t *recv_msg; - - /* 如果当前任务的消息队列为空，则挂起当前任务 */ - if (is_msg_queue_empty()) { - wait_for_msg(); - } - - /* 从消息队列中取出一条消息 */ - recv_msg = get_msg_from_queue(); - if (recv_msg == NULL) { +/******************************************************************************* +* 函 数 名: suspend_task +* 功能描述: 挂起任务 +* 形 参: task_id:任务的id +* 返 回 值: 挂起成功返回0 +*******************************************************************************/ +int suspend_task(int task_id) { + // 获取要挂起的任务控制块 + tcb *task = get_task_by_id(task_id); + if (task == NULL) { return -1; } - - /* 如果消息的长度大于接收缓冲区的长度，则返回错误码 */ - if (recv_msg->len > len) { - ret = -1; - } else { - /* 复制消息的内容到接收缓冲区中 */ - memcpy(msg, recv_msg->data, recv_msg->len); + if (task->state == TASK_RUNNING) { + // 如果要挂起的任务正在运行，则切换到下一个任务 + switch_to_next_task(); } - - /* 释放消息结构体 */ - free_msg(recv_msg); - - return ret; + // 修改任务状态为阻塞状态 + task->state = TASK_BLOCKED; + return 0; } -tcb_t *task_get_current_tcb(void) { - tcb_t *tcb; - /* 获取当前任务的堆栈指针 */ - void *sp = get_current_sp(); +/******************************************************************************* +* 函 数 名: resume_task +* 功能描述: 恢复任务 +* 形 参: task_id:任务的id +* 返 回 值: 恢复成功返回0 +*******************************************************************************/ +int resume_task(int task_id) { + // 获取要恢复的任务控制块 + tcb *task = get_task_by_id(task_id); + if (task == NULL) { + return -1; + } + if (task->state != TASK_BLOCKED) { + // 如果要恢复的任务不是阻塞状态，则直接返回 + return -1; + } + // 修改任务状态为就绪状态 + task->state = task_READY; + // 添加任务到就绪队列 + add_task_to_ready_queue(task); + return 0; +} - /* 从任务列表中查找与当前堆栈指针对应的控制块 */ - for (int i = 0; i < NUM_TASKS; i++) { - tcb = &task_list[i]; - if (tcb->sp == sp) { - return tcb; + +/******************************************************************************* +* 函 数 名: set_task_priority +* 功能描述: 调整任务优先级 +* 形 参: task_id:任务的id，priority:要调整的优先级 +* 返 回 值: 销毁成功返回0 +*******************************************************************************/ +int set_task_priority(int task_id, int priority) { + // 获取要调整优先级的任务控制块 + tcb *task = get_task_by_id(task_id); + if (task == NULL) { + return -1; + } + // 修改任务优先级 + task->priority = priority; + return 0; +} + +/******************************************************************************* +* 函 数 名: get_current_task_id +* 功能描述: 获取当前任务的ID +* 形 参: 无 +* 返 回 值: 获取成功返回0 +*******************************************************************************/ +int get_current_task_id() { + if (scheduler->current_task == NULL) { + return -1; + } + return scheduler->current_task->id; +} + + +/******************************************************************************* +* 函 数 名: get_current_cpu_id +* 功能描述: 获取当前CPU的ID +* 形 参: 无 +* 返 回 值: 获取到的当前CPU的ID +* 说 名: 不同的处理器获取方式不同,这里以ARM-A9系列芯片为例 +*******************************************************************************/ +uint16_t get_current_cpu_id() { + uint32_t mpidr; + asm volatile ("mrc p15, 0, %0, c0, c0, 5" : "=r" (mpidr)); + return mpidr & 0xff; +} + + +/******************************************************************************* +* 函 数 名: get_task_by_id +* 功能描述: 通过任务ID获取任务控制块 +* 形 参: task_id:任务的id +* 返 回 值: 获取到的任务控制块的指针 +*******************************************************************************/ +tcb *get_task_by_id(int task_id) { + // 遍历就绪队列和当前任务，寻找任务控制块 + for (int i = 0; i < scheduler->num_cpus * scheduler->num_tasks_per_cpu; i++) { + tcb *task = scheduler->ready_queue[i]; + if (task != NULL && task->id == task_id) { + return task; } } - - /* 如果没有找到对应的控制块，则返回空指针 */ + tcb *task = scheduler->current_task; + if (task != NULL && task->id == task_id) { + return task; + } return NULL; } -pid_t task_get_pid(tcb_t *tcb) { - return tcb->pid; + +/******************************************************************************* +* 函 数 名: generate_task_id +* 功能描述: 生成任务ID +* 形 参: 无 +* 返 回 值: 生成的任务ID +*******************************************************************************/ +int generate_task_id() { + static int next_task_id = 1; // 静态变量，记录下一个可用的任务ID + int task_id = next_task_id++; // 生成任务ID，并将next_task_id加1 + return task_id; } -int task_get_priority(tcb_t *tcb) { - return tcb->priority; -} -void task_set_priority(tcb_t *tcb, int pri) { - /* 确保优先级的值在合法范围内 */ - if (pri < MIN_PRIORITY) { - pri = MIN_PRIORITY; - } else if (pri > MAX_PRIORITY) { - pri = MAX_PRIORITY; +/******************************************************************************* +* 函 数 名: switch_to_next_task +* 功能描述: 切换到下一个任务 +* 形 参: 无 +* 返 回 值: 无 +*******************************************************************************/ +void switch_to_next_task() { + // 保存当前任务的上下文 + // TODO: 保存当前任务的上下文 + // 从就绪队列中取出下一个任务 + task_t *next_task = NULL; + for (int i = scheduler->current_cpu_id * scheduler->num_tasks_per_cpu; i < (scheduler->current_cpu_id + 1) * scheduler->num_tasks_per_cpu; i++) { + task_t *task = scheduler->ready_queue[i]; + if (task != NULL && (next_task == NULL ||task->priority > next_task->priority)) { + next_task = task; + } } - - /* 设置任务的优先级 */ - tcb->priority = pri; -} - -int task_get_state(tcb_t *tcb) { - return tcb->state; -} - -void task_set_state(tcb_t *tcb, int state) { - /* 确保状态的值在合法范围内 */ - if (state < TASK_STATE_CREATED || state > TASK_STATE_TERMINATED) { - return; + if (next_task == NULL) { + // 如果就绪队列为空，则切换到空闲任务 + // TODO: 切换到空闲任务 + } else { + // 切换到下一个任务 + scheduler->current_task = next_task; + scheduler->current_task->state = TASK_RUNNING; + // TODO: 恢复下一个任务的上下文 } - - /* 设置任务的状态 */ - tcb->state = state; } -int task_get_async_flags(tcb_t *tcb) { - return tcb->async_flags; -} -void task_set_async_flags(tcb_t *tcb, int flags) { - /* 设置任务的异步事件标志 */ - tcb->async_flags = flags; -} - -uint32_t task_get_time_quantum(tcb_t *tcb) { - return tcb->time_quantum; -} - -void task_set_time_quantum(tcb_t *tcb, uint32_t quantum) { - /* 确保时间片大小的值在合法范围内 */ - if (quantum < MIN_TIME_QUANTUM) { - quantum = MIN_TIME_QUANTUM; - } else if (quantum > MAX_TIME_QUANTUM) { - quantum = MAX_TIME_QUANTUM; +/******************************************************************************* +* 函 数 名: add_task_to_ready_queue +* 功能描述: 添加任务到就绪队列 +* 形 参: task:任务控制块的指针 +* 返 回 值: 无 +*******************************************************************************/ +void add_task_to_ready_queue(task_t *task) { + // 找到任务所在的CPU的就绪队列 + int cpu_id = task->cpu_id; + int start_index = cpu_id * scheduler->num_tasks_per_cpu; + int end_index = (cpu_id + 1) * scheduler->num_tasks_per_cpu; + // 找到一个空闲的位置插入任务 + for (int i = start_index; i < end_index; i++) { + if (scheduler->ready_queue[i] == NULL) { + scheduler->ready_queue[i] = task; + return; + } } - - /* 设置任务的时间片大小 */ - tcb->time_quantum = quantum; + // 如果没有空闲的位置，则替换掉优先级最低的任务 + task_t *lowest_priority_task = NULL; + int lowest_priority = 0; + for (int i = start_index; i < end_index; i++) { + task_t *t = scheduler->ready_queue[i]; + if (t != NULL && (lowest_priority_task == NULL || t->priority < lowest_priority)) { + lowest_priority_task = t; + lowest_priority = t->priority; + } + } + scheduler->ready_queue[lowest_priority_task - scheduler->ready_queue] = task; } -uint32_t task_get_stack_size(tcb_t *tcb) { - return tcb->stack_size; + +/******************************************************************************* +* 函 数 名: remove_task_from_ready_queue +* 功能描述: 从就绪队列中移除任务 +* 形 参: task:任务控制块的指针 +* 返 回 值: 无 +*******************************************************************************/ +void remove_task_from_ready_queue(task_t *task) { + // 找到任务所在的CPU的就绪队列 + int cpu_id = task->cpu_id; + int start_index = cpu_id * scheduler->num_tasks_per_cpu; + int end_index = (cpu_id + 1) * scheduler->num_tasks_per_cpu; + // 从就绪队列中移除任务 + for (int i = start_index; i < end_index; i++) { + if (scheduler->ready_queue[i] == task) { + scheduler->ready_queue[i] = NULL; + return; + } + } } -void *task_get_stack_top(tcb_t *tcb) { - return tcb->stack_top; + +/******************************************************************************* +* 函 数 名: init_stack +* 功能描述: 初始化任务堆栈 +* 形 参: stack_ptr:任务堆栈指针,stack_size:堆栈大小 + func:入口函数的指针,arg:入口函数的参数指针 + task:任务控制块指针 +* 返 回 值: 无 +*******************************************************************************/ +void init_stack(uint32_t *stack_ptr, size_t stack_size, void (*func)(void *), void *arg,tcb* task) { + // 计算堆栈底部指针 + uint32_t *stack_bottom = stack_ptr - stack_size / sizeof(uint32_t); + // 将任务参数压入堆栈中 + *(--stack_ptr) = (uint32_t)arg; + // 将任务入口函数压入堆栈中 + *(--stack_ptr) = (uint32_t)func; + // 设置堆栈指针和堆栈底部指针 + task->stack_ptr = stack_ptr; + task->stack_bottom = stack_bottom; } -uint32_t task_get_cpu_affinity(tcb_t *tcb) { - return tcb->cpu_affinity; -} - -void task_set_cpu_affinity(tcb_t *tcb, uint32_t affinity) { - /* 设置任务的CPU亲和性 */ - tcb->cpu_affinity = affinity; + +/******************************************************************************* +* 函 数 名: idle_task +* 功能描述: 空闲任务的入口函数 +* 形 参: 无 +* 返 回 值: 无 +*******************************************************************************/ +void idle_task(void *arg) { + while (1) { + // 休眠等待，直到接收到调度器的唤醒信号 + asm volatile ("wfi"); + } } +/******************************************************************************* +* 函 数 名: init_idle_task +* 功能描述: 初始化空闲任务 +* 形 参: 无 +* 返 回 值: 无 +*******************************************************************************/ +void init_idle_task() { + // 创建空闲任务的TCB + tcb *task = (tcb *)malloc(sizeof(tcb)); + memset(task, 0, sizeof(tcb)); + task->state = task_READY; + task->priority = 0; + task->cpu_id = get_current_cpu_id(); + task->task_id = generate_task_id(); + // 初始化空闲任务的堆栈 + uint32_t *stack_ptr = (uint32_t *)malloc(DEF_STACK_SIZE); + memset(stack_ptr, 0, DEF_STACK_SIZE); + init_stack(stack_ptr + DEF_STACK_SIZE / sizeof(uint32_t), DEF_STACK_SIZE, idle_task, NULL,task); + task->stack_ptr = stack_ptr + DEF_STACK_SIZE / sizeof(uint32_t) - 1; + task->stack_bottom = stack_ptr; + // 将空闲任务添加到就绪队列中 + add_tcbo_ready_queue(task); +} \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/softkernel/task/task.h b/Ubiquitous/XiZi_AIoT/softkernel/task/task.h index 619061c78..064837652 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/task/task.h +++ b/Ubiquitous/XiZi_AIoT/softkernel/task/task.h @@ -6,210 +6,86 @@ #include #include -typedef uint16_t pid_t; -#define TASK_NAME_MAX_LENGTH 256 +#include +#include -#define MAX_PRIORITY 512 -#define MIN_PRIORITY 1 -#define MIN_TIME_QUANTUM 10 /* 最小时间片大小为10毫秒 */ -#define MAX_TIME_QUANTUM 100 /* 最大时间片大小为100毫秒 */ +// 定义线程状态 +typedef enum { + THREAD_READY, // 就绪状态 + THREAD_RUNNING, // 运行状态 + THREAD_BLOCKED, // 阻塞状态 + THREAD_TERMINATED // 终止状态 +} task_state_t; -// 线程状态 -typedef enum thread_state { - TASK_STATE_CREATED, // 线程已创建，但未启动 - TASK_STATE_READY, // 线程就绪 - TASK_STATE_RUNNING, // 线程正在运行 - TASK_STATE_BLOCKED, // 线程被阻塞（等待某些事件的发生） - TASK_STATE_WAITING, // 线程正在休眠（等待一段时间后被唤醒） - TASK_STATE_SUSPENDED, // 线程被挂起（暂停执行） - TASK_STATE_TERMINATED // 线程已终止 -} task_state; - +// 定义线程控制块（TCB） typedef struct { - /* 通用寄存器 */ - uint32_t ebx; - uint32_t ecx; - uint32_t edx; - uint32_t esi; - uint32_t edi; - uint32_t ebp; - - /* 返回地址 */ - uint32_t eip; - - /* 特权级 */ - uint32_t cs; - uint32_t eflags; -}context; + int id; // 任务ID + int priority; // 任务优先级 + task_state_t state; // 任务状态 + uint32_t* stack_ptr; // 任务堆栈指针 + size_t stack_size; // 任务堆栈大小 + uint32_t *stack_bottom; // 任务堆栈底部 + void (*entry_point)(void); // 任务入口函数 + void *arg; // 任务参数 + uint16_t cpu_id; // 任务所在的CPU ID +} tcb; +// 定义任务调度器 typedef struct { - /* 消息类型 */ - uint8_t m_type; + int num_cpus; // CPU数量 + int num_tasks_per_cpu; // 每个CPU的任务数量 + tcb **ready_queue; // 就绪队列 + tcb *current_task; // 当前正在运行的任务 + uint16_t current_cpu_id; // 当前CPU的ID + uint32_t *interrupt_stack_ptr; // 中断堆栈指针 +} scheduler_t; - /* 发送者的PID */ - pid_t m_sender; +// 初始化任务调度器 +scheduler_t *scheduler_init(int num_cpus, int num_tasks_per_cpu); - /* 消息数据 */ - uint8_t m_data[512]; -} message_t; +// 创建任务 +int create_task(void (*func)(void *), void *arg, int priority, size_t stack_size); -typedef struct { - /* 消息队列长度 */ - uint16_t count; +// 销毁任务 +int destroy_task(int task_id); - /* 队列头指针 */ - void* front; +// 挂起任务 +int suspend_task(int task_id); - /* 队列尾指针 */ - void* rear; +// 恢复任务 +int resume_task(int task_id); - /* 消息队列缓冲区 */ - message_t *buffer; -}message_queue; +// 调整任务优先级 +int set_task_priority(int task_id, int priority); +// 获取当前任务的ID +int get_current_task_id(); -typedef struct { - /* 队列头指针 */ - tcb_t *head; +// 获取当前CPU的ID +uint16_t get_current_cpu_id; - /* 队列尾指针 */ - tcb_t *tail; -}task_list; +// 获取任务控制块 +tcb *get_task_by_id(int task_id); -typedef struct{ - /* 端点ID */ - uint16_t id; +// 生成任务ID +int generate_task_id(); - /* 端点状态 */ - uint32_t flags; +// 切换到下一个任务 +void switch_to_next_task(); - /* 发送队列 */ - message_queue send_queue; +// 添加任务到就绪队列 +void add_tcbo_ready_queue(tcb *task); - /* 接收队列 */ - message_queue recv_queue; +// 从就绪队列中移除任务 +void remove_task_from_ready_queue(tcb *task); - /* 端点等待队列 */ - task_list waiting; -}endpoint; +// 初始化任务堆栈 +void init_stack(uint32_t *stack_ptr, size_t stack_size, void (*func)(void *), void *arg,tcb* task); -typedef struct tcb { - /* 任务ID */ - pid_t pid; - - /* 任务状态 */ - task_state state; - - /* 任务优先级 */ - uint16_t priority; - - /* 任务类型 */ - uint16_t flags; - - /* 任务的延迟计数器 */ - uint16_t delay_ticks; - - /* 任务栈顶指针 */ - uint32_t stack_top; - - /* 任务栈大小 */ - uint16_t stack_size; - - /* 内核栈顶指针 */ - uint32_t kstack_top; - - /* 内核栈大小 */ - uint16_t kstack_size; - - /* 任务上下文 */ - context context; - - /* 消息队列 */ - message_queue message_queue; - - /* 关联的端点 */ - endpoint *endpoint; - - /* 异步通知标志 */ - unsigned int async_flags; - - /* 任务的CPU亲和力 */ - unsigned int cpu_affinity; - - /* 任务的私有数据 */ - void* private; -} tcb_t; - - - -/* 创建任务 */ -tcb_t *task_create(char *name, int pri, uint32_t stack_size, void (*entry)(void *arg), void *arg); - -/* 销毁任务 */ -void task_destroy(tcb_t *tcb); - -/* 暂停任务 */ -void task_suspend(tcb_t *tcb); - -/* 恢复任务 */ -void task_resume(tcb_t *tcb); - -/* 延时 */ -void task_delay(uint32_t ticks); - -/* 异步通知 */ -void task_notify_async(tcb_t *tcb, int flags); - -/* 等待异步通知 */ -int task_wait_async(int flags); - -/* 发送消息 */ -int task_send_msg(tcb_t *tcb, void *msg, int len); - -/* 接收消息 */ -int task_recv_msg(void *msg, int len); - -/* 获取当前任务的TCB */ -tcb_t *task_get_current_tcb(void); - -/* 获取任务ID */ -pid_t task_get_pid(tcb_t *tcb); - -/* 获取任务优先级 */ -int task_get_priority(tcb_t *tcb); - -/* 设置任务优先级 */ -void task_set_priority(tcb_t *tcb, int pri); - -/* 获取任务状态 */ -int task_get_state(tcb_t *tcb); - -/* 设置任务状态 */ -void task_set_state(tcb_t *tcb, int state); - -/* 获取任务的异步通知标志 */ -int task_get_async_flags(tcb_t *tcb); - -/* 设置任务的异步通知标志 */ -void task_set_async_flags(tcb_t *tcb, int flags); - -/* 获取任务的时间片大小 */ -uint32_t task_get_time_quantum(tcb_t *tcb); - -/* 设置任务的时间片大小 */ -void task_set_time_quantum(tcb_t *tcb, uint32_t quantum); - -/* 获取任务的栈大小 */ -uint32_t task_get_stack_size(tcb_t *tcb); - -/* 获取任务的栈顶指针 */ -void *task_get_stack_top(tcb_t *tcb); - -/* 获取任务的CPU亲和力 */ -uint32_t task_get_cpu_affinity(tcb_t *tcb); - -/* 设置任务的CPU亲和力 */ -void task_set_cpu_affinity(tcb_t *tcb, uint32_t affinity); +// 空闲任务的入口函数 +void idle_task(void *arg); +// 初始化空闲任务 +void init_idle_task(); #endif