$ copy

// copy.c: 复制输入到输出

#include "kernel/types.h"   // 包含系统调用相关的类型定义
#include "user/user.h"      // 包含用户态函数的声明（如 read, write, exit）

int
main()
{
  char buf[64];  // 定义一个缓冲区，用于存储读取的数据

  // 无限循环，直到读取到文件结束标志或出现错误
  while(1){
    // 从标准输入（文件描述符 0）中读取数据到 buf 中
    int n = read(0, buf, sizeof(buf));
    
    // 如果读取到的数据量小于等于 0，则表示输入结束或发生了错误
    if(n <= 0)
      break;  // 退出循环

    // 将读取的数据写入标准输出（文件描述符 1）
    write(1, buf, n);
  }

  // 正常退出程序
  exit(0);
}

$ echo hello

$ fork

int pipeFd[2];    // 管道文件描述符数组，pipeFd[0]为读取端，pipeFd[1]为写入端
char *arguments[2];  // 存储传递给exec的参数

int main() {
    // 设置要执行的命令和参数
    arguments[0] = "wc";   // 将 "wc" 命令作为参数传递给exec，用于统计输入的行、单词和字符数
    arguments[1] = 0;      // 以NULL表示参数结束
    
    // 创建管道
    pipe(pipeFd);          // pipeFd[0]用于读取，pipeFd[1]用于写入
    
    // 创建子进程
    if(fork() == 0) {      // 子进程代码，fork()返回0表示当前是子进程
        close(0);          // 关闭标准输入（文件描述符0）
        dup(pipeFd[0]);    // 将管道的读取端复制到文件描述符0，使标准输入重定向到管道的读取端
        close(pipeFd[0]);  // 关闭管道的读取端，已重定向到标准输入，不再需要
        close(pipeFd[1]);  // 关闭管道的写入端，子进程不负责写入数据
        exec("/bin/wc", arguments);  // 执行wc命令，读取标准输入（从管道中读取），计算行、单词和字符数
    } else {               // 父进程代码
        close(pipeFd[0]);  // 关闭管道的读取端，父进程不负责读取数据
        // 向管道写入数据
        write(pipeFd[1], "hello world\n", 12);  // 将 "hello world\n" 写入管道，供子进程读取
        close(pipeFd[1]);  // 关闭管道的写入端，表示数据写入完成
    }

    return 0;
}

#include "kernel/types.h"   // 包含系统调用相关的类型定义
#include "kernel/stat.h"    // 包含文件状态相关的定义
#include "user/user.h"      // 包含用户态函数的声明（如 read, write, open, close, fprintf, exit）

char buf[512];  // 定义一个缓冲区，用于存储读取的数据

// 函数：cat
// 参数：int fd - 文件描述符
// 功能：从文件描述符 fd 中读取数据，并将其写入标准输出（文件描述符 1）
void
cat(int fd)
{
  int n;

  // 从文件描述符 fd 中读取数据到 buf 中，读取的字节数存储在 n 中
  while((n = read(fd, buf, sizeof(buf))) > 0) {
    // 将读取的数据写入标准输出
    if (write(1, buf, n) != n) {
      // 如果写入的字节数不等于读取的字节数，报告写入错误
      fprintf(2, "cat: write error\n");
      exit(1);
    }
  }
  
  // 如果读取过程中出现错误，报告读取错误并退出
  if(n < 0){
    fprintf(2, "cat: read error\n");
    exit(1);
  }
}

// 主函数
int
main(int argc, char *argv[])
{
  int fd, i;

  // 如果没有提供文件参数，默认读取标准输入（文件描述符 0）
  if(argc <= 1){
    cat(0);
    exit(0);
  }

  // 遍历命令行参数中的文件名
  for(i = 1; i < argc; i++){
    // 打开文件，获取文件描述符
    if((fd = open(argv[i], 0)) < 0){
      // 如果文件无法打开，报告错误并退出
      fprintf(2, "cat: cannot open %s\n", argv[i]);
      exit(1);
    }
    // 调用 cat 函数，将文件内容输出到标准输出
    cat(fd);
    // 关闭文件描述符
    close(fd);
  }
  
  // 正常退出
  exit(0);
}

#include "kernel/types.h"   // 包含系统调用相关的类型定义
#include "kernel/stat.h"    // 包含文件状态相关的定义
#include "user/user.h"      // 包含用户态函数的声明（如 write, exit, strlen）

int
main(int argc, char *argv[])
{
  int i;

  // 遍历命令行参数，从第一个参数（argv[1]）开始
  for(i = 1; i < argc; i++){
    // 将当前参数 argv[i] 写入标准输出（文件描述符 1）
    write(1, argv[i], strlen(argv[i]));
    
    // 如果不是最后一个参数，在其后写入一个空格
    if(i + 1 < argc){
      write(1, " ", 1);
    } else {
      // 如果是最后一个参数，在其后写入一个换行符
      write(1, "\n", 1);
    }
  }
  
  // 正常退出程序
  exit(0);
}

