操作系统入门系列-MIT6.828（操作系统工程）学习条记（三）---- xv6初探与 ...

系列文章目录

操作系统入门系列-MIT6.S081（操作系统）学习条记（一）---- 操作系统介绍与接口示例
操作系统入门系列-MIT6.828（操作系统工程）学习条记（二）----课程实行环境搭建（wsl2+ubuntu+quem+xv6）
操作系统入门系列-MIT6.828（操作系统工程）学习条记（三）---- xv6初探与实行一(Lab: Xv6 and Unix utilities)
操作系统入门系列-MIT6.828（操作系统工程）学习条记（四）---- C语言与盘算机架构(Programming xv6 in C)

---

  

---

前言

MIT 6.828课程资料与进度计划表
完成第一节课的学习后，按照课程的计划进度表，应当阅读xv6文档的第一章节，以及完成实行1。
本文主要内容就是对xv6文档（2023年版）和实行（2023年版）的讲解
xv6英文文档—2023
xv6中文文档—2013
xv6实行1原文

---

一、xv6文档第一章

1. 引论

xv6操作系统提供 Unix 操作系统中的基本接口（由 Ken Thompson 和 Dennis Ritchie 引入），同时模拟 Unix 的内部计划，包括 BSD，Linux，Mac OS X，Solaris （甚至 Microsoft Windows 在某种程度上）都有雷同 Unix 的接口，理解 xv6 是理解这些操作系统的一个精良起点。
首先需要对操作系统有一个系统结构的大致概念，如下图：

如图所示，操作系统的核心就是kernel。kernel起到了桥梁的作用，连接各种应用程序和底层硬件资源。从软件编程者的角度来看，程序员就是利用各种kernel提供的系统调用函数，来实现各种各样的功能。xv6的系统调用函数如下图所示：

反面的实行就是需要调用这些系统调用函数来实现相应的功能，比如在Linux里面常用的find、xargs等命令的浅易版。
在之前的文章中已经将第一章的部分进行了讲解，详情见：
操作系统入门系列-MIT6.S081（操作系统）学习条记（一）---- 操作系统介绍与接口示例
二、实行一

1.启动xv6

详见xv6环境的设置和启动
操作系统入门系列-MIT6.828（操作系统工程）学习条记（二）----课程实行环境搭建（wsl2+ubuntu+quem+xv6）
（1）实行系统目录：
整个实行代码的文件目录如下，我们需要关注：

1. 1.绿色的”grade-lab-util“可执行文件，它是测试机，用来测试你的实验代码正确性。
2. 2.kernel文件夹，是xv6的kernel代码
3. 3.Makefile是用来编译内核的，需要在这里添加参数，我们写的实验代码才能编译进去
4. 4.user文件夹是我们添加自己实验代码的地方，也就是用户空间       

复制代码

（2）Makefile添加文件

（3）退出xv6
利用”ctrl+a“，后按x退出
（4）测试机打分
需要在lab目录中添加time.txt文件，里面写一个整数，代表你的实行花了多少小时。

2.实现休眠函数

（1）原题如下：

（2）大致内容为：
调用“系统调用函数——sleep()”（一次sleep()系统暂停一个tick），实现输入数字，系统暂停该数字次数的ticks。
参数错误时，要有错误打印
（3）代码如下：

1. // 参考echo.c、grep.c、rm.c的头文件引用
2. #include "kernel/types.h"//声明数据类型
3. #include "kernel/stat.h"//声明文件数据结构
4. #include "kernel/fcntl.h"//open函数的模式参数申明
5. #include "user/user.h"//声明各种系统调用函数、以及有用的库函数
8. int main(int argc, char *argv[])
9. {
10.     int number;
12.     //参数数量不对，打印错误信息
13.     //参数还有其他错误情况，此处仅考虑数量问题
14.     if(argc <= 1)
15.     {
16.         fprintf(2, "usage: sleep number\n");
17.         exit(1);
18.     }
20.     number = atoi(argv[1]);//字符串转整数
21.     sleep(number);//系统调用
23.     exit(0);
24. }

复制代码

（4）效果如下：
利用官方提供的测试机程序，在lab目录下面运行"./grade-lab-util + 文件名"

1. ./grade-lab-util sleep

复制代码

测试机自主进行测试，如下图：

（5）总结：
在做实行之前我们需要知道有哪些函数我们是可以调用的，可以检察文件：“user/user.h”

