文章目录
- 前言
- 一、启动xv6(难度：Easy)
- 解析：
- 二、sleep(难度：Easy)
- 解析：
- 三、pingpong（难度：Easy）
- 解析：
- 四、Primes(素数，难度：Moderate/Hard)
- 解析：
- 五、find（难度：Moderate）
- 解析：
- 六、xargs（难度：Moderate）
- 解析：
- 总结
前言
一个本硕双非的小菜鸡，备战24年秋招。打算尝试6.S081，将它的Lab逐一实现，并记录期间心酸历程。
代码下载
官方网站：6.S081官方网站
安装方式：
通过 APT 安装 （Debian/Ubuntu）
确保你的 debian 版本运行的是 “bullseye” 或 “sid”（在 ubuntu 上，这可以通过运行 cat /etc/debian_version 来检查），然后运行：
sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu
（“buster”上的 QEMU 版本太旧了，所以你必须单独获取。
qemu-system-misc 修复
此时此刻，似乎软件包 qemu-system-misc 收到了一个更新，该更新破坏了它与我们内核的兼容性。如果运行 make qemu 并且脚本在 qemu-system-riscv64 -machine virt -bios none -kernel/kernel -m 128M -smp 3 -nographic -drive file=fs.img，if=none，format=raw，id=x0 -device virtio-blk-device，drive=x0，bus=virtio-mmio-bus.0 之后出现挂起
，
则需要卸载该软件包并安装旧版本：
$ sudo apt-get remove qemu-system-misc
$ sudo apt-get install qemu-system-misc=1:4.2-3ubuntu6
在 Arch 上安装
sudo pacman -S riscv64-linux-gnu-binutils riscv64-linux-gnu-gcc riscv64-linux-gnu-gdb qemu-arch-extra
测试您的安装
若要测试安装，应能够检查以下内容：
$ riscv64-unknown-elf-gcc --version
riscv64-unknown-elf-gcc (GCC) 10.1.0
...
$ qemu-system-riscv64 --version
QEMU emulator version 5.1.0
您还应该能够编译并运行 xv6： 要退出 qemu，请键入：Ctrl-a x。
# in the xv6 directory
$ make qemu
# ... lots of output ...
init: starting sh
$
一、启动xv6(难度：Easy)
获取实验室的xv6源代码并切换到util分支
$ git clone git://g.csail.mit.edu/xv6-labs-2020
Cloning into 'xv6-labs-2020'...
...
$ cd xv6-labs-2020
$ git checkout util
Branch 'util' set up to track remote branch 'util' from 'origin'.
Switched to a new branch 'util'
Xv6-labs-2020存储库与本书的xv6-riscv稍有不同;它主要添加一些文件。如果你好奇的话，可以执行git log:
$ git log
您将需要使用Git版本控制系统管理和提交文件以及后续的实验室作业。接下来，切换到一个分支(执行git checkout util)，其中包含针对该实验室定制的xv6版本。要了解关于Git的更多信息，请查看Git用户手册。Git允许您跟踪对代码所做的更改。例如，如果你完成了其中一个练习，并且想检查你的进度，你可以通过运行以下命令来提交你的变化:
$ git commit -am 'my solution for util lab exercise 1'
Created commit 60d2135: my solution for util lab exercise 1
1 files changed, 1 insertions(+), 0 deletions(-)
$
您可以使用git diff命令跟踪您的更改。运行git diff将显示自上次提交以来对代码的更改，git diff origin/util将显示相对于初始xv6-labs-2020代码的更改。这里，origin/xv6-labs-2020是git分支的名称，它是包含您下载的初始代码分支。
构建并运行xv6
$ make qemu
riscv64-unknown-elf-gcc -c -o kernel/entry.o kernel/entry.S
riscv64-unknown-elf-gcc -Wall -Werror -O -fno-omit-frame-pointer -ggdb -DSOL_UTIL -MD -mcmodel=medany -ffreestanding -fno-common -nostdlib -mno-relax -I. -fno-stack-protector -fno-pie -no-pie -c -o kernel/start.o kernel/start.c
...
riscv64-unknown-elf-ld -z max-page-size=4096 -N -e main -Ttext 0 -o user/_zombie user/zombie.o user/ulib.o user/usys.o user/printf.o user/umalloc.o
riscv64-unknown-elf-objdump -S user/_zombie > user/zombie.asm
riscv64-unknown-elf-objdump -t user/_zombie | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$/d' > user/zombie.sym
mkfs/mkfs fs.img README user/xargstest.sh user/_cat user/_echo user/_forktest user/_grep user/_init user/_kill user/_ln user/_ls user/_mkdir user/_rm user/_sh user/_stressfs user/_usertests user/_grind user/_wc user/_zombie
nmeta 46 (boot, super, log blocks 30 inode blocks 13, bitmap blocks 1) blocks 954 total 1000
balloc: first 591 blocks have been allocated
balloc: write bitmap block at sector 45
qemu-system-riscv64 -machine virt -bios none -kernel kernel/kernel -m 128M -smp 3 -nographic -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0
xv6 kernel is booting
hart 2 starting
hart 1 starting
init: starting sh
$
如果你在提示符下输入 ls，你会看到类似如下的输出:
$ ls
. 1 1 1024
.. 1 1 1024
README 2 2 2059
xargstest.sh 2 3 93
cat 2 4 24256
echo 2 5 23080
forktest 2 6 13272
grep 2 7 27560
init 2 8 23816
kill 2 9 23024
ln 2 10 22880
ls 2 11 26448
mkdir 2 12 23176
rm 2 13 23160
sh 2 14 41976
stressfs 2 15 24016
usertests 2 16 148456
grind 2 17 38144
wc 2 18 25344
zombie 2 19 22408
console 3 20 0
这些是mkfs在初始文件系统中包含的文件；大多数是可以运行的程序。你刚刚跑了其中一个：ls。
xv6没有ps命令，但是如果您键入Ctrl-p，内核将打印每个进程的信息。如果现在尝试，您将看到两行：一行用于init，另一行用于sh。
退出 qemu : Ctrl-a x。
解析：
没啥好说的，配置环境是个大关。
按着官方文档来就好了，6.S081官方环境配置链接
唯一问题是：安装RISC-V交叉编译工具 超级无敌巨坑！！！估计其他环境搭建文章肯定也提到这事了。
以下这句官方配置代码，仅限于ubuntu 20.04，我之前使用 ubuntu 16.04报了个镜像源链接错误，害得我换了个遍也没解决，最后无奈下载ubuntu 20.04。
sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu
剩下什么安装QEMU，下载源码都没啥，一步步按着官方操作就行。
最后make qemu一下，ls出结果，Ctrl-a按完松手再按x退出。
二、sleep(难度：Easy)
实现xv6的UNIX程序sleep：您的sleep应该暂停到用户指定的计时数。一个滴答(tick)是由xv6内核定义的时间概念，即来自定时器芯片的两个中断之间的时间。您的解决方案应该在文件user/sleep.c中
提示：
在你开始编码之前，请阅读《book-riscv-rev1》的第一章
看看其他的一些程序（如/user/echo.c, /user/grep.c, /user/rm.c）查看如何获取传递给程序的命令行参数
如果用户忘记传递参数，sleep应该打印一条错误信息
命令行参数作为字符串传递; 您可以使用atoi将其转换为数字（详见/user/ulib.c）
使用系统调用sleep
请参阅kernel/sysproc.c以获取实现sleep系统调用的xv6内核代码（查找sys_sleep），user/user.h提供了sleep的声明以便其他程序调用，用汇编程序编写的user/usys.S可以帮助sleep从用户区跳转到内核区。
确保main函数调用exit()以退出程序。
将你的sleep程序添加到Makefile中的UPROGS中；完成之后，make qemu将编译您的程序，并且您可以从xv6的shell运行它。
看看Kernighan和Ritchie编著的《C程序设计语言》（第二版）来了解C语言。
从xv6 shell运行程序：
$ make qemu
...
init: starting sh
$ sleep 10
(nothing happens for a little while)
$
如果程序在如上所示运行时暂停，则解决方案是正确的。运行make grade看看你是否真的通过了睡眠测试。
请注意，make grade运行所有测试，包括下面作业的测试。如果要对一项作业运行成绩测试，请键入（不要启动XV6，在外部终端下使用）：
$ ./grade-lab-util sleep
这将运行与sleep匹配的成绩测试。或者，您可以键入：
$ make GRADEFLAGS=sleep grade
效果是一样的。
解析：
这题练手题，明白int argc, char *argv[]都是啥，会调sleep函数就ok。
argc是命令行总的参数个数 。
argv[]为保存命令行参数的字符串指针。其中第0个参数是程序的全名，以后的参数为命令行后面跟的用户输入的参数。
就比如说该命令sleep 10。其中argc就应该是1，argv[1]就是输入的10。
答案：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(2, "usage: sleep pattern [file ...]\n");
exit(1);
}
sleep(atoi(argv[1]));
exit(0);
}
记得修改makefile文件，在152行那里添加
$U/_sleep\
如果出现/usr/bin/env: “python”: 没有那个文件或目录，这个错误。把grade-lab-util中第一句改成：
#!/usr/bin/env python3
就好了
三、pingpong（难度：Easy）
使用管道编写prime sieve(筛选素数)的并发版本。这个想法是由Unix管道的发明者Doug McIlroy提出的。请查看这个网站(翻译在下面)，该网页中间的图片和周围的文字解释了如何做到这一点。您的解决方案应该在user/primes.c文件中。
提示：
使用pipe来创造管道
使用fork创建子进程
使用read从管道中读取数据，并且使用write向管道中写入数据
使用getpid获取调用进程的pid
将程序加入到Makefile的UPROGS
xv6上的用户程序有一组有限的可用库函数。您可以在user/user.h中看到可调用的程序列表；源代码（系统调用除外）位于user/ulib.c、user/printf.c和user/umalloc.c中。
运行程序应得到下面的输出
$ make qemu
...
init: starting sh
$ pingpong
4: received ping
3: received pong
$
如果您的程序在两个进程之间交换一个字节并产生如上所示的输出，那么您的解决方案是正确的。
解析：
通过管道，记得多做异常判断和使用完了就要关闭读写。
答案：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "kernel/fcntl.h"
#include "user/user.h"
#include "kernel/param.h"
int main(int argc, char *argv[])
{
int p1[2], p2[2];
pipe(p1);//子进程->父进程
pipe(p2);//父进程->子进程
if (argc != 1) {
printf("Parameter missing\n");
exit(0);
}
char *buf = argv[1];
int pid = fork();
if (pid > 0) {
close(p1[1]);
close(p2[0]);
if (write(p2[1], &buf, sizeof(char)) != sizeof(char)) {
printf(" father write error \n");
exit(0);
}
if (read(p1[0], &buf, sizeof(char)) != sizeof(char)) {
printf(" father read error \n");
exit(0);
} else {
printf("%d: received pong \n", getpid());
exit(0);
}
close(p1[0]);
close(p2[1]);
} else if (pid == 0) {
close(p1[0]);
close(p2[1]);
if (read(p2[0], &buf, sizeof(char)) != sizeof(char)) {
printf(" child read error \n");
exit(0);
}
if (write(p1[1], &buf, sizeof(char)) != sizeof(char)) {
printf(" child write error \n");
exit(0);
} else {
printf("%d: received ping \n", getpid());
exit(0);
}
close(p1[1]);
close(p2[0]);
} else {
printf(" fork error!\n ");
close(p1[0]);
close(p1[1]);
close(p2[0]);
close(p2[1]);
exit(0);
}
}
结果：
四、Primes(素数，难度：Moderate/Hard)
使用管道编写prime sieve(筛选素数)的并发版本。这个想法是由Unix管道的发明者Doug McIlroy提出的。请查看这个网站(翻译在下面)，该网页中间的图片和周围的文字解释了如何做到这一点。您的解决方案应该在user/primes.c文件中。
您的目标是使用pipe和fork来设置管道。第一个进程将数字2到35输入管道。对于每个素数，您将安排创建一个进程，该进程通过一个管道从其左邻居读取数据，并通过另一个管道向其右邻居写入数据。由于xv6的文件描述符和进程数量有限，因此第一个进程可以在35处停止。
提示：
请仔细关闭进程不需要的文件描述符，否则您的程序将在第一个进程达到35之前就会导致xv6系统资源不足。
一旦第一个进程达到35，它应该使用wait等待整个管道终止，包括所有子孙进程等等。因此，主primes进程应该只在打印完所有输出之后，并且在所有其他primes进程退出之后退出。
提示：当管道的write端关闭时，read返回零。
最简单的方法是直接将32位（4字节）int写入管道，而不是使用格式化的ASCII I/O。
您应该仅在需要时在管线中创建进程。
将程序添加到Makefile中的UPROGS
如果您的解决方案实现了基于管道的筛选并产生以下输出，则是正确的：
$ make qemu
...
init: starting sh
$ primes
prime 2
prime 3
prime 5
prime 7
prime 11
prime 13
prime 17
prime 19
prime 23
prime 29
prime 31
$
解析：
难点在于看懂那个文章和递归遍历
参考：
p = get a number from left neighbor
print p
loop:
n = get a number from left neighbor
if (p does not divide n)
send n to right neighbor
p = 从左邻居中获取一个数
print p
loop:
n = 从左邻居中获取一个数
if (n不能被p整除)
将n发送给右邻居
生成进程可以将数字2、3、4、…、1000输入管道的左端：行中的第一个进程消除2的倍数，第二个进程消除3的倍数，第三个进程消除5的倍数，依此类推。
答案：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "kernel/fcntl.h"
#include "user/user.h"
#include "kernel/param.h"
int lpipe_first_data(int lpipe[2], int *dst)
{
if (read(lpipe[0], dst, sizeof(int)) == sizeof(int)) {
printf("prime %d\n", *dst);
return 0;
}
return -1;
}
void traversal(int lpipe[2])
{
close(lpipe[1]);
int first;
if (lpipe_first_data(lpipe, &first) == 0) {
int p[2];
pipe(p);
int data;
while (read(lpipe[0], &data, sizeof(int)) == sizeof(int)) {
if (data % first)
write(p[1], &data, sizeof(int));
}
close(lpipe[0]);
close(p[1]);
if (fork() == 0)
traversal(p);
else {
close(p[0]);
wait(0);
}
}
exit(0);
}
int main(int argc, char *argv[])
{
if (argc != 2) {
printf("Parameter missing\n");
exit(0);
}
int nums = atoi(argv[1]);
int p[2];
pipe(p);
for (int i = 2; i <= nums; i++) {
write(p[1], &i, sizeof(int));
}
if (fork() == 0) {
traversal(p);
} else {
close(p[1]);
close(p[0]);
wait(0);
}
exit(0);
}
五、find（难度：Moderate）
写一个简化版本的UNIX的find程序：查找目录树中具有特定名称的所有文件，你的解决方案应该放在user/find.c
提示：
查看user/ls.c文件学习如何读取目录
使用递归允许find下降到子目录中
不要在“.”和“…”目录中递归
对文件系统的更改会在qemu的运行过程中一直保持；要获得一个干净的文件系统，请运行make clean，然后make qemu
你将会使用到C语言的字符串，要学习它请看《C程序设计语言》（K&R）,例如第5.5节
注意在C语言中不能像python一样使用“==”对字符串进行比较，而应当使用strcmp()
将程序加入到Makefile的UPROGS
如果你的程序输出下面的内容，那么它是正确的（当文件系统中包含文件b和a/b的时候）
$ make qemu
...
init: starting sh
$ echo > b
$ mkdir a
$ echo > a/b
$ find . b
./b
./a/b
$
解析：
确实没啥说的，代码基本上都是ls.c中的内容。
答案：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"
void find(char* path, char* filename)
{
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;
}
//fstat() 用来将参数filedes 所指向的文件状态复制到参数buf 所指向的结构
if(fstat(fd, &st) < 0) {
fprintf(2, "find: cannot stat %s\n", path);
close(fd);
return;
}
//参数错误，find的第一个参数必须是目录
if (st.type != T_DIR) {
fprintf(2, "usage: find <DIRECTORY> <filename>\n");
return;
}
//检查路径长度是否适合存储在buf中
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf) {
printf("find: path too long\n");
return;
}
strcpy(buf, path);
p = buf+strlen(buf);
*p++ = '/';
while(read(fd, &de, sizeof(de)) == sizeof(de)) {
if(de.inum == 0)
continue;
memmove(p, de.name, DIRSIZ);
p[DIRSIZ] = 0;
if(stat(buf, &st) < 0) {
printf("find: cannot stat %s\n", buf);
continue;
}
//不要在“.”和“..”目录中递归
if (st.type == T_DIR && strcmp(p, ".") != 0 && strcmp(p, "..") != 0) {
find(buf, filename);
} else if (strcmp(filename, p) == 0)
printf("%s\n", buf);
}
close(fd);
}
int main(int argc, char* argv[])
{
if (argc != 3) {
printf("Parameter missing\n");
exit(0);
}
find(argv[1], argv[2]);
return 0;
}
结果：
六、xargs（难度：Moderate）
编写一个简化版UNIX的xargs程序：它从标准输入中按行读取，并且为每一行执行一个命令，将行作为参数提供给命令。你的解决方案应该在user/xargs.c
下面的例子解释了xargs的行为
$ echo hello too | xargs echo bye
bye hello too
$
注意，这里的命令是echo bye，额外的参数是hello too，这样就组成了命令echo bye hello too，此命令输出bye hello too
请注意，UNIX上的xargs进行了优化，一次可以向该命令提供更多的参数。 我们不需要您进行此优化。 要使UNIX上的xargs表现出本实验所实现的方式，请将-n选项设置为1。例如
$ echo "1\n2" | xargs -n 1 echo line
line 1
line 2
$
提示：
使用fork和exec对每行输入调用命令，在父进程中使用wait等待子进程完成命令。
要读取单个输入行，请一次读取一个字符，直到出现换行符（‘\n’）。
kernel/param.h声明MAXARG，如果需要声明argv数组，这可能很有用。
将程序添加到Makefile中的UPROGS。
对文件系统的更改会在qemu的运行过程中保持不变；要获得一个干净的文件系统，请运行make clean，然后make qemu
xargs、find和grep结合得很好
$ find . b | xargs grep hello
将对“.”下面的目录中名为b的每个文件运行grep hello。
要测试您的xargs方案是否正确，请运行shell脚本xargstest.sh。如果您的解决方案产生以下输出，则是正确的：
$ make qemu
...
init: starting sh
$ sh < xargstest.sh
$ $ $ $ $ $ hello
hello
hello
$ $
你可能不得不回去修复你的find程序中的bug。输出有许多$ ，因为xv6 shell没有意识到它正在处理来自文件而不是控制台的命令，并为文件中的每个命令打印$。
解析：
这题我感觉是第一节中最难的，主要是没有换行符判断很难受。
听从大佬解法使用滑动窗口解决。
大佬解法链接
具体解释看代码注释。
答案：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/param.h"
int main(int argc, char *argv[])
{
char buf[512] = {0};//滑动窗口
char *xargv[MAXARG] = {0};
uint size = 0;//字节大小
int endIndex = 0;//字段末尾标识符
for (int i = 1; i < argc; i++) {
xargv[i - 1] = argv[i];
}
while (!(endIndex && size == 0)) {
if (!endIndex) {
int readBytes = read(0, buf + size, 512 - size);
if (readBytes < 0) {
printf(" read error \n");
exit(0);
}
/*如果读取到 0 字节（即已到达标准输入的末尾），则关闭标准输入并设置为真*/
if (readBytes == 0) {
close(0);
endIndex = 1;
}
size += readBytes;
}
/*处理读取的行*/
char* lineEnd = strchr(buf, '\n');//每一行的结束
while (lineEnd) {
char xbuf[513] = {0};
memcpy(xbuf, buf, lineEnd - buf);
xargv[argc - 1] = xbuf;
int pid = fork();
if (pid == 0) {
/*子进程使用 exec 执行由 argv[1] 指定的程序，并将 xargv 作为参数传递*/
if (!endIndex)
close(0);
if (exec(argv[1], xargv) < 0) {
fprintf(2, "xargv: exec fails [file ...]\n");
exit(1);
}
} else if (pid > 0) {
/*父进程从滑动窗口中移除已处理的行*/
memmove(buf, lineEnd + 1, size - (lineEnd - buf) - 1);
size -= lineEnd - buf + 1;
memset(buf + size, 0, 512 - size);
/*回收僵尸*/
int status;
int ret = wait(&status);
//成功返回0 失败返回-1
if( ret < 0) {
printf("wait error");
exit(1);
}
/*继续查找和处理下一行*/
lineEnd = strchr(buf, '\n');
} else {
printf("%d: received ping \n", getpid());
exit(0);
}
}
}
exit(0);
}
其实还是有点小毛病，使用给出的sh < xargstest.sh，输出有点问题
其他是对的
之后再仔细瞅瞅。
总结
我稍微有些操作系统的学习知识，做的不算太卡。哈工大的我感觉底层东西介绍的多，但是有些其他知识覆盖面少，就比如进程通信、锁、管道之类的就没咋说。
个人感觉比起csapp的lab容易。
现在据说这个实验也没那么新颖了，可以根据自己理解整点新东西。
