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

local:
	@make clean
	@make userprogs
	@sh ./gen_initcode.sh
	@make build platform=qemu
	@make fs
	@$(QEMU) $(QEMUOPTS)

#! /bin/bash

cd ~/OS/testsuits-for-oskernel/
sudo rm -rf ./riscv-syscalls-testing/user/build/
sudo rm -rf ./riscv-syscalls-testing/user/riscv64
docker run -ti --rm -v ./riscv-syscalls-testing:/testing -w /testing/user --privileged=true docker.educg.net/cg/os-contest:2024p6 /bin/bash -c "sh build-oscomp.sh"
cd ~/OS/xv6-os/
cp -r ~/OS/testsuits-for-oskernel/riscv-syscalls-testing/user/build/riscv64 .

timebase-frequency = <7800000>;

 _____         _     _  __                    _
|_   _|__  ___| |_  | |/ /___ _ __ _ __   ___| |
  | |/ _ \/ __| __| | ' // _ \ '__| '_ \ / _ \ |
  | |  __/\__ \ |_  | . \  __/ |  | | | |  __/ |
  |_|\___||___/\__| |_|\_\___|_|  |_| |_|\___|_|
================================================
| boot hart id          |                    6 |
| smp                   |                    8 |
| timebase frequency    |          10000000 Hz |
| dtb physical address  |           0x87e00000 |
------------------------------------------------

apt-get install device-tree-compiler
qemu-system-riscv64 -machine virt,dumpdtb=virt.dtb
dtc -I dtb -O dts -o virt.dts virt.dtb

timebase-frequency = <0x989680>;

#define INTERVAL     (390000000 / 200) // timer interrupt interval

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

struct timezone {
    int tz_minuteswest;     /* minutes west of Greenwich */
    int tz_dsttime;         /* type of DST correction */
};

int gettimeofday(struct timeval *tv, struct timezone *tz);

#define SYS_gettimeofday 169

struct timespec *ts;
int ret = syscall(SYS_gettimeofday, ts, 0);

// riscv-syscalls-testing/user/include/stddef.h
typedef struct
{
    uint64 sec;  // 自 Unix 纪元起的秒数
    uint64 usec; // 微秒数
} TimeVal;

// riscv-syscalls-testing/user/lib/syscall.c
int64 get_time()
{
    TimeVal time;
    int err = sys_get_time(&time, 0);
    if (err == 0)
    {
        return ((time.sec & 0xffff) * 1000 + time.usec / 1000);
    }
    else
    {
        return -1;
    }
}

/*
注意区分硬件 tick 和操作系统 tick：
- 硬件 tick：通过 r_time() 获取到的 tick 数，按照 CLOCK_FREQ 频率增长
- 操作系统 tick：通过 ticks 全局变量获取到的 tick 数，每 INTERVAL 个硬件 tick 增长 1 次

通过 README 或者在容器内获取设备树可以发现 QEMU 的硬件时钟计数器的更新频率（timebase-frequency，即 r_time() 获取到的硬件 tick 更新频率）为 virt 机器默认的 10000000 Hz（10 MHz）
而读取 bootloader/SBI/rustsbi-k210/kendryte-k210.dtsi 可以发现 K210 的硬件时钟计数器的更新频率为 7800000 Hz（7.8 MHz），所以我们发现这里实际上是原来是每 50 秒 200 个时钟中断，也即每秒 4 个时钟中断，ticks 这个全局变量按照 4ticks/s 增长，非常慢
所以这里改写为 (CLOCK_FREQ / 200)，即每秒触发 200 个时钟中断，也即 200 ticks/s，ticks 这个全局变量按照 200ticks/s 增长
*/
// #define INTERVAL     (390000000 / 200) // timer interrupt interval
#define CLOCK_FREQ   10000000 // 10 MHz
#define TICKS_PER_SECOND    200 // 每秒时钟中断次数
#define INTERVAL     (CLOCK_FREQ / TICKS_PER_SECOND) // timer interrupt interval

/**
 * @brief 实现 gettimeofday 系统调用，获取当前时间。
 * @param addr timespec 结构体存到的目标地址
 * @return 0 成功，-1 失败
 * @note 注意，根据测试样例的要求，需要返回 tv_usec 微秒而不是 Linux 标准中的 tv_nsec 纳秒
 */
