syscall.cpp File Reference

#include "syscall.hpp"
#include "kernel.h"
#include "kernel_log.hpp"
#include "spinlock.hpp"
#include "task_manager.hpp"

Include dependency graph for syscall.cpp:

Go to the source code of this file.

Functions
auto	syscall_dispatcher (int64_t syscall_id, uint64_t args[6]) -> int
auto	sys_write (int fd, const char *buf, size_t len) -> int
	向文件描述符写入数据
auto	sys_exit (int code) -> int
	退出当前进程或线程
auto	sys_yield () -> int
	主动放弃CPU，让出时间片
auto	sys_sleep (uint64_t ms) -> int
	休眠指定毫秒数
auto	sys_clone (uint64_t flags, void *stack, int *parent_tid, int *child_tid, void *tls) -> int
	创建新线程（或进程）
auto	sys_fork () -> int
	创建新进程（fork）
auto	sys_gettid () -> int
	获取当前线程ID
auto	sys_set_tid_address (int *tidptr) -> int
	设置线程ID地址（用于线程退出时的清理）
auto	sys_futex (int *uaddr, int op, int val, const void *timeout, int *uaddr2, int val3) -> int
	快速用户空间互斥锁操作（futex）
auto	sys_sched_getaffinity (int pid, size_t cpusetsize, uint64_t *mask) -> int
	获取线程的CPU亲和性
auto	sys_sched_setaffinity (int pid, size_t cpusetsize, const uint64_t *mask) -> int
	设置线程的CPU亲和性

Function Documentation

sys_clone()

auto sys_clone	(	uint64_t	flags,
		void *	stack,
		int *	parent_tid,
		int *	child_tid,
		void *	tls
	)		-> int

创建新线程（或进程）

Parameters

flags	克隆标志（CLONE_VM、CLONE_THREAD、CLONE_SIGHAND 等）
stack	新线程的栈指针（用户空间）
parent_tid	父线程TID存储地址（可选）
child_tid	子线程TID存储地址（可选）
tls	线程本地存储指针

Returns

成功返回新线程TID，失败返回负数

Note

使用场景：

• pthread_create 底层实现
• fork() 实现（不带 CLONE_VM）

• 创建轻量级线程

  flags 常用组合：

  • CLONE_VM | CLONE_THREAD | CLONE_SIGHAND: 创建共享地址空间的线程
  • 0: 创建独立进程（类似 fork）