// 测试 fork 是否能在进程表满时优雅地失败。
// 这个程序是一个小的可执行文件，用于填充进程表以测试 fork 的行为。

#include "kernel/types.h"   // 包含系统调用相关的类型定义
#include "kernel/stat.h"    // 包含文件状态相关的定义
#include "user/user.h"      // 包含用户态函数的声明（如 write, exit, fork, wait, strlen）

#define N  1000  // 定义测试的 fork 最大次数

// 函数：print
// 参数：const char *s - 要输出的字符串
// 功能：将字符串 s 写入标准输出（文件描述符 1）
void
print(const char *s)
{
  write(1, s, strlen(s));  // 使用 write 系统调用将字符串写入标准输出
}

// 函数：forktest
// 功能：测试 fork 系统调用的行为，特别是在进程表满时
void
forktest(void)
{
  int n, pid;

  // 输出开始测试的信息
  print("fork test\n");

  // 循环尝试创建 N 个子进程
  for(n = 0; n < N; n++){
    pid = fork();  // 创建一个子进程
    if(pid < 0)
      break;  // 如果 fork 失败，退出循环
    if(pid == 0)
      exit(0);  // 子进程退出
  }

  // 如果成功创建了 N 个子进程，表示 fork 行为异常
  if(n == N){
    print("fork claimed to work N times!\n");
    exit(1);
  }

  // 等待所有子进程结束
  for(; n > 0; n--){
    if(wait(0) < 0){  // 等待子进程结束
      print("wait stopped early\n");
      exit(1);  // 如果 wait 失败，报告错误并退出
    }
  }

  // 如果 wait 没有返回 -1，表示还有多余的子进程
  if(wait(0) != -1){
    print("wait got too many\n");
    exit(1);
  }

  // 输出测试成功的信息
  print("fork test OK\n");
}

// 主函数
int
main(void)
{
  forktest();  // 执行 fork 测试
  exit(0);     // 正常退出程序
}

// Demonstrate that moving the "acquire" in iderw after the loop that
// appends to the idequeue results in a race.

// For this to work, you should also add a spin within iderw's
// idequeue traversal loop.  Adding the following demonstrated a panic
// after about 5 runs of stressfs in QEMU on a 2.1GHz CPU:
//    for (i = 0; i < 40000; i++)
//      asm volatile("");

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

int
main(int argc, char *argv[])
{
  int fd, i;
  char path[] = "stressfs0";
  char data[512];

  printf("stressfs starting\n");
  memset(data, 'a', sizeof(data));

  for(i = 0; i < 4; i++)
    if(fork() > 0)
      break;

  printf("write %d\n", i);

  path[8] += i;
  fd = open(path, O_CREATE | O_RDWR);
  for(i = 0; i < 20; i++)
//    printf(fd, "%d\n", i);
    write(fd, data, sizeof(data));
  close(fd);

  printf("read\n");

  fd = open(path, O_RDONLY);
  for (i = 0; i < 20; i++)
    read(fd, data, sizeof(data));
  close(fd);

  wait(0);

  exit(0);
}

#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 [the times of ticks]...\n");
    exit(1);
  }

  int times = atoi(argv[1]);

  sleep(times);

  exit(0);
}

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

int main(int argc, char *argv[])
{
    if (argc > 1)
    {
        fprintf(2, "Usage: pingpong (without any parameters)\n");
        exit(1);
    }

    int pipe_fd[2];
    if (pipe(pipe_fd) < 0)
    {
        fprintf(2, "pipe error\n");
        exit(1);
    }

    int pid = fork();
    if (pid > 0)
    {
        // 父进程关闭管道的写端
        close(pipe_fd[1]);

        // 父进程等待子进程的信号
        char buf[1];
        read(pipe_fd[0], buf, 1);

        pid = wait((int *)0);
        printf("%d: received pong\n", getpid());

        // 父进程关闭管道的读端
        close(pipe_fd[0]);
    }
    else if (pid == 0)
    {
        // 子进程关闭管道的读端
        close(pipe_fd[0]);

        printf("%d: received ping\n", getpid());

        // 子进程通过管道向父进程发送信号
        write(pipe_fd[1], "x", 1);

        // 子进程关闭管道的写端
        close(pipe_fd[1]);

        exit(0);
    }
    else
    {
        printf("fork error\n");
        exit(1);
    }

    exit(0);
}

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

