optinal finished

.lldbinit

@@ -0,0 +1,5 @@
+settings set target.default-arch riscv64
+platform select remote-gdb-server
+process connect connect://127.0.0.1:26000
+target create kernel/kernel
+settings set stop-disassembly-display always

Makefile

@@ -194,6 +194,9 @@ UPROGS=\
 	$U/_primes\
 	$U/_find\
 	$U/_xargs\
+	$U/_trace\
+	$U/_sysinfo\
+	$U/_sysinfotest\
 
 
 

answers-syscall.txt

@@ -0,0 +1,18 @@
+在xv6中，当执行到地址 0x3ffffff11c 处的 sret 指令时，特权级和执行流程的变化如下：
+
+1. 特权级变化  
+   - 执行前：核心态（S模式，特权级 1）  
+   - 执行后：用户态（U模式，特权级 0）  
+   sret 指令会从 sstatus 寄存器中恢复之前的特权级（由 SPP 位决定）。在进入陷阱处理时，处理器已自动将用户态的特权级（0）保存到 sstatus.SPP，因此 sret 会将特权级切换回用户态。
+
+2. 恢复点地址  
+   恢复点地址由 sepc 寄存器指定。在进入陷阱处理时，sepc 被设置为触发 ecall 的下一条指令地址（即 0x14）。因此，sret 执行后，程序会跳转到 0x14 处继续执行用户代码。
+
+3. 执行的函数  
+   sret 返回后，用户程序会从 0x14 处继续执行。根据 initcode.S 的代码，0x14 是 ecall 指令的下一条地址。若 exec 系统调用成功，用户地址空间会被替换为新程序（如 init），此时 sret 返回后直接进入新程序的入口点。若 exec 失败（理论上不会发生），则会继续执行 initcode.S 中 ecall 后的代码（但实际代码中 ecall 后无其他指令）。
+
+综上所述
+- 特权级：核心态（1）→ 用户态（0）  
+- 恢复点地址：0x14（用户代码中 ecall 的下一条指令）  
+- 执行函数：若 exec 成功，执行新程序（如 init）；否则继续 initcode.S 的后续代码（实际无后续指令）。
+

conf/lab.mk

@@ -1 +1 @@
-LAB=util
+LAB=syscall

grade-lab-syscall

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+
+import re
+from gradelib import *
+
+r = Runner(save("xv6.out"))
+
+@test(5, "answers-syscall.txt")
+def test_answers():
+    # just a simple sanity check, will be graded manually
+    check_answers("answers-syscall.txt")
+
+@test(5, "trace 32 grep")
+def test_trace_32_grep():
+    r.run_qemu(shell_script([
+        'trace 32 grep hello README'
+    ]))
+
+    sys_cnt = {
+    'read' : 0
+    }
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 1023'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 961'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 321'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 0'
+    r.match(s)
+
+@test(5, "trace all grep")
+def test_trace_all_grep():
+    r.run_qemu(shell_script([
+        'trace 2147483647 grep hello README'
+    ]))
+
+    sys_cnt = {
+    'read' : 0,
+    'trace' : 0,
+    'exec' : 0,
+    'open' : 0,
+    'close' : 0,
+    'fork' : 0,
+    }
+
+    sys_cnt['trace'] += 1
+    s = r'^\d+: syscall trace\(trace counts: ' + str(sys_cnt['trace']) + r'\) -> 0'
+    r.match(s)
+
+    sys_cnt['exec'] += 1
+    s = r'^\d+: syscall exec\(trace counts: ' + str(sys_cnt['exec']) + r'\) -> 3'
+    r.match(s)
+
+    sys_cnt['open'] += 1
+    s = r'^\d+: syscall open\(trace counts: ' + str(sys_cnt['open']) + r'\) -> 3'
+    r.match(s)
+
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 1023'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 961'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 321'
+    r.match(s)
+
+    sys_cnt['read'] += 1
+    s = r'^\d+: syscall read\(trace counts: ' + str(sys_cnt['read']) + r'\) -> 0'
+    r.match(s)
+
+    sys_cnt['close'] += 1
+    s = r'^\d+: syscall close\(trace counts: ' + str(sys_cnt['close']) + r'\) -> 0'
+    r.match(s)
+
+@test(5, "trace nothing")
+def test_trace_nothing():
+    r.run_qemu(shell_script([
+        'grep hello README'
+    ]))
+    r.match(no=[".* syscall .*"])
+
+@test(5, "trace children")
+def test_trace_children():
+    r.run_qemu(shell_script([
+        'trace 2 usertests forkforkfork'
+    ]))
+
+    sys_cnt = {
+    'read' : 0,
+    'trace' : 0,
+    'exec' : 0,
+    'open' : 0,
+    'close' : 0,
+    'fork' : 0,
+    }
+
+    sys_cnt['fork'] += 1
+    s = r'3: syscall fork\(trace counts: ' + str(sys_cnt['fork']) + r'\) -> 4'
+    r.match(s)
+    
+    s = r'^5: syscall fork\(trace counts: \d+\) -> \d+'
+    r.match(s)
+    
+    s = r'^6: syscall fork\(trace counts: \d+\) -> \d+'
+    r.match(s)
+
+    s = r'^\d+: syscall fork\(trace counts: \d+\) -> -1'
+    r.match(s)
+    
+    r.match('^ALL TESTS PASSED')
+
+@test(14, "sysinfotest")
+def test_sysinfotest():
+    r.run_qemu(shell_script([
+        'sysinfotest'
+    ]))
+    r.match('^sysinfotest: OK', no=[".* FAIL .*"])
+
+@test(1, "time")
+def test_time():
+    check_time()
+
+run_tests()
+