Definition at line 95 of file syscall.cpp.

                                                               {
  auto& task_manager = TaskManagerSingleton::instance();
  auto current = task_manager.GetCurrentTask();
 
  if (!current || !current->trap_context_ptr) {
    klog::Err("[Syscall] sys_clone: Invalid current task or trap context");
    return -1;
  }
 
  // 调用 TaskManager 的 Clone 方法
  auto result = task_manager.Clone(flags, stack, parent_tid, child_tid, tls,
                                   *current->trap_context_ptr);
 
  if (!result.has_value()) {
    // 失败返回 -1
    klog::Err("[Syscall] sys_clone failed: {}", result.error().message());
    return -1;
  }
 
  Pid child_pid = result.value();
  if (child_pid == 0) {
    // 子进程/线程返回 0
    return 0;
  } else {
    // 父进程返回子进程 PID
    return static_cast<int>(child_pid);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_exit()

auto sys_exit

(

int

code

)

-> int

退出当前进程或线程

Parameters

code

退出码

Returns

不返回

Note

使用场景：

• 进程正常/异常终止

• 线程退出（clone 创建的线程调用时只退出当前线程）

  行为取决于线程创建方式：

  • 普通进程：退出整个进程
  • CLONE_THREAD 线程：仅退出当前线程

Definition at line 75 of file syscall.cpp.

                               {
  klog::Info("[Syscall] Process {} exited with code {}",
             TaskManagerSingleton::instance().GetCurrentTask()->pid, code);
  // 调用 TaskManager 的 Exit 方法处理线程退出
  TaskManagerSingleton::instance().Exit(code);
  // 不会执行到这里，因为 Exit 会触发调度切换
  klog::Err("[Syscall] sys_exit should not return!");
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_fork()

auto sys_fork

(

)

-> int

创建新进程（fork）

Returns

父进程返回子进程 PID，子进程返回 0，失败返回 -1

Note

使用场景：

• 进程创建

• 完全复制父进程的地址空间和资源

  fork 创建的子进程：

  • 拥有独立的地址空间（页表被复制）
  • 拥有独立的进程 ID (PID)
  • 继承父进程的文件描述符、信号处理器等
  • 父子进程独立运行，互不影响

Definition at line 125 of file syscall.cpp.

                                     {
  auto& task_manager = TaskManagerSingleton::instance();
  auto current = task_manager.GetCurrentTask();
 
  if (!current || !current->trap_context_ptr) {
    klog::Err("[Syscall] sys_fork: Invalid current task or trap context");
    return -1;
  }
 
  // fork = clone with flags=0 (完全复制，不共享任何资源)
  auto result = task_manager.Clone(0, nullptr, nullptr, nullptr, nullptr,
                                   *current->trap_context_ptr);
 
  if (!result.has_value()) {
    // 失败返回 -1
    klog::Err("[Syscall] sys_fork failed: {}", result.error().message());
    return -1;
  }
 
  Pid child_pid = result.value();
  if (child_pid == 0) {
    // 子进程返回 0
    return 0;
  } else {
    // 父进程返回子进程 PID
    return static_cast<int>(child_pid);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_futex()

auto sys_futex	(	int *	uaddr,
		int	op,
		int	val,
		const void *	timeout,
		int *	uaddr2,
		int	val3
	)		-> int

快速用户空间互斥锁操作（futex）

Parameters

uaddr	用户空间的futex地址
op	操作类型（FUTEX_WAIT、FUTEX_WAKE 等）
val	操作参数
timeout	超时时间（可选）
uaddr2	第二个futex地址（部分操作使用）
val3	第三个参数（部分操作使用）

Returns

依操作类型而定，失败返回负数

Note

使用场景：

• 实现互斥锁（mutex）
• 实现条件变量（condition variable）
• 实现读写锁（rwlock）
• 实现信号量（semaphore）
• 实现 pthread_join（等待线程退出）

• 实现 pthread_detach（线程状态管理）

  常用操作：

  • FUTEX_WAIT: 等待futex值变化
  • FUTEX_WAKE: 唤醒等待的线程
  • FUTEX_REQUEUE: 重新排队等待的线程

Todo:

应该返回实际唤醒的线程数

Todo:

实现 FUTEX_REQUEUE

Definition at line 178 of file syscall.cpp.

                                                               {
  // Futex 常量定义
  static constexpr int kFutexWait = 0;
  static constexpr int kFutexWake = 1;
  static constexpr int kFutexRequeue = 3;
 
  // 提取操作类型（低位）
  int cmd = op & 0x7F;
 
  auto& task_manager = TaskManagerSingleton::instance();
 
  switch (cmd) {
    case kFutexWait: {
      klog::Debug("[Syscall] FUTEX_WAIT on {:#x} (val={})",
                  static_cast<uint64_t>(reinterpret_cast<uintptr_t>(uaddr)),
                  val);
 
      ResourceId futex_id(ResourceType::kFutex,
                          reinterpret_cast<uintptr_t>(uaddr));
      {
        LockGuard<SpinLock> guard(futex_lock_);
        if (*uaddr != val) {
          return 0;
        }
      }
      // futex_lock_ released before Block() — SpinLock must NOT be held
      // across context switch boundaries (Block → Schedule → switch_to).
      // A narrow race exists: FUTEX_WAKE between lock release and Block()
      // can miss this thread. Production kernels solve this with a two-phase
      // API (add-to-waitqueue under lock, schedule after release). This is
      // still far safer than the original completely-unprotected check.
      task_manager.Block(futex_id);
      return 0;
    }
 
    case kFutexWake: {
      klog::Debug("[Syscall] FUTEX_WAKE on {:#x} (count={})",
                  static_cast<uint64_t>(reinterpret_cast<uintptr_t>(uaddr)),
                  val);
 
      ResourceId futex_id(ResourceType::kFutex,
                          reinterpret_cast<uintptr_t>(uaddr));
      {
        LockGuard<SpinLock> guard(futex_lock_);
        task_manager.Wakeup(futex_id);
      }
 
      return val;
    }
 
    case kFutexRequeue: {
      // 将等待 uaddr 的线程重新排队到 uaddr2
      klog::Warn("[Syscall] FUTEX_REQUEUE not implemented");
      return -1;
    }
 
    default:
      klog::Err("[Syscall] Unknown futex operation: {}", cmd);
      return -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_gettid()

auto sys_gettid

(

)

-> int

获取当前线程ID

Returns

当前线程的TID

Note

使用场景：

• 线程标识
• 调试信息输出
• 线程本地数据索引

Definition at line 154 of file syscall.cpp.

                                       {
  auto current = TaskManagerSingleton::instance().GetCurrentTask();
  if (!current) {
    klog::Err("[Syscall] sys_gettid: No current task");
    return -1;
  }
  return static_cast<int>(current->pid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_sched_getaffinity()

auto sys_sched_getaffinity	(	int	pid,
		size_t	cpusetsize,
		uint64_t *	mask
	)		-> int

获取线程的CPU亲和性

Parameters

pid	线程ID（0 表示当前线程）
cpusetsize	CPU集合大小
mask	CPU亲和性掩码

Returns

成功返回 0，失败返回负数

Definition at line 245 of file syscall.cpp.

                                                                {
  auto& task_manager = TaskManagerSingleton::instance();
 
  TaskControlBlock* target;
  if (pid == 0) {
    // pid=0 表示当前线程
    target = task_manager.GetCurrentTask();
  } else {
    // 查找指定 PID 的任务
    target = task_manager.FindTask(static_cast<Pid>(pid));
    if (!target) {
      klog::Err("[Syscall] sys_sched_getaffinity: Task {} not found", pid);
      return -1;
    }
  }
 
  if (!target) {
    return -1;
  }
 
  // 简单实现：将 cpu_affinity 复制到用户空间
  if (cpusetsize < sizeof(uint64_t)) {
    return -1;
  }
 
  *mask = target->aux->cpu_affinity;
  return 0;
}

Here is the call graph for this function:

sys_sched_setaffinity()

auto sys_sched_setaffinity	(	int	pid,
		size_t	cpusetsize,
		const uint64_t *	mask
	)		-> int

设置线程的CPU亲和性

Parameters

pid	线程ID（0 表示当前线程）
cpusetsize	CPU集合大小
mask	CPU亲和性掩码

Returns

成功返回 0，失败返回负数

Note

使用场景：

• CPU绑定优化
• 实时任务调度
• NUMA优化

Todo:

如果当前任务不在允许的 CPU 上运行，应该触发迁移

Definition at line 275 of file syscall.cpp.

                                                                      {
  auto& task_manager = TaskManagerSingleton::instance();
 
  TaskControlBlock* target;
  if (pid == 0) {
    target = task_manager.GetCurrentTask();
  } else {
    // 查找指定 PID 的任务
    target = task_manager.FindTask(static_cast<Pid>(pid));
    if (!target) {
      klog::Err("[Syscall] sys_sched_setaffinity: Task {} not found", pid);
      return -1;
    }
  }
 
  if (!target) {
    return -1;
  }
 
  // 简单实现：更新 cpu_affinity
  if (cpusetsize < sizeof(uint64_t)) {
    return -1;
  }
 
  target->aux->cpu_affinity = *mask;
 
  klog::Debug("[Syscall] Set CPU affinity for task {} to {:#x}", target->pid,
              *mask);
 
 
  return 0;
}

Here is the call graph for this function:

sys_set_tid_address()

auto sys_set_tid_address

(

int *

tidptr

)

-> int

设置线程ID地址（用于线程退出时的清理）

Parameters

tidptr

线程ID存储地址

Returns

成功返回0，失败返回负数

Note

使用场景：

• 线程库内部使用
• 实现线程退出时的通知机制

Todo:

需要在 TaskControlBlock 中添加字段保存 tidptr

Definition at line 163 of file syscall.cpp.

                                                                            {
  auto current = TaskManagerSingleton::instance().GetCurrentTask();
  if (!current) {
    klog::Err("[Syscall] sys_set_tid_address: No current task");
    return -1;
  }
 
  // 保存 tidptr，在线程退出时会清零该地址并执行 futex wake
  // current->clear_child_tid = tidptr;
 
  // 返回当前线程的 TID
  return static_cast<int>(current->pid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_sleep()

auto sys_sleep

(

uint64_t

ms

)

-> int

休眠指定毫秒数

Parameters

ms

休眠时长（毫秒）

Returns

0 表示成功

Note

使用场景：定时任务、延迟执行

Definition at line 90 of file syscall.cpp.

                                                 {
  TaskManagerSingleton::instance().Sleep(ms);
  return 0;
}

Here is the caller graph for this function:

sys_write()

auto sys_write	(	int	fd,
		const char *	buf,
		size_t	len
	)		-> int

向文件描述符写入数据

Parameters

fd	文件描述符
buf	数据缓冲区
len	数据长度

Returns

成功写入的字节数，失败返回负数

Note

使用场景：标准输出、日志输出等

Todo:

应该检查 buf 是否在用户空间合法范围内

Definition at line 63 of file syscall.cpp.

                                                                         {
  // 简单实现：仅支持向标准输出(1)和错误输出(2)打印
  if (fd == 1 || fd == 2) {
    for (size_t i = 0; i < len; ++i) {
      etl_putchar(buf[i]);
    }
    return static_cast<int>(len);
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sys_yield()

auto sys_yield

(

)

-> int

主动放弃CPU，让出时间片

Returns

0 表示成功

Note

使用场景：协作式调度、忙等待优化

Definition at line 85 of file syscall.cpp.

                                      {
  TaskManagerSingleton::instance().Schedule();
  return 0;
}

Here is the caller graph for this function:

syscall_dispatcher()

auto syscall_dispatcher	(	int64_t	syscall_id,
		uint64_t	args[6]
	)		-> int

Definition at line 17 of file syscall.cpp.

                                                                     {
  int64_t ret = 0;
  switch (syscall_id) {
    case kSyscallWrite:
      ret = sys_write(static_cast<int>(args[0]),
                      reinterpret_cast<const char*>(args[1]),
                      static_cast<size_t>(args[2]));
      break;
    case kSyscallExit:
      ret = sys_exit(static_cast<int>(args[0]));
      break;
    case kSyscallYield:
      ret = sys_yield();
      break;
    case kSyscallClone:
      ret = sys_clone(args[0], reinterpret_cast<void*>(args[1]),
                      reinterpret_cast<int*>(args[2]),
                      reinterpret_cast<int*>(args[3]),
                      reinterpret_cast<void*>(args[4]));
      break;
    case kSyscallFork:
      ret = sys_fork();
      break;
    case kSyscallGettid:
      ret = sys_gettid();
      break;
    case kSyscallSetTidAddress:
      ret = sys_set_tid_address(reinterpret_cast<int*>(args[0]));
      break;
    case kSyscallFutex:
      ret = sys_futex(
          reinterpret_cast<int*>(args[0]), static_cast<int>(args[1]),
          static_cast<int>(args[2]), reinterpret_cast<const void*>(args[3]),
          reinterpret_cast<int*>(args[4]), static_cast<int>(args[5]));
      break;
    case kSyscallSleep:
      ret = sys_sleep(args[0]);
      break;
    default:
      klog::Err("[Syscall] Unknown syscall id: {}", syscall_id);
      ret = -1;
      break;
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function: