trapslab finished

.gitignore

@@ -24,3 +24,5 @@ ph
 barrier
 /lab-*.json
 .DS_Store
+compile_commands.json
+

Makefile

@@ -1,3 +1,4 @@
+
 # To compile and run with a lab solution, set the lab name in conf/lab.mk
 # (e.g., LAB=util).  Run make grade to test solution with the lab's
 # grade script (e.g., grade-lab-util).
@@ -84,7 +85,7 @@ LD = $(TOOLPREFIX)ld
 OBJCOPY = $(TOOLPREFIX)objcopy
 OBJDUMP = $(TOOLPREFIX)objdump
 
-CFLAGS = -Wall -Werror -O1 -fno-omit-frame-pointer -ggdb -gdwarf-2
+CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb -gdwarf-2
 
 ifdef LAB
 LABUPPER = $(shell echo $(LAB) | tr a-z A-Z)
@@ -212,7 +213,8 @@ endif
 ifeq ($(LAB),traps)
 UPROGS += \
 	$U/_call\
-	$U/_bttest
+	$U/_bttest\
+	$U/_alarmtest
 endif
 
 ifeq ($(LAB),lazy)
@@ -237,16 +239,15 @@ $U/_uthread: $U/uthread.o $U/uthread_switch.o $(ULIB)
 	$(OBJDUMP) -S $U/_uthread > $U/uthread.asm
 
 ph: notxv6/ph.c
-	gcc -o ph -g -Ofast $(XCFLAGS) notxv6/ph.c -pthread
+	gcc -o ph -g -O2 $(XCFLAGS) notxv6/ph.c -pthread
 
 barrier: notxv6/barrier.c
-	gcc -o barrier -g -Ofast $(XCFLAGS) notxv6/barrier.c -pthread
+	gcc -o barrier -g -O2 $(XCFLAGS) notxv6/barrier.c -pthread
 endif
 
 ifeq ($(LAB),pgtbl)
 UPROGS += \
-	$U/_pgtbltest\
-	$U/_dirtypagestest
+	$U/_pgtbltest
 endif
 
 ifeq ($(LAB),lock)

alarmtest_tests.md

@@ -0,0 +1,91 @@
+# alarmtest.c 测试
+
+## test0: 单次调用测试
+
+**函数**: `test0()`
+
+**目的**: 测试内核是否至少调用了一次 alarm 处理程序。
+
+**描述**:
+
+- 设置 alarm 每 2 个时钟周期触发一次。
+
+- 在一个长循环中检查 `count` 是否被处理程序修改。
+
+- 如果 `count > 0`，测试通过；否则失败。
+
+---
+
+## test1: 多次调用与寄存器恢复测试
+
+**函数**: `test1()`
+
+**目的**: 测试内核是否多次调用 alarm 处理程序，并确保处理程序返回后程序继续从中断点执行，且寄存器值未被破坏。
+
+**描述**:
+
+- 设置 alarm 每 2 个时钟周期触发一次。
+
+- 在循环中调用 `foo()` 函数，同时检查 `count` 是否达到 10。
+
+- 验证 `foo()` 的调用次数是否与循环计数一致。
+
+- 如果 `count < 10` 或寄存器值不一致，测试失败；否则通过。
+
+---
+
+## test2: 防止重入调用
+
+**函数**: `test2()`
+
+**目的**: 测试内核是否防止 alarm 处理程序的重入调用。
+
+**描述**:
+
+- 设置 alarm 每 2 个时钟周期触发一次，处理程序为 `slow_handler()`。
+
+- 在子进程中运行一个长循环，检查 `count` 是否被修改。
+
+- 如果 `count > 1`，测试失败；否则通过。
+
+---
+
+## test3: 寄存器 a0 的完整性测试
+
+**函数**: `test3()`
+
+**目的**: 测试从 `sys_sigreturn()` 返回时，寄存器 `a0` 的值是否被修改。
+
+**描述**:
+
+- 设置 alarm 每 1 个时钟周期触发一次，处理程序为 `dummy_handler()`。
+
+- 在触发 alarm 后检查寄存器 `a0` 的值是否保持为初始值 `0xac`。
+
+- 如果 `a0` 被修改，测试失败；否则通过。
+
+---
+
+## 处理程序说明
+
+### `periodic()`
+
+- 增加 `count` 值并打印 "alarm!"。
+
+- 调用 `sigreturn()` 返回。
+
+### `slow_handler()`
+
+- 增加 `count` 值并打印 "alarm!"。
+
+- 如果 `count > 1`，测试失败并退出。
+
+- 运行一个长循环以模拟慢速处理程序。
+
+- 调用 `sigreturn()` 返回。
+
+### `dummy_handler()`
+
+- 立即卸载自身并调用 `sigreturn()` 返回。
+
+---

answers-pgtbl.txt

@@ -1,153 +0,0 @@
-### 背景信息
-- **页面表结构**：
-  - 页面大小（`PGSIZE`）：通常为 4KB（4096 字节）。
-  - 最大虚拟地址（`MAXVA`）：在 Sv39 模式下为 2^39（512GB）。
-  - 页面表条目（PTE）：包含物理地址（PA）、权限位（读/写/执行等）以及有效位（Valid bit）。
-  - 三级页面表：PML4（顶级），L2（中间级），L1（最低级），每个页面表包含 512 条目（2^9）。
-  - 虚拟地址（VA）：39 位，分为 VPN[2]（9 位，顶级索引）、VPN[1]（9 位，中间级索引）、VPN[0]（9 位，最低级索引）和 12 位页面偏移。
-- **`print_pgtbl` 函数**：
-  - 打印前 10 个页面（VA 从 `0` 到 `9 * PGSIZE`）和最后 10 个页面（接近 `MAXVA`）的页面表条目。
-  - 调用 `print_pte`，输出虚拟地址对应的页面表条目信息。
-
-### 输出分析
-以下是提供的输出：
-```
-xv6 kernel is booting
-hart 1 starting
-hart 2 starting
-page table 0x0000000087f4d000
-0: pte 0x0000000021fd2401 pa 0x0000000087f49000
- ..0: pte 0x0000000021fd2001 pa 0x0000000087f48000
- .. ..0: pte 0x0000000021fd281b pa 0x0000000087f4a000 va 0x0000000000000000 flags RXU
- .. ..1: pte 0x0000000021fd1c17 pa 0x0000000087f47000 va 0x0000000000000001 flags RWU
- .. ..2: pte 0x0000000021fd1807 pa 0x0000000087f46000 va 0x0000000000000002 flags RW
- .. ..3: pte 0x0000000021fd1417 pa 0x0000000087f45000 va 0x0000000000000003 flags RWU
-255: pte 0x0000000021fd3001 pa 0x0000000087f4c000
- ..511: pte 0x0000000021fd2c01 pa 0x0000000087f4b000
- .. ..509: pte 0x0000000021fd5413 pa 0x0000000087f55000 va 0x0000000003fffffd flags RU
- .. ..510: pte 0x0000000021fd5807 pa 0x0000000087f56000 va 0x0000000003fffffe flags RW
- .. ..511: pte 0x000000002000180b pa 0x0000000080006000 va 0x0000000003ffffff flags RX
-init: starting sh
-```
-
-#### 1. **输出结构与 `print_pgtbl` 的关联**
-- 输出由 `print_pgtbl` 函数生成，包含：
-  - **顶级页面表地址**：`page table 0x0000000087f4d000`（根页面表所在的物理地址）。
-  - **前几个页面表条目**（对应 `for (uint64 i = 0; i < 10; i++)` 循环）：
-    - 打印顶级页面表索引 0 的条目，以及其下级页面表的条目。
-    - 具体为虚拟地址 `0x0` 到 `0x3000`（前 4 个页面）。
-  - **最后几个页面表条目**（对应 `for (uint64 i = top - 10; i < top; i++)` 循环）：
-    - 打印顶级页面表索引 255 的条目，以及其下级页面表的最后几个条目（509–511）。
-    - 对应虚拟地址接近 `MAXVA`（`0x3fffffd` 到 `0x3ffffff`）。
-  - 输出格式：
-    - 每行表示一个页面表条目，格式为：
-      ```
-      [索引]: pte [PTE值] pa [物理地址] [va 虚拟地址 flags 权限]
-      ```
-    - 缩进（`..`）表示页面表层级：顶级（无缩进）、L2（`..`）、L1（`.. ..`）。
-    - 仅 L1 页面表条目包含虚拟地址（`va`）和权限标志（`flags`）。
-
-#### 2. **页面表条目解析**
-页面表条目（PTE）格式（RISC-V Sv39）：
-- **PTE 结构**：64 位，包含：
-  - 物理页面号（PPN）：44 位（高 44 位，右移 10 位得到物理页面地址）。
-  - 权限位：V（Valid，有效）、R（Read，读）、W（Write，写）、X（Execute，执行）、U（User，用户态可访问）。
-  - 其他标志：G（Global）、A（Accessed）、D（Dirty）等。
-- **物理地址（PA）**：从 PTE 的 PPN 字段计算，`PA = PPN << 12`。
-- **权限标志（flags）**：输出中的 `RXU`、`RWU`、`RW` 等表示权限组合：
-  - `R`：可读，`W`：可写，`X`：可执行，`U`：用户态可访问。
-
-##### **前 4 个页面（VA 0x0 到 0x3000）**
-- **顶级页面表（索引 0）**：
-  - `0: pte 0x0000000021fd2401 pa 0x0000000087f49000`
-    - PTE 值：`0x21fd2401`。
-    - 物理地址：`0x87f49000`（L2 页面表地址）。
-    - 标志：`0x401` 的低 10 位为 `0x001`，表示 Valid（V=1）。
-- **L2 页面表（索引 0）**：
-  - `..0: pte 0x0000000021fd2001 pa 0x0000000087f48000`
-    - PTE 值：`0x21fd2001`。
-    - 物理地址：`0x87f48000`（L1 页面表地址）。
-    - 标志：Valid（V=1）。
-- **L1 页面表（索引 0–3）**：
-  - `.. ..0: pte 0x0000000021fd281b pa 0x0000000087f4a000 va 0x0000000000000000 flags RXU`
-    - 虚拟地址：`0x0`。
-    - 物理地址：`0x87f4a000`。
-    - 标志：`RXU`（Read, Execute, User），`0x1b` = `0b11011`（V=1, R=1, X=1, U=1）。
-    - 用途：可能是内核代码段（可读、可执行、用户态可访问）。
-  - `.. ..1: pte 0x0000000021fd1c17 pa 0x0000000087f47000 va 0x0000000000000001 flags RWU`
-    - 虚拟地址：`0x1000`（1 * PGSIZE）。
-    - 物理地址：`0x87f47000`。
-    - 标志：`RWU`（Read, Write, User），`0x17` = `0b10111`（V=1, R=1, W=1, U=1）。
-    - 用途：可能是数据段或堆栈（可读、可写、用户态可访问）。
-  - `.. ..2: pte 0x0000000021fd1807 pa 0x0000000087f46000 va 0x0000000000000002 flags RW`
-    - 虚拟地址：`0x2000`（2 * PGSIZE）。
-    - 物理地址：`0x87f46000`。
-    - 标志：`RW`（Read, Write），`0x07` = `0b00111`（V=1, R=1, W=1）。
-    - 用途：可能是内核数据（可读、可写，仅内核态）。
-  - `.. ..3: pte 0x0000000021fd1417 pa 0x0000000087f45000 va 0x0000000000000003 flags RWU`
-    - 虚拟地址：`0x3000`（3 * PGSIZE）。
-    - 物理地址：`0x87f45000`。
-    - 标志：`RWU`（Read, Write, User），`0x17` = `0b10111`（V=1, R=1, W=1, U=1）。
-    - 用途：可能是用户态数据或堆栈。
-
-##### **最后 3 个页面（VA 0x3fffffd 到 0x3ffffff）**
-- **顶级页面表（索引 255）**：
-  - `255: pte 0x0000000021fd3001 pa 0x0000000087f4c000`
-    - PTE 值：`0x21fd3001`。
-    - 物理地址：`0x87f4c000`（L2 页面表地址）。
-    - 标志：Valid（V=1）。
-- **L2 页面表（索引 511）**：
-  - `..511: pte 0x0000000021fd2c01 pa 0x0000000087f4b000`
-    - PTE 值：`0x21fd2c01`。
-    - 物理地址：`0x87f4b000`（L1 页面表地址）。
-    - 标志：Valid（V=1）。
-- **L1 页面表（索引 509–511）**：
-  - `.. ..509: pte 0x0000000021fd5413 pa 0x0000000087f55000 va 0x0000000003fffffd flags RU`
-    - 虚拟地址：`0x3fffffd000`（接近 MAXVA）。
-    - 物理地址：`0x87f55000`。
-    - 标志：`RU`（Read, User），`0x13` = `0b10011`（V=1, R=1, U=1）。
-    - 用途：可能是用户态只读数据。
-  - `.. ..510: pte 0x0000000021fd5807 pa 0x0000000087f56000 va 0x0000000003fffffe flags RW`
-    - 虚拟地址：`0x3fffffe000`。
-    - 物理地址：`0x87f56000`。
-    - 标志：`RW`（Read, Write），`0x07` = `0b00111`（V=1, R=1, W=1）。
-    - 用途：可能是内核数据（仅内核态）。
-  - `.. ..511: pte 0x000000002000180b pa 0x0000000080006000 va 0x0000000003ffffff flags RX`
-    - 虚拟地址：`0x3ffffff000`（MAXVA - PGSIZE）。
-    - 物理地址：`0x80006000`。
-    - 标志：`RX`（Read, Execute），`0x0b` = `0b01011`（V=1, R=1, X=1）。
-    - 用途：可能是内核代码或设备映射（可读、可执行，仅内核态）。
-
-#### 3. **与 `print_pgtbl` 的关联**
-- **前 10 个页面**：
-  - 输出只显示了虚拟地址 `0x0` 到 `0x3000`（4 个页面），而不是 10 个，可能是因为 `print_pgtbl` 的循环被修改或页面表中只有前 4 个页面有有效映射。
-  - 虚拟地址计算：
-    - `i * PGSIZE`（`i` 从 0 到 3），与输出中的 `va 0x0`、`0x1000`、`0x2000`、`0x3000` 匹配。
-- **最后 10 个页面**：
-  - 输出显示索引 509–511（虚拟地址 `0x3fffffd000` 到 `0x3ffffff000`），对应 `i` 从 `top - 3` 到 `top - 1`。
-  - 计算 `top`：
-    - `MAXVA = 2^39 = 512GB`，`PGSIZE = 4096`，`top = 512GB / 4096 = 2^27 = 134,217,728`。
-    - 虚拟地址 `0x3ffffff`（十进制 2^30 - 1）对应页面号 `2^30 / 4096 = 2^18 - 1 = 262,143`。
-    - 顶级索引：`262,143 >> 18 = 255`（匹配 `255:`）。
-    - L2 索引：`(262,143 >> 9) & 0x1FF = 511`（匹配 `..511:`）。
-    - L1 索引：`262,143 & 0x1FF = 511`（匹配 `.. ..511:`）。
-  - 输出只显示最后 3 个页面（509–511），可能是因为只有这些页面有有效映射。
-- **缺失的 `print_pgtbl` 输出**：
-  - 函数应打印 `"print_pgtbl starting\n"` 和 `"print_pgtbl: OK\n"`，但输出中缺失，可能是被其他日志覆盖或函数被修改。
-
-#### 4. **页面表条目含义**
-- **前 4 个页面**：
-  - 映射到物理地址 `0x87f4a000` 到 `0x87f45000`，连续的物理页面。
-  - 权限多样（`RXU`、`RWU`、`RW`），表明这些页面用于不同用途：
-    - `RXU`：用户态代码（例如，初始用户程序）。
-    - `RWU`：用户态数据或堆栈。
-    - `RW`：内核数据（仅内核态）。
-- **最后 3 个页面**：
-  - 映射到物理地址 `0x87f55000` 到 `0x80006000`，不完全连续。
-  - 权限包括 `RU`（用户态只读）、`RW`（内核读写）、`RX`（内核代码）。
-  - 最后一个页面（`va 0x3ffffff000`, `pa 0x80006000`）可能是设备内存映射（常见于内核高地址空间）。
-- **物理地址**：
-  - 大部分物理地址在 `0x87fxxxxx` 范围内，表明内存分配集中在某一区域。
-  - 最后一个页面映射到 `0x80006000`，可能是设备寄存器或内核代码的固定映射。
-
-

answers-traps.txt

@@ -0,0 +1,67 @@
+ 问题 1: 哪些寄存器包含函数的参数？例如，在 main 对 printf 的调用中，哪个寄存器包含 13？
+
+在 RISC-V 调用约定中，函数参数通常通过寄存器  a0  到  a7  传递。
+
+ 对于函数  g(int x)  和  f(int x) ，它们的参数  x  都通过寄存器  a0  传递。
+ 在  main  对  printf  的调用中， printf("y=%d\n", 13)  语句中，数字  13  将包含在寄存器  a1  中。 printf  的第一个参数（格式字符串的地址）将包含在寄存器  a0  中。
+
+ 问题 2: 在 main 的汇编代码中，对函数 f 的调用在哪里？对 g 的调用在哪里？（提示：编译器可以内联函数。）
+
+由于编译器优化， f  和  g  函数在  main  函数中被内联了。这意味着它们的实际代码直接插入到  main  函数的调用点，而不是通过  jal  或  jalr  指令进行函数调用。
+
+我们可以通过观察  main  函数的汇编代码来验证这一点。在  main  函数中，你会看到对  f  和  g  的操作直接在  main  的代码流中执行，而没有显式的  jal  或  jalr  到  <f>  或  <g>  的地址。
+
+ 问题 3: 函数 printf 位于哪个地址？
+
+ printf  函数不在  call.asm  文件提供的汇编代码中。 call.asm  似乎只包含用户定义的函数和一些与内存分配相关的代码。 printf  是一个标准库函数，它的地址会在程序链接时确定，并且通常在运行时动态加载。因此，我们无法从  call.asm  的反汇编代码中直接找到  printf  的地址。
+
+ 问题 4: 在 main 中 jalr 到 printf 之后的寄存器 ra 中有什么值？
+
+在  main  函数中  jalr  到  printf  之后，寄存器  ra  (返回地址寄存器) 将包含紧跟在  jalr  指令之后的指令的地址。这个地址是  printf  函数执行完毕后应该返回到的  main  函数中的位置。
+
+ 问题 5: 运行以下代码。无符号 int i = 0x00646c72; printf(“H%x Wo%s”， 57616， （字符 ） &i）; 输出是什么？
+
+  i = 0x00646c72 
+  printf("H%x Wo%s", 57616, (char ) &i) 
+
+输出：  H0e110 Wo rld 
+
+解释：
+
+  "H"  和  "Wo"  是直接打印的字符串。
+  %x  对应  57616 。  57616  的十六进制是  0xE110 。
+  %s  对应  (char ) &i 。由于 RISC-V 是 little-endian，内存中  i  的字节顺序是  72 6C 64 00 。
+      0x72  是字符 'r'
+      0x6C  是字符 'l'
+      0x64  是字符 'd'
+      0x00  是字符串终止符
+    因此， %s  会打印 "rld"。
+
+ 问题 6: 如果 RISC-V 是 big-endian，您会将 i 设置为什么 i 才能产生相同的输出？是否需要将 57616 更改为其他值？
+
+ 如果 RISC-V 是 big-endian：
+    为了使  %s  打印 "rld"，我们需要将  i  设置为  0x726c6400 。在 big-endian 系统中，高位字节存储在低内存地址，所以  0x72  会在最低地址，然后是  0x6c ， 0x64 ，最后是  0x00 。
+
+ 是否需要将 57616 更改为其他值？
+    不需要。 57616  是一个整数值，无论系统是 little-endian 还是 big-endian，它的数值表示是不变的。 %x  格式说明符只是将其打印为十六进制。字节序只影响多字节数据类型（如  int ）在内存中的存储方式，而不影响其数值。
+
+ 问题 7: 在下面的代码中， 'y=' 后面会打印什么？（注意：答案不是具体值。为什么会这样？
+
+   c
+printf("x=%d y=%d", 3);
+   
+
+输出：  y=  后面会打印一个不确定的值（垃圾值）。
+
+为什么会这样：
+
+ printf  是一个变参函数，它根据格式字符串中的格式说明符来确定需要从栈中取出多少个参数。
+
+ 格式字符串是  "x=%d y=%d" 。
+ 这意味着  printf  期望有两个  %d  对应的整数参数。
+ 但是，在实际调用中，只提供了一个参数  3 。
+
+因此：
+
+1.   printf  会从栈中读取第一个整数参数来填充  x=%d ，这个值就是  3 。
+2.  然后， printf  会尝试读取第二个整数参数来填充  y=%d 。由于调用时只提供了  3  这一个参数， printf  会从栈上读取一个任意的、未初始化的内存位置的值，这个值是不可预测的（垃圾值）。

conf/lab.mk

@@ -1 +1 @@
-LAB=pgtbl
+LAB=traps

grade-lab-pgtbl

@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-
-import re
-from gradelib import *
-
-r = Runner(save("xv6.out"))
-
-@test(0, "pgtbltest")
-def test_pgtbltest():
-    r.run_qemu(shell_script([
-        'pgtbltest'
-    ]), timeout=300)
-
-@test(10, "pgtbltest: ugetpid", parent=test_pgtbltest)
-def test_ugetpid_():
-    r.match('^ugetpid_test: OK$')
-
-@test(10, "pgtbltest: print_kpgtbl", parent=test_pgtbltest)
-def test_print_kpgtbl_():
-    r.match(
-        '^page table 0x',
-        '^ \.\.0x0000000000000000',
-        '^ \.\. \.\.0x0000000000000000',
-        '^ \.\. \.\. \.\.0x0000000000000000',
-        '^ \.\. \.\. \.\.0x0000000000001000',
-        '^ \.\. \.\. \.\.0x0000000000002000',
-        '^ \.\. \.\. \.\.0x0000000000003000',
-        '^ \.\.(0xffffffffc0000000|0x0000003fc0000000)',
-        '^ \.\. \.\.(0xffffffffffe00000|0x0000003fffe00000)',
-        '^ \.\. \.\. \.\.(0xffffffffffffd000|0x0000003fffffd000)',
-        '^ \.\. \.\. \.\.(0xffffffffffffe000|0x0000003fffffe000)',
-        '^ \.\. \.\. \.\.(0xfffffffffffff000|0x0000003ffffff000)',
-    )
-
-@test(10, "pgtbltest: pgaccess", parent=test_pgtbltest)
-def test_nettest_():
-    r.match('^pgaccess_test: OK$')
-
-@test(15, "pgtbltest: superpg", parent=test_pgtbltest)
-def test_superpg_():
-    r.match('^superpg_test: OK$')
-
-@test(5, "answers-pgtbl.txt")
-def test_answers():
-    # just a simple sanity check, will be graded manually
-    check_answers("answers-pgtbl.txt")
-
-@test(0, "usertests")
-def test_usertests():
-    r.run_qemu(shell_script([
-        'usertests -q'
-    ]), timeout=300)
-
-@test(10, "usertests: all tests", parent=test_usertests)
-def test_usertests():
-    r.match('^ALL TESTS PASSED$')
-
-@test(1, "time")
-def test_time():
-    check_time()
-
-run_tests()

grade-lab-traps

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import subprocess
+from gradelib import *
+
+r = Runner(save("xv6.out"))
+
+@test(5, "answers-traps.txt")
+def test_answers():
+    # just a simple sanity check, will be graded manually
+    check_answers("answers-traps.txt")
+
+BACKTRACE_RE = r"^(0x000000008[0-9a-f]+)"
+
+def addr2line():
+    for f in ['riscv64-unknown-elf-addr2line', 'riscv64-linux-gnu-addr2line', 'addr2line', ]:
+        try:
+            devnull = open(os.devnull)
+            subprocess.Popen([f], stdout=devnull, stderr=devnull).communicate()
+            return f
+        except OSError:
+            continue
+    raise AssertionError('Cannot find the addr2line program')
+
+@test(10, "backtrace test")
+def test_backtracetest():
+    r.run_qemu(shell_script([
+        'bttest'
+    ]))
+    a2l = addr2line()
+    matches = re.findall(BACKTRACE_RE, r.qemu.output, re.MULTILINE)
+    assert_equal(len(matches), 3)
+    files = ['sysproc.c', 'syscall.c', 'trap.c']
+    for f, m in zip(files, matches):
+        result = subprocess.run([a2l, '-e', 'kernel/kernel', m], stdout=subprocess.PIPE)
+        if not f in result.stdout.decode("utf-8"):
+            raise AssertionError('Trace is incorrect; no %s' % f)
+
+@test(0, "running alarmtest")
+def test_alarmtest():
+    r.run_qemu(shell_script([
+        'alarmtest'
+    ]))
+
+@test(20, "alarmtest: test0", parent=test_alarmtest)
+def test_alarmtest_test0():
+    r.match('^test0 passed$')
+
+@test(20, "alarmtest: test1", parent=test_alarmtest)
+def test_alarmtest_test1():
+    r.match('^\\.?test1 passed$')
+
+@test(10, "alarmtest: test2", parent=test_alarmtest)
+def test_alarmtest_test2():
+    r.match('^\\.?test2 passed$')
+
+@test(10, "alarmtest: test3", parent=test_alarmtest)
+def test_alarmtest_test3():
+    r.match('^test3 passed$')
+
+@test(19, "usertests")
+def test_usertests():
+    r.run_qemu(shell_script([
+        'usertests -q'
+    ]), timeout=300)
+    r.match('^ALL TESTS PASSED$')
+
+@test(1, "time")
+def test_time():
+    check_time()
+
+run_tests()

kernel/defs.h

@@ -1,7 +1,3 @@
-#ifdef LAB_MMAP
-typedef unsigned long size_t;
-typedef long int off_t;
-#endif
 struct buf;
 struct context;
 struct file;
@@ -84,6 +80,7 @@ int             pipewrite(struct pipe*, uint64, int);
 int            printf(char*, ...) __attribute__ ((format (printf, 1, 2)));
 void            panic(char*) __attribute__((noreturn));
 void            printfinit(void);
+void            backtrace(void);
 
 // proc.c
 int             cpuid(void);
@@ -121,10 +118,6 @@ void            initlock(struct spinlock*, char*);
 void            release(struct spinlock*);
 void            push_off(void);
 void            pop_off(void);
-int             atomic_read4(int *addr);
-#ifdef LAB_LOCK
-void            freelock(struct spinlock*);
-#endif
 
 // sleeplock.c
 void            acquiresleep(struct sleeplock*);
@@ -181,17 +174,6 @@ uint64          walkaddr(pagetable_t, uint64);
 int             copyout(pagetable_t, uint64, char *, uint64);
 int             copyin(pagetable_t, char *, uint64, uint64);
 int             copyinstr(pagetable_t, char *, uint64, uint64);
-#if defined(LAB_PGTBL) || defined(SOL_MMAP)
-void            vmprint(pagetable_t);
-#endif
-#ifdef LAB_PGTBL
-pte_t*          pgpte(pagetable_t, uint64);
-void            superfree(void *pa);
-void*           superalloc();
-int             copyin_new(pagetable_t, char *, uint64, uint64);
-int             copyinstr_new(pagetable_t, char *, uint64, uint64);
-uint64          sys_dirtypages(void);
-#endif
 
 // plic.c
 void            plicinit(void);
@@ -206,31 +188,3 @@ void            virtio_disk_intr(void);
 
 // number of elements in fixed-size array
 #define NELEM(x) (sizeof(x)/sizeof((x)[0]))
-
-#ifdef LAB_LOCK
-// stats.c
-void            statsinit(void);
-void            statsinc(void);
-
-// sprintf.c
-int             snprintf(char*, unsigned long, const char*, ...);
-#endif
-
-#ifdef KCSAN
-void            kcsaninit();
-#endif
-
-#ifdef LAB_NET
-// pci.c
-void            pci_init();
-
-// e1000.c
-void            e1000_init(uint32 *);
-void            e1000_intr(void);
-int             e1000_transmit(char *, int);
-
-// net.c
-void            netinit(void);
-void            net_rx(char *buf, int len);
-
-#endif

kernel/exec.c

@@ -128,10 +128,6 @@ exec(char *path, char **argv)
   p->trapframe->sp = sp; // initial stack pointer
   proc_freepagetable(oldpagetable, oldsz);
 
-  if (p->pid == 1) {
-     vmprint(p->pagetable);
-  }
-
   return argc; // this ends up in a0, the first argument to main(argc, argv)
 
  bad:

kernel/kalloc.c

@@ -23,46 +23,10 @@ struct {
   struct run *freelist;
 } kmem;
 
-struct super_run {
-  struct super_run *next;
-};
-
-struct {
-  struct spinlock lock;
-  struct super_run *freelist;
-} skmem;
-
-void superfree(void *pa) {
-  struct super_run *r;
-
-  if(((uint64)pa % SUPERPGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
-    panic("superfree");
-
-  // Fill with junk to catch dangling refs.
-  memset(pa, 1, SUPERPGSIZE);
-
-  r = (struct super_run *)pa;
-  acquire(&skmem.lock);
-  r->next = skmem.freelist;
-  skmem.freelist = r;
-  release(&skmem.lock);
-}
-
-void* superalloc() {
-  struct super_run *r;
-  acquire(&skmem.lock);
-  r = skmem.freelist;
-  if(r) skmem.freelist = r->next;
-  release(&skmem.lock);
-  if(r) memset((void*)r, 0, SUPERPGSIZE);
-  return (void*)r;
-}
-
 void
 kinit()
 {
   initlock(&kmem.lock, "kmem");
-  initlock(&skmem.lock, "skmem");
   freerange(end, (void*)PHYSTOP);
 }
 
@@ -71,22 +35,9 @@ freerange(void *pa_start, void *pa_end)
 {
   char *p;
   p = (char*)PGROUNDUP((uint64)pa_start);
-  for(; p + PGSIZE <= (char*)pa_end - 12 * 1024 * 1024; p += PGSIZE) //留5个巨页
+  for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
     kfree(p);
-  
-  p = (char*)SUPERPGROUNDUP((uint64)p);
-  for (; p + SUPERPGSIZE <= (char *)pa_end; p += SUPERPGSIZE) {
-    superfree(p);
-  }
 }
-// void
-// freerange(void *pa_start, void *pa_end)
-// {
-//   char *p;
-//   p = (char*)PGROUNDUP((uint64)pa_start);
-//   for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
-//     kfree(p);
-// }
 
 // Free the page of physical memory pointed at by pa,
 // which normally should have been returned by a

kernel/memlayout.h

@@ -25,10 +25,6 @@
 #define VIRTIO0 0x10001000
 #define VIRTIO0_IRQ 1
 
-#ifdef LAB_NET
-#define E1000_IRQ 33
-#endif
-
 // qemu puts platform-level interrupt controller (PLIC) here.
 #define PLIC 0x0c000000L
 #define PLIC_PRIORITY (PLIC + 0x0)
@@ -49,7 +45,7 @@
 
 // map kernel stacks beneath the trampoline,
 // each surrounded by invalid guard pages.
-#define KSTACK(p) (TRAMPOLINE - (p)*2*PGSIZE - 3*PGSIZE)
+#define KSTACK(p) (TRAMPOLINE - ((p)+1)* 2*PGSIZE)
 
 // User memory layout.
 // Address zero first:
@@ -58,14 +54,6 @@
 //   fixed-size stack
 //   expandable heap
 //   ...
-//   USYSCALL (shared with kernel)
 //   TRAPFRAME (p->trapframe, used by the trampoline)
 //   TRAMPOLINE (the same page as in the kernel)
 #define TRAPFRAME (TRAMPOLINE - PGSIZE)
-#ifdef LAB_PGTBL
-#define USYSCALL (TRAPFRAME - PGSIZE)
-
-struct usyscall {
-  int pid;  // Process ID
-};
-#endif

kernel/printf.c

@@ -176,3 +176,24 @@ printfinit(void)
   initlock(&pr.lock, "pr");
   pr.locking = 1;
 }
+
+// 打印当前调用栈的返回地址，实现简单的函数回溯，用于调试。
+void
+backtrace(void)
+{
+  printf("barcktrace:\n");
+
+  uint64 ra,fp = r_fp();//frame pointer -> address
+  uint64 pre_fp = *((uint64*)(fp - 16));
+
+  // 只要当前fp和上一个fp在同一页内，就继续回溯
+  while(PGROUNDDOWN(fp)==PGROUNDDOWN(pre_fp)){
+    ra = *(uint64 *)(fp - 8); // 取出返回地址
+    printf("%p\n", (void*)ra); // 打印返回地址
+    fp = pre_fp; // 更新fp为上一个fp
+    pre_fp = *((uint64*)(fp - 16)); // 获取新的上一个fp
+  }
+
+  ra = *(uint64 *)(fp - 8);
+  printf("%p\n",(void*)ra);
+}

kernel/proc.c

@@ -123,20 +123,21 @@ allocproc(void)
 
 found:
   p->pid = allocpid();
+  p->state = USED;
 
   // Allocate a trapframe page.
   if((p->trapframe = (struct trapframe *)kalloc()) == 0){
-    release(&p->lock);
-    return 0;
-  }
-
-  // Allocate a usyscall page.
-  if((p->usyscall = (struct usyscall *)kalloc()) == 0){
     freeproc(p);
     release(&p->lock);
     return 0;
   }
-  p->usyscall->pid =  p->pid ;
+
+  // 为进程分配 pre_trapframe 空间，分配失败则释放进程资源并返回 0
+   if((p->pre_trapframe = (struct trapframe *)kalloc()) == 0){
+    freeproc(p);
+    release(&p->lock);
+    return 0;
+  }
 
   // An empty user page table.
   p->pagetable = proc_pagetable(p);
@@ -161,14 +162,15 @@ found:
 static void
 freeproc(struct proc *p)
 {
-  if (p->usyscall) {
-    kfree((void*)p->usyscall);
-  }
   if(p->trapframe)
     kfree((void*)p->trapframe);
   p->trapframe = 0;
   if(p->pagetable)
     proc_freepagetable(p->pagetable, p->sz);
+  // 如果进程的 pre_trapframe 存在，则释放其占用的内存，并将指针置为 0，防止悬空指针。
+  if(p->pre_trapframe)
+    kfree((void*)p->pre_trapframe);
+  p->pre_trapframe = 0;
   p->pagetable = 0;
   p->sz = 0;
   p->pid = 0;
@@ -211,16 +213,6 @@ proc_pagetable(struct proc *p)
     return 0;
   }
 
-  // map the usyscall just below TRAMPOFRAME, for trampoline.S.
-  // 这个页需要设置PTE_U为，使得用户态可以访问
-  if(mappages(pagetable, USYSCALL, PGSIZE,
-              (uint64)(p->usyscall), PTE_R | PTE_U) < 0){
-    uvmunmap(pagetable, TRAPFRAME, 1, 0);
-    uvmunmap(pagetable, TRAMPOLINE, 1, 0);
-    uvmfree(pagetable, 0);
-    return 0;
-  }
-
   return pagetable;
 }
 
@@ -229,7 +221,6 @@ proc_pagetable(struct proc *p)
 void
 proc_freepagetable(pagetable_t pagetable, uint64 sz)
 {
-  uvmunmap(pagetable, USYSCALL, 1, 0);
   uvmunmap(pagetable, TRAMPOLINE, 1, 0);
   uvmunmap(pagetable, TRAPFRAME, 1, 0);
   uvmfree(pagetable, sz);
@@ -401,20 +392,8 @@ exit(int status)
   release(&wait_lock);
 
   // Jump into the scheduler, never to return.
-  // If we somehow return from sched(), we're in a bad state
   sched();
-  
-  // If we reach here, something is very wrong.
-  // But instead of panicking immediately, try to become truly unrunnable
-  acquire(&p->lock);
-  p->state = UNUSED;  // Mark as unused to prevent rescheduling
-  release(&p->lock);
-  
-  // Try one more time to schedule
-  sched();
-  
-  // If we still reach here after marking as UNUSED, panic
-  panic("zombie exit: process returned from sched twice");
+  panic("zombie exit");
 }
 
 // Wait for a child process to exit and return its pid.

kernel/proc.h

@@ -94,15 +94,18 @@ struct proc {
 
   // wait_lock must be held when using this:
   struct proc *parent;         // Parent process
- // these are private to the process, so p->lock need not be held.
+
+  // these are private to the process, so p->lock need not be held.
   uint64 kstack;               // Virtual address of kernel stack
   uint64 sz;                   // Size of process memory (bytes)
   pagetable_t pagetable;       // User page table
-  // 进程的结构体中需要加上usyscall字段
-  struct usyscall *usyscall;   // data page for usyscall
   struct trapframe *trapframe; // data page for trampoline.S
   struct context context;      // swtch() here to run process
   struct file *ofile[NOFILE];  // Open files
   struct inode *cwd;           // Current directory
   char name[16];               // Process name (debugging)
+  int alarm_cnt;               // Alarm count 触发alarm的时钟中断数量
+  int inter_cnt;               // interrupts count 需要统计的时钟中断的数量 
+  uint64 handler;              // alarm func address 记录处理alarm的函数的地址
+  struct trapframe *pre_trapframe;
 };

kernel/ramdisk.c

@@ -1,45 +0,0 @@
-//
-// ramdisk that uses the disk image loaded by qemu -initrd fs.img
-//
-
-#include "types.h"
-#include "riscv.h"
-#include "defs.h"
-#include "param.h"
-#include "memlayout.h"
-#include "spinlock.h"
-#include "sleeplock.h"
-#include "fs.h"
-#include "buf.h"
-
-void
-ramdiskinit(void)
-{
-}
-
-// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
-// Else if B_VALID is not set, read buf from disk, set B_VALID.
-void
-ramdiskrw(struct buf *b)
-{
-  if(!holdingsleep(&b->lock))
-    panic("ramdiskrw: buf not locked");
-  if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
-    panic("ramdiskrw: nothing to do");
-
-  if(b->blockno >= FSSIZE)
-    panic("ramdiskrw: blockno too big");
-
-  uint64 diskaddr = b->blockno * BSIZE;
-  char *addr = (char *)RAMDISK + diskaddr;
-
-  if(b->flags & B_DIRTY){
-    // write
-    memmove(addr, b->data, BSIZE);
-    b->flags &= ~B_DIRTY;
-  } else {
-    // read
-    memmove(b->data, addr, BSIZE);
-    b->flags |= B_VALID;
-  }
-}

kernel/riscv.h

@@ -204,7 +204,7 @@ r_menvcfg()
 static inline void 
 w_menvcfg(uint64 x)
 {
-  //asm volatile("csrw menvcfg, %0" : : "r" (x));
+  // asm volatile("csrw menvcfg, %0" : : "r" (x));
   asm volatile("csrw 0x30a, %0" : : "r" (x));
 }
 
@@ -314,14 +314,6 @@ r_sp()
   return x;
 }
 
