TaskManager Class Reference

任务管理器 More...

#include <task_manager.hpp>

Collaboration diagram for TaskManager:

Classes
struct	InterruptWork
	中断线程处理结构体 More...

Public Member Functions
auto	InitCurrentCore () -> void
	初始化 per cpu 的调度数据，创建 idle 线程
auto	AddTask (etl::unique_ptr< TaskControlBlock > task) -> void
	添加任务（接管所有权）
auto	Schedule () -> void
	调度函数 选择下一个任务并切换上下文
auto	GetCurrentTask () const -> TaskControlBlock *
	获取当前任务
auto	TickUpdate () -> void
	更新系统 tick
auto	Sleep (uint64_t ms) -> void
	线程睡眠
auto	Exit (int exit_code=0) -> void
	退出当前线程
auto	Block (ResourceId resource_id) -> void
	阻塞当前任务
auto	Wakeup (ResourceId resource_id) -> void
	唤醒等待指定资源的所有任务
auto	Clone (uint64_t flags, void *user_stack, int *parent_tid, int *child_tid, void *tls, cpu_io::TrapContext &parent_context) -> Expected< Pid >
	克隆当前任务 (fork/clone 系统调用)
auto	Wait (Pid pid, int *status, bool no_hang=false, bool untraced=false) -> Expected< Pid >
	等待子进程退出
auto	FindTask (Pid pid) -> TaskControlBlock *
	按 PID 查找任务
构造/析构函数
	TaskManager ()=default
	TaskManager (const TaskManager &)=delete
	TaskManager (TaskManager &&)=delete
auto	operator= (const TaskManager &) -> TaskManager &=delete
auto	operator= (TaskManager &&) -> TaskManager &=delete
	~TaskManager ()

Private Types
using	InterruptWorkQueue = mpmc_queue::MPMCQueue< InterruptWork, kInterruptQueueCapacity >
	中断工作队列

Private Member Functions
auto	AllocatePid () -> size_t
	分配新的 PID
auto	Balance () -> void
	负载均衡 (空闲 core 窃取任务)
auto	GetCurrentCpuSched () -> CpuSchedData &
	获取当前核心的调度数据
auto	GetThreadGroup (Pid tgid) -> etl::vector< TaskControlBlock *, kernel::config::kMaxReadyTasks >
	获取线程组的所有线程
auto	SignalThreadGroup (Pid tgid, int signal) -> void
	向线程组中的所有线程发送信号
auto	ReapTask (TaskControlBlock *task) -> void
	回收僵尸进程资源
auto	ReparentChildren (TaskControlBlock *parent) -> void
	将孤儿进程过继给 init 进程

Private Attributes
std::array< CpuSchedData, SIMPLEKERNEL_MAX_CORE_COUNT >	cpu_schedulers_ {}
	每个核心的调度数据
SpinLock	task_table_lock_ {"task_table_lock"}
	全局任务表 (PID -> TCB 映射)
etl::unordered_map< Pid, etl::unique_ptr< TaskControlBlock >, kernel::config::kMaxTasks, kernel::config::kMaxTasksBuckets >	task_table_
SpinLock	interrupt_threads_lock_ {"interrupt_threads_lock"}
	中断线程相关数据保护锁
etl::unordered_map< uint64_t, TaskControlBlock *, kernel::config::kMaxInterruptThreads, kernel::config::kMaxInterruptThreadsBuckets >	interrupt_threads_
	中断号 -> 中断线程映射
etl::unordered_map< uint64_t, InterruptWorkQueue *, kernel::config::kMaxInterruptThreads, kernel::config::kMaxInterruptThreadsBuckets >	interrupt_work_queues_
	中断号 -> 工作队列映射
std::atomic< size_t >	pid_allocator_ {1}
	PID 分配器

Static Private Attributes
static constexpr size_t	kInterruptQueueCapacity = 256
	中断工作队列容量

Detailed Description

任务管理器

负责管理系统中的所有任务，包括任务的创建、调度、切换等。

Definition at line 84 of file task_manager.hpp.

Member Typedef Documentation

InterruptWorkQueue

using TaskManager::InterruptWorkQueue = mpmc_queue::MPMCQueue<InterruptWork, kInterruptQueueCapacity>

private

中断工作队列

Definition at line 220 of file task_manager.hpp.

Constructor & Destructor Documentation

TaskManager() [1/3]

TaskManager::TaskManager ( )

default

TaskManager() [2/3]

TaskManager::TaskManager ( const TaskManager &  )

delete

TaskManager() [3/3]

TaskManager::TaskManager ( TaskManager &&  )

delete

~TaskManager()

TaskManager::~TaskManager

(

)

Definition at line 262 of file task_manager.cpp.

                          {
  // unique_ptr in cpu_schedulers_.schedulers[] auto-deletes on destruction
}

Member Function Documentation

AddTask()

auto TaskManager::AddTask

(

etl::unique_ptr< TaskControlBlock >

task

)

-> void

添加任务（接管所有权）

根据任务的调度策略，将其添加到对应的调度器中。

Parameters

task	任务控制块，所有权转移给 TaskManager

Precondition

task 非空，状态为 kUnInit