1. struct stat;
3. // system calls
4. int fork(void);
5. int exit(int) __attribute__((noreturn));
6. int wait(int*);
7. int pipe(int*);
8. int write(int, const void*, int);
9. int read(int, void*, int);
10. int close(int);
11. int kill(int);
12. int exec(const char*, char**);
13. int open(const char*, int);
14. int mknod(const char*, short, short);
15. int unlink(const char*);
16. int fstat(int fd, struct stat*);
17. int link(const char*, const char*);
18. int mkdir(const char*);
19. int chdir(const char*);
20. int dup(int);
21. int getpid(void);
22. char* sbrk(int);
23. int sleep(int);
24. int uptime(void);
26. // ulib.c
27. int stat(const char*, struct stat*);
28. char* strcpy(char*, const char*);
29. void *memmove(void*, const void*, int);
30. char* strchr(const char*, char c);
31. int strcmp(const char*, const char*);
32. void fprintf(int, const char*, ...);
33. void printf(const char*, ...);
34. char* gets(char*, int max);
35. uint strlen(const char*);
36. void* memset(void*, int, uint);
37. void* malloc(uint);
38. void free(void*);
39. int atoi(const char*);
40. int memcmp(const void *, const void *, uint);
41. void *memcpy(void *, const void *, uint);

复制代码

3.实现父子进程pingpong打印

（1）原题如下：

（2）大致内容为：
实现过程：父进程向子进程发送ping，子进程打印该信息，后子进程向父进程发送pong，父进程再打印该信息
实现效果为：

（3）代码如下：
分为单管道实现和双管道实现
单管道实现：

1. #include "kernel/types.h"
2. #include "kernel/stat.h"
3. #include "kernel/fcntl.h"
4. #include "user/user.h"
6. int main(int argc, char *argv[])
7. {
8.     int p[2];
9.     char buf[512];//用来接收信息的buffer
11.     pipe(p);//父 <=======> 子
13.     //子进程执行if，父进程执行else
14.     if(fork() == 0)
15.     {
16.         read(p[0], buf, sizeof(buf));//阻塞，直到父进程写入管道p内容，后读取父进程的信息
17.         fprintf(1,"%d: received %s\n", getpid(), buf);//打印父进程的信息
18.         write(p[1], "pong", 5);//使用p的写通道向父进程发送信息
19.         close(p[0]);//关闭读通道
20.         close(p[1]);//关闭写通道
21.         exit(0);//子进程退出
22.     }
23.     else
24.     {
25.         write(p[1], "ping", 5);//父进程通过p的写通道向子进程发送信息
26.         wait((int *)0);//等待子进程结束
27.         read(p[0], buf, sizeof(buf));//读取p管道中子进程的信息
28.         fprintf(1,"%d: received %s\n", getpid(), buf);//打印子进程的信息
29.         close(p[0]);//关闭读通道
30.         close(p[1]);//关闭写通道
31.     }
33.     exit(0);
34. }

复制代码

双管道实现：

1. #include "kernel/types.h"
2. #include "kernel/stat.h"
3. #include "kernel/fcntl.h"
4. #include "user/user.h"
6. int main(int argc, char *argv[])
7. {
8.     int p[2];
9.     int p2[2];
10.     char buf[512];//用来接收信息的buffer
12.     //向内核申请两个管道
13.     pipe(p);//父进程写，子进程读：父 ——————> 子
14.     pipe(p2);//子进程写，父进程读：子 ——————> 父
16.     //子进程执行if，父进程执行else
17.     if(fork() == 0)
18.     {
19.         close(p[1]);//关闭p的写通道，以便于父进程写完可以直接读取
20.         read(p[0], buf, sizeof(buf));//阻塞，直到父进程写入管道p内容，后读取父进程的信息
21.         fprintf(1,"%d: received %s\n", getpid(), buf);//打印父进程的信息
22.         close(p[0]);//关闭p的读通道
23.         write(p2[1], "pong", 5);//使用p2的写通道向父进程发送信息
24.         close(p2[1]);//写完关闭写通道
25.         close(p2[0]);//关闭p2的读通道
26.         exit(0);//子进程退出
27.     }
28.     else
29.     {
30.         write(p[1], "ping", 5);//父进程通过p的写通道向子进程发送信息
31.         close(p[1]);//写完关闭写通道
32.         close(p2[1]);//关闭p2的写通道，以便于子进程写完可以直接读取
33.         read(p2[0], buf, sizeof(buf));//阻塞，直到子进程写入管道p2内容，读取子进程的信息
34.         fprintf(1,"%d: received %s\n", getpid(), buf);//打印子进程的信息
35.         close(p[0]);//关闭p的读通道
36.         close(p2[0]);//关闭p2的读通道
37.     }
39.     exit(0);//结束程序
40. }

复制代码

（4）效果如下：

（5）总结：
无
4.利用pipeline实现质数检测

（1）原题如下：

