MIT 6.S081 Lab1: Xv6 and Unix utilities

写在前面

这周开始做 MIT 的 6.S801 操作系统实验，补一下本科时的基础，希望能一直做下去，二哥监督！

虽然2021年的实验已经出来了，但我还是选择做2020年的，实验地址在这里。主要考虑到自己太菜了，20年的网上有一些代码可供参考，有时候实在不会做硬看也不一定能做出来，能够读懂别人的也算收获，哈哈。

刚做完实验一，地址在 Lab: Xv6 and Unix utilities， 在这里做一下记录。

实验内容

实验环境（Boot xv6）

这次实验主要使用 MIT 提供的代码，将 xv6 系统在 qemu 上跑起来。git checkout util 是将分支切换到 util 上。

我在自己电脑上刷了一个 Ubuntu 20.04 的系统，然后按照实验指导书的过程一点点敲命令，就好了。中间需要安装一些必备的软件包和一些依赖，提示缺啥就安装啥就成，环境没啥大问题，不需要折腾太久。感觉折腾装环境啥的没什么意义，不如快点开始实验。

在安装好环境后就可以开始实验了。这部分的实验主要是写五个系统调用的命令，分别是 sleep, pingpong, primes, find 和 xargs。建议先看一下xv6 book的第一章，主要看一下 1.1-1.3。

任务一（sleep）

这是最简单的一个任务，直接调用提供的 sleep 方法即可，纯属为了好上手。头文件参考其他的 user 目录下的 .c 文件即可。

#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 time...\n");
	exit(1);
  }
  int time = atoi(argv[1]);
  sleep(time);
  exit(0);
}

在写完 .c 代码后，需要在 Makefile 文件中的 UPROGS 字段中添加 $U/_[xxx]\，然后才能使用 ./grade-lab-util 进行测试。

任务二（pingpong）

使用 pipe() 和 fork() 实现父进程发送一个字符，子进程成功接收该字符后打印 received ping，再向父进程发送一个字符，父进程成功接收后打印 received pong。

• 文件描述符

这里需要懂得什么是文件描述符。在 Linux 操作系统中，一切皆文件，内核通过文件描述符访问文件。每个进程都会默认打开3个文件描述符,即0、1、2。其中0代表标准输入流（stdin）、1代表标准输出流（stdout）、2代表标准错误流（stderr）。可以使用 > 或 >> 的方式重定向。

• 管道

管道是操作系统进程间通信的一种方式，可以使用 pipe() 函数进行创建。有在管道创建后，就有两个文件描述符，一个是负责读，一个是负责写。两个描述符对应内核中的同一块内存，管道的主要特点：

1. 数据在管道中以字节流的形式传输，由于管道是半双工的，管道中的数据只能单向流动。

2. 管道只能用于具有亲缘关系的进程通信，父子进程或者兄弟进程。

3. 在 fork() 后，父进程和子进程拥有相同的管道描述符，通常为了安全起见，我们关闭一个进程的读描述符和另一个进程的写描述符，这样就可以让数据更安全地传输。

下面是代码实现：

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int main(int argc, char *argv[]) {
  int p1[2], p2[2];
  char buffer[] = {'l'};
  int len = sizeof(buffer);
  pipe(p1);
  pipe(p2);
  if (fork() == 0) {
	close(p1[1]);
	close(p2[0]);
	if (read(p1[0], buffer, len) != len) {
	  printf("child read error!\n");
	  exit(1);
	}
	printf("%d: received ping\n", getpid());
	if (write(p2[1], buffer, len) != len) {
	  printf("child write error\n");
	  exit(1);
	}
	exit(0);
  } else {
	close(p1[0]);
	close(p2[1]);
	if (write(p1[1], buffer, len) != len) {
	  printf("parent write error!\n");
	  exit(1);
	}
	if (read(p2[0], buffer, len) != len) {
	  printf("parent read error!\n");
	  exit(1);
	}
	printf("%d: received pong\n");
	exit(0);
  }
  exit(0);
}

注：这里需要使用两个管道，我尝试改成一个，并没有成功…不太懂如何使用一个管道，感觉还是使用两个管道更加安全些。

任务三（primes）

任务是输出区间内的质数 [2, 35]，如果一般的方法，直接挨个遍历计算就行，但由于这里需要充分使用 pipe 和 fork 方法，因此需要一些不一样的方法。

下面使用的方法是埃拉托斯特尼素数筛，简称筛法。简单地说就是，每次得到一个素数时，在所有小于 n 的数中，删除它的倍数，然后不断迭代，剩下的就全是素数了。

实现思想是，只要还没获取到所有的素数，便不断遍历/递归。每次递归时：

1. 先在父进程中创建一个子进程。
2. 利用子进程将剩下的所有数全都写到管道中。
3. 在父进程中，将数不断读出来，管道中第一个数一定是素数，然后删除它的倍数（如果不是它的倍数，就继续更新数组，同时记录数组中目前已有的数字数量）。

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