Definition at line 94 of file task_manager.cpp.

                                                                      {
  assert(task.get() != nullptr && "AddTask: task must not be null");
  assert(task->GetStatus() == TaskStatus::kUnInit &&
         "AddTask: task status must be kUnInit");
  // 分配 PID
  if (task->pid == 0) {
    task->pid = AllocatePid();
  }
 
  // 如果 tgid 未设置，则将其设为自己的 pid (单线程进程或线程组的主线程)
  if (task->aux->tgid == 0) {
    task->aux->tgid = task->pid;
  }
 
  auto* task_ptr = task.get();
  Pid pid = task_ptr->pid;
 
  // 加入全局任务表
  {
    LockGuard lock_guard{task_table_lock_};
    if (task_table_.full()) {
      klog::Err("AddTask: task_table_ full, cannot add task (pid={})", pid);
      return;
    }
    task_table_[pid] = std::move(task);
  }
 
  // 设置任务状态为 kReady
  // Transition: kUnInit -> kReady
  task_ptr->fsm.Receive(MsgSchedule{});
 
  // 简单的负载均衡：如果指定了亲和性，放入对应核心，否则放入当前核心
  // 更复杂的逻辑可以是：寻找最空闲的核心
  size_t target_core = cpu_io::GetCurrentCoreId();
 
  if (task_ptr->aux->cpu_affinity.value() != UINT64_MAX) {
    // 寻找第一个允许的核心
    for (size_t core_id = 0; core_id < SIMPLEKERNEL_MAX_CORE_COUNT; ++core_id) {
      if (task_ptr->aux->cpu_affinity.value() & (1UL << core_id)) {
        target_core = core_id;
        break;
      }
    }
  }
 
  auto& cpu_sched = cpu_schedulers_[target_core];
 
  {
    LockGuard<SpinLock> lock_guard(cpu_sched.lock);
    if (task_ptr->policy < SchedPolicy::kPolicyCount) {
      if (cpu_sched.schedulers[static_cast<uint8_t>(task_ptr->policy)]) {
        cpu_sched.schedulers[static_cast<uint8_t>(task_ptr->policy)]->Enqueue(
            task_ptr);
      }
    }
  }
 
  // 如果是当前核心，且添加了比当前任务优先级更高的任务，触发抢占
  if (target_core == cpu_io::GetCurrentCoreId()) {
    auto& cpu_data = per_cpu::GetCurrentCore();
    TaskControlBlock* current = cpu_data.running_task;
    // 如果当前是 idle 任务，或新任务的策略优先级更高，触发调度
    if (current == cpu_data.idle_task ||
        (current && task_ptr->policy < current->policy)) {
      // 注意：这里不能直接调用 Schedule()，因为可能在中断上下文中
      // 实际应该设置一个 need_resched 标志，在中断返回前检查
      // 为简化，这里暂时不做抢占，只在时间片耗尽时调度
    }
  }
}

Here is the call graph for this function:

AllocatePid()

auto TaskManager::AllocatePid ( ) -> size_t

private

分配新的 PID

Returns

size_t 新的 PID

Note

当前 PID 分配器为简单的原子自增，存在以下限制：

1. 不支持 PID 回收与重用（已退出的任务的 PID 不会被回收）
2. 不检测溢出（size_t 耗尽后回绕为 0，可能与现有 PID 冲突）
3. 不保证全局唯一性（依赖 size_t 足够大 + 系统生命周期内不会耗尽） 对于教学内核而言，size_t 的范围（2^64）在实际使用中不会溢出。 生产级实现应使用位图或 ID 分配器（如 Linux 的 IDR/IDA）。

Definition at line 165 of file task_manager.cpp.

                                        {
  return pid_allocator_.fetch_add(1);
}

Balance()

auto TaskManager::Balance ( ) -> void

private

负载均衡 (空闲 core 窃取任务)

Definition at line 181 of file task_manager.cpp.

                                  {
  // 算法留空
  // TODO: 检查其他核心的运行队列长度，如果比当前核心长，则窃取任务
}

Block()

auto TaskManager::Block

(

ResourceId

resource_id

)

-> void

阻塞当前任务

Parameters

resource_id

等待的资源 ID

Copyright

Copyright The SimpleKernel Contributors

Definition at line 12 of file block.cpp.

                                                      {
  auto& cpu_sched = GetCurrentCpuSched();
 
  auto* current = GetCurrentTask();
  assert(current != nullptr && "Block: No current task to block");
  assert(current->GetStatus() == TaskStatus::kRunning &&
         "Block: current task status must be kRunning");
 
  {
    LockGuard<SpinLock> lock_guard(cpu_sched.lock);
 
    // Check capacity before transitioning FSM
    auto& list = cpu_sched.blocked_tasks[resource_id];
    if (list.full()) {
      klog::Err(
          "Block: blocked_tasks list full for resource, cannot block task {}",
          current->pid);
      // Rollback: task stays kRunning, do not transition FSM
      return;
    }
 
    // Transition: kRunning -> kBlocked
    current->fsm.Receive(MsgBlock{resource_id});
    // Record blocked resource
    current->aux->blocked_on = resource_id;
    list.push_back(current);
 
    klog::Debug("Block: pid={} blocked on resource={}, data={:#x}",
                current->pid, resource_id.GetTypeName(),
                static_cast<uint64_t>(resource_id.GetData()));
  }
 
  // 调度到其他任务
  Schedule();
 
  // 任务被唤醒后会从这里继续执行
}

Here is the call graph for this function:

Clone()

auto TaskManager::Clone	(	uint64_t	flags,
		void *	user_stack,
		int *	parent_tid,
		int *	child_tid,
		void *	tls,
		cpu_io::TrapContext &	parent_context
	)		-> Expected<Pid>

克隆当前任务 (fork/clone 系统调用)

Parameters

flags	克隆标志位 kCloneVm: 共享地址空间 kCloneThread: 共享线程组 kCloneFiles: 共享文件描述符表 kCloneSighand: 共享信号处理器 0: 完全复制 (fork)
user_stack	用户栈指针 (nullptr 表示复制父进程栈)
parent_tid	父进程 TID 存储地址
child_tid	子进程 TID 存储地址
tls	线程局部存储指针
parent_context	父进程的 trap 上下文 (用于复制寄存器)

Returns

Expected<Pid> 父进程返回子进程 PID，子进程返回 0，失败返回错误

Copyright