uint64 sys_gettimeofday(void) {
  struct timespec ts;
  uint64 htick = r_time(); // 硬件(hardware) tick，注意全局变量 ticks 是操作系统(os) tick，中间差了 200 倍

  ts.tv_sec = htick / CLOCK_FREQ; // 换算成秒
  ts.tv_usec = (htick % CLOCK_FREQ) * 1000000 / CLOCK_FREQ; // 换算成微秒, 1μs = 10^-6 s

  if (get_and_copyout(0, (char *)&ts, sizeof(ts)) < 0) {
    return -1;
  }
  return 0;
}

int nanosleep(const struct timespec *duration, struct timespec *rem);

#define SYS_nanosleep 101

struct timespec {
    time_t tv_sec;        /* 秒 */
    long   tv_nsec;       /* 纳秒, 范围在0~999999999 */
};
const struct timespec *req, struct timespec *rem;
int ret = syscall(SYS_nanosleep, req, rem);

/**
 * @brief 实现 nanosleep 系统调用，睡眠指定时间。
 * @param req_addr 输入参数，指定的睡眠时间结构体 timespec 存放的地址，需要使用 copyin2 从用户空间拷贝到内核空间
 * @param rem_addr 输出参数，实际睡眠时间结构体 timespec 存放的地址，若实际睡眠时间小于指定睡眠时间，则返回剩余睡眠时间，反之返回 0，需要使用 copyout2 从内核空间拷贝到用户空间
 * @return 0 成功，-1 失败
 * @note 注意，根据测试样例的要求，需要睡眠时间以纳秒为单位
 */
uint64
sys_nanosleep(void)
{
  uint64 req_addr, rem_addr;
  struct timespec req_tv; // tv: timeval
  if (argaddr(0, &req_addr) < 0 || argaddr(1, &rem_addr) < 0) {
    return -1;
  }
  // 从用户空间拷贝到内核空间
  if (copyin2((char *)&req_tv, req_addr, sizeof(struct timespec)) < 0) {
    return -1;
  }

  uint64 target_ticks = req_tv.tv_sec * TICKS_PER_SECOND + req_tv.tv_usec * TICKS_PER_SECOND / 1000000;

  uint64 ticks0;
  acquire(&tickslock);
  ticks0 = ticks;
  while (ticks - ticks0 < target_ticks) {
    if (myproc()->killed) {
      // 如果输出参数 rem_addr 不为空，则返回剩余睡眠时间
      if (rem_addr != NULL) {
        uint64 elapsed_ticks = ticks - ticks0;
        uint64 rem_ticks = (target_ticks > elapsed_ticks) ? (target_ticks - elapsed_ticks) : 0;
        struct timespec rem_tv;
        rem_tv.tv_sec = rem_ticks / TICKS_PER_SECOND;
        rem_tv.tv_usec = (rem_ticks % TICKS_PER_SECOND) * 1000000 / TICKS_PER_SECOND;
        if (copyout2(rem_addr, (char *)&rem_tv, sizeof(struct timespec)) < 0) {
          release(&tickslock);
          return -1;
        }
      }
      release(&tickslock);
      return -1;
    }
    sleep(&ticks, &tickslock);
  }
  release(&tickslock);
  return 0;

}

int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);

#define SYS_clone 220

pid_t ret = syscall(SYS_clone, flags, stack, ptid, tls, ctid)

// riscv-syscalls-testing/user/include/unistd.h
pid_t clone(int (*fn)(void *arg), void *arg, void *stack, size_t stack_size, unsigned long flags);

// riscv-syscalls-testing/user/src/oscomp/clone.c
#include "stdio.h"
#include "stdlib.h"
#include "unistd.h"

size_t stack[1024] = {0};
static int child_pid;

static int child_func(void){
    printf("  Child says successfully!\n");
    return 0;
}

void test_clone(void){
    TEST_START(__func__);
    int wstatus;
    child_pid = clone(child_func, NULL, stack, 1024, SIGCHLD);
    assert(child_pid != -1);
    if (child_pid == 0){
	exit(0);
    }else{
	if(wait(&wstatus) == child_pid)
	    printf("clone process successfully.\npid:%d\n", child_pid);
	else
	    printf("clone process error.\n");
    }

    TEST_END(__func__);
}

int main(void){
    test_clone();
    return 0;
}