（2）大致内容为：
利用pipeline+多进程来检测35以内的质数检测
这个过程比力难想，但是在纸上推演一下流程就懂了，参考文献如下：Bell Labs and CSP Threads
参考伪代码：

参考图：

（3）代码如下：

1. #include "kernel/types.h"
2. #include "kernel/stat.h"
3. #include "kernel/fcntl.h"
4. #include "user/user.h"
7. void child(int * p)
8. {
9.     int p1[2];
10.     char num[35];
11.     int prime;
12.     int i;
13.     int ret;
14.     int number;
16.     pipe(p1);
18.     close(p[1]);
19.     number = 0;
20.     for(i=0;i<35;i++)
21.     {
22.         ret = read(p[0], num+i, 1);
23.         if(ret == 0)
24.         {
25.             break;
26.         }
27.         number++;
28.     }
30.     if(number == 0)
31.     {
32.         exit(0);
33.     }
35.     prime = num[0];
36.     printf("prime %d\n", prime);
37.     close(p[0]);
39.     if(fork() == 0)
40.     {
41.         child(p1);
42.     }
43.     else
44.     {
45.         close(p1[0]);
46.         for(i=1;i<number;i++)
47.         {
48.             if((num[i]%prime)!=0)
49.             {
50.                 write(p1[1], num+i, 1);
51.             }
52.         }
53.         close(p1[1]);
54.         wait((int *)0);
55.     }
57.     exit(0);
58. }
61. int main()
62. {
63.     int prime = 2;
64.     int p[2];
65.     int i;
67.     pipe(p);
69.     if(fork() == 0)
70.     {
71.         child(p);
72.     }
73.     else
74.     {
75.         close(p[0]);
76.         printf("prime %d\n", prime);
77.         for(i=3;i<=35;i++)
78.         {
79.             if((i%prime)!=0)
80.             {
81.                 write(p[1], &i, 1);
82.             }
83.         }
84.         close(p[1]);
85.         wait((int *)0);
86.     }
89.     exit(0);
90. }

复制代码

（4）效果如下：

（5）总结：
核心是算法题，载体是进程树之间利用pipeline进行读写控制
5.实现find函数（文件查找）

（1）原题如下：

（2）大致内容为：
实现目录下搜刮文件的功能，要求能够找到该文件夹目录下以及其子目录下的指定文件名，输出所有满足文件的路径。（不要求实现正则表达式）（！！！记得规避".“与”…"子文件）（如何访问文件夹可以参考文件ls.c的实现）

1.   "  .  "  表示当前目录
2.   "  ..  "  表示当前目录的上一级目录。
3.   "  ./  "  表示当前目录下的某个文件或文件夹，视后面跟着的名字而定
4.   "  ../  "   表示当前目录上一级目录的文件或文件夹，视后面跟着的名字而定。

复制代码

（3）代码如下：

1. #include "kernel/types.h"
2. #include "kernel/stat.h"
3. #include "kernel/fcntl.h"
4. #include "kernel/fs.h"
5. #include "user/user.h"
7. char* fmtname(char *path)
8. {
9.   char *p;
11.   // Find first character after last slash.
12.   for(p=path+strlen(path); p >= path && *p != '/'; p--)
13.     ;
14.   p++;
16.   return p;
17. }
19. int find(char *name, char *p)
20. {
21.     int fd;
22.     int path=0;
23.     char buf[512];
24.     struct dirent de;
25.     struct stat st;
27.     fd = open(p, O_RDONLY);
28.     if(fd < 0)
29.     {
30.         fprintf(2, "fd: can not open %s\n");
31.         exit(1);
32.     }
33.     strcpy(buf, p);
34.     p = buf+strlen(buf);
35.     *p++ = '/';
36.     // printf("%d  %s\n", fd, buf);
38.     while(read(fd, &de, sizeof(de)) == sizeof(de))
39.     {
40.         if(de.inum == 0)
41.         {
42.             continue;
43.         }
45.         memmove(p, de.name, DIRSIZ);
46.         p[DIRSIZ] = 0;
48.         // printf("%s\n", p);
50.         if(stat(buf, &st) < 0)
51.         {
52.             printf("ls: cannot stat %s\n", buf);
53.             continue;
54.         }
56.         // printf("%s %s %d\n", buf, fmtname(buf), st.type);
57.         // printf("%d %d %d\n", strcmp(fmtname(buf), name), strcmp(fmtname(buf), "."), strcmp(".", "."));
59.         if (st.type == T_FILE && (strcmp(fmtname(buf), name) == 0))
60.         {
61.             printf("%s\n", buf);
62.             path = 1;
63.         }
65.         if (st.type == T_DIR && (strcmp(fmtname(buf), ".") != 0) && (strcmp(fmtname(buf), "..") != 0))
66.         {
67.             path = find(name, buf);
68.         }   
69.     }
71.     return path;
72. }
75. int main(int argc, char *argv[])
76. {
77.     int path;
79.     if(argc < 3)
80.     {
81.         fprintf(2, "fd: find [dir] [filename]\n");
82.         exit(1);
83.     }
85.     path = find(argv[2], argv[1]);
86.     if(path == 0)
87.     {
88.         fprintf(1, "can not find such file\n");
89.     }
91.     exit(0);
92. }