Copyright The SimpleKernel Contributors

Todo:

当前未实现文件系统，此标志暂时仅记录

Todo:

当前未实现信号机制，此标志暂时仅记录

Todo:

当前未实现文件系统，此标志暂时仅记录

Definition at line 13 of file clone.cpp.

                                                                            {
  auto* parent = GetCurrentTask();
  if (!parent) {
    klog::Err("Clone: No current task");
    return std::unexpected(Error(ErrorCode::kTaskNoCurrentTask));
  }
 
  // 验证克隆标志的合法性
  // 如果设置了 kCloneThread，必须同时设置 kCloneVm, kCloneFiles, kCloneSighand
  if ((flags & clone_flag::kThread) &&
      (!(flags & clone_flag::kVm) || !(flags & clone_flag::kFiles) ||
       !(flags & clone_flag::kSighand))) {
    klog::Warn(
        "Clone: kCloneThread requires kCloneVm, kCloneFiles, kCloneSighand");
    // 自动补全必需的标志
    flags |= (clone_flag::kVm | clone_flag::kFiles | clone_flag::kSighand);
  }
 
  // 分配新的 PID
  Pid new_pid = AllocatePid();
  if (new_pid == 0) {
    klog::Err("Clone: Failed to allocate PID");
    return std::unexpected(Error(ErrorCode::kTaskPidAllocationFailed));
  }
 
  // 创建子任务控制块
  auto child_ptr = kstd::make_unique<TaskControlBlock>();
  if (!child_ptr) {
    klog::Err("Clone: Failed to allocate child task");
    return std::unexpected(Error(ErrorCode::kTaskAllocationFailed));
  }
  auto* child = child_ptr.get();
  // Default ctor leaves FSM in set_states-but-not-started state.
  // Start it so get_state_id() returns kUnInit instead of deref null.
  child->fsm.Start();
 
  // 基本字段设置
  child->pid = new_pid;
  child->name = parent->name;
  child->policy = parent->policy;
  child->sched_info = parent->sched_info;
 
  // 设置父进程 ID
  if (flags & clone_flag::kParent) {
    // 保持与父进程相同的父进程
    child->aux->parent_pid = parent->aux->parent_pid;
  } else {
    child->aux->parent_pid = parent->pid;
  }
 
  // 处理线程组 ID (TGID)
  if (flags & clone_flag::kThread) {
    // 创建线程: 共享线程组
    child->aux->tgid = parent->aux->tgid;
    child->aux->pgid = parent->aux->pgid;
    child->aux->sid = parent->aux->sid;
 
    // 将子线程加入父线程的线程组
    if (parent->IsThreadGroupLeader()) {
      child->JoinThreadGroup(parent);
    } else {
      // 找到线程组的主线程
      TaskControlBlock* leader = FindTask(parent->aux->tgid);
      if (leader) {
        child->JoinThreadGroup(leader);
      } else {
        klog::Warn("Clone: Thread group leader not found for tgid={}",
                   parent->aux->tgid);
      }
    }
  } else {
    // 创建进程: 新的线程组
    // 新进程的 tgid 是自己的 pid
    child->aux->tgid = new_pid;
    child->aux->pgid = parent->aux->pgid;
    child->aux->sid = parent->aux->sid;
  }
 
  // 克隆标志位
  child->aux->clone_flags = CloneFlags(flags);
 
  // 处理文件描述符表 (kCloneFiles)
  if (flags & clone_flag::kFiles) {
    klog::Debug("Clone: sharing file descriptor table (not implemented)");
  } else {
    klog::Debug("Clone: copying file descriptor table (not implemented)");
  }
 
  // 处理信号处理器 (kCloneSighand)
  if (flags & clone_flag::kSighand) {
    klog::Debug("Clone: sharing signal handlers (not implemented)");
  } else {
    klog::Debug("Clone: copying signal handlers (not implemented)");
  }
 
  // 处理文件系统信息 (kCloneFs)
  if (flags & clone_flag::kFs) {
    klog::Debug("Clone: sharing filesystem info (not implemented)");
  } else {
    klog::Debug("Clone: copying filesystem info (not implemented)");
  }
 
  // 处理地址空间
  if (flags & clone_flag::kVm) {
    // 共享地址空间（线程）
    child->page_table = parent->page_table;
    klog::Debug("Clone: sharing page table {:#x}",
                reinterpret_cast<uintptr_t>(child->page_table));
  } else {
    // 复制地址空间（进程）
    if (parent->page_table) {
      // copy_mappings=true 表示复制用户空间映射
      auto result = VirtualMemorySingleton::instance().ClonePageDirectory(
          parent->page_table, true);
      if (!result.has_value()) {
        klog::Err("Clone: Failed to clone page table: {}",
                  result.error().message());
        // 独立页表已由 unique_ptr 在作用域结束时自动释放
        // 仅需清理页表
        if (child->page_table && !(flags & clone_flag::kVm)) {
          VirtualMemorySingleton::instance().DestroyPageDirectory(
              child->page_table, false);
          child->page_table = nullptr;
        }
        return std::unexpected(Error(ErrorCode::kTaskAllocationFailed));
      }
      child->page_table = reinterpret_cast<uint64_t*>(result.value());
      klog::Debug("Clone: cloned page table from {:#x} to {:#x}",
                  reinterpret_cast<uintptr_t>(parent->page_table),
                  reinterpret_cast<uintptr_t>(child->page_table));
    } else {
      // 父进程没有页表（内核线程），子进程也不需要
      child->page_table = nullptr;
    }
  }
 
  // 分配内核栈
  child->kernel_stack = static_cast<uint8_t*>(
      aligned_alloc(cpu_io::virtual_memory::kPageSize,
                    TaskControlBlock::kDefaultKernelStackSize));
  if (!child->kernel_stack) {
    klog::Err("Clone: Failed to allocate kernel stack");
    // 清理已分配的资源
    if (child->page_table && !(flags & clone_flag::kVm)) {
      VirtualMemorySingleton::instance().DestroyPageDirectory(child->page_table,
                                                              false);
      child->page_table = nullptr;
    }
    return std::unexpected(Error(ErrorCode::kTaskKernelStackAllocationFailed));
  }
 
  // 初始化内核栈内容
  kstd::memset(child->kernel_stack, 0,
               TaskControlBlock::kDefaultKernelStackSize);
 
  // 复制 trap context
  child->trap_context_ptr = reinterpret_cast<cpu_io::TrapContext*>(
      child->kernel_stack + TaskControlBlock::kDefaultKernelStackSize -
      sizeof(cpu_io::TrapContext));
  kstd::memcpy(child->trap_context_ptr, &parent_context,
               sizeof(cpu_io::TrapContext));
 
  // 设置用户栈
  if (user_stack) {
    child->trap_context_ptr->UserStackPointer() =
        reinterpret_cast<uint64_t>(user_stack);
  }
 
  // 设置 TLS (Thread Local Storage)
  if (tls) {
    child->trap_context_ptr->ThreadPointer() = reinterpret_cast<uint64_t>(tls);
  }
 
  // 父进程返回子进程 PID
  parent_context.ReturnValue() = new_pid;
  // 子进程返回 0
  child->trap_context_ptr->ReturnValue() = 0;
 
  // 写入 TID
  if (parent_tid) {
    *parent_tid = new_pid;
  }
  if (child_tid) {
    *child_tid = new_pid;
  }
 
  // 将子任务添加到调度器
  AddTask(std::move(child_ptr));
 
  // 打印详细的 clone 信息
  const char* clone_type = (flags & clone_flag::kThread) ? "thread" : "process";
  const char* vm_type = (flags & clone_flag::kVm) ? "shared" : "copied";
  klog::Debug(
      "Clone: created {} - parent={}, child={}, tgid={}, vm={}, flags={:#x}",
      clone_type, parent->pid, new_pid, child->aux->tgid, vm_type,
      static_cast<uint64_t>(flags));
  return new_pid;
}