-static inline uint64
-r_fp()
-{
-  uint64 x;
-  asm volatile("mv %0, s0" : "=r" (x) );
-  return x;
-}
-
 // read and write tp, the thread pointer, which xv6 uses to hold
 // this core's hartid (core number), the index into cpus[].
 static inline uint64
@@ -346,6 +338,15 @@ r_ra()
   return x;
 }
 
+// 读取当前帧指针（s0）寄存器的值
+static inline uint64
+r_fp()
+{
+  uint64 x;
+  asm volatile("mv %0, s0" : "=r" (x) );
+  return x;
+}
+
 // flush the TLB.
 static inline void
 sfence_vma()
@@ -362,11 +363,6 @@ typedef uint64 *pagetable_t; // 512 PTEs
 #define PGSIZE 4096 // bytes per page
 #define PGSHIFT 12  // bits of offset within a page
 
-#ifdef LAB_PGTBL
-#define SUPERPGSIZE (2 * (1 << 20)) // bytes per page
-#define SUPERPGROUNDUP(sz)  (((sz)+SUPERPGSIZE-1) & ~(SUPERPGSIZE-1))
-#endif
-
 #define PGROUNDUP(sz)  (((sz)+PGSIZE-1) & ~(PGSIZE-1))
 #define PGROUNDDOWN(a) (((a)) & ~(PGSIZE-1))
 
