CDerL
CDerL

RISC-V ISA Simulator系列之fesvr＜5＞

深入解析 FESVR（Front-End Server）

url: https://github.com/riscv/riscv-isa-sim.git
commid: fcbdbe7946079650d0e656fa3d353e3f652d471f

目录

  1. FESVR 概述
  2. FESVR 代码结构分析
  3. ELF 加载机制

在RISC-V ISA Simulator系列之fesvr＜1-4＞中我们已经完成了

1. FESVR 概述
2. FESVR 代码结构分析
   1. ELF 相关文件
   2. HTIF（Host-Target Interface）
   3. 设备模拟
      3.1. `device.h` / `device.cc`
      3.2. `rfb.h` / `rfb.cc`

内容的，下面我们继续完成下列内容。

2. FESVR 代码结构分析

fesvr 的代码主要位于 riscv-isa-sim/fesvr/ 目录，主要文件及作用如下：

fesvr 目录下的源码文件清单，涉及 ELF 加载、设备仿真、HTIF 交互、系统调用 等多个模块。下面是各文件的简要介绍：

3. 设备模拟

  • device.h / device.cc：模拟目标系统中的 I/O 设备，如 UART、存储器等。
  • rfb.h / rfb.cc：是远程帧缓冲（Remote Frame Buffer）相关的仿真代码。
  • memif.h / memif.cc：提供对目标内存的读写访问，供 ELF 加载器和 HTIF 使用。
3.3 memif.h / memif.cc

memif.h

class chunked_memif_t
{
public:
  virtual void read_chunk(addr_t taddr, size_t len, void* dst) = 0;
  virtual void write_chunk(addr_t taddr, size_t len, const void* src) = 0;
  virtual void clear_chunk(addr_t taddr, size_t len) = 0;

  virtual size_t chunk_align() = 0;
  virtual size_t chunk_max_size() = 0;

  virtual endianness_t get_target_endianness() const {
    return endianness_little;
  }

  virtual ~chunked_memif_t() = default;
};

chunked_memif_t 是一个抽象基类，定义了对内存块进行操作的接口。它的成员函数包括：

  • read_chunk(): 用于从内存中读取指定长度的数据到目标地址。
  • write_chunk(): 用于将指定长度的数据写入到内存中。
  • clear_chunk(): 用于清除内存中的指定数据。
  • chunk_align(): 返回数据块的对齐方式。
  • chunk_max_size(): 返回数据块的最大大小。
  • get_target_endianness(): 返回目标平台的字节序，默认返回小端字节序。

这些虚函数提供了操作内存的通用接口，而具体的实现由派生类提供。

class memif_t
{
public:
  memif_t(chunked_memif_t* _cmemif) : cmemif(_cmemif) {}
  virtual ~memif_t(){}

  virtual void read(addr_t addr, size_t len, void* bytes);
  virtual void write(addr_t addr, size_t len, const void* bytes);

  virtual target_endian<uint8_t> read_uint8(addr_t addr);
  virtual target_endian<int8_t> read_int8(addr_t addr);
  virtual void write_uint8(addr_t addr, target_endian<uint8_t> val);
  virtual void write_int8(addr_t addr, target_endian<int8_t> val);

  virtual target_endian<uint16_t> read_uint16(addr_t addr);
  virtual target_endian<int16_t> read_int16(addr_t addr);
  virtual void write_uint16(addr_t addr, target_endian<uint16_t> val);
  virtual void write_int16(addr_t addr, target_endian<int16_t> val);

  virtual target_endian<uint32_t> read_uint32(addr_t addr);
  virtual target_endian<int32_t> read_int32(addr_t addr);
  virtual void write_uint32(addr_t addr, target_endian<uint32_t> val);
  virtual void write_int32(addr_t addr, target_endian<int32_t> val);

  virtual target_endian<uint64_t> read_uint64(addr_t addr);
  virtual target_endian<int64_t> read_int64(addr_t addr);
  virtual void write_uint64(addr_t addr, target_endian<uint64_t> val);
  virtual void write_int64(addr_t addr, target_endian<int64_t> val);

  virtual endianness_t get_target_endianness() const {
    return cmemif->get_target_endianness();
  }

protected:
  chunked_memif_t* cmemif;
};

memif_t 是一个更高级的内存接口类，提供了多种数据类型的内存读写操作，包括字节（uint8_t）、16位（uint16_t）、32位（uint32_t）、64位（uint64_t）等类型。这个类包含的函数通过 chunked_memif_t 提供的接口来实现内存的读写，并支持目标端字节序（大端或小端）。它提供了以下功能：

  • read() 和 write()：用于从内存读取和向内存写入指定长度的字节数组。
  • read_uint8()、write_uint8() 等：这些函数是为不同的数据类型（如 8 位、16 位、32 位、64 位）提供读写操作。
  • get_target_endianness()：返回目标平台的字节序。

该类的设计允许用户在更高层次上进行内存操作，同时确保数据访问的正确性。

class incompat_xlen : public std::exception {
public:
  const unsigned expected_xlen;
  const unsigned actual_xlen;
  incompat_xlen(unsigned _expected_xlen, unsigned _actual_xlen) : expected_xlen(_expected_xlen), actual_xlen(_actual_xlen) {}
};

incompat_xlen 是一个自定义异常类，用于处理数据宽度（XLen）不匹配的情况。该类包含两个成员变量：expected_xlen 和 actual_xlen，它们分别表示期望的数据宽度和实际的数据宽度。如果在处理数据时发生了宽度不匹配的情况，系统将抛出此异常。它继承自 std::exception，使得异常可以与其他标准异常类型兼容。

memif.cc

1. read 函数

void memif_t::read(addr_t addr, size_t len, void* bytes)
{
  size_t align = cmemif->chunk_align();  // 获取内存对齐要求
  • 通过调用 cmemif->chunk_align() 获取内存对齐的要求。align 变量存储了每个内存块需要的对齐方式。对齐方式决定了从内存中读取数据时，每次读取的起始地址必须满足对齐要求。
  if (len && (addr & (align-1)))  // 如果地址不对齐
  {
    size_t this_len = std::min(len, align - size_t(addr & (align-1)));  // 计算需要读取的首块长度
    uint8_t chunk[align];  // 分配一个内存块，用于读取数据
  • 这段代码检查 addr 地址是否对齐。如果地址不是 align 的整数倍（即 addr & (align-1) 非零），说明地址不对齐。
  • 如果不对齐，this_len 计算出从当前位置到对齐边界的长度，确保读取的第一个块长度不会超过剩余的读取长度。
  • chunk 数组用于暂时存储从内存中读取的整块数据。
    cmemif->read_chunk(addr & ~(align-1), align, chunk);  // 从内存中读取一整块数据
    memcpy(bytes, chunk + (addr & (align-1)), this_len);  // 将数据从块中复制到目标地址
  • cmemif->read_chunk 读取的是从 addr & ~(align-1) 开始的对齐内存块。这是通过清除 addr 中的对齐掩码部分来获取对齐地址。
  • 然后将读取的块数据 chunk 中的数据复制到目标内存 bytes 中，从 chunk 中的偏移位置（addr & (align-1)）开始，确保读取的部分对齐。
    bytes = (char*)bytes + this_len;  // 更新目标地址
    addr += this_len;  // 更新源地址
    len -= this_len;  // 更新剩余长度
  }
  • 更新目标地址 bytes 和源地址 addr，并减少剩余要读取的数据长度 len。
  if (len & (align-1))  // 如果剩余长度未对齐
  {
    size_t this_len = len & (align-1);  // 计算未对齐部分的长度
    size_t start = len - this_len;  // 计算起始位置
    uint8_t chunk[align];  // 分配内存块
  • 这里是处理剩余数据是否对齐。如果剩余的 len 不是对齐的（即 len & (align-1) 非零），则计算出剩余未对齐部分的长度。
    cmemif->read_chunk(addr + start, align, chunk);  // 读取未对齐部分的数据
    memcpy((char*)bytes + start, chunk, this_len);  // 复制数据到目标地址
  • 从内存中读取未对齐的块，并将读取的数据复制到目标内存。
    len -= this_len;  // 更新剩余长度
  }
  • 更新剩余要读取的长度 len。
  // 现在对齐了
  for (size_t pos = 0; pos < len; pos += cmemif->chunk_max_size())  // 逐块读取剩余数据
    cmemif->read_chunk(addr + pos, std::min(cmemif->chunk_max_size(), len - pos), (char*)bytes + pos);
}
  • 数据已经对齐，接下来就是按块读取数据。cmemif->chunk_max_size() 返回单个块的最大大小，根据剩余长度 len 逐块读取数据并复制到目标内存。