void sieve(int p_left) {
    int p_right[2];
    int prime;

    // 从左侧管道读取第一个数字
    if (read(p_left, &prime, sizeof(int)) == 0) {
        close(p_left);
        exit(0);
    }

    // 输出该素数
    printf("prime %d\n", prime);

    // 创建一个新的管道
    if (pipe(p_right) < 0) {
        fprintf(2, "pipe error\n");
        exit(1);
    }

    if (fork() == 0) {
        // 子进程递归处理
        close(p_right[1]);
        sieve(p_right[0]);
    } else {
        // 父进程继续读取并筛选
        close(p_right[0]);

        int num;
        while (read(p_left, &num, sizeof(int)) != 0) {
            if (num % prime != 0) {
                write(p_right[1], &num, sizeof(int));
            }
        }

        // 关闭管道，等待子进程结束
        close(p_left);
        close(p_right[1]);
        wait(0);
        exit(0);
    }
}

int main(int argc, char *argv[]) {
    int p[2];

    if (pipe(p) < 0) {
        fprintf(2, "pipe error\n");
        exit(1);
    }

    if (fork() == 0) {
        close(p[1]);
        sieve(p[0]);
    } else {
        close(p[0]);

        // 将 2 到 35 的数字写入管道
        for (int i = 2; i <= 35; i++) {
            write(p[1], &i, sizeof(int));
        }

        close(p[1]);
        wait(0);
        exit(0);
    }

    return 0;
}

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

#define MAXBUF 512  // 定义缓冲区大小

/**
 * find - 递归查找目录树中与指定文件名匹配的文件。
 * @path: 要搜索的目录路径。
 * @filename: 要查找的文件名。
 *
 * 该函数通过递归遍历目录树，打印出与指定文件名匹配的文件的路径。
 * 它会忽略特殊目录项 `.` 和 `..` 以避免递归回到当前或父目录。
 */
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;
    }

    // 获取文件状态（例如确定是文件还是目录）
    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(filename), filename) == 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 (strcmp(de.name, ".") == 0 || strcmp(de.name, "..") == 0)
                continue;
            // 递归调用 find 函数处理子目录或文件
            find(buf, filename);
        }
        break;
    }

    // 关闭文件描述符以释放资源
    close(fd);
}

/**
 * main - 程序的入口点，解析命令行参数并调用 find 函数。
 * @argc: 参数个数。
 * @argv: 参数值数组。
 *
 * 该函数验证参数的正确性，并调用 find 函数开始递归查找。
 */
int main(int argc, char *argv[]) {
    // 检查命令行参数是否正确
    if (argc < 3) {
        // 如果参数不足，打印使用说明并退出
        fprintf(2, "Usage: find <directory> <filename>\n");
        exit(1);
    }

    // 调用 find 函数，开始查找文件
    find(argv[1], argv[2]);
    exit(0);
}

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

#define MAXARG 32   // 最大参数数量
#define MAXBUF 1024 // 最大输入缓冲区大小

// 从标准输入读取一行
int read_line(char *buf, int size)
{
    int i = 0; // 当前字符索引
    char c;    // 存储读取的字符

    // 从标准输入逐字符读取，直到遇到换行符或缓冲区已满
    while (i < size - 1)
    {
        if (read(0, &c, 1) != 1)
        {
            return i; // 到达输入结束或发生错误
        }
        if (c == '\n')
        {
            break; // 遇到换行符，停止读取
        }
        buf[i++] = c; // 将读取的字符存入缓冲区
    }
    buf[i] = '\0'; // 在字符串末尾添加 null 终止符
    return i;
}

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        fprintf(2, "Usage: xargs command [initial-args]\n"); // 如果没有提供命令参数，输出用法提示
        exit(1);                                             // 退出程序
    }

    char buf[MAXBUF]; // 用于存储输入行的缓冲区

    // 从标准输入读取每一行
    while (read_line(buf, sizeof(buf)) > 0)
    {
        // 创建命令行参数数组
        char *cmd_argv[MAXARG + 2]; // +2: 一个存放命令名，一个存放拼接后的参数
        cmd_argv[0] = argv[1];      // 命令名称

        int i;
        // 复制用户提供的初始参数（如果有）
        for (i = 1; i < argc - 1 && i < MAXARG; i++)
        {
            cmd_argv[i] = argv[i + 1];
        }

        // 将读取的行作为最后一个参数
        cmd_argv[i++] = buf;

        cmd_argv[i] = 0; // 参数列表以 null 终止

        int pid = fork(); // 创建子进程
        if (pid < 0)
        {
            fprintf(2, "xargs: fork failed\n"); // 如果创建子进程失败，输出错误信息
            exit(1);                            // 退出程序
        }
        else if (pid == 0)
        {
            exec(cmd_argv[0], cmd_argv);        // 执行命令
            fprintf(2, "xargs: exec failed\n"); // 如果执行命令失败，输出错误信息
            exit(1);                            // 退出子进程
        }
        else
        {
            // 父进程中
            wait(0); // 等待子进程完成
        }
    }

    exit(0); // 正常退出程序
}