riscv64-linux-gnu-objdump -d riscv64/clone > clone.asm

riscv64/clone:     file format elf64-littleriscv


Disassembly of section .text:

0000000000001000 <_start>:
    1000:	850a                	mv	a0,sp
    1002:	0f40006f          	j	10f6 <__start_main>

0000000000001006 <child_func>:
    1006:	1141                	addi	sp,sp,-16
    1008:	00001517          	auipc	a0,0x1
    100c:	02850513          	addi	a0,a0,40 # 2030 <__clone+0x2a>
    1010:	e406                	sd	ra,8(sp)
    1012:	306000ef          	jal	ra,1318 <printf>
    1016:	60a2                	ld	ra,8(sp)
    1018:	4501                	li	a0,0
    101a:	0141                	addi	sp,sp,16
    101c:	8082                	ret

000000000000101e <test_clone>:
    101e:	1101                	addi	sp,sp,-32
    1020:	00001517          	auipc	a0,0x1
    1024:	03050513          	addi	a0,a0,48 # 2050 <__clone+0x4a>
    1028:	ec06                	sd	ra,24(sp)
    102a:	e822                	sd	s0,16(sp)
    102c:	2ca000ef          	jal	ra,12f6 <puts>
    1030:	00003517          	auipc	a0,0x3
    1034:	0e050513          	addi	a0,a0,224 # 4110 <__func__.1191>
    1038:	2be000ef          	jal	ra,12f6 <puts>
    103c:	00001517          	auipc	a0,0x1
    1040:	02c50513          	addi	a0,a0,44 # 2068 <__clone+0x62>
    1044:	2b2000ef          	jal	ra,12f6 <puts>
    1048:	4745                	li	a4,17
    104a:	40000693          	li	a3,1024
    104e:	00001617          	auipc	a2,0x1
    1052:	0ba60613          	addi	a2,a2,186 # 2108 <stack>
    1056:	4581                	li	a1,0
    1058:	00000517          	auipc	a0,0x0
    105c:	fae50513          	addi	a0,a0,-82 # 1006 <child_func>
    1060:	5ab000ef          	jal	ra,1e0a <clone>

 // 中间无关代码省略之

0000000000001e0a <clone>:
    1e0a:	85b2                	mv	a1,a2
    1e0c:	863a                	mv	a2,a4
    1e0e:	c191                	beqz	a1,1e12 <clone+0x8>
    1e10:	95b6                	add	a1,a1,a3
    1e12:	4781                	li	a5,0
    1e14:	4701                	li	a4,0
    1e16:	4681                	li	a3,0
    1e18:	2601                	sext.w	a2,a2
    1e1a:	1ec0006f          	j	2006 <__clone>

0000000000002006 <__clone>:
    2006:	15c1                	addi	a1,a1,-16
    2008:	e188                	sd	a0,0(a1)
    200a:	e594                	sd	a3,8(a1)
    200c:	8532                	mv	a0,a2
    200e:	863a                	mv	a2,a4
    2010:	86be                	mv	a3,a5
    2012:	8742                	mv	a4,a6
    2014:	0dc00893          	li	a7,220
    2018:	00000073          	ecall
    201c:	c111                	beqz	a0,2020 <__clone+0x1a>
    201e:	8082                	ret
    2020:	6582                	ld	a1,0(sp)
    2022:	6522                	ld	a0,8(sp)
    2024:	9582                	jalr	a1
    2026:	05d00893          	li	a7,93
    202a:	00000073          	ecall

         高地址  ^
                |
       0x2508   +----------------+ <-- 阶段二计算出的栈顶
                |  arg (NULL/0)  | <-- sd a3, 8(a1) 写入这里 (地址 0x2500)
       0x2500   +----------------+
                |fn (&child_func)| <-- sd a0, 0(a1) 写入这里 (地址 0x24F8)
       0x24F8   +----------------+ <-- 最终传给内核的 a1 指针
                |                |
                |(useable space) |
                |      ...       |
                |                |
       0x2108   +----------------+ <-- stack 数组基地址
                |
         低地址  v

// kernel/proc.c