grade-lab-util

@@ -1,86 +0,0 @@
-#!/usr/bin/env python3
-
-import re
-from gradelib import *
-
-r = Runner(save("xv6.out"))
-
-@test(5, "sleep, no arguments")
-def test_sleep_no_args():
-    r.run_qemu(shell_script([
-        'sleep'
-    ]))
-    r.match(no=["exec .* failed", "$ sleep\n$"])
-
-@test(5, "sleep, returns")
-def test_sleep_no_args():
-    r.run_qemu(shell_script([
-        'sleep',
-        'echo OK'
-    ]))
-    r.match('^OK$', no=["exec .* failed", "$ sleep\n$"])
-
-@test(10, "sleep, makes syscall")
-def test_sleep():
-    r.run_qemu(shell_script([
-        'sleep 10',
-        'echo FAIL'
-    ]), stop_breakpoint('sys_sleep'))
-    r.match('\\$ sleep 10', no=['FAIL'])
-
-@test(20, "pingpong")
-def test_pingpong():
-    r.run_qemu(shell_script([
-        'pingpong', 'echo OK'
-    ]))
-    r.match('^\\d+: received ping$', '^\\d+: received pong$', '^OK$')
-
-@test(20, "primes")
-def test_primes():
-    r.run_qemu(shell_script([
-        'primes', 'echo OK'
-    ]))
-    args = ['prime %d' % i for i in [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]]
-    args.append('^OK$')
-    r.match(*args)
-
-@test(10, "find, in current directory")
-def test_find_curdir():
-    fn = random_str()
-    r.run_qemu(shell_script([
-        'echo > %s' % fn,
-        'find . %s' % fn
-    ]))
-    r.match('./%s' % fn)
-
-@test(10, "find, recursive")
-def test_find_recursive():
-    needle = random_str()
-    dirs = [random_str() for _ in range(3)]
-    r.run_qemu(shell_script([
-        'mkdir %s' % dirs[0],
-        'echo > %s/%s' % (dirs[0], needle),
-        'mkdir %s/%s' % (dirs[0], dirs[1]),
-        'echo > %s/%s/%s' % (dirs[0], dirs[1], needle),
-        'mkdir %s' % dirs[2],
-        'echo > %s/%s' % (dirs[2], needle),
-        'find . %s' % needle
-    ]))
-    r.match('./%s/%s' % (dirs[0], needle),
-            './%s/%s/%s' % (dirs[0], dirs[1], needle),
-            './%s/%s' % (dirs[2], needle))
-
-@test(19, "xargs")
-def test_xargs():
-    r.run_qemu(shell_script([
-        'sh < xargstest.sh',
-        'echo DONE',
-    ], 'DONE'))
-    matches = re.findall("hello", r.qemu.output)
-    assert_equal(len(matches), 3, "Number of appearances of 'hello'")
-
-@test(1, "time")
-def test_time():
-    check_time()
-    
-run_tests()

kernel/defs.h

@@ -63,6 +63,7 @@ void ramdiskrw(struct buf *);
 void *kalloc(void);
 void kfree(void *);
 void kinit(void);
+int freemem(void);
 
 // log.c
 void initlog(int, struct superblock *);
@@ -106,6 +107,8 @@ void yield(void);
 int either_copyout(int user_dst, uint64 dst, void *src, uint64 len);
 int either_copyin(void *dst, int user_src, uint64 src, uint64 len);
 void procdump(void);
+int proc_size(void);
+int update_load(void);
 
 // swtch.S
 void swtch(struct context *, struct context *);

