MIT6.S081操作系统实验2021——lab1
参考文章
sleep
要求为xv6实现UNIX 程序sleep；其应该暂停用户指定的ticks number。tick是 xv6 内核定义的时间概念，即计时器芯片的两次中断之间的时间（两次时钟中断之间的时间）。您的解决方案应该在文件user/sleep.c中。
- 如果用户忘记传递参数，sleep 应该打印一条错误消息。
- 确保main调用exit()以退出程序。
- 在 Makefile 中将你的sleep程序添加到UPROGS；完成后，make qemu将编译您的程序，您将能够从 xv6 shell 运行它。
Run the program from the xv6 shell:
$ make qemu
...
init: starting sh
$ sleep 10
(nothing happens for a little while)
$
提示
- 查看 user/ 中的一些其他程序（ 例如user/echo.c、user/grep.c和user/rm.c），了解如何获取传递给程序的命令行参数。（argc是包括程序名本身的参数个数，argv是包括程序名本身在内的所有参数的字符串指针数组）
- 命令行参数作为字符串传递；您可以使用atoi将其转换为int（请参阅 user/ulib.c）。
- 使用系统调用sleep。
思路
实现首先检查参数个数，然后把参数中给出的ticks number转变为int，之后使用sleep系统调用，输出提示信息即可。
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
int main(int argc,char *argv[])
{
if(argc == 1)
{
printf("sleep need one argument\n");
exit(1);
}
uint ticks = atoi(argv[1]);
sleep(ticks);
printf("(nothing happens for a little while)");
exit(0);
}
pingpong
要求编写一个程序，使用 UNIX 系统调用通过一对管道在两个进程之间“pingpong”一个字节，一个管道用于每个方向。父进程应该向子进程发送一个字节；子进程应该打印“: received ping”，其中 是它的进程 ID，将管道上的字节写入父进程，然后退出；父进程应该从子进程那里读取字节，打印“: received pong”，然后退出。您的解决方案应该在文件user/pingpong.c中。
Run the program from the xv6 shell and it should produce the following output:
$ make qemu
...
init: starting sh
$ pingpong
4: received ping
3: received pong
$
提示
- 使用pipe创建管道。
- 使用fork创建一个子进程。
- 使用read从管道读取，并使用write写入管道。
- 使用getpid查找调用进程的进程 ID。
- 将程序添加到Makefile 中的UPROGS。
- xv6 上的用户程序有一组有限的库函数可供他们使用。您可以在 user/user.h中看到声明；定义（系统调用除外）位于user/ulib.c user/printf.c和user/umalloc.c中。
思路
- 父进程关闭管道1读端，向写端写入ping，关闭管道1写端。关闭管道2写端，从管道2读端读出pong，关闭管道2读端。使用wait让子进程先打印ping,然后打印pong.
- 子进程关闭管道1写端，从管道1读端读出ping，关闭管道1读端。关闭管道2读端，向写端写入pong，关闭管道2写端，然后打印ping。
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#define READ 0
#define WRITE 1
int main(int argc, char *argv[])
{
if(argc != 1) printf("dont input arguments\n");
int pipeParToChr[2];
int pipeChrToPar[2];
char buf[8];
pipe(pipeParToChr);
pipe(pipeChrToPar);
int pid = fork();
if( pid == 0 ) // 子进程
{
close(pipeParToChr[WRITE]);
read(pipeParToChr[READ] , buf , sizeof(buf));
close(pipeParToChr[READ]);
close(pipeChrToPar[READ]);
write(pipeChrToPar[WRITE],"pong\n",5);
close(pipeChrToPar[WRITE]);
printf("%d: received %s",getpid(),buf);
exit(0);
}else // 父进程
{
close(pipeParToChr[READ]);
write(pipeParToChr[WRITE] , "ping\n" , 5);
close(pipeParToChr[WRITE]);
close(pipeChrToPar[WRITE]);
read(pipeChrToPar[READ],buf,sizeof(buf));
close(pipeChrToPar[READ]);
wait((int*)0);
printf("%d: received %s",getpid(),buf);
exit(0);
}
}
primes
要求
使用管道编写一个并发版本的初筛。这个想法归功于 Unix 管道的发明者 Doug McIlroy。本页中间的图片和周围的文字说明了如何做到这一点。您的解决方案应该在文件user/primes.c 中。您的目标是使用pipe和fork来设置管道。第一个过程将数字 2 到 35 输入管道。对于每个素数，您将安排创建一个进程，该进程通过管道从其左邻居读取并通过另一管道向其右邻居写入。由于 xv6 的文件描述符和进程数量有限，第一个进程可以在 35 处停止。
Your solution is correct if it implements a pipe-based sieve and produces the following output:
$ 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
$
提示
- 尽早关闭进程不需要的文件描述符，否则你的程序将在第一个进程达到 35 之前耗尽 xv6 的资源。
- 一旦第一个进程达到 35，它应该等到整个程序终止，包括所有子孙进程。因此，主进程（产生2~35数字的进程）应该只在所有输出都被打印出来，并且在所有其他子孙进程都退出之后才退出。
- 提示：当管道的写端关闭时，读取该管道的read()立即返回零。
- 将 32 位（4 字节）的int直接写入管道是最简单的，而不是使用格式化的 ASCII I/O。
- 您应该仅在需要时在管道流水线中创建进程。
- 将程序添加到Makefile 中的UPROGS。
实现
并发的素数筛模型：根据该图，我们可以看出需要一个主进程将2~35的int数据输入到第一个子进程。而从子进程的视角看，所有子进程的任务都是从父进程那里读取数据。将读到的第一个数据print出来，并以此为基，将所有读到的不是它的倍数的数据传递给自己的子进程。此外，流水线停止的条件是一个子进程从父进程那里读不到数据，说明所有数据已经筛选完毕。
思路
- 父进程输出一个数组和数组的个数
- 子进程接收数组，接收数组的第一个为最小素数，为基数。输出
- 之后数据分别判断是否为基数的整数倍，如果是抛弃，不是则给下一级子进程
- 最后实现递归，当输入数组的元素个数为1时，输出，结束进程
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#define READ 0
#define WRITE 1
void function(int num[] , int size)
{
int pipe1[2];
pipe(pipe1);
int pid = fork();
if(pid > 0)
{
close(pipe1[READ]);
for(int i=0; i<size; i++)
{
write(pipe1[WRITE],&num[i],sizeof(num[i]));
}
close(pipe1[WRITE]);
wait((int*)0);
}else
{
close(pipe1[WRITE]);
int numchr[34] , indnx = 0;
int tmp , min;
while(read(pipe1[READ] ,&tmp,sizeof(tmp) ))
{
if(indnx == 0)
{
min = tmp;
printf("prime %d\n", min);
indnx++;
}
if(tmp%min != 0)
{
numchr[indnx-1] = tmp;
indnx++;
}
}
close(pipe1[READ]);
function(numchr,indnx-1);
exit(0);
}
}
int main(int argc, char *argv[])
{
int num[34];
int indnx = 0;
for(int i = 2; i <= 35 ;i++)
{
num[indnx] = i;
indnx++;
}
function(num,34);
exit(0);
}
find
要求编写一个简单版本的 UNIX 查找程序：查找目录树中具有特定名称的所有文件。您的解决方案应该在文件user/find.c中。
Your solution is correct if produces the following output (when the file system contains the files b and a/b):
$ make qemu
...
init: starting sh
$ echo > b
$ mkdir a
$ echo > a/b
$ find . b
./b
./a/b
$
即find的功能是在argv[1]所给目录和它的所有子目录(不包括.和…)中查找名为argv[2]的文件。
提示
- 查看 user/ls.c 以了解如何读取操纵目录。
- 使用递归允许 find 进入到子目录。
- 不要递归到 . 和 …
- 对文件系统的更改在 qemu 运行中持续存在；运行干净的文件系统make clean，然后make qemu.
- 用 strcmp()比较字符串。
- 将程序添加到Makefile 中的UPROGS。
为了支持递归，我们需要实现一个在给定目录中查找给定文件的find()函数：
void find(char *path,char *name);
提示告诉我们研究ls.c来了解对目录和文件的读取，其中主要是函数void ls(char *path)：
首先以读的方式打开path这个file（unix中一切皆file，包括普通文件、目录、设备），返回一个fd.接着使用fstat()把这个file的一些文件系统相关的信息填充进st结构体中。
对于要实现的函数void find(char *path,char *name)，path必为目录，则直接仿照ls中case T_DIR的情况处理就行。和ls不同的是，我们不需要输出所有文件的所有信息，即在stat(buf, &st)之后，我们不需要printf出文件的信息，而是进行筛选，当这个file类型是文件并且名字与要找的name相同，则输出buf中存储的相对路径即可。如果这个file类型是目录并且不是.和…，就进入此目录递归查找。
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"
void find(char *path , char *target)
{
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;
}
switch(st.type)
{
case T_FILE:
if(strcmp( path + strlen(path) - strlen(target) , target ) ==0)
{
printf("%s\n", path);
}
break;
case T_DIR:
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
printf("find: path too long\n");
break;
}
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(strcmp(".", de.name) != 0 && strcmp("..", de.name) != 0)
{
find(buf, target);
}
}
break;
}
close(fd);
}
int main(int argc, char *argv[])
{
if(argc != 3)
{
printf("input arguments : find <path> <file name>\n");
exit(1);
}
find(argv[1], argv[2]);
exit(0);
}
xargs
要求编写一个简单版本的 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”。
提示
- 使用fork和exec对每一行输入调用命令。在父进程中使用wait等待子进程完成命令。
- 要读取单行输入，请一次读取一个字符，直到出现换行符 (‘\n’)。
- kernel/param.h 声明了 MAXARG，如果您需要声明 argv 数组，这可能很有用。
- 将程序添加到Makefile 中的UPROGS。
实现
- 我们已经知道，shell中可以使用管道 | 将’|‘之前的命令的标准输出作为之后的命令的标准输入。而xargs的作用是将’| xargs’之前的命令的标准输出作为之后的命令的附加的命令行参数。标准输入和命令行参数，有很大的不同。
- 以$ echo hello too | xargs echo bye为例，其argc为3。即实际的命令行参数从xargs开始算起。
- 程序的功能应是维护一个新的new_argv数组，先从argv[1]开始把本来的参数复制到new_argv中，然后从stdin（文件描述符0）读取字节，每读取到’\0’就把这个新参数添加到new_argv末尾，读取到’\n’就fork出一个子进程以new_argv为基础使用exec来执行命令。然后从本来的参数末尾重新开始添加参数。
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/param.h"
int main(int argc, char *argv[])
{
char *new_argv[MAXARG];
int cur_argv = 1;
for( cur_argv = 1 ;cur_argv <= argc - 1 ; cur_argv++)
{
new_argv[cur_argv - 1] = argv[cur_argv];
}
char ch;
char buf[128];
char *cur_buf = buf;
new_argv[cur_argv-1] = buf;
while(read(0,&ch,sizeof(char)))
{
if( ch == ' ')
{
*cur_buf = '\0';
cur_buf++;
new_argv[cur_argv ] = cur_buf;
cur_argv++;
}else if( ch == '\n' )
{
*cur_buf = '\0';
new_argv[cur_argv] = 0;
int pid = fork();
if( pid == 0)
{
exec(new_argv[0] , new_argv);
exit(0);
}else
{
wait((int*)0);
cur_buf = buf;
cur_argv = argc;
}
}else
{
*cur_buf = ch;
cur_buf++;
}
}
exit(0);
}
makefile