Here is the call graph for this function:

Exit()

auto TaskManager::Exit

(

int

exit_code = 0

)

-> void

退出当前线程

Parameters

exit_code

退出码

Copyright

Copyright The SimpleKernel Contributors

Todo:

通知父进程 (发送 SIGCHLD)

Definition at line 12 of file exit.cpp.

                                            {
  auto& cpu_sched = GetCurrentCpuSched();
  auto* current = GetCurrentTask();
  assert(current != nullptr && "Exit: No current task to exit");
  assert(current->GetStatus() == TaskStatus::kRunning &&
         "Exit: current task status must be kRunning");
 
  {
    LockGuard<SpinLock> lock_guard(cpu_sched.lock);
 
    // 设置退出码
    current->aux->exit_code = exit_code;
 
    // 检查是否是线程组的主线程
    bool is_group_leader = current->IsThreadGroupLeader();
 
    // 如果是线程组的主线程，需要检查是否还有其他线程
    if (is_group_leader && current->GetThreadGroupSize() > 1) {
      klog::Warn(
          "Exit: Thread group leader (pid={}, tgid={}) exiting, but group "
          "still has {} threads",
          current->pid, current->aux->tgid, current->GetThreadGroupSize());
    }
 
    // 从线程组中移除
    current->LeaveThreadGroup();
 
    // 将子进程过继给 init 进程 (仅当是进程时)
    if (is_group_leader) {
      ReparentChildren(current);
    }
 
    if (current->aux->parent_pid != 0) {
      // 有父进程，进入僵尸状态等待回收
      // Transition: kRunning -> kZombie
      current->fsm.Receive(MsgExit{exit_code, true});
 
      // 唤醒等待此进程退出的父进程
      // 父进程会阻塞在 ChildExit 类型的资源上，数据是父进程自己的 PID
      auto wait_resource_id =
          ResourceId(ResourceType::kChildExit, current->aux->parent_pid);
      Wakeup(wait_resource_id);
 
 
      klog::Debug("Exit: pid={} waking up parent={} on resource={}",
                  current->pid, current->aux->parent_pid,
                  wait_resource_id.GetTypeName());
    } else {
      // 没有父进程，直接退出并释放资源
      // Transition: kRunning -> kExited
      current->fsm.Receive(MsgExit{exit_code, false});
      // No parent to call wait(), reap immediately to free TCB + stack
      ReapTask(current);
    }
  }
 
  Schedule();
 
  klog::Err("Exit: Task {} should not return from Schedule()", current->pid);
 
  // UNREACHABLE: 任务退出后 Schedule() 不应返回
  __builtin_unreachable();
}

Here is the call graph for this function:

FindTask()

auto TaskManager::FindTask

(

Pid

pid

)

-> TaskControlBlock*

按 PID 查找任务

Parameters

pid

进程 ID

Returns

TaskControlBlock* 找到的任务，未找到返回 nullptr

Definition at line 175 of file task_manager.cpp.

                                                       {
  LockGuard lock_guard{task_table_lock_};
  auto it = task_table_.find(pid);
  return (it != task_table_.end()) ? it->second.get() : nullptr;
}

GetCurrentCpuSched()

auto TaskManager::GetCurrentCpuSched ( ) -> CpuSchedData&

inlineprivate

获取当前核心的调度数据

Returns

CpuSchedData& 当前核心的调度数据引用

Definition at line 264 of file task_manager.hpp.

                                                           {
    return cpu_schedulers_[cpu_io::GetCurrentCoreId()];
  }

Here is the call graph for this function:

GetCurrentTask()