2. write 函数

void memif_t::write(addr_t addr, size_t len, const void* bytes)
{
  size_t align = cmemif->chunk_align();  // 获取内存对齐要求
  • 和 read 函数一样，首先获取内存块的对齐要求。
  if (len && (addr & (align-1)))  // 如果地址不对齐
  {
    size_t this_len = std::min(len, align - size_t(addr & (align-1)));  // 计算需要写入的首块长度
    uint8_t chunk[align];  // 分配一个内存块，用于写入数据
  • 检查地址是否对齐。如果地址不对齐，计算出需要写入的首块长度。
    cmemif->read_chunk(addr & ~(align-1), align, chunk);  // 从内存中读取一整块数据
    memcpy(chunk + (addr & (align-1)), bytes, this_len);  // 将数据从源地址复制到内存块中
    cmemif->write_chunk(addr & ~(align-1), align, chunk);  // 写入修改后的内存块
  • 读取一整块内存，然后将新数据复制到内存块中，最后写回修改后的内存块。
    bytes = (char*)bytes + this_len;  // 更新源地址
    addr += this_len;  // 更新目标地址
    len -= this_len;  // 更新剩余长度
  }
  • 更新源地址、目标地址和剩余写入的数据长度。
  if (len & (align-1))  // 如果剩余长度未对齐
  {
    size_t this_len = len & (align-1);  // 计算未对齐部分的长度
    size_t start = len - this_len;  // 计算起始位置
    uint8_t chunk[align];  // 分配内存块
  • 处理剩余未对齐部分的数据，首先计算未对齐部分的长度。
    cmemif->read_chunk(addr + start, align, chunk);  // 读取未对齐部分的数据
    memcpy(chunk, (char*)bytes + start, this_len);  // 将数据复制到内存块中
    cmemif->write_chunk(addr + start, align, chunk);  // 将修改后的数据写回内存
  • 读取并写入未对齐部分的数据。
    len -= this_len;  // 更新剩余长度
  }
  • 更新剩余的写入长度。
  // 现在对齐了
  bool all_zero = len != 0;  // 检查数据是否全为零
  for (size_t i = 0; i < len; i++)  // 检查每个字节是否为零
    all_zero &= ((const char*)bytes)[i] == 0;
  • 检查数据是否全部为零。如果是，直接清除内存区域。
  if (all_zero) {  // 如果数据全为零
    cmemif->clear_chunk(addr, len);  // 清除内存块
  } else {  // 否则按块写入数据
    size_t max_chunk = cmemif->chunk_max_size();
    for (size_t pos = 0; pos < len; pos += max_chunk)
      cmemif->write_chunk(addr + pos, std::min(max_chunk, len - pos), (char*)bytes + pos);
  }
}
  • 如果数据全部为零，则通过 cmemif->clear_chunk 清除指定的内存区域。
  • 否则，逐块写入内存，直到所有数据写入完毕。

3. MEMIF_READ_FUNC 和 MEMIF_WRITE_FUNC 宏

#define MEMIF_READ_FUNC \
  if(addr & (sizeof(val)-1)) \
    throw std::runtime_error("misaligned address"); \
  this->read(addr, sizeof(val), &val); \
  return val
  • 该宏在进行读取操作时，首先检查地址是否对齐。如果地址不对齐，则抛出 misaligned address 异常。如果对齐，调用 read 函数读取数据并返回。
#define MEMIF_WRITE_FUNC \
  if(addr & (sizeof(val)-1)) \
    throw std::runtime_error("misaligned address"); \
  this->write(addr, sizeof(val), &val)
  • 该宏在进行写入操作时，首先检查地址是否对齐。如果不对齐，则抛出异常。如果对齐，调用 write 函数写入数据。

4. 类型特定的读写函数

这些函数都使用了 MEMIF_READ_FUNC 和 MEMIF_WRITE_FUNC 宏来读取和写入特定类型的数据，例如 uint8_t, int8_t, uint16_t, int16_t 等。

target_endian<uint8_t> memif_t::read_uint8(addr_t addr)
{
  target_endian<uint8_t> val;
  MEMIF_READ_FUNC;
}
  • 该函数读取 uint8_t 类型的数据。如果地址不对齐，抛出异常。如果对齐，调用 read 函数进行数据读取。

类似的处理也应用于其他类型（如 int8_t, uint16_t, int16_t, 等）。

总结：

  • read 和 write 函数的核心逻辑是处理内存对齐，确保数据按对齐要求读写。对于不对齐的数据，进行块读写，并处理剩余未对齐部分的数据。
  • 使用宏 MEMIF_READ_FUNC 和 MEMIF_WRITE_FUNC 来简化对不同数据类型的读写操作，并保证地址对齐。
  • 在写操作中，若数据全为零，会优化为清除内存，而不是逐字节写入。

4. 系统调用

  • syscall.h / syscall.cc：处理 ecall 指令，将 RISC-V 系统调用映射到宿主机的系统调用。

syscall.h

这是一个名为 syscall_t 的 C++ 类定义，主要用于处理系统调用，特别是与文件系统、进程控制和 I/O 操作相关的系统调用。

类结构和成员变量

class syscall_t : public device_t
{
 public:
  syscall_t(htif_t*);
  ~syscall_t();
  
  void set_chroot(const char* where);
  
 private:
  const char* identity() { return "syscall_proxy"; }
  
  htif_t* htif;         // 高级接口，通常用来与主机或外部设备通信
  memif_t* memif;       // 内存接口，可能用于直接操作内存（例如读取、写入）
  std::vector<syscall_func_t> table;  // 系统调用表，存储不同系统调用的处理函数
  fds_t fds;            // 文件描述符管理
  std::vector<reg_t> fds_index;  // 文件描述符索引，用于跟踪打开的文件描述符
  
  void handle_syscall(command_t cmd);  // 处理系统调用
  void dispatch(addr_t mm);            // 调度系统调用，可能涉及内存操作
  
  std::string chroot;  // 存储当前的 chroot 路径
  std::string do_chroot(const char* fn);  // 执行 chroot 操作
  std::string undo_chroot(const char* fn);  // 恢复 chroot 操作
  