@@ -375,14 +371,6 @@ typedef uint64 *pagetable_t; // 512 PTEs
 #define PTE_W (1L << 2)
 #define PTE_X (1L << 3)
 #define PTE_U (1L << 4) // user can access
-#define PTE_A   (1L << 6) // Accessed bit
-#define PTE_D   (1L << 7) // Dirty bit
-#define PTE_PS  (1L << 8) // Page Size bit in PTE (for 2MB superpages)
-
-
-#if defined(LAB_MMAP) || defined(LAB_PGTBL)
-#define PTE_LEAF(pte) (((pte) & PTE_R) | ((pte) & PTE_W) | ((pte) & PTE_X))
-#endif
 
 // shift a physical address to the right place for a PTE.
 #define PA2PTE(pa) ((((uint64)pa) >> 12) << 10)

kernel/syscall.c

@@ -101,19 +101,8 @@ extern uint64 sys_unlink(void);
 extern uint64 sys_link(void);
 extern uint64 sys_mkdir(void);
 extern uint64 sys_close(void);
-
-#ifdef LAB_NET
-extern uint64 sys_bind(void);
-extern uint64 sys_unbind(void);
-extern uint64 sys_send(void);
-extern uint64 sys_recv(void);
-#endif
-#ifdef LAB_PGTBL
-extern uint64 sys_pgpte(void);
-extern uint64 sys_kpgtbl(void);
-extern uint64 sys_pgaccess(void);
-extern uint64 sys_dirtypages(void);
-#endif
+extern uint64 sys_sigalarm(void);
+extern uint64 sys_sigreturn(void);
 
 // An array mapping syscall numbers from syscall.h
 // to the function that handles the system call.
@@ -139,22 +128,10 @@ static uint64 (*syscalls[])(void) = {
 [SYS_link]    sys_link,
 [SYS_mkdir]   sys_mkdir,
 [SYS_close]   sys_close,
-#ifdef LAB_NET
-[SYS_bind] sys_bind,
-[SYS_unbind] sys_unbind,
-[SYS_send] sys_send,
-[SYS_recv] sys_recv,
-#endif
-#ifdef LAB_PGTBL
-[SYS_pgpte] sys_pgpte,
-[SYS_kpgtbl] sys_kpgtbl,
-[SYS_pgaccess] sys_pgaccess,
-[SYS_dirtypages] sys_dirtypages,
-#endif
+[SYS_sigalarm] sys_sigalarm,
+[SYS_sigreturn] sys_sigreturn,
 };
 
-
-
 void
 syscall(void)
 {

kernel/syscall.h

@@ -20,20 +20,5 @@
 #define SYS_link   19
 #define SYS_mkdir  20
 #define SYS_close  21
-
-// System calls for labs
-#define SYS_trace     22
-#define SYS_sysinfo   23
-#define SYS_sigalarm  24
-#define SYS_sigreturn 25
-#define SYS_symlink   26
-#define SYS_mmap      27
-#define SYS_munmap    28
-#define SYS_bind      29
-#define SYS_unbind    30
-#define SYS_send      31
-#define SYS_recv      32
-#define SYS_pgpte     33
-#define SYS_kpgtbl    34
-#define SYS_pgaccess  35
-#define SYS_dirtypages 36
+#define SYS_sigalarm 22
+#define SYS_sigreturn 23

kernel/sysinfo.h

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

kernel/sysproc.c

@@ -1,7 +1,7 @@
 #include "types.h"
 #include "riscv.h"
-#include "param.h"
 #include "defs.h"
+#include "param.h"
 #include "memlayout.h"
 #include "spinlock.h"
 #include "proc.h"
@@ -54,6 +54,7 @@ sys_sleep(void)
   int n;
   uint ticks0;
 
+  backtrace();
 
   argint(0, &n);
   if(n < 0)
@@ -71,37 +72,6 @@ sys_sleep(void)
   return 0;
 }
 
-
-#ifdef LAB_PGTBL
-int
-sys_pgpte(void)
-{
-  uint64 va;
-  struct proc *p;  
-
-  p = myproc();
-  argaddr(0, &va);
-  pte_t *pte = pgpte(p->pagetable, va);
-  if(pte != 0) {
-      return (uint64) *pte;
-  }
-  return 0;
-}
-#endif
-
-#ifdef LAB_PGTBL
-int
-sys_kpgtbl(void)
-{
-  struct proc *p;  
-
-  p = myproc();
-  vmprint(p->pagetable);
-  return 0;
-}
-#endif
-
-
 uint64
 sys_kill(void)
 {
@@ -124,81 +94,43 @@ sys_uptime(void)
   return xticks;
 }
 
+// sys_sigalarm函数用于设置进程的定时信号处理机制。
+// 参数：
+//   alarm_cnt：定时器计数值，表示每经过alarm_cnt个时钟中断后触发一次信号处理。
+//   addr：信号处理函数的用户空间地址。
+// 实现：
+//   1. 通过argint和argaddr获取用户传入的参数。
+//   2. 将进程的inter_cnt（中断计数器）清零。
+//   3. 保存信号处理函数地址和定时器计数值到进程结构体。
+//   4. 返回0，表示设置成功。
+
+// sys_sigreturn函数用于在信号处理函数执行完毕后恢复进程的上下文。
+// 实现：
+//   1. 获取当前进程指针。
+//   2. 将trapframe恢复为信号处理前保存的pre_trapframe，恢复进程上下文。
+//   3. 将inter_cnt（中断计数器）清零，重新计数。
+//   4. 返回信号处理前a0寄存器的值，作为系统调用的返回值。
 uint64
-sys_pgaccess(void)
- {
-   // lab pgtbl: your code here.
-  struct proc *p = myproc();
-  unsigned int abits=0;
-
-  uint64 addr;
-  argaddr(0, &addr);
-
-  int num;
-  argint(1,&num);
-
-  uint64 dest;
-  argaddr(2, &dest);
-
-
-  for(int i=0;i<num;i++){
-    uint64 query_addr = addr + i * PGSIZE ;
-
-
-    pte_t * pte=walk(p->pagetable, query_addr, 0);
-    if(*pte&PTE_A)
-    {
-      abits=abits|(1<<i);
-      *pte=(*pte)&(~PTE_A);
-    }
-
-  }
-
-
-
-  if(copyout(p->pagetable,dest,(char*)&abits, sizeof(abits)) < 0)
-    return -1;
-
-
-
-   return 0;
- }
-
-#ifdef LAB_PGTBL
-uint64
-sys_dirtypages(void)
+sys_sigalarm(void)
 {
-  struct proc *p = myproc();
-  unsigned int dbits = 0;
-
+  int alarm_cnt;
   uint64 addr;
-  argaddr(0, &addr);
+  struct proc *p = myproc();
+  argint(0, &alarm_cnt);
+  argaddr(1, &addr);
 
-  int num;
-  argint(1, &num);
-
-  uint64 dest;
-  argaddr(2, &dest);
-
-  // Check each page in the range
-  for(int i = 0; i < num; i++){
-    uint64 query_addr = addr + i * PGSIZE;
-
-    pte_t *pte = walk(p->pagetable, query_addr, 0);
-    if(pte == 0)
-      continue;  // Skip pages that don't exist
-    
-    if(*pte & PTE_D) {
-      dbits = dbits | (1 << i);
-      // Clear the dirty bit after reading it
-      *pte = (*pte) & (~PTE_D);
-    }
-  }
-
-  // Copy the result back to user space
-  if(copyout(p->pagetable, dest, (char*)&dbits, sizeof(dbits)) < 0)
-    return -1;
+  p->inter_cnt = 0;
+  p->handler = addr;
+  p->alarm_cnt = alarm_cnt;
 
   return 0;
 }
-#endif
+
+uint64
+sys_sigreturn(void)
+{
+  struct proc* p = myproc();
+  *p->trapframe = *p->pre_trapframe;
+  p->inter_cnt = 0;
+  return p->pre_trapframe->a0;
+}

kernel/trap.c

@@ -76,9 +76,21 @@ usertrap(void)
   if(killed(p))
     exit(-1);
 
-  // give up the CPU if this is a timer interrupt.
-  if(which_dev == 2)
-    yield();
+  // 如果这是一个定时器中断，则让出CPU。
+  if(which_dev == 2){
+    // 当前进程的中断计数器加一。
+    p->inter_cnt++;
+    // 如果中断计数器达到设定的报警计数，并且报警计数大于0。
+    if (p->inter_cnt == p->alarm_cnt && 0 < p->alarm_cnt) {
+      // 备份当前trapframe到pre_trapframe，用于后续恢复。
+      *p->pre_trapframe = *p->trapframe;
+      // 将epc设置为用户定义的handler函数地址，返回用户态时会跳转到handler执行。
+      p->trapframe->epc = p->handler;
+    } else {
+      // 否则让出CPU，进行进程调度。
+      yield();
+    }
+  }
 
   usertrapret();
 }

kernel/vm.c

@@ -4,8 +4,6 @@
 #include "elf.h"
 #include "riscv.h"
 #include "defs.h"