auto TaskManager::GetCurrentTask ( ) const -> TaskControlBlock*

inline

获取当前任务

Returns

TaskControlBlock* 当前正在运行的任务

Definition at line 116 of file task_manager.hpp.

                                                                 {
    return per_cpu::GetCurrentCore().running_task;
  }

Here is the call graph for this function:

GetThreadGroup()

auto TaskManager::GetThreadGroup ( Pid  tgid ) -> etl::vector<TaskControlBlock*, kernel::config::kMaxReadyTasks>

private

获取线程组的所有线程

Parameters

tgid

线程组 ID

Returns

etl::vector<TaskControlBlock*, kernel::config::kMaxReadyTasks> 线程组中的所有线程

Definition at line 234 of file task_manager.cpp.

                                                                {
  etl::vector<TaskControlBlock*, kernel::config::kMaxReadyTasks> result;
 
  LockGuard lock_guard(task_table_lock_);
 
  // 遍历任务表，找到所有 tgid 匹配的线程
  for (auto& [pid, task] : task_table_) {
    if (task && task->aux->tgid == tgid) {
      result.push_back(task.get());
    }
  }
 
  return result;
}

InitCurrentCore()

auto TaskManager::InitCurrentCore

(

)

-> void

初始化 per cpu 的调度数据，创建 idle 线程

Definition at line 39 of file task_manager.cpp.

                                          {
  auto core_id = cpu_io::GetCurrentCoreId();
  auto& cpu_sched = cpu_schedulers_[core_id];
 
  LockGuard lock_guard{cpu_sched.lock};
 
  if (!cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kNormal)]) {
    cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kRealTime)] =
        kstd::make_unique<FifoScheduler>();
    cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kNormal)] =
        kstd::make_unique<RoundRobinScheduler>();
    cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kIdle)] =
        kstd::make_unique<IdleScheduler>();
  }
 
  // 关联 PerCpu
  auto& cpu_data = per_cpu::GetCurrentCore();
  cpu_data.sched_data = &cpu_sched;
 
  // 创建 boot 任务作为当前执行上下文的占位符
  // 首次 Schedule():
  // current(boot_task) != next(idle_task) -> switch_to -> idle_thread
  auto boot_task_ptr = kstd::make_unique<TaskControlBlock>(
      "Boot",
      std::numeric_limits<
          decltype(TaskControlBlock::SchedInfo::priority)>::max(),
      nullptr, nullptr);
  auto* boot_task = boot_task_ptr.release();
  // kUnInit -> kReady
  boot_task->fsm.Receive(MsgSchedule{});
  // kReady -> kRunning
  boot_task->fsm.Receive(MsgSchedule{});
  boot_task->policy = SchedPolicy::kIdle;
  cpu_data.running_task = boot_task;
 
  // 创建独立的 Idle 线程
  auto idle_task_ptr = kstd::make_unique<TaskControlBlock>(
      "Idle",
      std::numeric_limits<
          decltype(TaskControlBlock::SchedInfo::priority)>::max(),
      IdleThread, nullptr);
  auto* idle_task = idle_task_ptr.release();
  // kUnInit -> kReady
  idle_task->fsm.Receive(MsgSchedule{});
  idle_task->policy = SchedPolicy::kIdle;
 
  // 将 idle 任务加入 Idle 调度器
  if (cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kIdle)]) {
    cpu_sched.schedulers[static_cast<uint8_t>(SchedPolicy::kIdle)]->Enqueue(
        idle_task);
  }
 
  cpu_data.idle_task = idle_task;
}

Here is the call graph for this function:

operator=() [1/2]

auto TaskManager::operator= ( const TaskManager &  ) -> TaskManager &=delete

delete

operator=() [2/2]

auto TaskManager::operator= ( TaskManager &&  ) -> TaskManager &=delete

delete

ReapTask()

auto TaskManager::ReapTask ( TaskControlBlock *  task ) -> void

private

回收僵尸进程资源

Parameters

task	要回收的任务 (必须处于 kZombie 状态)

Note

释放内核栈、页表、TCB，回收 PID

Definition at line 186 of file task_manager.cpp.

                                                         {
  if (!task) {
    return;
  }
 
  // 确保任务处于僵尸或退出状态
  if (task->GetStatus() != TaskStatus::kZombie &&
      task->GetStatus() != TaskStatus::kExited) {
    klog::Warn("ReapTask: Task {} is not in zombie/exited state", task->pid);
    return;
  }
 
  // Capture pid before erase (unique_ptr deletes on erase)
  Pid pid = task->pid;
 
  // 从全局任务表中移除 (unique_ptr auto-deletes TCB)
  {
    LockGuard lock_guard{task_table_lock_};
    task_table_.erase(pid);
  }
 
  klog::Debug("ReapTask: Task {} resources freed", pid);
}

Here is the call graph for this function:

ReparentChildren()

auto TaskManager::ReparentChildren ( TaskControlBlock *  parent ) -> void

private

将孤儿进程过继给 init 进程

Parameters

parent

退出的父进程

Note

在父进程退出时调用，防止子进程变成僵尸无人回收

Todo:

当前的 pid 是自增的，需要考虑多核情况

Todo:

实现向 init 进程发送 SIGCHLD 信号

Definition at line 210 of file task_manager.cpp.

                                                                   {
  if (!parent) {
    return;
  }
 
  // init 进程的 PID 通常是 1
  static constexpr Pid kInitPid = 1;
 
  LockGuard lock_guard{task_table_lock_};
 
  // 遍历所有任务，找到父进程是当前任务的子进程
  for (auto& [pid, task] : task_table_) {
    if (task && task->aux->parent_pid == parent->pid) {
      // 将子进程过继给 init 进程
      task->aux->parent_pid = kInitPid;
      klog::Debug("ReparentChildren: Task {} reparented to init (PID {})",
                  task->pid, kInitPid);
      // 如果子进程已经是僵尸状态，通知 init 进程回收
    }
  }
}