  // 各种系统调用函数声明，处理不同的系统调用
  reg_t sys_exit(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_openat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_read(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_pread(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_write(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_pwrite(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_close(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_lseek(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_fstat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_lstat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_statx(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_fstatat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_faccessat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_fcntl(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_ftruncate(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_renameat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_linkat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_unlinkat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_mkdirat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_getcwd(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_getmainvars(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_chdir(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
  reg_t sys_readlinkat(reg_t, reg_t, reg_t, reg_t, reg_t, reg_t, reg_t);
};

成员变量

  • htif_t* htif;：指向 htif_t 类型的指针，可能用于处理主机或外部接口。htif 可能代表一种 “host-target interface”（主机-目标接口）用于与外部设备进行通信。
  • memif_t* memif;：指向 memif_t 类型的指针，可能用于进行内存操作。它提供了对内存的直接访问，如读写内存。
  • std::vector table;：存储了系统调用函数的列表。syscall_func_t 是一个函数指针类型，指向每个系统调用的处理函数。
  • fds_t fds;：文件描述符管理类，负责分配和释放文件描述符。
  • std::vector fds_index;：文件描述符索引，可能用于跟踪哪些文件描述符已被分配。

成员函数

  • set_chroot(const char* where);：设置当前进程的 chroot 路径。chroot 是一个将进程限制在指定目录中的机制。
  • identity()：返回设备的身份字符串，这里是 “syscall_proxy”。
  • handle_syscall(command_t cmd);：处理一个系统调用的函数，接受一个 command_t 类型的命令。
  • dispatch(addr_t mm);：根据内存地址调度系统调用。
  • do_chroot(const char* fn); 和 undo_chroot(const char* fn);：执行和撤销 chroot 操作。

系统调用处理函数

  • sys_exit：处理 exit 系统调用，退出程序。
  • sys_openat：处理 openat 系统调用，用于打开一个文件。
  • sys_read：处理 read 系统调用，用于读取文件。
  • sys_write：处理 write 系统调用，用于写入文件。
  • sys_close：处理 close 系统调用，关闭文件描述符。
  • sys_lseek：处理 lseek 系统调用，定位文件指针。
  • 其他类似的函数处理各类文件系统操作和 I/O 系统调用。

fds_t 类

class fds_t
{
 public:
  reg_t alloc(int fd);  // 分配文件描述符
  void dealloc(reg_t fd);  // 释放文件描述符
  int lookup(reg_t fd);  // 查找文件描述符的状态
  
 private:
  std::vector<int> fds;  // 存储文件描述符
};
  • alloc()：分配一个文件描述符。
  • dealloc()：释放指定的文件描述符。
  • lookup()：查找文件描述符的状态。

系统调用表
table 是一个存储系统调用函数指针的向量。系统调用的每个函数（如 sys_exit、sys_openat 等）都定义了不同的功能，它们接收不同的参数并返回不同类型的结果。每个系统调用都会按照表中的索引调用相应的函数。

其他成员函数

  • set_chroot 和 do_chroot/undo_chroot：提供了对 chroot 操作的封装，使得进程可以在受限的目录树中运行。
  • handle_syscall：处理具体的系统调用命令，可能涉及根据命令选择不同的系统调用函数。
  • dispatch：根据内存地址或命令调度对应的系统调用处理函数。

总结
syscall_t 类定义了一个系统调用处理代理，主要包括处理与文件操作、进程管理相关的系统调用。它通过函数指针表管理和调用不同的系统调用函数，且提供了对文件描述符的分配和管理。chroot 操作的封装也使得进程可以在特定的目录环境中执行。

syscall.cc

  1. 结构体构造函数

riscv_stat::riscv_stat(const struct stat& s, htif_t* htif)

  riscv_stat(const struct stat& s, htif_t* htif)
    : dev(htif->to_target<uint64_t>(s.st_dev)),
      ino(htif->to_target<uint64_t>(s.st_ino)),
      mode(htif->to_target<uint32_t>(s.st_mode)),
      nlink(htif->to_target<uint32_t>(s.st_nlink)),
      uid(htif->to_target<uint32_t>(s.st_uid)),
      gid(htif->to_target<uint32_t>(s.st_gid)),
      rdev(htif->to_target<uint64_t>(s.st_rdev)), __pad1(),
      size(htif->to_target<uint64_t>(s.st_size)),
      blksize(htif->to_target<uint32_t>(s.st_blksize)), __pad2(),
      blocks(htif->to_target<uint64_t>(s.st_blocks)),
      atime(htif->to_target<uint64_t>(s.st_atime)), __pad3(),
      mtime(htif->to_target<uint64_t>(s.st_mtime)), __pad4(),
      ctime(htif->to_target<uint64_t>(s.st_ctime)), __pad5(),
      __unused4(), __unused5() {}
};
  • 功能：将标准 struct stat 结构体的数据转换为 riscv_stat 结构体，并且将数据转换为目标端格式。
  • 参数：
    • s：标准 struct stat 结构体，包含文件的状态信息。
    • htif：htif_t 类型的指针，用于进行端序转换。
  • 实现：将 s 中的每个成员通过 htif->to_target 方法转换为目标端格式，并赋值给 riscv_stat 的对应成员。

riscv_statx::riscv_statx(const struct statx& s, htif_t* htif)（仅在 HAVE_STATX 定义时有效）

  riscv_statx(const struct statx& s, htif_t* htif)
    : mask(htif->to_target<uint32_t>(s.stx_mask)),
      blksize(htif->to_target<uint32_t>(s.stx_blksize)),
      attributes(htif->to_target<uint64_t>(s.stx_attributes)),
      nlink(htif->to_target<uint32_t>(s.stx_nlink)),
      uid(htif->to_target<uint32_t>(s.stx_uid)),
      gid(htif->to_target<uint32_t>(s.stx_gid)),
      mode(htif->to_target<uint16_t>(s.stx_mode)), __spare0(),
      ino(htif->to_target<uint64_t>(s.stx_ino)),
      size(htif->to_target<uint64_t>(s.stx_size)),
      blocks(htif->to_target<uint64_t>(s.stx_blocks)),
      attributes_mask(htif->to_target<uint64_t>(s.stx_attributes_mask)),
      atime {
        htif->to_target<int64_t>(s.stx_atime.tv_sec),
        htif->to_target<uint32_t>(s.stx_atime.tv_nsec)
      },
      btime {
        htif->to_target<int64_t>(s.stx_btime.tv_sec),
        htif->to_target<uint32_t>(s.stx_btime.tv_nsec)
      },
      ctime {
        htif->to_target<int64_t>(s.stx_ctime.tv_sec),
        htif->to_target<uint32_t>(s.stx_ctime.tv_nsec)
      },
      mtime {
        htif->to_target<int64_t>(s.stx_mtime.tv_sec),
        htif->to_target<uint32_t>(s.stx_mtime.tv_nsec)
      },
      rdev_major(htif->to_target<uint32_t>(s.stx_rdev_major)),
      rdev_minor(htif->to_target<uint32_t>(s.stx_rdev_minor)),
      dev_major(htif->to_target<uint32_t>(s.stx_dev_major)),
      dev_minor(htif->to_target<uint32_t>(s.stx_dev_minor)),
#ifdef HAVE_STATX_MNT_ID
      mnt_id(htif->to_target<uint64_t>(s.stx_mnt_id)),
      __spare2(), __spare3()
#else
      __spare2()
#endif
      {}
};
  • 功能：将标准 struct statx 结构体的数据转换为 riscv_statx 结构体，并且将数据转换为目标端格式。
  • 参数：
    • s：标准 struct statx 结构体，包含文件的扩展状态信息。
    • htif：htif_t 类型的指针，用于进行端序转换。
  • 实现：将 s 中的每个成员通过 htif->to_target 方法转换为目标端格式，并赋值给 riscv_statx 的对应成员。对于时间戳成员，分别处理秒和纳秒部分。
  1. syscall_t 类的成员函数

syscall_t::syscall_t(htif_t* htif)

syscall_t::syscall_t(htif_t* htif)
  : htif(htif), memif(&htif->memif()), table(2048)
{
  table[17] = &syscall_t::sys_getcwd;
  table[25] = &syscall_t::sys_fcntl;
  table[34] = &syscall_t::sys_mkdirat;
  table[35] = &syscall_t::sys_unlinkat;
  table[37] = &syscall_t::sys_linkat;
  table[38] = &syscall_t::sys_renameat;
  table[46] = &syscall_t::sys_ftruncate;
  table[48] = &syscall_t::sys_faccessat;
  table[49] = &syscall_t::sys_chdir;
  table[56] = &syscall_t::sys_openat;
  table[57] = &syscall_t::sys_close;
  table[62] = &syscall_t::sys_lseek;
  table[63] = &syscall_t::sys_read;
  table[64] = &syscall_t::sys_write;
  table[67] = &syscall_t::sys_pread;
  table[68] = &syscall_t::sys_pwrite;
  table[78] = &syscall_t::sys_readlinkat;
  table[79] = &syscall_t::sys_fstatat;
  table[80] = &syscall_t::sys_fstat;
  table[93] = &syscall_t::sys_exit;
  table[291] = &syscall_t::sys_statx;
  table[1039] = &syscall_t::sys_lstat;
  table[2011] = &syscall_t::sys_getmainvars;

  register_command(0, std::bind(&syscall_t::handle_syscall, this, _1), "syscall");

  int stdin_fd = dup(0), stdout_fd0 = dup(1), stdout_fd1 = dup(1);
  if (stdin_fd < 0 || stdout_fd0 < 0 || stdout_fd1 < 0)
    throw std::runtime_error("could not dup stdin/stdout");

  fds_index.push_back(fds.alloc(stdin_fd)); // stdin -> stdin
  fds_index.push_back(fds.alloc(stdout_fd0)); // stdout -> stdout
  fds_index.push_back(fds.alloc(stdout_fd1)); // stderr -> stdout
}
  • 功能：syscall_t 类的构造函数，初始化系统调用表，注册系统调用处理命令，复制标准输入输出文件描述符。
  • 参数：
    • htif：htif_t 类型的指针，代表硬件接口。
  • 实现：
    • 初始化 htif、memif 和 table 成员变量。
    • 将系统调用号映射到对应的成员函数，填充 table 数组。
    • 注册系统调用处理命令，使用 std::bind 绑定 handle_syscall 方法。
    • 复制标准输入输出文件描述符，并将其分配到 fds 中。

syscall_t::~syscall_t()

syscall_t::~syscall_t() {
  for (auto i: fds_index) {
    close(fds.lookup(i));
    fds.dealloc(i);
  }
}
  • 功能：syscall_t 类的析构函数，关闭所有打开的文件描述符并释放资源。
  • 实现：遍历 fds_index，关闭对应的文件描述符，并从 fds 中释放索引。

std::string syscall_t::do_chroot(const char* fn)

std::string syscall_t::do_chroot(const char* fn)
{
  if (!chroot.empty() && *fn == '/')
    return chroot + fn;
  return fn;
}
  • 功能：如果设置了根目录，将绝对路径转换为包含根目录的路径。
  • 参数：
    • fn：文件路径。
  • 实现：如果 chroot 不为空且 fn 是绝对路径，则返回 chroot 与 fn 拼接后的路径；否则返回原路径。

std::string syscall_t::undo_chroot(const char* fn)

std::string syscall_t::undo_chroot(const char* fn)
{
  if (chroot.empty())
    return fn;
  if (strncmp(fn, chroot.c_str(), chroot.size()) == 0
      && (chroot.back() == '/' || fn[chroot.size()] == '/'))
    return fn + chroot.size() - (chroot.back() == '/');
  return "/";
}
  • 功能：如果设置了根目录，将包含根目录的路径转换为相对路径。
  • 参数：
    • fn：文件路径。
  • 实现：如果 chroot 为空，返回原路径；否则，检查 fn 是否以 chroot 开头，如果是，则返回去除 chroot 后的路径；否则返回根路径 /。

void syscall_t::handle_syscall(command_t cmd)


void syscall_t::handle_syscall(command_t cmd)
{
  if (cmd.payload() & 1) // test pass/fail
  {
    htif->exitcode = cmd.payload();
    if (htif->exit_code())
      std::cerr << "*** FAILED *** (tohost = " << htif->exit_code() << ")" << std::endl;
    return;
  }
  else // proxied system call
    dispatch(cmd.payload());

  cmd.respond(1);
}
  • 功能：处理系统调用命令，根据命令负载判断是测试结果还是代理系统调用。
  • 参数：
    • cmd：command_t 类型的命令对象。
  • 实现：
    • 如果 cmd.payload() 的最低位为 1，表示测试结果，设置 htif->exitcode 并输出错误信息（如果测试失败）。
    • 否则，调用 dispatch 方法处理代理系统调用，并回复命令。

reg_t syscall_t::sys_exit(reg_t code, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_exit(reg_t code, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  htif->htif_exit(code << 1 | 1);
  return 0;
}
  • 功能：实现 exit 系统调用，设置退出码。
  • 参数：
    • code：退出码。
    • a1 - a6：其他参数（未使用）。
  • 实现：设置 htif->exitcode 为 code << 1 | 1，并返回 0。

static reg_t sysret_errno(sreg_t ret)

static reg_t sysret_errno(sreg_t ret)
{
  return ret == -1 ? -errno : ret;
}
  • 功能：将系统调用的返回值转换为包含错误码的返回值。
  • 参数：
    • ret：系统调用的原始返回值。
  • 实现：如果 ret 为 -1，表示系统调用失败，返回 -errno；否则返回 ret。

reg_t syscall_t::sys_read(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_read(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> buf(len);
  ssize_t ret = read(fds.lookup(fd), buf.data(), len);
  reg_t ret_errno = sysret_errno(ret);
  if (ret > 0)
    memif->write(pbuf, ret, buf.data());
  return ret_errno;
}
  • 功能：实现 read 系统调用，从文件描述符读取数据。
  • 参数：
    • fd：文件描述符。
    • pbuf：缓冲区地址。
    • len：读取的字节数。
    • a3 - a6：其他参数（未使用）。
  • 实现：
    • 创建一个长度为 len 的缓冲区。
    • 调用 read 函数从文件描述符读取数据。
    • 如果读取成功，将数据写入 pbuf 指向的内存。
    • 返回处理后的返回值。

reg_t syscall_t::sys_pread(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_pread(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> buf(len);
  ssize_t ret = pread(fds.lookup(fd), buf.data(), len, off);
  reg_t ret_errno = sysret_errno(ret);
  if (ret > 0)
    memif->write(pbuf, ret, buf.data());
  return ret_errno;
}
  • 功能：实现 pread 系统调用，从文件描述符指定偏移量处读取数据。
  • 参数：
    • fd：文件描述符。
    • pbuf：缓冲区地址。
    • len：读取的字节数。
    • off：偏移量。
    • a4 - a6：其他参数（未使用）。
  • 实现：与 sys_read 类似，只是调用 pread 函数并指定偏移量。

reg_t syscall_t::sys_write(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_write(reg_t fd, reg_t pbuf, reg_t len, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> buf(len);
  memif->read(pbuf, len, buf.data());
  reg_t ret = sysret_errno(write(fds.lookup(fd), buf.data(), len));
  return ret;
}
  • 功能：实现 write 系统调用，向文件描述符写入数据。
  • 参数：
    • fd：文件描述符。
    • pbuf：缓冲区地址。
    • len：写入的字节数。
    • a3 - a6：其他参数（未使用）。
  • 实现：
    • 创建一个长度为 len 的缓冲区。
    • 从 pbuf 指向的内存读取数据到缓冲区。
    • 调用 write 函数将数据写入文件描述符。
    • 返回处理后的返回值。

reg_t syscall_t::sys_pwrite(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_pwrite(reg_t fd, reg_t pbuf, reg_t len, reg_t off, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> buf(len);
  memif->read(pbuf, len, buf.data());
  reg_t ret = sysret_errno(pwrite(fds.lookup(fd), buf.data(), len, off));
  return ret;
}
  • 功能：实现 pwrite 系统调用，向文件描述符指定偏移量处写入数据。
  • 参数：
    • fd：文件描述符。
    • pbuf：缓冲区地址。
    • len：写入的字节数。
    • off：偏移量。
    • a4 - a6：其他参数（未使用）。
  • 实现：与 sys_write 类似，只是调用 pwrite 函数并指定偏移量。

reg_t syscall_t::sys_close(reg_t fd, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_close(reg_t fd, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  if (close(fds.lookup(fd)) < 0)
    return sysret_errno(-1);
  fds.dealloc(fd);
  return 0;
}
  • 功能：实现 close 系统调用，关闭文件描述符。
  • 参数：
    • fd：文件描述符。
    • a1 - a6：其他参数（未使用）。
  • 实现：
    • 调用 close 函数关闭文件描述符。
    • 如果关闭失败，返回处理后的错误码；否则，从 fds 中释放索引并返回 0。

reg_t syscall_t::sys_lseek(reg_t fd, reg_t ptr, reg_t dir, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_lseek(reg_t fd, reg_t ptr, reg_t dir, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  return sysret_errno(lseek(fds.lookup(fd), ptr, dir));
}
  • 功能：实现 lseek 系统调用，设置文件偏移量。
  • 参数：
    • fd：文件描述符。
    • ptr：偏移量。
    • dir：偏移基准。
    • a3 - a6：其他参数（未使用）。
  • 实现：调用 lseek 函数并返回处理后的返回值。

reg_t syscall_t::sys_fstat(reg_t fd, reg_t pbuf, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_fstat(reg_t fd, reg_t pbuf, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  struct stat buf;
  reg_t ret = sysret_errno(fstat(fds.lookup(fd), &buf));
  if (ret != (reg_t)-1)
  {
    riscv_stat rbuf(buf, htif);
    memif->write(pbuf, sizeof(rbuf), &rbuf);
  }
  return ret;
}
  • 功能：实现 fstat 系统调用，获取文件状态信息。
  • 参数：
    • fd：文件描述符。
    • pbuf：缓冲区地址。
    • a2 - a6：其他参数（未使用）。
  • 实现：
    • 调用 fstat 函数获取文件状态信息。
    • 如果获取成功，将状态信息转换为 riscv_stat 结构体并写入 pbuf 指向的内存。
    • 返回处理后的返回值。

reg_t syscall_t::sys_fcntl(reg_t fd, reg_t cmd, reg_t arg, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_fcntl(reg_t fd, reg_t cmd, reg_t arg, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  return sysret_errno(fcntl(fds.lookup(fd), cmd, arg));
}
  • 功能：实现 fcntl 系统调用，对文件描述符进行控制操作。
  • 参数：
    • fd：文件描述符。
    • cmd：操作命令。
    • arg：操作参数。
    • a3 - a6：其他参数（未使用）。
  • 实现：调用 fcntl 函数并返回处理后的返回值。

reg_t syscall_t::sys_ftruncate(reg_t fd, reg_t len, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_ftruncate(reg_t fd, reg_t len, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  return sysret_errno(ftruncate(fds.lookup(fd), len));
}
  • 功能：实现 ftruncate 系统调用，截断文件到指定长度。
  • 参数：
    • fd：文件描述符。
    • len：截断长度。
    • a2 - a6：其他参数（未使用）。
  • 实现：调用 ftruncate 函数并返回处理后的返回值。

reg_t syscall_t::sys_lstat(reg_t pname, reg_t len, reg_t pbuf, reg_t a3, reg_t a4, reg_t a5, reg_t a6)


reg_t syscall_t::sys_lstat(reg_t pname, reg_t len, reg_t pbuf, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());

  struct stat buf;
  reg_t ret = sysret_errno(lstat(do_chroot(name.data()).c_str(), &buf));
  if (ret != (reg_t)-1)
  {
    riscv_stat rbuf(buf, htif);
    memif->write(pbuf, sizeof(rbuf), &rbuf);
  }
  return ret;
}
  • 功能：实现 lstat 系统调用，获取文件或符号链接的状态信息。
  • 参数：
    • pname：文件名地址。
    • len：文件名长度。
    • pbuf：缓冲区地址。
    • a3 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 lstat 函数获取文件状态信息。
    • 如果获取成功，将状态信息转换为 riscv_stat 结构体并写入 pbuf 指向的内存。
    • 返回处理后的返回值。

reg_t syscall_t::sys_statx(reg_t fd, reg_t pname, reg_t len, reg_t flags, reg_t mask, reg_t pbuf, reg_t a6)（仅在 HAVE_STATX 定义时有效）

reg_t syscall_t::sys_statx(reg_t fd, reg_t pname, reg_t len, reg_t flags, reg_t mask, reg_t pbuf, reg_t a6)
{
#ifndef HAVE_STATX
  return -ENOSYS;
#else
  std::vector<char> name(len);
  memif->read(pname, len, name.data());

  struct statx buf;
  reg_t ret = sysret_errno(statx(fds.lookup(fd), do_chroot(name.data()).c_str(), flags, mask, &buf));
  if (ret != (reg_t)-1)
  {
    riscv_statx rbuf(buf, htif);
    memif->write(pbuf, sizeof(rbuf), &rbuf);
  }
  return ret;
#endif
}
  • 功能：实现 statx 系统调用，获取文件的扩展状态信息。
  • 参数：
    • fd：文件描述符。
    • pname：文件名地址。
    • len：文件名长度。
    • flags：标志位。
    • mask：掩码。
    • pbuf：缓冲区地址。
    • a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 statx 函数获取文件状态信息。
    • 如果获取成功，将状态信息转换为 riscv_statx 结构体并写入 pbuf 指向的内存。
    • 返回处理后的返回值。

reg_t syscall_t::sys_openat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t mode, reg_t a5, reg_t a6)

#define AT_SYSCALL(syscall, fd, name, ...) \
  (syscall(fds.lookup(fd), int(fd) == RISCV_AT_FDCWD ? do_chroot(name).c_str() : (name), __VA_ARGS__))

reg_t syscall_t::sys_openat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t mode, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());
  int fd = sysret_errno(AT_SYSCALL(openat, dirfd, name.data(), flags, mode));
  if (fd < 0)
    return sysret_errno(-1);
  return fds.alloc(fd);
}
  • 功能：实现 openat 系统调用，打开文件。
  • 参数：
    • dirfd：目录文件描述符。
    • pname：文件名地址。
    • len：文件名长度。
    • flags：打开标志。
    • mode：文件权限。
    • a5 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 openat 函数打开文件。
    • 如果打开成功，分配一个新的文件描述符索引并返回；否则返回处理后的错误码。

reg_t syscall_t::sys_fstatat(reg_t dirfd, reg_t pname, reg_t len, reg_t pbuf, reg_t flags, reg_t a5, reg_t a6)

reg_t syscall_t::sys_fstatat(reg_t dirfd, reg_t pname, reg_t len, reg_t pbuf, reg_t flags, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());

  struct stat buf;
  reg_t ret = sysret_errno(AT_SYSCALL(fstatat, dirfd, name.data(), &buf, flags));
  if (ret != (reg_t)-1)
  {
    riscv_stat rbuf(buf, htif);
    memif->write(pbuf, sizeof(rbuf), &rbuf);
  }
  return ret;
}
  • 功能：实现 fstatat 系统调用，获取文件状态信息。
  • 参数：
    • dirfd：目录文件描述符。
    • pname：文件名地址。
    • len：文件名长度。
    • pbuf：缓冲区地址。
    • flags：标志位。
    • a5 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 fstatat 函数获取文件状态信息。
    • 如果获取成功，将状态信息转换为 riscv_stat 结构体并写入 pbuf 指向的内存。
    • 返回处理后的返回值。

reg_t syscall_t::sys_faccessat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_faccessat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());
  return sysret_errno(AT_SYSCALL(faccessat, dirfd, name.data(), mode, 0));
}
  • 功能：实现 faccessat 系统调用，检查文件的访问权限。
  • 参数：
    • dirfd：目录文件描述符。
    • pname：文件名地址。
    • len：文件名长度。
    • mode：访问模式。
    • a4 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 faccessat 函数检查文件访问权限。
    • 返回处理后的返回值。

reg_t syscall_t::sys_renameat(reg_t odirfd, reg_t popath, reg_t olen, reg_t ndirfd, reg_t pnpath, reg_t nlen, reg_t a6)

reg_t syscall_t::sys_renameat(reg_t odirfd, reg_t popath, reg_t olen, reg_t ndirfd, reg_t pnpath, reg_t nlen, reg_t a6)
{
  std::vector<char> opath(olen), npath(nlen);
  memif->read(popath, olen, opath.data());
  memif->read(pnpath, nlen, npath.data());
  return sysret_errno(renameat(fds.lookup(odirfd), int(odirfd) == RISCV_AT_FDCWD ? do_chroot(opath.data()).c_str() : opath.data(),
                             fds.lookup(ndirfd), int(ndirfd) == RISCV_AT_FDCWD ? do_chroot(npath.data()).c_str() : npath.data()));
}
  • 功能：实现 renameat 系统调用，重命名文件或目录。
  • 参数：
    • odirfd：旧目录文件描述符。
    • popath：旧文件名地址。
    • olen：旧文件名长度。
    • ndirfd：新目录文件描述符。
    • pnpath：新文件名地址。
    • nlen：新文件名长度。
    • a6：其他参数（未使用）。
  • 实现：
    • 从 popath 和 pnpath 指向的内存读取旧文件名和新文件名。
    • 调用 renameat 函数重命名文件或目录。
    • 返回处理后的返回值。

reg_t syscall_t::sys_linkat(reg_t odirfd, reg_t poname, reg_t olen, reg_t ndirfd, reg_t pnname, reg_t nlen, reg_t flags)

reg_t syscall_t::sys_linkat(reg_t odirfd, reg_t poname, reg_t olen, reg_t ndirfd, reg_t pnname, reg_t nlen, reg_t flags)
{
  std::vector<char> oname(olen), nname(nlen);
  memif->read(poname, olen, oname.data());
  memif->read(pnname, nlen, nname.data());
  return sysret_errno(linkat(fds.lookup(odirfd), int(odirfd) == RISCV_AT_FDCWD ? do_chroot(oname.data()).c_str() : oname.data(),
                             fds.lookup(ndirfd), int(ndirfd) == RISCV_AT_FDCWD ? do_chroot(nname.data()).c_str() : nname.data(),
                             flags));
}
  • 功能：实现 linkat 系统调用，创建硬链接。
  • 参数：
    • odirfd：旧目录文件描述符。
    • poname：旧文件名地址。
    • olen：旧文件名长度。
    • ndirfd：新目录文件描述符。
    • pnname：新文件名地址。
    • nlen：新文件名长度。
    • flags：标志位。
  • 实现：
    • 从 poname 和 pnname 指向的内存读取旧文件名和新文件名。
    • 调用 linkat 函数创建硬链接。
    • 返回处理后的返回值。

reg_t syscall_t::sys_unlinkat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_unlinkat(reg_t dirfd, reg_t pname, reg_t len, reg_t flags, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());
  return sysret_errno(AT_SYSCALL(unlinkat, dirfd, name.data(), flags));
}
  • 功能：实现 unlinkat 系统调用，删除文件或目录。
  • 参数：
    • dirfd：目录文件描述符。
    • pname：文件名地址。
    • len：文件名长度。
    • flags：标志位。
    • a4 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取文件名。
    • 调用 unlinkat 函数删除文件或目录。
    • 返回处理后的返回值。

reg_t syscall_t::sys_mkdirat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_mkdirat(reg_t dirfd, reg_t pname, reg_t len, reg_t mode, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> name(len);
  memif->read(pname, len, name.data());
  return sysret_errno(AT_SYSCALL(mkdirat, dirfd, name.data(), mode));
}
  • 功能：实现 mkdirat 系统调用，创建目录。
  • 参数：
    • dirfd：目录文件描述符。
    • pname：目录名地址。
    • len：目录名长度。
    • mode：目录权限。
    • a4 - a6：其他参数（未使用）。
  • 实现：
    • 从 pname 指向的内存读取目录名。
    • 调用 mkdirat 函数创建目录。
    • 返回处理后的返回值。

reg_t syscall_t::sys_getcwd(reg_t pbuf, reg_t size, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_getcwd(reg_t pbuf, reg_t size, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<char> buf(size);
  char* ret = getcwd(buf.data(), size);
  if (ret == NULL)
    return sysret_errno(-1);
  std::string tmp = undo_chroot(buf.data());
  if (size <= tmp.size())
    return -ENOMEM;
  memif->write(pbuf, tmp.size() + 1, tmp.data());
  return tmp.size() + 1;
}
  • 功能：实现 getcwd 系统调用，获取当前工作目录。
  • 参数：
    • pbuf：缓冲区地址。
    • size：缓冲区大小。
    • a2 - a6：其他参数（未使用）。
  • 实现：
    • 调用 getcwd 函数获取当前工作目录。
    • 如果获取成功，将路径转换为相对路径并写入 pbuf 指向的内存。
    • 返回路径长度。

reg_t syscall_t::sys_getmainvars(reg_t pbuf, reg_t limit, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)


reg_t syscall_t::sys_getmainvars(reg_t pbuf, reg_t limit, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  std::vector<std::string> args = htif->target_args();
  std::vector<target_endian<uint64_t>> words(args.size() + 3);
  words[0] = htif->to_target<uint64_t>(args.size());
  words[args.size()+1] = target_endian<uint64_t>::zero; // argv[argc] = NULL
  words[args.size()+2] = target_endian<uint64_t>::zero; // envp[0] = NULL

  size_t sz = (args.size() + 3) * sizeof(words[0]);
  for (size_t i = 0; i < args.size(); i++)
  {
    words[i+1] = htif->to_target<uint64_t>(sz + pbuf);
    sz += args[i].length() + 1;
  }

  std::vector<char> bytes(sz);
  memcpy(bytes.data(), words.data(), sizeof(words[0]) * words.size());
  for (size_t i = 0; i < args.size(); i++)
    strcpy(&bytes[htif->from_target(words[i+1]) - pbuf], args[i].c_str());

  if (bytes.size() > limit)
    return -ENOMEM;

  memif->write(pbuf, bytes.size(), bytes.data());
  return 0;
}
  • 功能：获取目标参数并写入内存。
  • 参数：
    • pbuf：缓冲区地址。
    • limit：缓冲区大小限制。
    • a2 - a6：其他参数（未使用）。
  • 实现：
    • 获取目标参数。
    • 构造一个包含参数信息的数组。
    • 将参数信息和参数值写入缓冲区。
    • 如果缓冲区大小超过限制，返回 -ENOMEM；否则返回 0。

reg_t syscall_t::sys_chdir(reg_t path, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)

reg_t syscall_t::sys_chdir(reg_t path, reg_t a1, reg_t a2, reg_t a3, reg_t a4, reg_t a5, reg_t a6)
{
  size_t size = 0;
  while (memif->read_uint8(path + size++))
    ;
  std::vector<char> buf(size);
  for (size_t offset = 0;; offset++)
  {
    buf[offset] = memif->read_uint8(path + offset);
    if (!buf[offset])
      break;
  }
  return sysret_errno(chdir(buf.data()));
}
  • 功能：实现 chdir 系统调用，更改当前工作目录。
  • 参数：
    • path：目录路径地址。
    • a1 - a6：其他参数（未使用）。
  • 实现：
    • 从 path 指向的内存读取目录路径。
    • 调用 chdir 函数更改当前工作目录。
    • 返回处理后的返回值。

void syscall_t::dispatch(reg_t mm)

void syscall_t::dispatch(reg_t mm)
{
  target_endian<reg_t> magicmem[8];
  memif->read(mm, sizeof(magicmem), magicmem);

  reg_t n = htif->from_target(magicmem[0]);
  if (n >= table.size() || !table[n])
    throw std::runtime_error("bad syscall #" + std::to_string(n));

  magicmem[0] = htif->to_target((this->*table[n])(htif->from_target(magicmem[1]), htif->from_target(magicmem[2]), htif->from_target(magicmem[3]), htif->from_target(magicmem[4]), htif->from_target(magicmem[5]), htif->from_target(magicmem[6]), htif->from_target(magicmem[7])));

  memif->write(mm, sizeof(magicmem), magicmem);
}
  • 功能：根据系统调用号调用对应的成员函数。
  • 参数：
    • mm：系统调用信息的内存地址。
  • 实现：
    • 从 mm 指向的内存读取系统调用号和参数。
    • 根据系统调用号查找对应的成员函数。
    • 调用成员函数并将结果写回 mm 指向的内存。
  1. fds_t 类的成员函数

reg_t fds_t::alloc(int fd)

reg_t fds_t::alloc(int fd)
{
  reg_t i;
  for (i = 0; i < fds.size(); i++)
    if (fds[i] == -1)
      break;

  if (i == fds.size())
    fds.resize(i+1);

  fds[i] = fd;
  return i;
}
  • 功能：分配一个新的文件描述符索引。
  • 参数：
    • fd：实际的文件描述符。
  • 实现：
    • 查找 fds 数组中第一个空闲的索引。
    • 如果没有空闲索引，扩展 fds 数组。
    • 将 fd 存储到该索引位置，并返回索引。

void fds_t::dealloc(reg_t fd)

void fds_t::dealloc(reg_t fd)
{
  fds[fd] = -1;
}
  • 功能：释放文件描述符索引。
  • 参数：
    • fd：文件描述符索引。
  • 实现：将 fds[fd] 设置为 -1，表示该索引空闲。

int fds_t::lookup(reg_t fd)

int fds_t::lookup(reg_t fd)
{
  if (int(fd) == RISCV_AT_FDCWD)
    return AT_FDCWD;
  return fd >= fds.size() ? -1 : fds[fd];
}
  • 功能：根据索引查找对应的文件描述符。
  • 参数：
    • fd：文件描述符索引。
  • 实现：如果 fd 等于 RISCV_AT_FDCWD，返回 AT_FDCWD；否则，如果 fd 在 fds 数组范围内，返回 fds[fd]；否则返回 -1。
  1. syscall_t::set_chroot(const char* where)
void syscall_t::set_chroot(const char* where)
{
  char buf1[PATH_MAX], buf2[PATH_MAX];

  if (getcwd(buf1, sizeof(buf1)) == NULL
      || chdir(where) != 0
      || getcwd(buf2, sizeof(buf2)) == NULL
      || chdir(buf1) != 0)
  {
    fprintf(stderr, "could not chroot to %s\n", where);
    exit(-1);
  }

  chroot = buf2;
}
  • 功能：设置根目录，用于文件路径的转换。
  • 参数：
    • where：根目录路径。
  • 实现：
    • 保存当前工作目录。
    • 切换到指定的根目录并获取新的工作目录。
    • 切换回原来的工作目录。
    • 如果任何步骤失败，输出错误信息并退出程序；否则，将新的工作目录设置为 chroot。

这段代码实现了 syscall_t 类中的 sys_readlinkat 成员函数，其主要功能是模拟 readlinkat 系统调用，用于读取符号链接的内容。

  1. reg_t syscall_t::sys_readlinkat(reg_t dirfd, reg_t ppathname, reg_t ppathname_size, reg_t pbuf, reg_t bufsiz, reg_t a5, reg_t a6)
reg_t syscall_t::sys_readlinkat(reg_t dirfd, reg_t ppathname, reg_t ppathname_size,
                                reg_t pbuf, reg_t bufsiz, reg_t a5, reg_t a6)
  • 参数说明：
    • dirfd：目录文件描述符，用于指定相对路径的基准目录。
    • ppathname：指向符号链接路径名的内存地址。
    • ppathname_size：符号链接路径名的大小。
    • pbuf：用于存储符号链接内容的缓冲区的内存地址。
    • bufsiz：缓冲区的大小。
    • a5 和 a6：未使用的额外参数。
  1. 读取符号链接路径名
std::vector<char> pathname(ppathname_size);
memif->read(ppathname, ppathname_size, pathname.data());
  • 创建一个大小为 ppathname_size 的 std::vector 类型的 pathname 容器，用于存储符号链接的路径名。
  • 调用 memif 对象的 read 方法，从 ppathname 指向的内存地址读取 ppathname_size 字节的数据到 pathname 容器中。
  1. 创建存储符号链接内容的缓冲区
std::vector<char> buf(bufsiz);
  • 创建一个大小为 bufsiz 的 std::vector 类型的 buf 容器，用于存储符号链接的内容。
  1. 调用 readlinkat 系统调用
ssize_t ret = sysret_errno(AT_SYSCALL(readlinkat, dirfd, pathname.data(), buf.data(), bufsiz));
  • 使用 AT_SYSCALL 宏调用 readlinkat 系统调用，尝试读取符号链接的内容到 buf 容器中。
  • sysret_errno 函数用于处理系统调用的返回值，如果系统调用失败（返回 -1），则将错误码转换为合适的返回值。
  1. 将读取的内容写入指定缓冲区
if (ret > 0)
    memif->write(pbuf, ret, buf.data());
  • 如果 readlinkat 系统调用成功，且返回的字节数大于 0，则调用 memif 对象的 write 方法，将 buf 容器中的内容写入到 pbuf 指向的内存地址。
  1. 返回结果
return ret;
  • 返回 readlinkat 系统调用的结果，可能是读取的字节数或者错误码。

下一篇：RISC-V ISA Simulator系列之fesvr＜6＞

你可能感兴趣的:(riscv-isa-sim)

  • riscv-isa-sim的使用 a_weiming RISC-V&rocket-chip
    3.3riscv-isa-sim的使用主要资料来源：https://github.com/riscv/riscv-isa-sim/tree/d48f107dba6a96fb827cb47fdf290261feadeb35riscv-isa-sim是一个RISC-V指令的仿真器，riscv-isa-sim的正常运行需要依赖riscv-pk和riscv-fesvr工具。前面有对这些工具的说明。risc
  • mondb入手 木zi_鸣 mongodb
    windows 启动mongodb  编写bat文件， mongod --dbpath D:\software\MongoDBDATA mongod --help  查询各种配置 配置在mongob 打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口 启动配置文件配置， 数据更灵活 
  • 大型高并发高负载网站的系统架构 bijian1013 高并发负载均衡
            扩展Web应用程序 一.概念         简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种：         1.
  • DISPLAY变量和xhost(原创) czmmiao display
    DISPLAY 在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
  • 获取B/S客户端IP 周凡杨 java编程jspWeb浏览器
       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为：    String ip = InetAddress.getLocalHost().getHostAddress(); 然而对于WEB
  • 浅谈类和对象 朱辉辉33 编程
        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的， 占用存储空间。     类是由属性和方法构成的，基本格式是public  class 类名{ //定义属性 private/public 数据类型 属性名； //定义方法 publ
  • android activity与viewpager+fragment的生命周期问题 肆无忌惮_ viewpager
    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。 第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。 super.onResume(); bindService(intent, conn, BIND_AUTO_CREATE);
  • base64Encode对图片进行编码 843977358 base64图片encoder
    /** * 对图片进行base64encoder编码 * * @author mrZhang * @param path * @return */ public static String encodeImage(String path) { BASE64Encoder encoder = null; byte[] b = null; I
  • Request Header简介 aigo servlet
    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
  • HttpClient4.3 创建SSL协议的HttpClient对象 alleni123 httpclient爬虫ssl
    public class HttpClientUtils { public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){ SSLContext sslContext=null; try { sslContext=new SSLContextBuilder().l
  • java取反 -右移-左移-无符号右移的探讨 百合不是茶 位运算符 位移
    取反： 在二进制中第一位，1表示符数，0表示正数 byte a = -1; 原码：10000001 反码：11111110 补码：11111111 //异或: 00000000 byte b = -2; 原码：10000010 反码：11111101 补码：11111110 //异或: 00000001
  • java多线程join的作用与用法 bijian1013 java多线程
            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
  • Java发送http请求(get 与post方法请求) bijian1013 javaspring
    PostRequest.java package com.bijian.study; import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURL
  • 【Struts2二】struts.xml中package下的action配置项默认值 bit1129 struts.xml
    在第一部份，定义了struts.xml文件，如下所示：   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts
  • 【Kafka十三】Kafka Simple Consumer bit1129 simple
    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。 实际情况是需要将host和port绑定到一起，   package kafka.examples.lowlevel; import kafka.api.FetchRequest; import kafka.api.FetchRequestBuilder; impo
  • nodejs学习api ronin47 nodejs api
    NodeJS基础 什么是NodeJS JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。 每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
  • java-64.寻找第N个丑数 bylijinnan java
    public class UglyNumber { /** * 64.查找第N个丑数 具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url] * 题目：我们把只包含因子 2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
  • 二维数组（矩阵）对角线输出 bylijinnan 二维数组
    /** 二维数组 对角线输出 两个方向 例如对于数组： { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 }, slash方向输出： 1 5 2 9 6 3 13 10 7 4 14 11 8 15 12 16 backslash输出： 4 3
  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新) comsci 工作流
       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理    大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
  • redis常见使用 cuityang redis常见使用
    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets 引入jar包 jedis-2.1.0.jar  (本文下方提供下载) package redistest; import redis.clients.jedis.Jedis; public class Listtest
  • 配置多个redis dalan_123 redis
    配置多个redis客户端 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
  • attrib命令 dcj3sjt126com attr
      attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统.    只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护.    存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件. 
  • Yii使用公共函数 dcj3sjt126com yii
    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。 在入口文件index.php里添加 require_once('protected/function.php'); 即可对其引用，成为公用的函数集合。 function.php如下：   <?php /**   * This is the shortcut to D
  • linux 系统资源的查看（free、uname、uptime、netstat） eksliang netstatlinux unamelinux uptimelinux free
    linux 系统资源的查看 转载请出自出处：http://eksliang.iteye.com/blog/2167081   http://eksliang.iteye.com 一、free查看内存的使用情况 语法如下：   free [-b][-k][-m][-g] [-t] 参数含义 -b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
  • JAVA的位操作符 greemranqq 位运算JAVA位移<<>>>
    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。   1.按位操作符 ：    按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。    与（&）运算：    1&1 = 1, 1&0 = 0, 0&0 &
  • Web前段学习网站 ihuning Web
      Web前段学习网站 菜鸟学习：http://www.w3cschool.cc/   JQuery中文网：http://www.jquerycn.cn/   内存溢出：http://outofmemory.cn/#csdn.blog   http://www.icoolxue.com/   http://www.jikexue
  • 强强联合：FluxBB 作者加盟 Flarum justjavac r
    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
  • java统计在线人数（session存储信息的） macroli javaWeb
    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！   由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！ 我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。 1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。 public class Ses
  • bootstrp carousel初体验 快速构建图片播放 qiaolevip 每天进步一点点学习永无止境bootstrap纵观千象
    img{ border: 1px solid white; box-shadow: 2px 2px 12px #333; _width: expression(this.width > 600 ? "600px" : this.width + "px"); _height: expression(this.width &
  • SparkSQL读取HBase数据，通过自定义外部数据源 superlxw1234 sparksparksqlsparksql读取hbasesparksql外部数据源
    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源     前面文章介绍了SparSQL通过Hive操作HBase表。   SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
  • Spring Boot 1.3.0.M1发布 wiselyman spring boot
        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下：   1.提供一个新的sprin
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他