int
clone(void)
{
  // ... 与 fork 类似的进程分配、内存拷贝等 ...
  struct proc* p = myproc();
  uint64 stack;

  // ...
  *(np->trapframe) = *(p->trapframe);

  argaddr(1, &stack); // 从第二个参数获取用户指定的栈顶地址
  // 如果用户提供了栈地址
  if (stack != NULL) {
    uint64 fn, arg;
    // 从用户指定的栈中读取 fn 和 arg
    // 注意：这里需要确保 stack 是有效的用户地址
    // 注意 copyin 比 copyin2 更安全，未修改前 copyin2 只做了简单的边界检查 srcva + len > sz
    // 而 sz 与映射页表无关，从而无法处理映射页表
    if (copyin(p->pagetable, (char*)&fn, stack, sizeof(fn)) < 0 ||
      copyin(p->pagetable, (char*)&arg, stack + 8, sizeof(arg)) < 0) {
      freeproc(np);
      release(&np->lock);
      return -1;
    }
  }

  // 让子进程的返回值为 0
  np->trapframe->a0 = 0;
  // ...
}

/**
 * @brief 实现 clone 系统调用，创建子进程/线程。
 * @return 0 成功，-1 失败
 */
uint64 sys_clone(void) {
  return clone();
}

pid_t wait(int *wstatus);
pid_t waitpid(pid_t pid, int *wstatus, int options);

#define SYS_wait4 260

pid_t pid, int *status, int options;
pid_t ret = syscall(SYS_wait4, pid, status, options);

// kernel/proc.c

// 原签名: int wait(uint64 addr)
// 新签名:
int
wait(int wpid, uint64 addr)
{
  // ...
}

// kernel/proc.c wait() 函数内

if (np->parent == p) {
  // 如果指定了 wpid，但当前遍历到的子进程 np 不是目标，则跳过
  if (wpid > 0 && np->pid != wpid) {
    havekids = 1; // 标记仍然有其他子进程存在
    continue;
  }
  // ... 找到目标子进程（或任意子进程）后的处理逻辑
}

// kernel/proc.c wait() 函数内

// ...
status = np->xstate << 8;
if (addr != 0 && copyout2(addr, (char*)&status, sizeof(status)) < 0) {
  // ... 错误处理
}
// ...

// kernel/sysproc.c

uint64
sys_wait(void)
{
  uint64 p;
  if(argaddr(0, &p) < 0)
    return -1;
  // 原来是 wait(p);
  return wait(-1, p);
}

// kernel/sysproc.c

uint64
sys_sched_yield(void) {
  yield();
  return 0;
}

// kernel/sysproc.c

uint64
sys_getppid(void)
{
  return myproc()->parent->pid;
}

qwe
make clean
make local

hart 0 init done
// 前略
init: starting sh
========== START test_wait ==========
This is child process
wait child success.
wstatus: 0
========== END test_wait ==========
init: starting sh
========== START test_waitpid ==========
This is child process
waitpid successfully.
wstatus: 3
========== END test_waitpid ==========
init: starting sh
========== START test_clone ==========
  Child says successfully!
clone process successfully.
pid:12
========== END test_clone ==========
init: starting sh
========== START test_fork ==========
  child process.
  parent process. wstatus:0
========== END test_fork ==========
init: starting sh
========== START test_execve ==========
  I am test_echo.
execve success.
========== END main ==========
init: starting sh
========== START test_getppid ==========
  getppid success. ppid : 1
========== END test_getppid ==========
init: starting sh
========== START test_exit ==========
exit OK.
========== END test_exit ==========
init: starting sh
========== START test_yield ==========
  I am child process:   I am child process: 21. iteration 1.
  I am child process: 22. iteration 2.
20. iteration 0.
  I am child process: 21. iteration 1.
  I am child process: 20. iteration 0.
  I am child process: 21. iteration 1.
  I am child process: 22. iteration 2.
  I am child process: 20. iteration 0.
  I am child process: 21. iteration 1.
  I am child process: 22. iteration 2.
  I am child process: 21. iteration 1.
  I am child process: 22. iteration 2.
  I am child process: 20. iteration 0.
  I am child process: 22. iteration 2.
  I am child process: 20. iteration 0.
========== END test_yield ==========
init: starting sh
========== START test_gettimeofday ==========
gettimeofday success.
start:836, end:911
interval: 75
========== END test_gettimeofday ==========
init: starting sh
========== START test_sleep ==========
sleep success.
========== END test_sleep ==========