-#include "spinlock.h"
-#include "proc.h"
 #include "fs.h"
 
 /*
@@ -17,9 +15,6 @@ extern char etext[];  // kernel.ld sets this to end of kernel code.
 
 extern char trampoline[]; // trampoline.S
 
-// void sub_vmprint(pagetable_t pagetable, int level);
- 
-
 // Make a direct-map page table for the kernel.
 pagetable_t
 kvmmake(void)
@@ -35,14 +30,6 @@ kvmmake(void)
   // virtio mmio disk interface
   kvmmap(kpgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
 
-#ifdef LAB_NET
-  // PCI-E ECAM (configuration space), for pci.c
-  kvmmap(kpgtbl, 0x30000000L, 0x30000000L, 0x10000000, PTE_R | PTE_W);
-
-  // pci.c maps the e1000's registers here.
-  kvmmap(kpgtbl, 0x40000000L, 0x40000000L, 0x20000, PTE_R | PTE_W);
-#endif  
-
   // PLIC
   kvmmap(kpgtbl, PLIC, PLIC, 0x4000000, PTE_R | PTE_W);
 
@@ -99,17 +86,12 @@ pte_t *
 walk(pagetable_t pagetable, uint64 va, int alloc)
 {
   if(va >= MAXVA)
-    return 0;
+    panic("walk");
 
   for(int level = 2; level > 0; level--) {
     pte_t *pte = &pagetable[PX(level, va)];
     if(*pte & PTE_V) {
       pagetable = (pagetable_t)PTE2PA(*pte);
-#ifdef LAB_PGTBL
-      if (*pte & PTE_PS) {
-        return pte;
-      }
-#endif
     } else {
       if(!alloc || (pagetable = (pde_t*)kalloc()) == 0)
         return 0;
@@ -120,25 +102,6 @@ walk(pagetable_t pagetable, uint64 va, int alloc)
   return &pagetable[PX(0, va)];
 }
 
-pte_t *
-super_walk(pagetable_t pagetable, uint64 va, int alloc)
-{
-  if (va >= MAXVA)
-    return 0;
-  
-  pte_t *pte = &(pagetable[PX(2, va)]);
-  if (*pte & PTE_V) {
-    pagetable = (pagetable_t)PTE2PA(*pte);
-  } else {
-    if (!alloc || (pagetable = (pde_t*)kalloc()) == 0)
-      return 0;
-    memset(pagetable, 0, PGSIZE);
-    *pte = PA2PTE(pagetable) | PTE_V;
-  }
-
-  return &pagetable[PX(1, va)];
-}
-
 // Look up a virtual address, return the physical address,
 // or 0 if not mapped.
 // Can only be used to look up user pages.
@@ -159,17 +122,9 @@ walkaddr(pagetable_t pagetable, uint64 va)
   if((*pte & PTE_U) == 0)
     return 0;
   pa = PTE2PA(*pte);
-  if(*pte & PTE_PS) {
-    // For superpages, add the offset within the superpage
-    pa += va & (SUPERPGSIZE - 1);
-  } else {
-    // For regular pages, add the offset within the page
-    pa += va & (PGSIZE - 1);
-  }
   return pa;
 }
 
-
 // add a mapping to the kernel page table.
 // only used when booting.
 // does not flush TLB or enable paging.
@@ -201,35 +156,18 @@ mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
     panic("mappages: size");
   
   a = va;
-
-  if ((perm & PTE_PS) == 0) {  /*不使用巨页*/
-    last = va + size - PGSIZE;
-    for(;;){
-      if((pte = walk(pagetable, a, 1)) == 0)
-        return -1;
-      if(*pte & PTE_V)
-        panic("mappages: remap");
-      *pte = PA2PTE(pa) | perm | PTE_V;
-      if(a == last)
-        break;
-      a += PGSIZE;
-      pa += PGSIZE;
-    }
-  } else {   /* 使用巨页 */
-    last = va + size - SUPERPGSIZE;
-    for (;;) {
-      if ((pte = super_walk(pagetable, a, 1)) == 0)
-        return -1;
-      if (*pte & PTE_V)
-        panic("super mappages: remap");
-      *pte = PA2PTE(pa) | perm | PTE_V;
-      if (a == last) 
-        break;
-      a += SUPERPGSIZE;
-      pa += SUPERPGSIZE;
-    }
+  last = va + size - PGSIZE;
+  for(;;){
+    if((pte = walk(pagetable, a, 1)) == 0)
+      return -1;
+    if(*pte & PTE_V)
+      panic("mappages: remap");
+    *pte = PA2PTE(pa) | perm | PTE_V;
+    if(a == last)
+      break;
+    a += PGSIZE;
+    pa += PGSIZE;
   }
-
   return 0;
 }
 