kernel/kalloc.c

@@ -7,6 +7,7 @@
 #include "memlayout.h"
 #include "spinlock.h"
 #include "riscv.h"
+#include "proc.h"
 #include "defs.h"
 
 void freerange(void *pa_start, void *pa_end);
@@ -80,3 +81,17 @@ kalloc(void)
     memset((char*)r, 5, PGSIZE); // fill with junk
   return (void*)r;
 }
+
+int 
+freemem(void)
+{
+  struct run* p = kmem.freelist;
+  uint64 num = 0;
+  while (p) {
+    num += 1;
+    p = p->next;
+  }
+  return num * PGSIZE;
+}
+
+

kernel/proc.c

@@ -5,6 +5,9 @@
 #include "spinlock.h"
 #include "proc.h"
 #include "defs.h"
+#include "sysinfo.h"
+
+uint64 current_load = 0;
 
 struct cpu cpus[NCPU];
 
@@ -146,6 +149,9 @@ found:
   p->context.ra = (uint64)forkret;
   p->context.sp = p->kstack + PGSIZE;
 
+  // 初始化计数器
+  memset(p->syscall_counts, 0, sizeof(p->syscall_counts));
+
   return p;
 }
 
@@ -310,6 +316,8 @@ fork(void)
 
   safestrcpy(np->name, p->name, sizeof(p->name));
 
+  // 复制掩码
+  np->tracemask = p->tracemask;
   pid = np->pid;
 
   release(&np->lock);
@@ -446,6 +454,7 @@ scheduler(void)
 {
   struct proc *p;
   struct cpu *c = mycpu();
+  /*update_load_avg();*/
 
   c->proc = 0;
   for(;;){
@@ -462,6 +471,7 @@ scheduler(void)
         // before jumping back to us.
         p->state = RUNNING;
         c->proc = p;
+        current_load += 1;
         swtch(&c->context, &p->context);
 
         // Process is done running for now.
@@ -686,3 +696,18 @@ procdump(void)
     printf("\n");
   }
 }
+
+int
+proc_size()
+{
+  int i =0, n = 0;
+  for (; i < NPROC; ++i) {
+    if (proc[i].state != UNUSED) n += 1;
+  }
+  return n;
+}
+
+int
+update_load() {
+  return current_load;
+}

kernel/proc.h