Here is the call graph for this function:

Schedule()

auto TaskManager::Schedule

(

)

-> void

调度函数 选择下一个任务并切换上下文

Note

被调用意味着需要调度决策，可能是 时间片耗尽（TickUpdate 检测到需要抢占） 主动让出 CPU (yield) 任务阻塞、睡眠或退出

Copyright

Copyright The SimpleKernel Contributors

Definition at line 26 of file schedule.cpp.

                                   {
  auto& cpu_sched = GetCurrentCpuSched();
  cpu_sched.scheduler_started = true;
  cpu_sched.lock.Lock().or_else([](auto&& err) {
    klog::Err("Schedule: Failed to acquire lock: {}", err.message());
    while (true) {
      cpu_io::Pause();
    }
    return Expected<void>{};
  });
 
  auto* current = GetCurrentTask();
  assert(current != nullptr && "Schedule: No current task to schedule");
 
  // 处理当前任务状态
  if (current->GetStatus() == TaskStatus::kRunning) {
    // 将当前任务标记为就绪并重新入队（如果它还能运行）
    current->fsm.Receive(MsgYield{});
    auto* scheduler =
        cpu_sched.schedulers[static_cast<uint8_t>(current->policy)].get();
 
    if (scheduler) {
      scheduler->OnPreempted(current);
      // 调度器决定如何处理被抢占的任务
      // 大多数情况下需要重新入队，除非是特殊策略
      if (scheduler->OnTimeSliceExpired(current)) {
        scheduler->Enqueue(current);
      }
    }
  }
 
  // 选择下一个任务 (按策略优先级: RealTime > Normal > Idle)
  TaskControlBlock* next = nullptr;
  for (auto& scheduler : cpu_sched.schedulers) {
    if (scheduler && !scheduler->IsEmpty()) {
      next = scheduler->PickNext();
      if (next) {
        break;
      }
    }
  }
 
  // 如果没有任务可运行
  if (!next) {
    // 如果当前任务仍然可以运行，继续运行它
    if (current->GetStatus() == TaskStatus::kReady) {
      next = current;
    } else {
      // 否则统计空闲时间并返回
      cpu_sched.idle_time++;
      cpu_sched.lock.UnLock().or_else([](auto&& err) {
        klog::Err("Schedule: Failed to release lock: {}", err.message());
        while (true) {
          cpu_io::Pause();
        }
        return Expected<void>{};
      });
      return;
    }
  }
 
  // 切换到下一个任务
  assert(next != nullptr && "Schedule: next task must not be null");
  assert((next->GetStatus() == TaskStatus::kReady ||
          next->policy == SchedPolicy::kIdle) &&
         "Schedule: next task must be kReady or kIdle policy");
 
  next->fsm.Receive(MsgSchedule{});
  // 重置时间片（对于 RR 和 FIFO 有效，CFS 使用 vruntime 不依赖此字段）
  next->sched_info.time_slice_remaining = next->sched_info.time_slice_default;
  next->sched_info.context_switches++;
  cpu_sched.total_schedules++;
 
  // 调用调度器钩子
  auto* scheduler =
      cpu_sched.schedulers[static_cast<uint8_t>(next->policy)].get();
  if (scheduler) {
    scheduler->OnScheduled(next);
  }
 
  // 更新 per-CPU running_task
  per_cpu::GetCurrentCore().running_task = next;
 
  cpu_sched.lock.UnLock().or_else([](auto&& err) {
    klog::Err("Schedule: Failed to release lock: {}", err.message());
    while (true) {
      cpu_io::Pause();
    }
    return Expected<void>{};
  });
 
  // 上下文切换
  if (current != next) {
    switch_to(&current->task_context, &next->task_context);
  }
}

Here is the call graph for this function:

SignalThreadGroup()

auto TaskManager::SignalThreadGroup ( Pid  tgid, int  signal  ) -> void

private

向线程组中的所有线程发送信号

Parameters

tgid	线程组 ID
signal	信号编号

Note

暂未实现信号机制，预留接口

Todo:

实现信号机制后，向线程组中的所有线程发送信号

Definition at line 250 of file task_manager.cpp.

                                                                {
  klog::Debug("SignalThreadGroup: tgid={}, signal={} (not implemented)", tgid,
              signal);
 
  // 预期实现：
  // auto threads = GetThreadGroup(tgid);
  // for (auto* thread : threads) {
  //   SendSignal(thread, signal);
  // }
}

Here is the call graph for this function:

Sleep()

auto TaskManager::Sleep

(

uint64_t

ms

)

-> void

线程睡眠

Parameters

ms

睡眠毫秒数

Definition at line 14 of file sleep.cpp.

                                           {
  auto& cpu_sched = GetCurrentCpuSched();
 
  auto* current = GetCurrentTask();
  assert(current != nullptr && "Sleep: No current task to sleep");
  assert(current->GetStatus() == TaskStatus::kRunning &&
         "Sleep: current task status must be kRunning");
 
  // 如果睡眠时间为 0，仅让出 CPU（相当于 yield）
  if (ms == 0) {
    Schedule();
    return;
  }
 
  {
    LockGuard<SpinLock> lock_guard(cpu_sched.lock);
 
    // 计算唤醒时间 (当前 tick + 睡眠时间)
    uint64_t sleep_ticks = (ms * SIMPLEKERNEL_TICK) / kMillisecondsPerSecond;
    current->sched_info.wake_tick = cpu_sched.local_tick + sleep_ticks;
 
    // Check capacity before transitioning FSM
 
    // 将任务加入睡眠队列（优先队列会自动按 wake_tick 排序）
    if (cpu_sched.sleeping_tasks.full()) {
      klog::Err("Sleep: sleeping_tasks full, cannot sleep task {}",
                current->pid);
      return;
    }
    current->fsm.Receive(MsgSleep{current->sched_info.wake_tick});
    cpu_sched.sleeping_tasks.push(current);
  }
 
  // 调度到其他任务
  Schedule();
 
  // 任务被唤醒后会从这里继续执行
}

