更适合北大宝宝体质的 xv6 OS Lab 踩坑记 - Part4

int dup(int oldfd);

#define SYS_dup 23

int dup3(int oldfd, int newfd, int flags);

#define SYS_dup3 24

/**
 * @brief 实现 dup3 系统调用，复制文件描述符
 * @param old_fd 被复制的文件描述符
 * @param new_fd 指定的新的文件描述符
 * @return 成功则返回新的文件描述符 new_fd，失败返回 -1
 * @note dup3 与 dup 的主要区别在于可以指定 new_fd。如果 new_fd 已经被占用，会先关闭它。
 */
uint64
sys_dup3(void)
{
  struct file* f;
  int old_fd, new_fd;

  // 1. 获取参数
  if (argfd(0, &old_fd, &f) < 0 || argint(1, &new_fd) < 0) {
    return -1;
  }

  // 2. 参数检查
  if (new_fd < 0 || new_fd >= NOFILE) {
    return -1;
  }
  if (new_fd == old_fd) {
    return -1;
  }

  struct proc* p = myproc();

  // 3. 如果 new_fd 已被占用，先关闭
  if (p->ofile[new_fd] != NULL) {
    fileclose(p->ofile[new_fd]);
  }

  // 4. 复制文件实例并赋给 new_fd
  p->ofile[new_fd] = filedup(f);

  return new_fd;
}

// kernel/include/param.h
#define NOFILE      256  // open files per process

#define FAT32_MAX_PATH      260
struct dirent {
    char  filename[FAT32_MAX_FILENAME + 1];
}

typedef struct short_name_entry {
    char        name[CHAR_SHORT_NAME];
    uint8       attr;
    uint8       _nt_res;
    uint8       _crt_time_tenth;
    uint16      _crt_time;
    uint16      _crt_date;
    uint16      _lst_acce_date;
    uint16      fst_clus_hi;
    uint16      _lst_wrt_time;
    uint16      _lst_wrt_date;
    uint16      fst_clus_lo;
    uint32      file_size;
} __attribute__((packed, aligned(4))) short_name_entry_t;

typedef struct long_name_entry {
    uint8       order;
    wchar       name1[5];
    uint8       attr;
    uint8       _type;
    uint8       checksum;
    wchar       name2[6];
    uint16      _fst_clus_lo;
    wchar       name3[2];
} __attribute__((packed, aligned(4))) long_name_entry_t;

union dentry {
    short_name_entry_t  sne;
    long_name_entry_t   lne;
};

['K', 'E', 'R', 'N', 'E', 'L', ' ', ' ', 'C', ' ', ' ']

uint16      fst_clus_hi;
uint16      fst_clus_lo;

int enext(struct dirent *dp, struct dirent *ep, uint off, int *count);

int getdents(unsigned int fd, struct linux_dirent *dirp, unsigned int count);

#define SYS_getdents64 61

// kernel/include/fat32.h
#define DT_UNKNOWN 0
#define DT_FIFO 1
#define DT_CHR 2
#define DT_DIR 4
#define DT_BLK 6
#define DT_REG 8
#define DT_LNK 10
#define DT_SOCK 12
#define DT_WHT 14

struct dirent64 {
    uint64 d_ino;
    uint64 d_off;
    unsigned short d_reclen;
    unsigned char d_type;
    char d_name[FAT32_MAX_FILENAME + 1];
};

/**
 * @brief 实现 getdents 系统调用，读取目录项
 * @param fd 目录的文件描述符
 * @param addr 用户空间缓冲区的地址，用于存放读取结果
 * @param len 缓冲区的长度
 * @return 成功则返回读取的字节数，读到目录末尾返回 0，失败返回 -1
 * @note getdents 是 ls 等命令的底层实现。
 */
uint64 sys_getdents(void) {
  int fd, len;
  uint64 addr;
  struct file* f;
  int nread = 0;
  int reclen = (int)sizeof(struct dirent64);

  if (argfd(0, &fd, &f) < 0 || argaddr(1, &addr) < 0 || argint(2, &len) < 0) {
    return -1;
  }

  // 缓冲区太小，至少要能装下一个目录项
  if (len < reclen) {
    return 0;
  }

  if (fd < 0 || fd >= NOFILE) {
    return -1;
  }

  // 必须是目录且可读
  if (f->readable == 0) {
    return -1;
  }

  if (f->ep == 0 || !(f->ep->attribute & ATTR_DIRECTORY)) {
    return -1;
  }

  // 循环读取，直到缓冲区满或目录读完
  while (nread + reclen <= len) {
    struct dirent de;
    int count = 0;
    int ret;

    elock(f->ep);
    // enext 会找到下一个有效的目录项，并填充到 de 中
    // 它会跳过空目录项和 LNE，直接返回一个完整的 SNE
    while ((ret = enext(f->ep, &de, f->off, &count)) == 0) {
      f->off += count * 32;
    }
    eunlock(f->ep);

    if (ret == -1) { // 读到目录末尾
      return nread; // 退出循环，返回已经读取的字节数
    }

    // 将内核的 dirent 格式转换为用户态的 dirent64 格式
    struct dirent64 out;
    out.d_ino = 0; // FAT32 没有 inode number 的概念
    out.d_off = f->off;
    out.d_reclen = sizeof(struct dirent64);
    if (de.attribute & ATTR_DIRECTORY) {
      out.d_type = DT_DIR;
    }
    else {
      out.d_type = DT_REG;
    }
    safestrcpy(out.d_name, de.filename, FAT32_MAX_FILENAME + 1);

    // 拷贝到用户空间
    if (copyout2(addr, (char*)&out, sizeof(out)) < 0) {
      return -1;
    }

    // 更新指针和计数器
    addr += sizeof(out);
    nread += sizeof(out);
    f->off += count * 32;
  }

  return nread;
}

int mkdirat(int dirfd, const char *pathname, mode_t mode);

#define SYS_mkdirat 34

/**
 * @brief 实现 mkdirat 系统调用，在指定位置创建目录
 * @param dirfd 目录文件描述符
 * @param path 目录路径
 * @param mode 创建模式（本次实验中未使用）
 * @return 成功返回 0，失败返回 -1
 * @note 核心是复用 get_path 将路径转换为绝对路径。
 */
uint64
sys_mkdirat(void)
{
  char path[FAT32_MAX_PATH];
  int dirfd, mode;
  struct dirent* ep;

  if (
    argint(0, &dirfd) < 0 ||
    argstr(1, path, FAT32_MAX_PATH) < 0 ||
    argint(2, &mode) < 0) {
    return -1;
  }

  if (strlen(path) == 0) {
    return -1;
  }

  // 将路径转换为绝对路径
  if (get_path(path, dirfd) < 0) {
    return -1;
  }

  // 调用底层 create 函数创建目录
  ep = create(path, T_DIR, 0);
  if (ep == NULL) {
    return -1;
  }

  // 释放资源并返回
  eunlock(ep);
  eput(ep);
  return 0;
}

int unlinkat(int dirfd, const char *pathname, int flags);

#define SYS_unlinkat 35

/**
 * @brief 实现 unlinkat 系统调用，删除文件或目录
 * @param dirfd 目录文件描述符
 * @param path 文件或目录的路径
 * @param flags 标志位，AT_REMOVEDIR 用于删除目录
 * @return 成功返回 0，失败返回 -1
 * @note 需要根据 flags 和文件类型（文件/目录）进行精细的判断。
 */
uint64 sys_unlinkat(void) {
  char path[FAT32_MAX_PATH];
  int dirfd, flags;
  struct dirent* ep;

  if (
    argint(0, &dirfd) < 0 ||
    argstr(1, path, FAT32_MAX_PATH) < 0 ||
    argint(2, &flags) < 0
  ) {
    return -1;
  }

  if (strlen(path) == 0) {
    return -1;
  }

  if (get_path(path, dirfd) < 0) {
    return -1;
  }

  char* basename = path;
  char* p = path;

  // 禁止删除 "." 和 ".."
  // 找到最后一个 '/'
  while (*p) {
    if (*p == '/') {
      basename = p + 1;
    }
    p++;
  }
  // 现在 basename 指向路径的最后一部分
  if (strncmp(basename, ".", 1) == 0 || strncmp(basename, "..", 2) == 0) {
    return -1;
  }

  // 获取路径对应的 dirent
  ep = ename(path);
  if (ep == NULL) {
    return -1;
  }
  elock(ep);
  if (ep->attribute & ATTR_DIRECTORY) {
    eremove(ep);
  }

  // 不允许删除挂载点
  if (is_mounted(ep)) {
    eunlock(ep);
    eput(ep);
    return -1;
  }

  // 根据文件类型和 flags 进行判断
  if (ep->attribute & ATTR_DIRECTORY) {
    // 意图删除目录，但 flags 不对
    if (!(flags & AT_REMOVEDIR)) {
      eunlock(ep);
      eput(ep);
      return -1;
    }
    // 目录非空
    if (!isdirempty(ep)) {
      eunlock(ep);
      eput(ep);
      return -1;
    }
  }
  else {
    // 意图删除文件，但 flags 不对
    if (flags & AT_REMOVEDIR) {
      eunlock(ep);
      eput(ep);
      return -1;
    }
  }

  // 执行删除
  elock(ep->parent);
  eremove(ep);
  eunlock(ep->parent);
  eunlock(ep);
  eput(ep);
  return 0;
}

int fstat(int fd, struct stat *statbuf);

#define SYS_fstat 80

// kernel/include/stat.h
struct kstat {
  uint64 st_dev;
  uint64 st_ino;
  uint st_mode;
  uint32 st_nlink;
  uint32 st_uid;
  uint32 st_gid;
  uint64 st_rdev;
  unsigned long __pad;
  long int st_size;
  uint32 st_blksize;
  int __pad2;
  uint64 st_blocks;
  long st_atime_sec;
  long st_atime_nsec;
  long st_mtime_sec;
  long st_mtime_nsec;
  long st_ctime_sec;
  long st_ctime_nsec;
  unsigned __unused[2];
};

/**
 * @brief 将 dirent 信息填充到 kstat 结构体中
 * @param de 源 dirent
 * @param st 目标 kstat 结构体指针
 * @note 这是 fstat 的核心辅助函数，用于对齐 Linux 的 stat 结构。
 */
void ekstat(struct dirent* de, struct kstat* st)
{
    memset(st, 0, sizeof(*st));
    st->st_dev = de->dev;
    st->st_ino = 0;

    st->st_mode = (de->attribute & ATTR_DIRECTORY) ? DT_DIR : DT_REG;

    st->st_nlink = 1;
    st->st_rdev = 0;
    st->st_size = de->file_size;
    st->st_blksize = 4096;
    st->st_blocks = (st->st_size + 511) / 512;
}

// Get metadata about file f.
// addr is a user virtual address, pointing to a struct stat.
int
filestat(struct file *f, uint64 addr)
{
  // struct proc *p = myproc();
  // 这行修改为使用 kstat 结构体
  struct kstat st;

  if(f->type == FD_ENTRY){
    elock(f->ep);
    // 这行修改为使用 ekstat 函数
    ekstat(f->ep, &st);
    eunlock(f->ep);
    // if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
    if(copyout2(addr, (char *)&st, sizeof(st)) < 0)
      return -1;
    return 0;
  }
  return -1;
}

int mount(const char *source, const char *target,
          const char *filesystemtype, unsigned long mountflags,
          const void *data);

int umount2(const char *target, int flags);

#define SYS_mount 40
#define SYS_umount2 39

// kernel/include/fat32.h
#define NMOUNT 16

struct mount {
    struct dirent* de;
    char path[FAT32_MAX_PATH];
    int used;
};

// kernel/sysfile.c
struct mount mounts[NMOUNT];

/**
 * @brief 实现 mount 系统调用（伪实现）
 * @param src 源设备（未使用）
 * @param dst 挂载点路径
 * @param fstype 文件系统类型（未使用）
 * @param flags 标志（未使用）
 * @param data 数据（未使用）
 * @return 成功返回 0，失败返回 -1
 * @note 仅记录挂载点信息，不执行实际挂载操作。
 */
uint64 sys_mount(void) {
  char src[FAT32_MAX_PATH];
  char dst[FAT32_MAX_PATH];
  char fstype[32];
  int flags;
  uint64 data;

  if (
    argstr(0, src, FAT32_MAX_PATH) < 0 ||
    argstr(1, dst, FAT32_MAX_PATH) < 0 ||
    argstr(2, fstype, sizeof(fstype)) < 0 ||
    argint(3, &flags) < 0 ||
    argaddr(4, &data) < 0
  ) {
    return -1;
  }

  if (get_path(dst, AT_FDCWD) < 0) {
    return -1;
  }

  struct dirent* dst_ep = ename(dst);
  if (dst_ep == NULL) {
    return -1;
  }

  elock(dst_ep);
  if (!(dst_ep->attribute & ATTR_DIRECTORY)) {
    eunlock(dst_ep);
    eput(dst_ep);
    return -1;
  }

  // 检查是否是挂载点，实现逻辑见后文，实际上没用，可以删掉
  if (is_mounted(dst_ep) || find_mount(dst) >= 0) {
    eunlock(dst_ep);
    eput(dst_ep);
    return -1;
  }

  int idx = -1;
  for (int i = 0; i < NMOUNT; i++) {
    if (!mounts[i].used) {
      idx = i;
      break;
    }
  }
  if (idx == -1) {
    eunlock(dst_ep);
    eput(dst_ep);
    return -1;
  }
  mounts[idx].de = edup(dst_ep);
  mounts[idx].used = 1;
  safestrcpy(mounts[idx].path, dst, FAT32_MAX_PATH);
  eunlock(dst_ep);
  eput(dst_ep);
  return 0;
}

/**
 * @brief 实现 umount 系统调用（伪实现）
 * @param path 挂载点路径
 * @param flags 标志（未使用）
 * @return 成功返回 0，失败返回 -1
 * @note 仅清除挂载点信息，不执行实际卸载操作。
 */
uint64 sys_umount(void) {
  char path[FAT32_MAX_PATH];
  int flags;

  if (
    argstr(0, path, FAT32_MAX_PATH) < 0 ||
    argint(1, &flags) < 0
  ) {
    return -1;
  }

  if (get_path(path, AT_FDCWD) < 0) {
    return -1;
  }

  int idx = find_mount(path);
  if (idx < 0) {
    return -1;
  }

  if (mounts[idx].de) {
    eput(mounts[idx].de);
  }

  mounts[idx].de = NULL;
  safestrcpy(mounts[idx].path, "", FAT32_MAX_PATH);
  mounts[idx].used = 0;

  return 0;
}

// kernel/fat32.c

// 全局挂载点数组的外部声明
extern struct mount mounts[NMOUNT];

/**
 * @brief 检查一个 dirent 是否是挂载点
 * @param de 要检查的 dirent
 * @return 如果是挂载点返回 1，否则返回 0
 */
int is_mounted(const struct dirent* de) {
    for (int i = 0; i < NMOUNT; i++) {
        if (mounts[i].used && mounts[i].de == de) {
            return 1;
        }
    }
    return 0;
}

/**
 * @brief 根据路径查找挂载点
 * @param path 要查找的路径
 * @return 如果找到，返回 mount 数组的索引，否则返回 -1
 */
int find_mount(const char* path) {
    for (int i = 0; i < NMOUNT; i++) {
        if (mounts[i].used && strncmp(mounts[i].path, path, FAT32_MAX_PATH) == 0) {
            return i;
        }
    }
    return -1;
}