复制代码

（4）效果如下：

（5）总结：
核心知识点是xv6系统下的文件结构体与文件夹结构体，利用递归方法进行实现。
6.实现xargs函数

（1）原题如下：

（2）大致内容为：
实现xargs命令，xargs命令很难简朴理解，发起先查一下命令的用法。
xargs 命令教程
（3）代码如下：

1. #include "kernel/types.h"
2. #include "kernel/stat.h"
3. #include "kernel/fcntl.h"
4. #include "user/user.h"
5. #include "kernel/param.h"
8. int getcmd(char *buf, char**arg, int arg_num)
9. {
10.     int i;
11.     int j;
12.     j = 0;
13.     arg[arg_num] = (char *)malloc(30 * sizeof(char));
16.     for(i=0; i<512; i++)
17.     {
18.         if((buf[i] == ' ') || (buf[i] == 10) || (buf[i] == '\0') || (buf[i] == '\n'))
19.         {
20.             // printf("%c %d\n", buf[i], buf[i]);
21.             arg_num++;
22.             if(buf[i] == 10)
23.             {
24.                 // printf("argmun: %d\n", arg_num);
25.                 return arg_num;
26.             }
27.             if(buf[i] == '\0')
28.             {
29.                 // printf("argmun: %d\n", arg_num);
30.                 return arg_num;
31.             }
32.             arg[arg_num] = (char *)malloc(30 * sizeof(char));
33.             // printf("111\n");
34.             // printf("%s %p kkk\n", arg[arg_num], arg[arg_num]);
35.             j = 0;
36.         }
37.         else
38.         {
39.             // printf("%d %d %c %d\n", j, i, buf[i], arg[arg_num][j]);
40.             arg[arg_num][j] = buf[i];
41.             // printf("%d %c \n", j, arg[arg_num][j]);
42.             j++;
43.         }
44.     }
46.     return arg_num;
47. }
50. int main(int argc, char *argv[])
51. {
52.     char buf[512];
53.     int num = 0;
54.     int ret;
55.     int cmd = 0;
56.     char *arg[MAXARG];
57.     int arg_num;
58.     arg_num = argc - 1;
59.    
60.     int i = 0;
61.     for(i=0; i<arg_num; i++)
62.     {
63.         arg[i] = argv[i+1];
64.     }
66.     if(argc < 2)
67.     {
68.         fprintf(2, "xarg: xarg [process] [args...]\n");
69.         exit(1);
70.     }
72.     int j = 0;
73.     while(1)
74.     {
75.         ret = read(0, buf+j, 1);
76.         if(ret != 1)
77.         {
78.             break;
79.         }
80.         else if(buf[j] == '\n')
81.         {
82.             // printf("read number is : %d\n%s\n", num, buf);
83.             j = 0;
84.             num = 0;
85.             cmd = getcmd(buf, arg, arg_num);
86.             // printf("\n\n%d %d\n", cmd, arg_num);
87.             // printf("%s\n%s\n%s\n%s\n", arg[0], arg[1], arg[2], arg[3]);
88.             if(cmd == arg_num)
89.             {
90.                 printf("%d %d\n", cmd, arg_num);
91.                 printf("no content of stdin\n");
92.             }
93.             else
94.             {
95.                 if(fork() == 0)
96.                 {
97.                     exec(argv[1], arg);
98.                     fprintf(2, "exec failed\n");
99.                     exit(1);
100.                 }
101.                 else
102.                 {
103.                     wait((int *)0);
104.                 }
105.             }
106.         }
107.         else
108.         {
109.             j++;
110.             num++;
111.         }
112.     }
113.    
114.     for(i=0; i<cmd; i++)
115.     {
116.         free(arg[i]);
117.     }
118.     exit(0);
119. }

复制代码

（4）效果如下：

（5）总结：
在实现字符串的单词分割的时候，对于指针的操作出现问题。
char **arg的arg[]元素应该动态分配空间，而不是讲temp数组的指针头直接赋值。

---

总结

课程每年大概有变化，本文按照最新的2023计划表进行学习

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。