• 6.1810: Operating System Engineering ＜LEC 1＞

    课程链接：6.1810 / Fall 2023

    一、本节任务 

    实验环境：

    二、introduction and examples

    2.1 open(), read(), write(), close(), dup()

    使用 open 打开或创建文件，得到文件描述符 fd，再对 fd 进行 read 或者 write 操作。每个进程都默认打开三个文件描述符：0（standard input），1（standard output），2（standard error），所以当我们想把输入内容复制到输出，可以有如下程序：

    1. // ex1.c: copy input to output.
    2.  
    3. #include "kernel/types.h"
    4. #include "user/user.h"
    5.  
    6. int
    7. main()
    8. {
    9.   char buf[64];
    10.  
    11.   while(1){
    12.     int n = read(0, buf, sizeof(buf));
    13.     if(n <= 0)
    14.       break;
    15.     write(1, buf, n);
    16.   }
    17.  
    18.   exit(0);
    19. }

    或者使用 open 打开一个文件，向文件内写数据：

    1. // ex2.c: create a file, write to it.
    2.  
    3. #include "kernel/types.h"
    4. #include "user/user.h"
    5. #include "kernel/fcntl.h"
    6.  
    7. int
    8. main()
    9. {
    10.   int fd = open("out", O_WRONLY | O_CREATE | O_TRUNC);
    11.  
    12.   printf("open returned fd %d\n", fd);
    13.  
    14.   write(fd, "ooo\n", 4);
    15.  
    16.   exit(0);
    17. }

    close() 系统调用会关闭对应的文件描述符，而 dup() 会复制一个文件描述符，被复制的文件描述符和原来的描述符指向相同的文件。 

    2.2 fork(), exec()

    使用 fork() 函数可以创建一个子进程，子进程相当于父进程的副本，包括指令和数据。fork 在子进程和父进程中都会返回。在子进程中，fork 返回子进程的 PID。在父进程中，fork 返回 0。如下：

    1. // ex3.c: create a new process with fork()
    2.  
    3. #include "kernel/types.h"
    4. #include "user/user.h"
    5.  
    6. int
    7. main()
    8. {
    9.   int pid;
    10.  
    11.   pid = fork();
    12.  
    13.   printf("fork() returned %d\n", pid);
    14.  
    15.   if(pid == 0){
    16.     printf("child\n");
    17.   } else {
    18.     printf("parent\n");
    19.   }
    20.   
    21.   exit(0);
    22. }

    exec() 使用一个可执行文件替代当前进程，相当于让子进程去执行可执行文件的内容，一般 fork() 和 exec() 是一起使用的：

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3.  
    4. // ex5.c: fork then exec
    5.  
    6. int
    7. main()
    8. {
    9.   int pid, status;
    10.  
    11.   pid = fork();
    12.   if(pid == 0){
    13.     char *argv[] = { "echo", "THIS", "IS", "ECHO", 0 };
    14.     exec("echo", argv);
    15.     printf("exec failed!\n");
    16.     exit(1);
    17.   } else {
    18.     printf("parent waiting\n");
    19.     wait(&status);
    20.     printf("the child exited with status %d\n", status);
    21.   }
    22.  
    23.   exit(0);
    24. }

    exec 会替换调用进程的内存，但将保留其文件打开表，从而使得调用 exec 来运行新程序可以实现I/O重定向：

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3. #include "kernel/fcntl.h"
    4.  
    5. // ex6.c: run a command with output redirected
    6.  
    7. int
    8. main()
    9. {
    10.   int pid;
    11.  
    12.   pid = fork();
    13.   if(pid == 0){
    14.     close(1);
    15.     open("out", O_WRONLY | O_CREATE | O_TRUNC);
    16.  
    17.     char *argv[] = { "echo", "this", "is", "redirected", "echo", 0 };
    18.     exec("echo", argv);
    19.     printf("exec failed!\n");
    20.     exit(1);
    21.   } else {
    22.     wait((int *) 0);
    23.   }
    24.  
    25.   exit(0);
    26. }

    这里先关掉了标准输出描述符 1，然后使用 open 打开 out 文件，因为 open 会选择最小的可使用的文件描述符，所以文件 out 对应的文件描述符为 1，再使用 exec 执行 echo程序，echo 程序就会把写到到标准输出上的内容写到文件 out 里。

    2.3 pipe()

    管道 pipe 是作为一对文件描述符公开给进程的一个小的内核缓冲区，一个用于读取，另一个用于写入（其实就是两个文件描述符指向同一个缓冲区，一个用来读，一个用来写）。将数据写入管道的一端，使该数据可以从管道的另一端读取。管道为流程提供了一种通信的方式。

    使用 pipe() 系统调用初始化一个管道，两个文件描述符放到数组里面，第一个文件描述符用于读，第二个用于写。使用管道可以让父进程和子进程通信，因为 fork 复制父进程的文件描述符表及其内存，所以子进程与父进程的打开文件表相同，故父子进程可以通过 pipe 的读写两端进行通信：

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3.  
    4. // ex8.c: communication between two processes
    5.  
    6. int
    7. main()
    8. {
    9.   int n, pid;
    10.   int fds[2];
    11.   char buf[100];
    12.   
    13.   // create a pipe, with two FDs in fds[0], fds[1].
    14.   pipe(fds);
    15.  
    16.   pid = fork();
    17.   if (pid == 0) {
    18.     // child
    19.     write(fds[1], "this is ex8\n", 12);
    20.   } else {
    21.     // parent
    22.     n = read(fds[0], buf, sizeof(buf));
    23.     write(1, buf, n);
    24.   }
    25.  
    26.   exit(0);
    27. }

    当 pipe 所有的写端被关闭后，使用 read() 系统调用会返回 0。

    相比于临时文件，管道的一大优势就是会自动清理自己。管道可以通过任意长的数据量。

    三、Lab util: Unix utilities

    安装实验工具链：

    sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu

    clone 并进入实验仓库：

    1. git clone git://g.csail.mit.edu/xv6-labs-2023
    2. cd xv6-labs-2023

    编译并运行 xv6：

    make qemu

    成功运行会打印如下信息：

    1. xv6 kernel is booting
    2.  
    3. hart 2 starting
    4. hart 1 starting
    5. init: starting sh
    6. $

    下面开始完成实验。 

    3.1 Sleep（easy）

    实现一个用户 sleep 函数，很简单，调用系统函数 sleep 就行： 

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3.  
    4. /*
    5.  * usage: sleep 
    6.  * to sleep for some tick
    7.  */
    9. int main(int argc, char *argv[])
    10. {
    11.         if (argc != 2)
    12.         {
    13.                 fprintf(2, "usage: sleep \n");
    14.                 exit(1);
    15.         }
    16.  
    17.         int ticks = atoi(argv[1]);
    18.  
    19.  
    20.         sleep(ticks);
    21.  
    22.         exit(0);
    23. }

    3.2 pingpong（easy）

    实现父进程和子进程之间交换一个字节，使用前面的 pipe 即可实现父子进程的通信，因为 pipe 不是全双工的，所以这里我们用两个管道：

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3.  
    4. int main(int argc, char *argv[])
    5. {
    6.         int pid, n;
    7.         int p1[2], p2[2];
    8.         char buf[10];
    9.  
    10.         pipe(p1);
    11.         pipe(p2);
    12.  
    13.         pid = fork();
    14.         if (pid ==  0)
    15.         {
    16.                 /* child */
    17.                 close(p1[1]); // close pipe1's write port
    18.                 close(p2[0]);
    19.                 n = read(p1[0], buf, 1);
    20.                 if (n == 1)
    21.                 {
    22.                         fprintf(1, "%d: received ping\n", getpid());
    23.                 }
    24.                 write(p2[1], buf, 1);
    25.         }
    26.         else
    27.         {
    28.                 /* parent */
    29.                 close(p1[0]);
    30.                 close(p2[1]);
    31.                 write(p1[1], "a", 1);
    32.                 n = read(p2[0], buf, 1);
    33.                 if (n == 1)
    34.                 {
    35.                         fprintf(1, "%d: received pong\n", getpid());
    36.                 }
    37.         }
    38.         exit(0);
    39. }

    3.3 primes（hard）

    实现Sieve质数算法，大致流程如下图，每个进程打印第一个输入的质数，然后使用第一个质数筛选一遍剩下的数（即不可被第一个质数整除），这样到达最后一个进程即可打印全部质数：

    代码：

    1. #include "kernel/types.h"
    2. #include "user/user.h"
    3.  
    4.  
    5. void run_process(int rd_pipe_fd)
    6. {
    7.         int pipes[2];
    8.         int num, n;
    9.         n = read(rd_pipe_fd, &num, sizeof(num));
    10.  
    11.         /* 判断是否有输入 */
    12.         if (n > 0)
    13.         {
    14.                 /* 打印第一个质数 */
    15.                 fprintf(1, "prime %d\n", num);
    16.                 pipe(pipes);
    17.  
    18.                 int pid = fork();
    19.  
    20.                 if (pid > 0)
    21.                 {
    22.                         int num1;
    23.                         /* 筛选一遍输入的数 */
    24.                         while ((n = read(rd_pipe_fd, &num1, sizeof(num1))) != 0)
    25.                         {
    26.                                 if (num1 % num != 0)
    27.                                         write(pipes[1], &num1, sizeof(num1));
    28.                         }
    29.                         close(pipes[1]);
    30.                         close(rd_pipe_fd);
    31.                         run_process(pipes[0]);
    32.  
    33.                         int status;
    34.                         wait(&status);
    35.                         exit(0);
    36.                 }
    37.         }
    38.         else
    39.         {
    40.                 close(rd_pipe_fd);
    41.                 exit(0);
    42.         }
    43.  
    44.         return;
    45. }
    46.  
    47. int main(int argc, char *argv[])
    48. {
    49.         int i;
    50.         int pipes[2];
    51.  
    52.         pipe(pipes);
    53.  
    54.         for (i = 2; i <= 35; i++)
    55.         {
    56.                 write(pipes[1], &i, sizeof(i));
    57.         }
    58.         close(pipes[1]);
    59.  
    60.         run_process(pipes[0]);
    61.  
    62.         exit(0);
    63. }

     3.4 find (moderate)

    实现 find 命令：

    1. #include "kernel/types.h"
    2. #include "kernel/stat.h"
    3. #include "user/user.h"
    4. #include "kernel/fs.h"
    5. #include "kernel/fcntl.h"
    6.  
    7.  
    8. char*
    9. fmtname(char *path)
    10. {
    11.   char *p;
    12.  
    13.   // Find first character after last slash.
    14.   for(p=path+strlen(path); p >= path && *p != '/'; p--)
    15.     ;
    16.   p++;
    17.  
    18.   return p;
    19. }
    20.  
    21. void find(char *path, char *filename)
    22. {
    23.         int fd;
    24.         char buf[512], *p;
    25.         struct stat st;
    26.         struct dirent dt;
    27.  
    28.         /* open file */
    29.         if ((fd = open(path, O_RDONLY)) < 0)
    30.         {
    31.                 fprintf(2, "cannot open %s\n", path);
    32.                 return;
    33.         }
    34.  
    35.         /* stat file */
    36.         if (fstat(fd, &st) < 0)
    37.         {
    38.                 fprintf(2, "cannot stat %s\n");
    39.                 close(fd);
    40.                 return;
    41.         }
    42.  
    43.         switch (st.type)
    44.         {
    45.                 case T_DEVICE:
    46.                 case T_FILE:
    47.                         if (strcmp(fmtname(path), filename) == 0)
    48.                         {
    49.                                 fprintf(1, "%s\n", path);
    50.                         }
    51.                         break;
    52.  
    53.                 case T_DIR:
    54.                         strcpy(buf, path);
    55.                         p = buf + strlen(buf);
    56.                         *p++ = '/';
    57.                         while ((read(fd, &dt, sizeof(dt))) == sizeof(dt))
    58.                         {
    59.                                 if ((dt.inum == 0) || (strcmp(dt.name, ".") == 0) || (strcmp(dt.name, "..") == 0))
    60.                                         continue;
    61.                                 memmove(p, dt.name, DIRSIZ);
    62.                                 p[DIRSIZ] = 0;
    63.                                 find(buf, filename);
    64.                         }
    65.                         break;
    66.         }
    67.         close(fd);
    68.  
    69. }
    70.  
    71. int main(int argc, char *argv[])
    72. {
    73.         if (argc != 3)
    74.         {
    75.                 fprintf(2, "Usage: find  \n");
    76.                 exit(1);
    77.         }
    78.  
    79.         find(argv[1], argv[2]);
    80.  
    81.         exit(0);
    82. }

    3.5 xargs (moderate)

    因为不是所有指令都能直接读取标准输入作为参数，所以需要 xargs 进行转换：

    1. #include "kernel/types.h"
    2. #include "kernel/param.h"
    3. #include "user/user.h"
    4.  
    5. int main(int argc, char *argv[])
    6. {
    7.         if (argc < 2)
    8.         {
    9.                 fprintf(2, "Usage: xargs  ...");
    10.                 exit(1);
    11.         }
    12.  
    13.         char buf[512], *p;
    14.         int n, i;
    15.  
    16.         p = buf;
    17.  
    18.         /* read from the standard input */
    19.         while ((n = read(0, p, sizeof(char))) > 0)
    20.         {
    21.                 if (*p == '\n')
    22.                 {
    23.                         char *args[MAXARG];
    24.                         *p = '\0';
    25.  
    26.                         for (i = 1; i < argc; i++)
    27.                         {
    28.                                 args[i-1] = argv[i];
    29.                         }
    30.  
    31.                         char *p2 = buf;
    32.                         char *ch_p;
    33.                         while ((ch_p = strchr(p2, ' ')) != 0 && ch_p < buf + strlen(buf))
    34.                         {
    35.                                 *ch_p = '\0';
    36.                                 args[i-1] = p2;
    37.                                 i++;
    38.                                 p2 = ch_p + 1;
    39.                         }
    40.                         args[i-1] = p2;
    41.  
    42.                         if (fork() == 0)
    43.                         {
    44.                                 exec(args[0], args);
    45.                         }
    46.                         wait(0);
    47.  
    48.                         p = buf;
    49.                 }
    50.                 else
    51.                 {
    52.                         p++;
    53.                 }
    54.         }
    55.  
    56.         exit(0);
    57. }

    最后所有 test 均通过： 

  • 相关阅读:
    hive和hbase的一些数据导入导出操作
    Linux用户与权限管理命令
    如何设计测试用例
    Python学习十：网络编程
    2023/10/05 部分汇编指令
    天宇优配|上架秒光 “3时代”的大额存单受宠
    算法练习（11）：牛客在线编程07 动态规划
    深入 lerna 发包机制 —— lerna publish - 掘金
    第一篇】 - XiaoZaiMultiAutoAiDevices框架开源啦
    IBM车库创新：为科技创新头号工程打造共创引擎
  • 原文地址：https://blog.csdn.net/qq_51103378/article/details/134416818