Here is the call graph for this function:

TickUpdate()

auto TaskManager::TickUpdate

(

)

-> void

更新系统 tick

Copyright

Copyright The SimpleKernel Contributors

Definition at line 9 of file tick_update.cpp.

                                     {
  auto& cpu_sched = GetCurrentCpuSched();
 
  bool need_preempt = false;
 
  {
    LockGuard<SpinLock> lock_guard(cpu_sched.lock);
 
    // 递增本核心的 tick 计数
    cpu_sched.local_tick++;
 
    auto* current = GetCurrentTask();
 
    // 唤醒睡眠队列中到时间的任务
    while (!cpu_sched.sleeping_tasks.empty()) {
      auto* task = cpu_sched.sleeping_tasks.top();
 
      // 检查是否到达唤醒时间
      if (task->sched_info.wake_tick > cpu_sched.local_tick) {
        // sleeping_tasks 是一个 priority_queue，只需要检查队首元素
        break;
      }
 
      // 唤醒任务
      cpu_sched.sleeping_tasks.pop();
      task->fsm.Receive(MsgWakeup{});
 
      // 将任务重新加入对应调度器的就绪队列
      auto* scheduler =
          cpu_sched.schedulers[static_cast<uint8_t>(task->policy)].get();
      if (scheduler) {
        scheduler->Enqueue(task);
      }
    }
 
    // 更新当前任务的统计信息
    if (current && current->GetStatus() == TaskStatus::kRunning) {
      // 更新总运行时间
      current->sched_info.total_runtime++;
 
      // 减少剩余时间片
      if (current->sched_info.time_slice_remaining > 0) {
        current->sched_info.time_slice_remaining--;
      }
 
      // 调用调度器的 OnTick，检查是否需要抢占
      auto* scheduler =
          cpu_sched.schedulers[static_cast<uint8_t>(current->policy)].get();
 
      if (scheduler) {
        // 调度器可能基于自己的策略决定是否抢占
        need_preempt = scheduler->OnTick(current);
      }
 
      // 检查时间片是否耗尽（对于基于时间片的调度器）
      if (!need_preempt && current->sched_info.time_slice_remaining == 0) {
        need_preempt = true;
      }
    }
  }
 
  if (need_preempt && cpu_sched.scheduler_started) {
    Schedule();
  }
}

Wait()

auto TaskManager::Wait	(	Pid	pid,
		int *	status,
		bool	no_hang = false,
		bool	untraced = false
	)		-> Expected<Pid>

等待子进程退出

Parameters

pid	子进程 PID (-1 表示任意子进程，0 表示同组，>0 表示指定进程)
status	退出状态存储位置 (可为 nullptr)
no_hang	非阻塞等待，立即返回 (类似 WNOHANG)
untraced	报告已停止的子进程 (类似 WUNTRACED)

Returns

Expected<Pid> 成功返回子进程 PID，无子进程或被中断返回错误

Copyright

Copyright The SimpleKernel Contributors

Definition at line 13 of file wait.cpp.

                     {
  auto* current = GetCurrentTask();
  assert(current != nullptr && "Wait: No current task");
  assert(current->GetStatus() == TaskStatus::kRunning &&
         "Wait: current task status must be kRunning");
 
  while (true) {
    TaskControlBlock* target = nullptr;
 
    {
      LockGuard lock_guard(task_table_lock_);
 
      // 遍历任务表寻找符合条件的子进程
      for (auto& [task_pid, task] : task_table_) {
        // 检查是否是当前进程的子进程
        bool is_child = (task->aux->parent_pid == current->pid);
 
        // 检查 PID 匹配条件
        bool pid_match = false;
        if (pid == static_cast<Pid>(-1)) {
          // 等待任意子进程
          pid_match = is_child;
        } else if (pid == 0) {
          // 等待同进程组的任意子进程
          pid_match = is_child && (task->aux->pgid == current->aux->pgid);
        } else if (pid > 0) {
          // 等待指定 PID 的子进程
          pid_match = is_child && (task->pid == pid);
        } else {
          // pid < -1: 等待进程组 ID 为 |pid| 的任意子进程
          pid_match = is_child && (task->aux->pgid == static_cast<Pid>(-pid));
        }
 
        if (!pid_match) {
          continue;
        }
 
        // 检查任务状态
        if (task->GetStatus() == TaskStatus::kZombie ||
            task->GetStatus() == TaskStatus::kExited) {
          target = task.get();
          break;
        }
 
        // untraced: 报告已停止的子进程
        if (untraced && task->GetStatus() == TaskStatus::kBlocked) {
          if (status) {
            // 表示停止状态
            *status = 0;
          }
          return task->pid;
        }
      }
    }
 
    // 找到了退出的子进程
    if (target) {
      assert((target->GetStatus() == TaskStatus::kZombie ||
              target->GetStatus() == TaskStatus::kExited) &&
             "Wait: target task must be kZombie or kExited");
      assert(target->aux->parent_pid == current->pid &&
             "Wait: target parent_pid must match current pid");
 
      Pid result_pid = target->pid;
 
      // 返回退出状态
      if (status) {
        *status = target->aux->exit_code;
      }
 
      // 清理僵尸进程
      {
        LockGuard lock_guard(task_table_lock_);
        auto it = task_table_.find(target->pid);
        assert(it != task_table_.end() &&
               "Wait: target must exist in task_table");
        task_table_.erase(it->first);
      }
 
      klog::Debug("Wait: pid={} reaped child={}", current->pid, result_pid);
      return result_pid;
    }
 
    // 如果设置了 no_hang，立即返回
    if (no_hang) {
      return 0;
    }
 
    // 没有找到符合条件的子进程，阻塞等待
    // 使用 ChildExit 类型的资源 ID，数据部分是当前进程的 PID
    auto wait_resource_id = ResourceId(ResourceType::kChildExit, current->pid);
 
    Block(wait_resource_id);
 
    klog::Debug("Wait: pid={} blocked on resource={}, data={}", current->pid,
                wait_resource_id.GetTypeName(),
                static_cast<uint64_t>(wait_resource_id.GetData()));
    // 被唤醒后重新检查
  }
}