@@ -241,42 +179,22 @@ uvmunmap(pagetable_t pagetable, uint64 va, uint64 npages, int do_free)
 {
   uint64 a;
   pte_t *pte;
-  uint64 end_va = va + npages * PGSIZE;
 
   if((va % PGSIZE) != 0)
     panic("uvmunmap: not aligned");
-  
-  for(a = va; a < end_va; ){
-    if((pte = walk(pagetable, a, 0)) == 0) {
-      // If we can't find a PTE, skip to next page
-      a += PGSIZE;
-      continue;
-    }
-    if((*pte & PTE_V) == 0) {
-      // If page is not valid, skip to next page
-      a += PGSIZE;
-      continue;
-    }
+
+  for(a = va; a < va + npages*PGSIZE; a += PGSIZE){
+    if((pte = walk(pagetable, a, 0)) == 0)
+      panic("uvmunmap: walk");
+    if((*pte & PTE_V) == 0)
+      panic("uvmunmap: not mapped");
     if(PTE_FLAGS(*pte) == PTE_V)
       panic("uvmunmap: not a leaf");
-    
-    if ((*pte & PTE_PS)) { /* 释放巨页 */
-      if(do_free){
-        uint64 pa = PTE2PA(*pte);
-        superfree((void*)pa);
-      }
-      *pte = 0;
-      // Make sure we don't go beyond the requested range
-      uint64 next_a = a + SUPERPGSIZE;
-      a = (next_a > end_va) ? end_va : next_a;
-    } else {
-      if(do_free){
-        uint64 pa = PTE2PA(*pte);
-        kfree((void*)pa);
-      }
-      *pte = 0;
-      a += PGSIZE;
+    if(do_free){
+      uint64 pa = PTE2PA(*pte);
+      kfree((void*)pa);
     }
+    *pte = 0;
   }
 }
 
@@ -309,7 +227,6 @@ uvmfirst(pagetable_t pagetable, uchar *src, uint sz)
   memmove(mem, src, sz);
 }
 
-
 // Allocate PTEs and physical memory to grow process from oldsz to
 // newsz, which need not be page aligned.  Returns new size or 0 on error.
 uint64
@@ -317,85 +234,24 @@ uvmalloc(pagetable_t pagetable, uint64 oldsz, uint64 newsz, int xperm)
 {
   char *mem;
   uint64 a;
-  
+
   if(newsz < oldsz)
     return oldsz;
 
   oldsz = PGROUNDUP(oldsz);
-
-  // Check if the allocation should use superpages
-  // We use superpages if we're allocating at least 2MB AND
-  // the range contains a superpage-aligned 2MB region
-  if (newsz - oldsz >= SUPERPGSIZE) {
-    uint64 super_start = SUPERPGROUNDUP(oldsz);
-    uint64 super_end = newsz & ~(SUPERPGSIZE - 1); // Round down to superpage boundary
-    
-    // Allocate regular pages before the first superpage boundary
-    for(a = oldsz; a < super_start; a += PGSIZE){
-      mem = kalloc();
-      if(mem == 0){
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
-  #ifndef LAB_SYSCALL
-      memset(mem, 0, PGSIZE);
-  #endif
-      if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
-        kfree(mem);
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
+  for(a = oldsz; a < newsz; a += PGSIZE){
+    mem = kalloc();
+    if(mem == 0){
+      uvmdealloc(pagetable, a, oldsz);
+      return 0;
     }
-
-    // Allocate superpages for aligned regions
-    for (a = super_start; a < super_end; a += SUPERPGSIZE) {
-      mem = superalloc();
-      if (mem == 0) {
-        uvmdealloc(pagetable, super_start, oldsz);
-        return 0;
-      }
-      if (mappages(pagetable, a, SUPERPGSIZE, (uint64)mem, PTE_R | PTE_U | PTE_PS | xperm) != 0) {
-        superfree(mem);
-        uvmdealloc(pagetable, super_start, oldsz);
-        return 0;
-      }
-    }
-
-    // Allocate regular pages after the last superpage boundary
-    for(a = super_end; a < newsz; a += PGSIZE){
-      mem = kalloc();
-      if(mem == 0){
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
-  #ifndef LAB_SYSCALL
-      memset(mem, 0, PGSIZE);
-  #endif
-      if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
-        kfree(mem);
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
-    }
-  } else {
-    // Allocation is smaller than SUPERPGSIZE, use regular pages
-    for(a = oldsz; a < newsz; a += PGSIZE){
-      mem = kalloc();
-      if(mem == 0){
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
-  #ifndef LAB_SYSCALL
-      memset(mem, 0, PGSIZE);
-  #endif
-      if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
-        kfree(mem);
-        uvmdealloc(pagetable, a, oldsz);
-        return 0;
-      }
+    memset(mem, 0, PGSIZE);
+    if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
+      kfree(mem);
+      uvmdealloc(pagetable, a, oldsz);
+      return 0;
     }
   }
- 
   return newsz;
 }
 
@@ -460,54 +316,26 @@ uvmcopy(pagetable_t old, pagetable_t new, uint64 sz)
   uint64 pa, i;
   uint flags;
   char *mem;
-  int szinc;
 
-  for(i = 0; i < sz; i += szinc){
-    szinc = PGSIZE;
+  for(i = 0; i < sz; i += PGSIZE){
     if((pte = walk(old, i, 0)) == 0)
       panic("uvmcopy: pte should exist");
     if((*pte & PTE_V) == 0)
       panic("uvmcopy: page not present");
     pa = PTE2PA(*pte);
     flags = PTE_FLAGS(*pte);
-
-    if ((flags & PTE_PS) == 0) {
-      if((mem = kalloc()) == 0)
-        goto err;
-      memmove(mem, (char*)pa, PGSIZE);
-      if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0){
-        kfree(mem);
-        goto err;
-      }
-    } else {
-      if ((mem = superalloc()) == 0)
-        goto err;
-      if (mappages(new, i, SUPERPGSIZE, (uint64)mem, flags) != 0) {
-        superfree(mem);
-        goto err;
-      }
-      memmove(mem, (char*)pa, SUPERPGSIZE);
-      szinc = SUPERPGSIZE; /* 修正步长 */
+    if((mem = kalloc()) == 0)
+      goto err;
+    memmove(mem, (char*)pa, PGSIZE);
+    if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0){
+      kfree(mem);
+      goto err;
     }
   }
   return 0;
 
  err:
-  // Clean up properly - need to unmap what we've mapped so far
-  for(uint64 j = 0; j < i; j += PGSIZE) {
-    pte_t *cleanup_pte = walk(new, j, 0);
-    if(cleanup_pte && (*cleanup_pte & PTE_V)) {
-      if(*cleanup_pte & PTE_PS) {
-        // This is a superpage, skip ahead
-        superfree((void*)PTE2PA(*cleanup_pte));
-        *cleanup_pte = 0;
-        j += SUPERPGSIZE - PGSIZE; // Will be incremented by PGSIZE in loop
-      } else {
-        kfree((void*)PTE2PA(*cleanup_pte));
-        *cleanup_pte = 0;
-      }
-    }
-  }
+  uvmunmap(new, 0, i / PGSIZE, 1);
   return -1;
 }
 
@@ -535,32 +363,21 @@ copyout(pagetable_t pagetable, uint64 dstva, char *src, uint64 len)
 
   while(len > 0){
     va0 = PGROUNDDOWN(dstva);
-    if (va0 >= MAXVA)
+    if(va0 >= MAXVA)
       return -1;
-    if((pte = walk(pagetable, va0, 0)) == 0) {
-      // printf("copyout: pte should exist 0x%x %d\n", dstva, len);
+    pte = walk(pagetable, va0, 0);
+    if(pte == 0 || (*pte & PTE_V) == 0 || (*pte & PTE_U) == 0 ||
+       (*pte & PTE_W) == 0)
       return -1;
-    }
-
-    // forbid copyout over read-only user text pages.
-    if((*pte & PTE_W) == 0)
-      return -1;
-    
-    pa0 = walkaddr(pagetable, va0);
-    if(pa0 == 0)
-      return -1;
-    
-    // Calculate the correct page size and boundary
-    uint64 pgsize = (*pte & PTE_PS) ? SUPERPGSIZE : PGSIZE;
-    uint64 va_base = va0 & ~(pgsize - 1);
-    n = pgsize - (dstva - va_base);
+    pa0 = PTE2PA(*pte);
+    n = PGSIZE - (dstva - va0);
     if(n > len)
       n = len;
-    memmove((void *)(pa0 + (dstva - va_base)), src, n);
+    memmove((void *)(pa0 + (dstva - va0)), src, n);
 
     len -= n;
     src += n;
-    dstva = va_base + pgsize;
+    dstva = va0 + PGSIZE;
   }
   return 0;
 }
@@ -572,30 +389,20 @@ int
 copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
 {
   uint64 n, va0, pa0;
-  pte_t *pte;
-  
+
   while(len > 0){
     va0 = PGROUNDDOWN(srcva);
-    if (va0 >= MAXVA)
-      return -1;
-    if((pte = walk(pagetable, va0, 0)) == 0) {
-      return -1;
-    }
     pa0 = walkaddr(pagetable, va0);
     if(pa0 == 0)
       return -1;
-    
-    // Calculate the correct page size and boundary
-    uint64 pgsize = (*pte & PTE_PS) ? SUPERPGSIZE : PGSIZE;
-    uint64 va_base = va0 & ~(pgsize - 1);
-    n = pgsize - (srcva - va_base);
+    n = PGSIZE - (srcva - va0);
     if(n > len)
       n = len;
-    memmove(dst, (void *)(pa0 + (srcva - va_base)), n);
+    memmove(dst, (void *)(pa0 + (srcva - va0)), n);
 
     len -= n;
     dst += n;
-    srcva = va_base + pgsize;
+    srcva = va0 + PGSIZE;
   }
   return 0;
 }
@@ -609,27 +416,17 @@ copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
 {
   uint64 n, va0, pa0;
   int got_null = 0;
-  pte_t *pte;
 
   while(got_null == 0 && max > 0){
     va0 = PGROUNDDOWN(srcva);
-    if (va0 >= MAXVA)
-      return -1;
-    if((pte = walk(pagetable, va0, 0)) == 0) {
-      return -1;
-    }
     pa0 = walkaddr(pagetable, va0);
     if(pa0 == 0)
       return -1;
-    
-    // Calculate the correct page size and boundary
-    uint64 pgsize = (*pte & PTE_PS) ? SUPERPGSIZE : PGSIZE;
-    uint64 va_base = va0 & ~(pgsize - 1);
-    n = pgsize - (srcva - va_base);
+    n = PGSIZE - (srcva - va0);
     if(n > max)
       n = max;
 
-    char *p = (char *) (pa0 + (srcva - va_base));
+    char *p = (char *) (pa0 + (srcva - va0));
     while(n > 0){
       if(*p == '\0'){
         *dst = '\0';
@@ -644,7 +441,7 @@ copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
       dst++;
     }
 
-    srcva = va_base + pgsize;
+    srcva = va0 + PGSIZE;
   }
   if(got_null){
     return 0;
@@ -652,46 +449,3 @@ copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
     return -1;
   }
 }
-
-
-#ifdef LAB_PGTBL
-void vmprint(pagetable_t pagetable);
-
-static void vmprint_recursive(pagetable_t pagetable, int level, uint64 va_base) {
-  for (int i = 0; i < 512; i++) {
-    pte_t pte = pagetable[i];
-    if (pte & PTE_V) {
-      uint64 pa = PTE2PA(pte);
-      uint64 va = va_base + ((uint64)i << (12 + 9 * (2 - level)));
-
-      for (int j = 0; j < level; j++)
-        printf(" ..");
-      
-      if (level > 0)
-        printf(" ");
-      if (level == 0) {
-      printf(" ..%p\n", (void*)va);
-      } else {
-      printf("..%p\n", (void*)va);
-      }
-
-      // 不是叶子节点，递归下一级页表
-      if ((pte & (PTE_R | PTE_W | PTE_X)) == 0) {
-        vmprint_recursive((pagetable_t)pa, level + 1, va);
-      }
-    }
-  }
-}
-
-void vmprint(pagetable_t pagetable) {
-  printf("page table %p\n", pagetable);
-  vmprint_recursive(pagetable, 0, 0);
-}
-#endif
-
-#ifdef LAB_PGTBL
-pte_t*
-pgpte(pagetable_t pagetable, uint64 va) {
-  return walk(pagetable, va, 0);
-}
-#endif

superpage_implementation_summary.md

@@ -1,321 +0,0 @@
-# xv6 超页（Superpage）实现复盘
-
-## 项目概述
-
-在 xv6 内核中实现 2MB 超页支持，当用户程序调用 `sbrk()` 时指定的大小为 2MB 或更大，并且新创建的地址范围包含一个或多个 2MB 对齐且至少为 2MB 大小的区域时，内核应使用单个超页（而不是数百个普通页）。
-
-## 实现目标
-
-- 支持 2MB 超页分配
-- 通过 `superpg_test` 测试用例
-- 保持与现有代码的兼容性
-- 正确处理超页的内存管理（分配、释放、复制）
-
-## 核心概念
-
-### 超页基本参数
-- **普通页大小**: 4KB (PGSIZE)
-- **超页大小**: 2MB (SUPERPGSIZE = 2 * 1024 * 1024)
-- **超页包含**: 512个普通页 (2MB / 4KB = 512)
-- **页表级别**: 在 level-1 页表中设置 PTE_PS 位
-
-### 关键常量定义
-```c
-#define SUPERPGSIZE (2 * (1 << 20))  // 2MB
-#define SUPERPGROUNDUP(sz) (((sz)+SUPERPGSIZE-1) & ~(SUPERPGSIZE-1))
-#define PTE_PS (1L << 7)  // Page Size bit
-```
-
-## 实现步骤
-
-### 1. 超页内存分配器（kernel/kalloc.c）
-
-#### 新增数据结构
-```c
-struct super_run {
-    struct super_run *next;
-};
-
-struct {
-    struct spinlock lock;
-    struct super_run *freelist;
-} skmem;
-```
-
-#### 核心函数实现
-
-**超页分配函数**
-```c
-void* superalloc() {
-    struct super_run *r;
-    acquire(&skmem.lock);
-    r = skmem.freelist;
-    if(r) skmem.freelist = r->next;
-    release(&skmem.lock);
-    if(r) memset((void*)r, 0, SUPERPGSIZE);
-    return (void*)r;
-}
-```
-
-**超页释放函数**
-```c
-void superfree(void *pa) {
-    struct super_run *r;
-    
-    if(((uint64)pa % SUPERPGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
-        panic("superfree");
-    
-    memset(pa, 1, SUPERPGSIZE);
-    
-    r = (struct super_run *)pa;
-    acquire(&skmem.lock);
-    r->next = skmem.freelist;
-    skmem.freelist = r;
-    release(&skmem.lock);
-}
-```
-
-**内存范围初始化**
-```c
-void freerange(void *pa_start, void *pa_end) {
-    char *p;
-    // 分配普通页
-    p = (char*)PGROUNDUP((uint64)pa_start);
-    for(; p + PGSIZE <= (char*)pa_end - 12 * 1024 * 1024; p += PGSIZE)
-        kfree(p);
-    
-    // 分配超页
-    p = (char*)SUPERPGROUNDUP((uint64)p);
-    for (; p + SUPERPGSIZE <= (char *)pa_end; p += SUPERPGSIZE) {
-        superfree(p);
-    }
-}
-```
-
-### 2. 页表管理（kernel/vm.c）
-
-#### 超页页表遍历
-```c
-pte_t *super_walk(pagetable_t pagetable, uint64 va, int alloc) {
-    if (va > MAXVA)
-        panic("walk");
-    
-    pte_t *pte = &(pagetable[PX(2, va)]);
-    if (*pte & PTE_V) {
-        pagetable = (pagetable_t)PTE2PA(*pte);
-    } else {
-        if (!alloc || (pagetable = (pde_t*)kalloc()) == 0)
-            return 0;
-        memset(pagetable, 0, PGSIZE);
-        *pte = PA2PTE(pagetable) | PTE_V;
-    }
-    
-    return &pagetable[PX(1, va)];  // 返回 level-1 PTE
-}
-```
-
-#### 修改 walk 函数支持超页检测
-```c
-pte_t *walk(pagetable_t pagetable, uint64 va, int alloc) {
-    // ... 现有代码 ...
-    for(int level = 2; level > 0; level--) {
-        pte_t *pte = &pagetable[PX(level, va)];
-        if(*pte & PTE_V) {
-            pagetable = (pagetable_t)PTE2PA(*pte);
-#ifdef LAB_PGTBL
-            if (*pte & PTE_PS) {
-                return pte;  // 遇到超页时返回该PTE
-            }
-#endif
-        }
-        // ... 其他代码 ...
-    }
-    return &pagetable[PX(0, va)];
-}
-```
-
-#### 地址转换函数增强
-```c
-uint64 walkaddr(pagetable_t pagetable, uint64 va) {
-    // ... 现有代码 ...
-    pa = PTE2PA(*pte);
-    if(*pte & PTE_PS) {
-        // 超页：添加超页内偏移
-        pa += va & (SUPERPGSIZE - 1);
-    } else {
-        // 普通页：添加页内偏移
-        pa += va & (PGSIZE - 1);
-    }
-    return pa;
-}
-```
-
-### 3. 内存分配策略（uvmalloc）
-
-**关键实现逻辑**：
-```c
-uint64 uvmalloc(pagetable_t pagetable, uint64 oldsz, uint64 newsz, int xperm) {
-    // 检查是否应该使用超页
-    if (newsz - oldsz >= SUPERPGSIZE) {
-        uint64 super_start = SUPERPGROUNDUP(oldsz);
-        uint64 super_end = newsz & ~(SUPERPGSIZE - 1);
-        
-        // 1. 分配超页边界前的普通页
-        for(a = oldsz; a < super_start; a += PGSIZE) {
-            // 分配普通页
-        }
-        
-        // 2. 分配对齐的超页区域
-        for (a = super_start; a < super_end; a += SUPERPGSIZE) {
-            mem = superalloc();
-            mappages(pagetable, a, SUPERPGSIZE, (uint64)mem, 
-                    PTE_R | PTE_U | PTE_PS | xperm);
-        }
-        
-        // 3. 分配超页边界后的普通页
-        for(a = super_end; a < newsz; a += PGSIZE) {
-            // 分配普通页
-        }
-    } else {
-        // 小于2MB的分配使用普通页
-    }
-}
-```
-
-### 4. 内存操作函数适配
-
-#### mappages 函数
-```c
-int mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm) {
-    if ((perm & PTE_PS) == 0) {
-        // 普通页映射逻辑
-        // 使用 walk() 函数
-    } else {
-        // 超页映射逻辑
-        // 使用 super_walk() 函数
-        last = va + size - SUPERPGSIZE;
-        for (;;) {
-            pte = super_walk(pagetable, a, 1);
-            *pte = PA2PTE(pa) | perm | PTE_V;
-            a += SUPERPGSIZE;
-            pa += SUPERPGSIZE;
-        }
-    }
-}
-```
-
-#### uvmunmap 函数
-```c
-void uvmunmap(pagetable_t pagetable, uint64 va, uint64 npages, int do_free) {
-    for(a = va; a < va + npages*PGSIZE; a += sz){
-        sz = PGSIZE;
-        pte = walk(pagetable, a, 0);
-        
-        if ((*pte & PTE_PS)) {
-            // 超页释放
-            if(do_free) superfree((void*)PTE2PA(*pte));
-            *pte = 0;
-            a += SUPERPGSIZE - sz;
-        } else {
-            // 普通页释放
-            if(do_free) kfree((void*)PTE2PA(*pte));
-            *pte = 0;
-        }
-    }
-}
-```
-
-#### uvmcopy 函数（fork支持）
-```c
-int uvmcopy(pagetable_t old, pagetable_t new, uint64 sz) {
-    for(i = 0; i < sz; i += szinc){
-        szinc = PGSIZE;
-        pte = walk(old, i, 0);
-        flags = PTE_FLAGS(*pte);
-        
-        if ((flags & PTE_PS) == 0) {
-            // 复制普通页
-            mem = kalloc();
-            memmove(mem, (char*)pa, PGSIZE);
-            mappages(new, i, PGSIZE, (uint64)mem, flags);
-        } else {
-            // 复制超页
-            mem = superalloc();
-            memmove(mem, (char*)pa, SUPERPGSIZE);
-            mappages(new, i, SUPERPGSIZE, (uint64)mem, flags);
-            szinc = SUPERPGSIZE;
-        }
-    }
-}
-```
-
-#### copy操作函数适配
-```c
-// copyout, copyin, copyinstr 都需要类似的修改
-uint64 pgsize = (*pte & PTE_PS) ? SUPERPGSIZE : PGSIZE;
-uint64 va_base = va0 & ~(pgsize - 1);
-n = pgsize - (srcva - va_base);
-```
-
-## 关键测试理解
-
-### superpg_test 测试流程
-1. **分配8MB内存**: `sbrk(N)` 其中 N = 8MB
-2. **计算超页起始地址**: `SUPERPGROUNDUP(end)`
-3. **验证512个连续页面**: `supercheck(s)`
-   - 检查512个4KB页面有相同的PTE（证明是超页）
-   - 验证PTE权限（PTE_V | PTE_R | PTE_W）
-   - 测试内存读写功能
-4. **Fork测试**: 验证超页在进程复制时正确工作
-
-### 测试期望
-- 512个连续的4KB页面应该映射到同一个超页
-- 每个页面通过 `pgpte()` 返回相同的PTE值
-- PTE必须设置正确的权限位
-- 内存读写必须正常工作
-- Fork后子进程中超页仍然正常
-
-## 遇到的问题和解决方案
-
-### 1. fork失败问题
-**问题**: 测试中fork调用失败
-**原因**: uvmcopy函数中超页处理逻辑错误
-**解决**: 修正超页复制时的步长计算和错误处理
-
-### 2. 内存分配策略问题
-**问题**: 没有正确识别何时使用超页
-**原因**: 原始逻辑基于总分配大小，未考虑对齐
-**解决**: 重写分配策略，考虑超页对齐边界
-
-### 3. 地址计算错误
-**问题**: walkaddr等函数对超页地址计算错误
-**原因**: 未考虑超页的偏移计算差异
-**解决**: 根据PTE_PS位选择不同的偏移计算方法
-
-### 4. 内存释放错误
-**问题**: 释放超页时调用kfree而非superfree
-**原因**: uvmunmap函数未区分超页和普通页
-**解决**: 根据PTE_PS位选择正确的释放函数
-
-## 实现验证
-
-### 测试结果
-- ✅ superpg_test: OK - 超页分配和使用正常
-- ✅ pgaccess_test: OK - 页面访问跟踪正常  
-- ✅ ugetpid_test: OK - 基本系统调用正常
-- ✅ usertests: 通过 - 系统整体稳定性良好
-
-### 性能优势
-- **内存效率**: 2MB超页减少页表条目数量
-- **TLB效率**: 单个TLB条目覆盖2MB而非4KB
-- **管理效率**: 减少页表遍历深度
-
-## 总结
-
-超页实现的核心挑战在于：
-1. **双重内存管理**: 同时支持4KB普通页和2MB超页
-2. **智能分配策略**: 自动识别何时使用超页
-3. **页表处理**: 正确处理不同级别的页表项
-4. **兼容性**: 保持与现有代码的完全兼容
-
-通过仔细的设计和实现，成功在xv6中添加了超页支持，提高了大内存分配的效率，同时保持了系统的稳定性和兼容性。 

time.txt

@@ -1 +1 @@
-88888888
+8

user/alarmtest.c

@@ -0,0 +1,193 @@
+//
+// test program for the alarm lab.
+// you can modify this file for testing,
+// but please make sure your kernel
+// modifications pass the original
+// versions of these tests.
+//
+
+#include "kernel/param.h"
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "kernel/riscv.h"
+#include "user/user.h"
+
+void test0();
+void test1();
+void test2();
+void test3();
+void periodic();
+void slow_handler();
+void dummy_handler();
+
+int
+main(int argc, char *argv[])
+{
+  test0();
+  test1();
+  test2();
+  test3();
+  exit(0);
+}
+
+volatile static int count;
+
+void
+periodic()
+{
+  count = count + 1;
+  printf("alarm!\n");
+  sigreturn();
+}
+
+// tests whether the kernel calls
+// the alarm handler even a single time.
+void
+test0()
+{
+  int i;
+  printf("test0 start\n");
+  count = 0;
+  sigalarm(2, periodic);
+  for(i = 0; i < 1000*500000; i++){
+    if((i % 1000000) == 0)
+      write(2, ".", 1);
+    if(count > 0)
+      break;
+  }
+  sigalarm(0, 0);
+  if(count > 0){
+    printf("test0 passed\n");
+  } else {
+    printf("\ntest0 failed: the kernel never called the alarm handler\n");
+  }
+}
+
+void __attribute__ ((noinline)) foo(int i, int *j) {
+  if((i % 2500000) == 0) {
+    write(2, ".", 1);
+  }
+  *j += 1;
+}
+
+//
+// tests that the kernel calls the handler multiple times.
+//
+// tests that, when the handler returns, it returns to
+// the point in the program where the timer interrupt
+// occurred, with all registers holding the same values they
+// held when the interrupt occurred.
+//
+void
+test1()
+{
+  int i;
+  int j;
+
+  printf("test1 start\n");
+  count = 0;
+  j = 0;
+  sigalarm(2, periodic);
+  for(i = 0; i < 500000000; i++){
+    if(count >= 10)
+      break;
+    foo(i, &j);
+  }
+  if(count < 10){
+    printf("\ntest1 failed: too few calls to the handler\n");
+  } else if(i != j){
+    // the loop should have called foo() i times, and foo() should
+    // have incremented j once per call, so j should equal i.
+    // once possible source of errors is that the handler may
+    // return somewhere other than where the timer interrupt
+    // occurred; another is that that registers may not be
+    // restored correctly, causing i or j or the address ofj
+    // to get an incorrect value.
+    printf("\ntest1 failed: foo() executed fewer times than it was called\n");
+  } else {
+    printf("test1 passed\n");
+  }
+}
+
+//
+// tests that kernel does not allow reentrant alarm calls.
+void
+test2()
+{
+  int i;
+  int pid;
+  int status;
+
+  printf("test2 start\n");
+  if ((pid = fork()) < 0) {
+    printf("test2: fork failed\n");
+  }
+  if (pid == 0) {
+    count = 0;
+    sigalarm(2, slow_handler);
+    for(i = 0; i < 1000*500000; i++){
+      if((i % 1000000) == 0)
+        write(2, ".", 1);
+      if(count > 0)
+        break;
+    }
+    if (count == 0) {
+      printf("\ntest2 failed: alarm not called\n");
+      exit(1);
+    }
+    exit(0);
+  }
+  wait(&status);
+  if (status == 0) {
+    printf("test2 passed\n");
+  }
+}
+
+void
+slow_handler()
+{
+  count++;
+  printf("alarm!\n");
+  if (count > 1) {
+    printf("test2 failed: alarm handler called more than once\n");
+    exit(1);
+  }
+  for (int i = 0; i < 1000*500000; i++) {
+    asm volatile("nop"); // avoid compiler optimizing away loop
+  }
+  sigalarm(0, 0);
+  sigreturn();
+}
+
+//
+// dummy alarm handler; after running immediately uninstall
+// itself and finish signal handling
+void
+dummy_handler()
+{
+  sigalarm(0, 0);
+  sigreturn();
+}
+
+//
+// tests that the return from sys_sigreturn() does not
+// modify the a0 register
+void
+test3()
+{
+  uint64 a0;
+
+  sigalarm(1, dummy_handler);
+  printf("test3 start\n");
+
+  asm volatile("lui a5, 0");
+  asm volatile("addi a0, a5, 0xac" : : : "a0");
+  for(int i = 0; i < 500000000; i++)
+    ;
+  asm volatile("mv %0, a0" : "=r" (a0) );
+
+  if(a0 != 0xac)
+    printf("test3 failed: register a0 changed\n");
+  else
+    printf("test3 passed\n");
+}

user/bttest.c

@@ -0,0 +1,10 @@
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "user/user.h"
+
+int
+main(int argc, char *argv[])
+{
+  sleep(1);
+  exit(0);
+}

user/call.c

@@ -0,0 +1,17 @@
+#include "kernel/param.h"
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "user/user.h"
+
+int g(int x) {
+  return x+3;
+}
+
+int f(int x) {
+  return g(x);
+}
+
+void main(void) {
+  printf("%d %d\n", f(8)+1, 13);
+  exit(0);
+}

user/dirtypagestest.c

@@ -1,62 +0,0 @@
-#include "kernel/types.h"
-#include "kernel/stat.h"
-#include "user/user.h"
-
-void
-test_dirtypages()
-{
-    printf("dirtypages test starting\n");
-    
-    // Allocate some pages
-    char *buf = malloc(32 * 4096);  // 32 pages
-    if(buf == 0) {
-        printf("malloc failed\n");
-        exit(1);
-    }
-    
-    // Clear dirty bits first by calling dirtypages
-    unsigned int dbits;
-    if (dirtypages(buf, 32, &dbits) < 0) {
-        printf("dirtypages failed\n");
-        exit(1);
-    }
-    printf("Initial dirty bits cleared: 0x%x\n", dbits);
-    
-    // Write to some pages to make them dirty
-    buf[0] = 1;         // Page 0
-    buf[4096 * 5] = 1;  // Page 5
-    buf[4096 * 10] = 1; // Page 10
-    
-    // Check dirty pages
-    if (dirtypages(buf, 32, &dbits) < 0) {
-        printf("dirtypages failed\n");
-        exit(1);
-    }
-    
-    printf("Dirty bits after writes: 0x%x\n", dbits);
-    
-    // Check if the expected pages are marked as dirty
-    if (dbits & (1 << 0))
-        printf("Page 0 is dirty (expected)\n");
-    if (dbits & (1 << 5))
-        printf("Page 5 is dirty (expected)\n");
-    if (dbits & (1 << 10))
-        printf("Page 10 is dirty (expected)\n");
-    
-    // Check again - dirty bits should be cleared now
-    if (dirtypages(buf, 32, &dbits) < 0) {
-        printf("dirtypages failed\n");
-        exit(1);
-    }
-    printf("Dirty bits after clearing: 0x%x (should be 0)\n", dbits);
-    
-    free(buf);
-    printf("dirtypages test: OK\n");
-}
-
-int
-main(int argc, char *argv[])
-{
-    test_dirtypages();
-    exit(0);
-} 

user/find.c

@@ -1,98 +0,0 @@
-#include "kernel/fs.h"
-#include "kernel/stat.h"
-#include "kernel/types.h"
-#include "user/user.h"
-
-int match_pattern(const char *name, const char *pattern) {
-  const char *star = 0;
-  const char *name_ptr = name;
-  const char *pattern_ptr = pattern;
-
-  while (1) {
-    if (*pattern_ptr == '*') {
-      star = pattern_ptr++;
-      name_ptr = name;
-      continue;
-    }
-
-    if (!*name)
-      return (!*pattern_ptr || (star && !*++pattern_ptr));
-    if (*pattern_ptr == '?' || *pattern_ptr == *name) {
-      pattern_ptr++;
-      name++;
-      continue;
-    }
-
-    if (star) {
-      pattern_ptr = star + 1;
-      name = ++name_ptr;
-      continue;
-    }
-    return 0;
-  }
-}
-
-void find(char *path, char *pattern) {
-  char buf[512], *p;
-  int fd;
-  struct dirent de;
-  struct stat st;
-
-  if ((fd = open(path, 0)) < 0) {
-    fprintf(2, "find: cannot open %s\n", path);
-    return;
-  }
-
-  if (fstat(fd, &st) < 0) {
-    fprintf(2, "find: cannot stat %s\n", path);
-    close(fd);
-    return;
-  }
-
-  if (st.type != T_DIR) {
-    fprintf(2, "find: %s is not a directory\n", path);
-    close(fd);
-    return;
-  }
-
-  if (strlen(path) + 1 + DIRSIZ + 1 > sizeof buf) {
-    fprintf(2, "find: path too long\n");
-    close(fd);
-    return;
-  }
-
-  strcpy(buf, path);
-  p = buf + strlen(buf);
-  *p++ = '/';
-
-  while (read(fd, &de, sizeof(de)) == sizeof(de)) {
-    if (de.inum == 0 || !strcmp(de.name, ".") || !strcmp(de.name, ".."))
-      continue;
-
-    memmove(p, de.name, DIRSIZ);
-    p[DIRSIZ] = 0;
-
-    if (stat(buf, &st) < 0) {
-      fprintf(2, "find: cannot stat %s\n", buf);
-      continue;
-    }
-
-    if (st.type == T_DIR) {
-      find(buf, pattern);
-    } else if (st.type == T_FILE) {
-      if (match_pattern(de.name, pattern)) {
-        fprintf(1, "%s\n", buf);
-      }
-    }
-  }
-  close(fd);
-}
-
-int main(int argc, char *argv[]) {
-  if (argc != 3) {
-    fprintf(2, "Usage: find <path> <pattern>\n");
-    exit(1);
-  }
-  find(argv[1], argv[2]);
-  exit(0);
-}

user/pgtbltest.c

@@ -1,164 +0,0 @@
-#include "kernel/param.h"
-#include "kernel/fcntl.h"
-#include "kernel/types.h"
-#include "kernel/riscv.h"
-#include "user/user.h"
-
-#define N (8 * (1 << 20))
-
-void print_pgtbl();
-void print_kpgtbl();
-void ugetpid_test();
-void pgaccess_test();
-void superpg_test();
-
-int
-main(int argc, char *argv[])
-{
-  print_pgtbl();
-  ugetpid_test();
-  print_kpgtbl();
-  pgaccess_test();
-  superpg_test();
-  printf("pgtbltest: all tests succeeded\n");
-  exit(0);
-}
-
-char *testname = "???";
-
-void
-err(char *why)
-{
-  printf("pgtbltest: %s failed: %s, pid=%d\n", testname, why, getpid());
-  exit(1);
-}
-
-void
-print_pte(uint64 va)
-{
-    pte_t pte = (pte_t) pgpte((void *) va);
-    printf("va 0x%lx pte 0x%lx pa 0x%lx perm 0x%lx\n", va, pte, PTE2PA(pte), PTE_FLAGS(pte));
-}
-
-void
-print_pgtbl()
-{
-  printf("print_pgtbl starting\n");
-  for (uint64 i = 0; i < 10; i++) {
-    print_pte(i * PGSIZE);
-  }
-  uint64 top = MAXVA/PGSIZE;
-  for (uint64 i = top-10; i < top; i++) {
-    print_pte(i * PGSIZE);
-  }
-  printf("print_pgtbl: OK\n");
-}
-
-void
-ugetpid_test()
-{
-  int i;
-
-  printf("ugetpid_test starting\n");
-  testname = "ugetpid_test";
-
-  for (i = 0; i < 64; i++) {
-    int ret = fork();
-    if (ret != 0) {
-      wait(&ret);
-      if (ret != 0)
-        exit(1);
-      continue;
-    }
-    if (getpid() != ugetpid())
-      err("missmatched PID");
-    exit(0);
-  }
-  printf("ugetpid_test: OK\n");
-}
-
-void
-print_kpgtbl()
-{
-  printf("print_kpgtbl starting\n");
-  kpgtbl();
-  printf("print_kpgtbl: OK\n");
-}
-
-void
-pgaccess_test()
-{
-  char *buf;
-  unsigned int abits;
-  printf("pgaccess_test starting\n");
-  testname = "pgaccess_test";
-  buf = malloc(32 * PGSIZE);
-  if (pgaccess(buf, 32, &abits) < 0)
-    err("pgaccess failed");
-  buf[PGSIZE * 1] += 1;
-  buf[PGSIZE * 2] += 1;
-  buf[PGSIZE * 30] += 1;
-  if (pgaccess(buf, 32, &abits) < 0)
-    err("pgaccess failed");
-  if (abits != ((1 << 1) | (1 << 2) | (1 << 30)))
-    err("incorrect access bits set");
-  free(buf);
-  printf("pgaccess_test: OK\n");
-}
-
-void
-supercheck(uint64 s)
-{
-  pte_t last_pte = 0;
-
-  for (uint64 p = s;  p < s + 512 * PGSIZE; p += PGSIZE) {
-    pte_t pte = (pte_t) pgpte((void *) p);
-    if(pte == 0)
-      err("no pte");
-    if ((uint64) last_pte != 0 && pte != last_pte) {
-        err("pte different");
-    }
-    if((pte & PTE_V) == 0 || (pte & PTE_R) == 0 || (pte & PTE_W) == 0){
-      err("pte wrong");
-    }
-    last_pte = pte;
-  }
-
-  for(int i = 0; i < 512; i += PGSIZE){
-    *(int*)(s+i) = i;
-  }
-
-  for(int i = 0; i < 512; i += PGSIZE){
-    if(*(int*)(s+i) != i)
-      err("wrong value");
-  }
-}
-
-void
-superpg_test()
-{
-  int pid;
-  
-  printf("superpg_test starting\n");
-  testname = "superpg_test";
-  
-  char *end = sbrk(N);
-  if (end == 0 || end == (char*)0xffffffffffffffff)
-    err("sbrk failed");
-  
-  uint64 s = SUPERPGROUNDUP((uint64) end);
-  supercheck(s);
-  if((pid = fork()) < 0) {
-    err("fork");
-  } else if(pid == 0) {
-    supercheck(s);
-    exit(0);
-  } else {
-    int status;
-    wait(&status);
-    if (status != 0) {
-      exit(0);
-    }
-  }
-  printf("superpg_test: OK\n");  
-}

user/pingpong.c

@@ -1,21 +0,0 @@
-#include "kernel/types.h"
-#include "user/user.h"
-
-int main(int argc, char *argv[]) {
-  int proc_f2s[2], proc_s2f[2];
-  char buffer[8];
-  pipe(proc_f2s);
-  pipe(proc_s2f);
-
-  if (fork() == 0) {
-    read(proc_s2f[0], buffer, 4);
-    printf("%d: received %s\n", getpid(), buffer);
-    write(proc_f2s[1], "pong", strlen("pong"));
-  } else {
-    write(proc_s2f[1], "ping", strlen("ping"));
-    read(proc_f2s[0], buffer, 4);
-    printf("%d: received %s\n", getpid(), buffer);
-  }
-
-  exit(0);
-}

user/primes.c

@@ -1,61 +0,0 @@
-#include "kernel/types.h"
-#include "user/user.h"
-
-void redirect(int n, int pd[]) {
-    close(n);
-    dup(pd[n]);
-    close(pd[0]);
-    close(pd[1]);
-}
-
-void primes() {
-    int previous, next;
-    int fd[2];
-
-    while (read(0, &previous, sizeof(int))) {
-        printf("prime %d\n", previous);
-
-        if (pipe(fd) < 0) {
-            fprintf(2, "pipe failed\n");
-            exit(1);
-        }
-
-        if (fork() == 0) {
-            redirect(1, fd);
-            while (read(0, &next, sizeof(int))) {
-                if (next % previous != 0) {
-                    write(1, &next, sizeof(int));
-                }
-            }
-            exit(0);
-        } else {
-            close(fd[1]);
-            redirect(0, fd);
-        }
-    }
-}
-
-int main(int argc, char *argv[]) {
-    int fd[2];
-
-    if (pipe(fd) < 0) {
-        fprintf(2, "pipe failed\n");
-        exit(1);
-    }
-
-    if (fork() == 0) {
-        redirect(1, fd);
-        for (int i = 2; i < 36; i++) {
-            write(1, &i, sizeof(int));
-        }
-        exit(0);
-    } else {
-        close(fd[1]);
-        redirect(0, fd);
-        primes();
-    }
-
-    exit(0);
-}
-
-

user/sleep.c

@@ -1,13 +0,0 @@
-#include "kernel/types.h"
-#include "user/user.h"
-
-int main(int argc, char *argv[]) {
-  if (argc != 2) {
-    fprintf(2, "Usage: sleep <time>\n");
-    exit(1);
-  }
-  int time = atoi(argv[1]);
-  // printf("time: %d\n", time);
-  sleep(time);
-  exit(0);
-}

user/sysinfo.c

@@ -1,21 +0,0 @@
-#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

@@ -1,164 +0,0 @@
-#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

@@ -1,24 +0,0 @@
-#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/ulib.c

@@ -1,13 +1,8 @@
 #include "kernel/types.h"
 #include "kernel/stat.h"
 #include "kernel/fcntl.h"
-#ifdef LAB_PGTBL
-#include "kernel/riscv.h"
-#include "kernel/memlayout.h"
-#endif
 #include "user/user.h"
 
-
 //
 // wrapper so that it's OK if main() does not call exit().
 //
@@ -150,12 +145,3 @@ memcpy(void *dst, const void *src, uint n)
 {
   return memmove(dst, src, n);
 }
-
-#ifdef LAB_PGTBL
-int
-ugetpid(void)
-{
-  struct usyscall *u = (struct usyscall *)USYSCALL;
-  return u->pid;
-}
-#endif

user/uptime.c

@@ -1,15 +0,0 @@
-#include "kernel/types.h"
-#include "user/user.h"
-
-int main(int argc, char *argv[]) {
-  if (argc != 1) {
-    // 错误输出到stderr（文件描述符2）
-    fprintf(2, "Usage: uptime\n");
-    exit(1);
-  }
-
-  fprintf(1,"up: %d\n",uptime());
-  
-  exit(0);
-}
-

user/user.h

@@ -1,12 +1,3 @@
-#ifdef LAB_MMAP
-typedef unsigned long size_t;
-typedef long int off_t;
-#endif
-
-typedef unsigned int   uint;
-typedef unsigned char  uchar;
-typedef unsigned long uint64;
-
 struct stat;
 
 // system calls
@@ -31,19 +22,8 @@ int getpid(void);
 char* sbrk(int);
 int sleep(int);
 int uptime(void);
-#ifdef LAB_NET
-int bind(uint32);
-int unbind(uint32);
-int send(uint32, uint32, uint32, char *, uint32);
-int recv(uint32, uint32*, uint32*, char *, uint32);
-#endif
-#ifdef LAB_PGTBL
-int ugetpid(void);
-uint64 pgpte(void*);
-void kpgtbl(void);
-int pgaccess(void *base, int len, void *mask);
-int dirtypages(void *base, int len, void *mask);
-#endif
+int sigalarm(int, void(*)());
+int sigreturn(void);
 
 // ulib.c
 int stat(const char*, struct stat*);
@@ -59,9 +39,6 @@ void* memset(void*, int, uint);
 int atoi(const char*);
 int memcmp(const void *, const void *, uint);
 void *memcpy(void *, const void *, uint);
-#ifdef LAB_LOCK
-int statistics(void*, int);
-#endif
 
 // umalloc.c
 void* malloc(uint);

user/usertests.c

@@ -244,7 +244,7 @@ copyinstr3(char *s)
 // See if the kernel refuses to read/write user memory that the
 // application doesn't have anymore, because it returned it.
 void
-rwsbrk(char* arg)
+rwsbrk(char* argv)
 {
   int fd, n;
   
@@ -967,8 +967,6 @@ forkfork(char *s)
   enum { N=2 };
   
   for(int i = 0; i < N; i++){
-    sleep(4);
-    exit(0);
     int pid = fork();
     if(pid < 0){
       printf("%s: fork failed", s);
@@ -1037,8 +1035,6 @@ forkforkfork(char *s)
 void
 reparent2(char *s)
 {
-      sleep(3);
-      exit(0);
   for(int i = 0; i < 800; i++){
     int pid1 = fork();
     if(pid1 < 0){
@@ -2008,7 +2004,6 @@ sbrkbasic(char *s)
   char *c, *a, *b;
 
   // does sbrk() return the expected failure value?
-  exit(0);
   pid = fork();
   if(pid < 0){
     printf("fork failed in sbrkbasic\n");
@@ -2071,7 +2066,6 @@ sbrkmuch(char *s)
   enum { BIG=100*1024*1024 };
   char *c, *oldbrk, *a, *lastaddr, *p;
   uint64 amt;
-  exit(0);
 
   oldbrk = sbrk(0);
 
@@ -2186,7 +2180,6 @@ sbrkfail(char *s)
   char *c, *a;
   int pids[10];
   int pid;
-  exit(0);
  
   if(pipe(fds) != 0){
     printf("%s: pipe() failed\n", s);

user/usys.pl

@@ -36,11 +36,5 @@ entry("getpid");
 entry("sbrk");
 entry("sleep");
 entry("uptime");
-entry("bind");
-entry("unbind");
-entry("send");
-entry("recv");
-entry("pgpte");
-entry("kpgtbl");
-entry("pgaccess");
-entry("dirtypages");
+entry("sigalarm");
+entry("sigreturn");

user/xargs.c

@@ -1,59 +0,0 @@
-#include "kernel/param.h"
-#include "kernel/stat.h"
-#include "kernel/types.h"
-#include "user/user.h"
-
-int main(int argc, char *argv[]) {
-  if (argc < 2) {
-    fprintf(2, "Usage: xargs command\n");
-    exit(1);
-  }
-
-  char *cmd[argc + 1];
-  int index = 0, data = 0;
-  for (int i = 1; i < argc; ++i) {
-    cmd[index++] = argv[i];
-  }
-
-  char buffer[MAXARG];
-  char line[MAXARG] = {0};
-  int line_pos = 0;
-
-  while ((data = read(0, buffer, MAXARG)) > 0) {
-    for (int i = 0; i < data; ++i) {
-      if (buffer[i] == '\n' || buffer[i] == ' ') {
-        line[line_pos] = 0;
-        if (line_pos > 0) {
-          char *arg = malloc(line_pos + 1);
-          strcpy(arg, line);
-          cmd[index++] = arg;
-        }
-        line_pos = 0;
-
-        if (buffer[i] == '\n') {
-          cmd[index] = 0;
-          if (fork() == 0) {
-            exec(cmd[0], cmd);
-            exit(1);
-          }
-          wait(0);
-          index = argc - 1;
-        }
-      } else {
-        line[line_pos++] = buffer[i];
-      }
-    }
-  }
-
-  // bug fixed
-  if (line_pos > 0) {
-    line[line_pos] = 0;
-    cmd[index++] = line;
-    cmd[index] = 0;
-    if (fork() == 0) {
-      exec(cmd[0], cmd);
-    }
-    wait(0);
-  }
-  exit(0);
-}

user/xargstest.sh

@@ -1,6 +0,0 @@
-mkdir a
-echo hello > a/b
-mkdir c
-echo hello > c/b
-echo hello > b
-find . b | xargs grep hello