@@ -1,3 +1,5 @@
+#include "defs.h"
+
 // Saved registers for kernel context switches.
 struct context {
   uint64 ra;
@@ -91,6 +93,7 @@ struct proc {
   int killed;                  // If non-zero, have been killed
   int xstate;                  // Exit status to be returned to parent's wait
   int pid;                     // Process ID
+  int tracemask;               // Trace Mask
 
   // wait_lock must be held when using this:
   struct proc *parent;         // Parent process
@@ -104,4 +107,5 @@ struct proc {
   struct file *ofile[NOFILE];  // Open files
   struct inode *cwd;           // Current directory
   char name[16];               // Process name (debugging)
+  int syscall_counts[24]; // 每个系统调用的调用次数
 };

kernel/syscall.c

@@ -7,6 +7,11 @@
 #include "syscall.h"
 #include "defs.h"
 
+// 保留系统调用别名
+char* syscalls_name[25] = {"", "fork", "exit", "wait", "pipe", "read", "kill", "exec",
+                      "fstat", "chdir", "dup", "getpid", "sbrk", "sleep", "uptime",
+                      "open", "write", "mknod", "unlink", "link", "mkdir", "close", "trace", "sysinfo"};
+
 // Fetch the uint64 at addr from the current process.
 int
 fetchaddr(uint64 addr, uint64 *ip)
@@ -101,6 +106,8 @@ extern uint64 sys_unlink(void);
 extern uint64 sys_link(void);
 extern uint64 sys_mkdir(void);
 extern uint64 sys_close(void);
+extern uint64 sys_trace(void);
+extern uint64 sys_sysinfo(void);
 
 // An array mapping syscall numbers from syscall.h
 // to the function that handles the system call.
@@ -126,6 +133,8 @@ static uint64 (*syscalls[])(void) = {
 [SYS_link]    sys_link,
 [SYS_mkdir]   sys_mkdir,
 [SYS_close]   sys_close,
+[SYS_trace]   sys_trace,
+[SYS_sysinfo]   sys_sysinfo,
 };
 
 void
@@ -139,6 +148,12 @@ syscall(void)
     // Use num to lookup the system call function for num, call it,
     // and store its return value in p->trapframe->a0
     p->trapframe->a0 = syscalls[num]();
+    if (p->tracemask & (1 << num)) {
+       p->syscall_counts[num]++;
+       printf("%d: syscall %s(trace counts: %d) -> %d\n",
+             p->pid, syscalls_name[num], p->syscall_counts[num], p->trapframe->a0);
+       printf("a1:%d a2:%d a3:%d a4:%d a5:%d a6:%d a7:%d\n",p->trapframe->a1,p->trapframe->a2,p->trapframe->a3,p->trapframe->a4,p->trapframe->a5,p->trapframe->a6,p->trapframe->a7);
+    }
   } else {
     printf("%d %s: unknown sys call %d\n",
             p->pid, p->name, num);

kernel/syscall.h

@@ -20,3 +20,5 @@
 #define SYS_link   19
 #define SYS_mkdir  20
 #define SYS_close  21
+#define SYS_trace  22
+#define SYS_sysinfo 23

kernel/sysinfo.h

@@ -0,0 +1,7 @@
+#include "kernel/types.h"
+struct sysinfo {
+  uint64 freemem;
+  uint64 nproc;
+  uint64 unused_proc_num;
+  uint64 load_avg;
+};

kernel/sysproc.c

@@ -5,6 +5,7 @@
 #include "memlayout.h"
 #include "spinlock.h"
 #include "proc.h"
+#include "sysinfo.h"
 
 uint64
 sys_exit(void)
@@ -91,3 +92,30 @@ sys_uptime(void)
   release(&tickslock);
   return xticks;
 }
+
+uint64
+sys_trace(void)
+{
+  int n;
+  argint(0, &n);
+  if(n<0) return -1;
+  myproc()->tracemask = n;
+  return 0;
+}
+
+uint64
+sys_sysinfo(void)
+{
+  struct sysinfo info;
+  uint64 addr;
+  argaddr(0, &addr);
+  if (addr < 0) return -1;
+  struct proc* p = myproc();
+  info.nproc = proc_size();
+  info.freemem = freemem();
+  info.unused_proc_num = NPROC - info.nproc;
+  info.load_avg = update_load() * 100 / sys_uptime();
+  if (copyout(p->pagetable, addr, (char*)&info, sizeof(info)) < 0)
+    return -1;
+  return 0;
+}

time.txt

@@ -1 +1 @@
-5
+4

user/find.c

@@ -95,4 +95,4 @@ int main(int argc, char *argv[]) {
   }
   find(argv[1], argv[2]);
   exit(0);
-}
+}

user/sysinfo.c

@@ -0,0 +1,21 @@
+#include "kernel/param.h"
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "user/user.h"
+
+int main() {
+  struct sysinfo info;
+
+  if (sysinfo(&info) < 0) {
+    printf("sysinfo: failed to retrieve system information\n");
+    exit(1);
+  }
+
+  printf("System Information:\n");
+  printf("  Free Memory: %d bytes\n", info.freemem);
+  printf("  Number of Processes: %d\n", info.nproc);
+  printf("  Unused Process Slots: %d\n", info.unused_proc_num);
+  printf("  Load Average: %d / 100 \n", info.load_avg);
+
+  exit(0);
+}

user/sysinfotest.c