Here is the call graph for this function:

Wakeup()

auto TaskManager::Wakeup

(

ResourceId

resource_id

)

-> void

唤醒等待指定资源的所有任务

Parameters

resource_id

资源 ID

Note

会唤醒所有阻塞在此资源上的任务

Copyright

Copyright The SimpleKernel Contributors

Definition at line 12 of file wakeup.cpp.

                                                       {
  auto& cpu_sched = GetCurrentCpuSched();
 
  LockGuard<SpinLock> lock_guard(cpu_sched.lock);
 
  // 查找等待该资源的任务列表
  auto it = cpu_sched.blocked_tasks.find(resource_id);
 
  if (it == cpu_sched.blocked_tasks.end()) {
    // 没有任务等待该资源
    klog::Debug("Wakeup: No tasks waiting on resource={}, data={:#x}",
                resource_id.GetTypeName(),
                static_cast<uint64_t>(resource_id.GetData()));
    return;
  }
 
  // 唤醒所有等待该资源的任务
  auto& waiting_tasks = it->second;
  size_t wakeup_count = 0;
 
  while (!waiting_tasks.empty()) {
    auto* task = waiting_tasks.front();
    waiting_tasks.pop_front();
 
    assert(task->GetStatus() == TaskStatus::kBlocked &&
           "Wakeup: task status must be kBlocked");
    assert(task->aux->blocked_on == resource_id &&
           "Wakeup: task blocked_on must match resource_id");
 
    // 将任务标记为就绪
    task->fsm.Receive(MsgWakeup{});
    task->aux->blocked_on = ResourceId{};
 
    // 将任务重新加入对应调度器的就绪队列
    auto* scheduler =
        cpu_sched.schedulers[static_cast<uint8_t>(task->policy)].get();
    assert(scheduler != nullptr && "Wakeup: scheduler must not be null");
    scheduler->Enqueue(task);
    wakeup_count++;
  }
 
  // 移除空的资源队列
  cpu_sched.blocked_tasks.erase(resource_id);
 
  klog::Debug("Wakeup: Woke up {} tasks from resource={}, data={:#x}",
              wakeup_count, resource_id.GetTypeName(),
              static_cast<uint64_t>(resource_id.GetData()));
}

Here is the call graph for this function:

Member Data Documentation

cpu_schedulers_

std::array<CpuSchedData, SIMPLEKERNEL_MAX_CORE_COUNT> TaskManager::cpu_schedulers_ {}

private

每个核心的调度数据

Definition at line 224 of file task_manager.hpp.

{};

interrupt_threads_

etl::unordered_map<uint64_t, TaskControlBlock*, kernel::config::kMaxInterruptThreads, kernel::config::kMaxInterruptThreadsBuckets> TaskManager::interrupt_threads_

private

中断号 -> 中断线程映射

Definition at line 239 of file task_manager.hpp.

interrupt_threads_lock_

SpinLock TaskManager::interrupt_threads_lock_ {"interrupt_threads_lock"}

private

中断线程相关数据保护锁

Definition at line 234 of file task_manager.hpp.

{"interrupt_threads_lock"};

interrupt_work_queues_

etl::unordered_map<uint64_t, InterruptWorkQueue*, kernel::config::kMaxInterruptThreads, kernel::config::kMaxInterruptThreadsBuckets> TaskManager::interrupt_work_queues_

private

中断号 -> 工作队列映射

Definition at line 244 of file task_manager.hpp.

kInterruptQueueCapacity

constexpr size_t TaskManager::kInterruptQueueCapacity = 256

staticconstexprprivate

中断工作队列容量

Definition at line 200 of file task_manager.hpp.

pid_allocator_

std::atomic<size_t> TaskManager::pid_allocator_ {1}

private

PID 分配器

Definition at line 247 of file task_manager.hpp.

{1};

task_table_

etl::unordered_map<Pid, etl::unique_ptr<TaskControlBlock>, kernel::config::kMaxTasks, kernel::config::kMaxTasksBuckets> TaskManager::task_table_

private

Definition at line 231 of file task_manager.hpp.

task_table_lock_

SpinLock TaskManager::task_table_lock_ {"task_table_lock"}

private

全局任务表 (PID -> TCB 映射)

Definition at line 227 of file task_manager.hpp.

{"task_table_lock"};

---

The documentation for this class was generated from the following files:

• /workspaces/SimpleKernel/src/task/include/task_manager.hpp
• /workspaces/SimpleKernel/src/task/block.cpp
• /workspaces/SimpleKernel/src/task/clone.cpp
• /workspaces/SimpleKernel/src/task/exit.cpp
• /workspaces/SimpleKernel/src/task/schedule.cpp
• /workspaces/SimpleKernel/src/task/sleep.cpp
• /workspaces/SimpleKernel/src/task/task_manager.cpp
• /workspaces/SimpleKernel/src/task/tick_update.cpp
• /workspaces/SimpleKernel/src/task/wait.cpp
• /workspaces/SimpleKernel/src/task/wakeup.cpp