void printPrime(int *input, int count)
{
  if (count == 0) {
    return;
  }
  int p[2], i = 0, prime = *input;
  pipe(p);
  char buff[4];
  printf("prime %d\n", prime);
  if (fork() == 0) {
	close(p[0]);
	for (; i < count; i++) {
	  write(p[1], (char *)(input + i), 4);
	}
	close(p[1]);
	exit(0);
  } else {
	close(p[1]);
	count = 0;
	while (read(p[0], buff, 4) != 0) {
	  int temp = *((int *)buff);
	  if (temp % prime) {
	    *input++ = temp;
		count++;
	  }
	}
	printPrime(input - count, count);
	close(p[0]);
	wait(0);
  }
}

int main(int argc, char *argv[]) {
  int input[34], i = 0;
  for (; i < 34; i++) {
    input[i] = i + 2;
  }
  printPrime(input, 34);
  exit(0);
}

无论是使用迭代的方式还是递归的方法，大致思想都是相同的。这道题我想了好久，。。

任务四（find）

在路径中查找特定文件名的文件。

基本直接复制 user/ls.c 文件内容。有几点需要注意的：

1. 在获取文件名的函数（fmtname ）中，需要设置 buf[strlen(p)] = 0; 否则比较函数 strcmp 会失效。
2. memmove() 是 memcpy() 的改进版，实现的功能相同，但更安全，具体分析见这篇博客，大致是说，一个是从头部开始复制，一个是从尾部开始复制。
3. 结构体 stat 和 dirent 分别存储文件的信息和目录的信息。没有很理解，留着以后再看。
4. 不太懂 de.inum 是干嘛的，有的代码还把它等于 1 的情况省略了，不懂为啥。

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"

char* fmtname(char *path) {
  static char buf[DIRSIZ + 1];
  char *p;
  for (p = path + strlen(path); p >= path && *p != '/';p--);
  p++;
  if (strlen(p) >= DIRSIZ) return p;
  memmove(buf, p, strlen(p));
  memset(buf+strlen(p), ' ', DIRSIZ-strlen(p));
  buf[strlen(p)] = 0;
  return buf;
}

void find(char *path, char *fileName) {
  char buf[512], *p;
  int fd;
  struct stat st;
  struct dirent de;
  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;
  }
  //printf("%s %s\n",path, fmtname(path));
  switch(st.type) {
  case T_FILE:
	//printf("%s\n", fmtname(path));
	if (strcmp(fmtname(path), fileName) == 0) {
	  printf("%s\n", path);
	}
	break;
  case T_DIR:
	//printf("%s %s\n", path, fmtname(path));
	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 || strcmp(de.name, ".") == 0 || strcmp(de.name, "..") == 0) {
		continue;
	  }
	  memmove(p, de.name, DIRSIZ);
	  p[DIRSIZ] = 0;
	  find(buf, fileName);
	}
	break;
  }
  close(fd);
}

int main(int argc, char *argv[]) {
  if (argc < 3) {
    printf("error\n");
	exit(1);
  }
  find(argv[1], argv[2]);
  exit(0);
}

任务五（xargs）

没咋用过这个命令，还是先查的它是啥功能。主要作用是读取标准输出中的信息，然后将其作为标准输入，拼接到下一个命令后面来执行。神奇！

注意的一点是，利用 fork() 让命令在子进程中执行后，函数并没有结束，还需要继续读取，因此一些变量需要继续设置新的值。

#include "kernel/types.h"
#include "user/user.h"
#include "kernel/param.h"

int main(int argc, char *argv[]) {
  int i, count = 0, k, m = 0;
  char* lineSplit[MAXARG], *p;
  char block[32], buf[32];
  p = buf;
  for (i = 1; i < argc; i++) {
	lineSplit[count++] = argv[i];
  }
  while ((k = read(0, block, sizeof(block))) > 0) {
    for (i = 0; i < k; i++) {
	  if (block[i] == '\n') {
		buf[m] = 0;
		lineSplit[count++] = p;
		lineSplit[count] = 0;
		m = 0;
		p = buf;
		count = argc - 1;
		if (fork() == 0) {
		  exec(argv[1], lineSplit);
		}
		wait(0);
	  } else if (block[i] == ' ') {
		buf[m++] = 0;
		lineSplit[count++] = p;
		p = &buf[m];
	  } else {
		buf[m++] = block[i];
	  }
	}
  }
  exit(0);
}

命令中的 | 表示管道（我一直以为这是与或非的或，。。惭愧）。

总结

这个实验算是熟悉一下 xv6 的环境和操作吧，确实感觉学到了很多东西，大赞！

代码地址在 github，文章同步在知乎。

参考文章

1. Mit6.S081-实验1-Xv6 and Unix utilities
2. 操作系统实验Mit6.S801笔记 Lab1: Util
3. MIT-6.s081-OS lab util Unix utilities
4. 【MIT-6.S081-2020】Lab1 Util