@@ -0,0 +1,164 @@
+#include "kernel/types.h"
+#include "kernel/riscv.h"
+/*#include "kernel/sysinfo.h"*/
+#include "user/user.h"
+
+
+void
+sinfo(struct sysinfo *info) {
+  if (sysinfo(info) < 0) {
+    printf("FAIL: sysinfo failed");
+    exit(1);
+  }
+}
+
+//
+// use sbrk() to count how many free physical memory pages there are.
+//
+int
+countfree()
+{
+  uint64 sz0 = (uint64)sbrk(0);
+  struct sysinfo info;
+  int n = 0;
+
+  while(1){
+    if((uint64)sbrk(PGSIZE) == 0xffffffffffffffff){
+      break;
+    }
+    n += PGSIZE;
+  }
+  sinfo(&info);
+  if (info.freemem != 0) {
+    printf("FAIL: there is no free mem, but sysinfo.freemem=%d\n",
+      info.freemem);
+    exit(1);
+  }
+  sbrk(-((uint64)sbrk(0) - sz0));
+  return n;
+}
+
+void
+testmem() {
+  struct sysinfo info;
+  uint64 n = countfree();
+  
+  sinfo(&info);
+
+  if (info.freemem!= n) {
+    printf("FAIL: free mem %d (bytes) instead of %d\n", info.freemem, n);
+    exit(1);
+  }
+  
+  if((uint64)sbrk(PGSIZE) == 0xffffffffffffffff){
+    printf("sbrk failed");
+    exit(1);
+  }
+
+  sinfo(&info);
+    
+  if (info.freemem != n-PGSIZE) {
+    printf("FAIL: free mem %d (bytes) instead of %d\n", n-PGSIZE, info.freemem);
+    exit(1);
+  }
+  
+  if((uint64)sbrk(-PGSIZE) == 0xffffffffffffffff){
+    printf("sbrk failed");
+    exit(1);
+  }
+
+  sinfo(&info);
+    
+  if (info.freemem != n) {
+    printf("FAIL: free mem %d (bytes) instead of %d\n", n, info.freemem);
+    exit(1);
+  }
+}
+
+void
+testcall() {
+  struct sysinfo info;
+  
+  if (sysinfo(&info) < 0) {
+    printf("FAIL: sysinfo failed\n");
+    exit(1);
+  }
+
+  if (sysinfo((struct sysinfo *) 0xeaeb0b5b00002f5e) !=  0xffffffffffffffff) {
+    printf("FAIL: sysinfo succeeded with bad argument\n");
+    exit(1);
+  }
+}
+
+void testproc() {
+  struct sysinfo info;
+  uint64 nproc, unused_proc_num;
+  int status;
+  int pid;
+  
+  sinfo(&info);
+  nproc = info.nproc;
+  unused_proc_num = info.unused_proc_num;
+
+  pid = fork();
+  if(pid < 0){
+    printf("sysinfotest: fork failed\n");
+    exit(1);
+  }
+  if(pid == 0){
+    sinfo(&info);
+    if(info.nproc != nproc+1) {
+      printf("sysinfotest: FAIL nproc is %d instead of %d\n", info.nproc, nproc+1);
+      exit(1);
+    }
+  
+    if(info.unused_proc_num != unused_proc_num-1) {
+      printf("sysinfotest: FAIL unused_proc_num is %d instead of %d\n", info.unused_proc_num, unused_proc_num-1);
+      exit(1);
+    }
+    exit(0);
+  }
+  wait(&status);
+  sinfo(&info);
+  if(info.nproc != nproc) {
+      printf("sysinfotest: FAIL nproc is %d instead of %d\n", info.nproc, nproc);
+      exit(1);
+  }
+  if(info.unused_proc_num != unused_proc_num) {
+      printf("sysinfotest: FAIL unused_proc_num is %d instead of %d\n", info.unused_proc_num, unused_proc_num);
+      exit(1);
+  }
+}
+
+void testbad() {
+  int pid = fork();
+  int xstatus;
+  
+  if(pid < 0){
+    printf("sysinfotest: fork failed\n");
+    exit(1);
+  }
+  if(pid == 0){
+      sinfo(0x0);
+      exit(0);
+  }
+  wait(&xstatus);
+  if(xstatus == -1)  // kernel killed child?
+    exit(0);
+  else {
+    printf("sysinfotest: testbad succeeded %d\n", xstatus);
+    exit(xstatus);
+  }
+}
+
+int
+main(int argc, char *argv[])
+{
+  printf("sysinfotest: start\n");
+  testcall();
+  testmem();
+  testproc();
+  printf("sysinfotest: OK\n");
+  exit(0);
+}
+

user/trace.c

@@ -0,0 +1,24 @@
+#include "kernel/param.h"
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "user/user.h"
+int
+main(int argc, char *argv[])
+{
+  int i;
+  char *nargv[MAXARG];
+
+  if(argc < 3 || (argv[1][0] < '0' || argv[1][0] > '9')){
+    fprintf(2, "Usage: %s mask command\n", argv[0]);
+    exit(1);
+  }
+  if (trace(atoi(argv[1])) < 0) {
+    fprintf(2, "%s: trace failed\n", argv[0]);
+    exit(1);
+  }
+  for(i = 2; i < argc && i < MAXARG; i++){
+    nargv[i-2] = argv[i];
+  }
+  exec(nargv[0], nargv);
+  exit(0);
+}

user/user.h

@@ -1,4 +1,5 @@
 #include "kernel/types.h"
+#include "kernel/sysinfo.h"
 struct stat;
 
 // system calls
@@ -23,6 +24,8 @@ int getpid(void);
 char *sbrk(int);
 int sleep(int);
 int uptime(void);
+int trace(int);
+int sysinfo(struct sysinfo*);
 
 // ulib.c
 int stat(const char *, struct stat *);

user/usys.pl

@@ -36,3 +36,5 @@ entry("getpid");
 entry("sbrk");
 entry("sleep");
 entry("uptime");
+entry("trace");
+entry("sysinfo");