操作系统实验报告

操作系统实验报告

1. myecho.c

1.1. 实验内容

• myecho.c的功能与系统echo程序相同
• 接受命令行参数，并将参数打印出来

1.2. 效果展示

myecho$ ./myecho a b c
a b c

1.3. 实验思路和关键代码

读取输入的参数，按顺序输出

int main(int argc, char *argv[])
{
    for (int i = 1; i < argc; i++)
    {
        printf("%s ", argv[i]);
    }
    printf("\n");
    return 0;
}

---

2. mycat.c

2.1. 实验内容

• mycat.c的功能与系统cat程序相同
• mycat将指定的文件内容输出到屏幕
• 要求使用系统调用open/read/write/close实现

2.2. 效果展示

mycat$ ./mycat mycat.c

//以下显示mycat.c文件的内容

2.3. 实验思路和关键代码

• 读取参数, 根据参数打开相应文件

    FILE *fp;
    int fsize;
    int fr;
    char *buffer;

    fp = fopen(argv[1], "r");
    if (!fp)
    {
        printf("不能打开该文件\n");
        exit(0);
    }

• 通过设置文件指针读取文件大小,分配缓冲区

    fseek(fp, 0, SEEK_END);
    fsize = ftell(fp);
    rewind(fp);

    buffer = (char *)malloc((1 + fsize) * sizeof(char));
    if (!buffer)
    {
        printf("分配空间失败\n");
        exit(0);
    }

• 将文件读取到缓冲区并输出

    fr = fread(buffer, 1, fsize, fp);
    if (!fr)
    {
        printf("读文件失败\n");
        exit(0);
    }

    printf("%s\n", buffer);

---

3. mycp.c

3.1. 实验内容

• mycp.c的功能与系统cp程序相同
• 将源文件复制到目标文件
• 要求使用系统调用open/read/write/close实现

3.2. 效果演示

mycp$ ./mycp mycp.c mycp1.c

//将mycp.c的内容复制到了mycp1.c

3.3. 实验思路和关键代码

• 与2.3.中相同, 不过在将源文件写到缓冲区后, 需要打开/创建目的文件, 将缓冲区内容写到目的文件

    fp = fopen(argv[2], "w");
    if (!fp)
    {
        printf("打开目的文件失败\n");
        exit(0);
    }

    fwrite(buffer, 1, fsize, fp);

---

4. mysys.c

4.1. 实验内容

实现函数mysys，用于执行一个系统命令，要求如下:

• mysys的功能与系统函数system相同，要求用进程管理相关系统调用自己实现一遍
• 使用fork/exec/wait系统调用实现mysys
• 不能通过调用系统函数system实现mysys

4.2. 效果演示

测试程序

int main()
{
    printf("---------------------------------\n");
    mysys("echo a b c d");
    printf("---------------------------------\n");
    mysys("ls /");
    printf("---------------------------------\n");
    return 0;
}

输出结果

---------------------------------
a b c d
---------------------------------
bin  boot  dev  etc  home  init  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  sbin  snap  srv  sys  tmp  usr  var
---------------------------------

4.3. 实验思路和关键代码

通过在子进程中使用execl()函数调用sh命令实现简单的系统命令调用

    pid = fork();
    if (pid == 0)
        execl("/bin/sh", "sh", "-c", str, NULL);
    wait(NULL);

sh命令是shell命令语言解释器，执行命令从标准输入读取或从一个文件中读取。通过用户输入命令，和内核进行沟通

---

5. sh3.c

5.1. 实验内容

• 该程序读取用户输入的命令，调用函数mysys执行用户的命令
  • 考虑如何实现内置命令cd、pwd、exit
• 实现文件重定向
• 实现管道
  • 只要求连接两个命令，不要求连接多个命令
  • 不要求同时处理管道和重定向

5.2. 效果演示

• 打开后自动显示工作路径(pwd)

sh$ ./sh3

当前工作目录是: /计算机操作系统/实验/homework/sh
>

• 读取指令并执行

当前工作目录是: /计算机操作系统/实验/homework/sh
> echo a b c
a b c

当前工作目录是: /计算机操作系统/实验/homework/sh
>

• cd指令

当前工作目录是: /计算机操作系统/实验/homework/sh
> cd /

当前工作目录是: /
> ls
bin  boot  dev  etc  home  init  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  sbin  snap  srv  sys  tmp  usr  var

• exit指令

当前工作目录是: /
> exit
已经退出shell

• 重定向

当前工作目录是: /计算机操作系统/实验/homework/sh
> echo a b c >out.txt

out.txt文件内容

a b c

• 管道

当前工作目录是: /计算机操作系统/实验/homework/sh
> cat /etc/passwd | wc -l
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
// 内容过多以下省略

5.3. 实验思路和关键代码

• 实验的要求是从sh1到sh3逐渐增加的，其代码也是从简单到复杂逐步构建

字符串分割

• 由于要处理输入的命令，所以我们要进行字符串的分割
  在实验过程中分析需求，决定构建以下数据结构，储存命令的缓冲区和需要进行分割得到的结构体

#define BUF_LEN 1024
char buffer[BUF_LEN];

#define ARGV_LEN 32
struct Command
{
    int argc;       //分割串的数量
    int redirectF;  //重定向标记
    int pipLineF;   //管道标记
    char *argv[ARGV_LEN];
};
struct Command command;

• 对命令进行分割, 使用strtok函数

C 库函数 char *strtok(char *str, const char *delim) 分解字符串 str 为一组字符串，delim 为分隔符。

• 对命令进行分割时，需要判断是否有’>‘重定向和’|‘管道命令。由于实验中并未同时支持重定向和管道命令，所以判断到’>‘或’|'时直接将它们对应的标记位置为其在char* argv[]中的位置
• 分割部分代码

    //进行分割
    char *buf;
    buf = strtok(buffer, " ");
    while (buf != NULL)
    {
        if (buf[0] == '>')
        {
            command.argv[command.argc] = NULL;
            command.redirectF = command.argc;
            command.argc++;
            command.argv[command.argc] = (char *)malloc(sizeof(char) * (strlen(buf) + 1));
            memcpy(command.argv[command.argc], buf + 1, strlen(buf));
            command.argc++;
        }
        else
        {
            command.argv[command.argc] = (char *)malloc(sizeof(char) * (strlen(buf) + 1));
            memcpy(command.argv[command.argc], buf, strlen(buf) + 1);
            if (!strcmp("|", buf))
            {
                command.pipLineF = command.argc;
            }
            command.argc++;
        }
        buf = strtok(NULL, " ");
        if (command.argc >= ARGV_LEN)
        {
            perror("指令分割过多\n");
            exit(-1);
        }
    }
    command.argv[command.argc - 1][strlen(command.argv[command.argc - 1]) - 1] = 0; //去掉换行
    command.argv[command.argc] = NULL;

sh1.c

• 在sh1.c中，不要求实现重定向和管道，但使用上个实验中的mysys并不合适，这里做了重新的实现，将execl函数换成exevp函数

int execvp(const char* file, const char* argv[])

• 第一个参数是要运行的文件，会在环境变量PATH中查找file，并执行
• 第二个参数，是一个参数列表，如同在shell中调用程序一样，参数列表为0，1，2，3……因此第0个参数，需要重复一遍
• argv列表最后一个必须是 NULL.
• 失败会返回－1， 成功无返回值，但是，失败会在当前进程运行，执行成功后，直接结束当前进程，可以在子进程中运行

• 实现代码

void mysys()
{
    pid_t pid;

    pid = fork();
    if (pid == 0)
    {
        execvp(command.argv[0], command.argv);
    }
    wait(NULL);
}

• sh1需要实现内置的pwd，cd和exit命令
• 通过getcwd函数获取工作路径

char *getcwd( char *buffer, int maxlen );
getcwd()会将当前工作目录的绝对路径复制到参数buffer所指的内存空间中,参数maxlen为buffer的空间大小。成功则返回当前工作目录，失败返回 FALSE

实现代码

    memset(buffer, 0, BUF_LEN);                 //清空缓冲区
    char *cwd = getcwd(buffer, sizeof(buffer)); //获取工作路径 实现pwd
    if (NULL == cwd)
    {
        perror("获取工作目录失败\n");
        exit(-1);
    }
    else
    {
        printf("当前工作目录是: %s\n", cwd);
    }

• cd命令的实现, 通过chdir函数

int chdir(const char * path);
chdir()用来将当前的工作目录改变成以参数path 所指的目录
行成功则返回0, 失败返回-1, errno 为错误代码

    //实现cd
    else if (command.argv[0] != NULL && !strcmp("cd", command.argv[0]))
    {
        if (command.argv[1] == NULL)
        {
            perror("参数错误\n");
        }
        else
        {
            chdir(command.argv[1]);
        }
    }

• 内置的exit命令

    if (command.argv[0] != NULL && !strcmp("exit", command.argv[0]))
    {
        printf("已经退出shell\n");
        exit(0);
    }

sh2.c

• 在sh2.c中添加重定向的功能，其中要使用到dup2()函数

int dup2(int oldfd, int newfd);
通过复制文件描述符oldfd，创建一个新的文件描述符newfd, newfd和oldfd指向相同的文件
如果成功，返回新复制的文件描述符; 如果失败，返回非0

• 先使用close(1)关闭标准输出，再使用dup2使得fd=1重定向到目标文件。这部分代码为

    int copyFd;
    if (command.redirectF != 0)
    {
        //需要重定向
        command.argv[command.redirectF] = NULL; //按>分割
        if (command.argv[command.redirectF + 1] == NULL)
        {
            perror("参数错误\n");
            exit(-1);
        }
        close(1);
        int fd = open(command.argv[command.redirectF + 1], O_WRONLY | O_CREAT, 0777);
        copyFd = dup2(1, fd);
    }
    execvp(command.argv[0], command.argv);
    if (command.redirectF != 0)
    {
        close(1);
        dup2(copyFd, 1);
    }

sh3.c

• sh3要求增加管道功能

• 需要开启两个子进程，分别设置管道的读端和写端，其代码实现

    int fds[2];
    pid_t pid1, pid2;
    command.argv[command.pipLineF] = NULL; //按|分割
    pid1 = fork();
    if (pid1 == 0)
    {
        dup2(fds[1], STDOUT_FILENO);
        dup2(fds[1], STDERR_FILENO);
        close(fds[0]);
        close(fds[1]);
        execvp(command.argv[0], command.argv);
        _exit(127);
    }
    pid2 = fork();
    if (pid2 == 0)
    {
        dup2(fds[0], STDIN_FILENO);
        close(fds[0]);
        close(fds[1]);
        execvp(command.argv[command.redirectF + 1], &command.argv[command.redirectF + 1]);
        _exit(127);
    }
    wait(&pid1);
    wait(&pid2);

---

6. pi1.c

6.1. 实验内容

使用2个线程根据莱布尼兹级数计算PI

• 莱布尼兹级数公式: 1 - 1/3 + 1/5 - 1/7 + 1/9 - … = PI/4
• 主线程创建1个辅助线程
• 主线程计算级数的前半部分
• 辅助线程计算级数的后半部分
• 主线程等待辅助线程运行結束后,将前半部分和后半部分相加

6.2. 效果演示

pi$ gcc -o pi1 pi1.c -lpthread
pi$ ./pi1
PI = 3.141543

6.3. 实验思路关键代码

• 计算级数第n项的宏，此处为了减少重复代码

#define F(i, j) (i % 2 == 0 ? (1 / (2 * j + 1)) : (-1 / (2 * j + 1)))

• 创建辅助线程

    pthread_t workerTid;
    pthread_create(&workerTid, NULL, &work, NULL);

• 辅助线程中的计算

void *work(void *arg)
{
    int i;
    double j;
    workerOutput = 0;           //全局变量
    for (i = 0; i < NUM; i++)   //NUM是宏
    {
        j = i;
        workerOutput += F(i, j);
    }
    return NULL;
}

• 主线程中的计算类似
• 等待两边计算完成，开始计算PI

---

7. pi2.c

7.1. 实验内容

使用N个线程根据莱布尼兹级数计算PI

• 主线程创建N个辅助线程
• 每个辅助线程计算一部分任务，并将结果返回
• 主线程等待N个辅助线程运行结束，将所有辅助线程的结果累加
• 使用线程参数，消除程序中的代码重复
• 不能使用全局变量存储线程返回值

7.2. 效果演示

pi$ gcc -o pi2 pi2.c -lpthread
pi$ ./pi2
PI = 3.141543

7.3. 实验思路和关键代码

• 由于要求使用线程参数且不能使用全局变量存储线程返回值。定义了两个结构体，分别用于传递参数和返回结果

struct param
{
    int start;
    int end;
};

struct result
{
    double workerOutput;
};

• 分别启动THREAD_NUM个线程计算

    for (i = 0; i < THREAD_NUM; i++)
    {
        struct param *param;
        param = &params[i];
        param->start = i * NUM;
        param->end = (i + 1) * NUM;
        pthread_create(&workerTids[i], NULL, worker, param);
    }

• 等待进程结束并输出结果，释放空间

    for (i = 0; i < THREAD_NUM; i++)
    {
        struct result *result;
        pthread_join(workerTids[i], (void **)&result);
        sum += result->workerOutput;
        free(result);
    }

这里free的空间在子线程中分配

---

8. sort.c

8.1. 实验内容

多线程排序

• 主线程创建两个辅助线程
• 辅助线程1使用选择排序算法对数组的前半部分排序
• 辅助线程2使用选择排序算法对数组的后半部分排序
• 主线程等待辅助线程运行結束后,使用归并排序算法归并子线程的计算结果
• 使用线程参数，消除程序中的代码重复

8.2. 效果演示

sort$ gcc -o sort sort.c -lpthread
sort$ ./sort
排序前：2 4 3 5 1 6 7 9 0 8
前半段：5 4 3 2 1
后半段：9 8 7 6 0
排序后：9 8 7 6 5 4 3 2 1 0

8.3. 实验思路和关键代码

• 创建两个线程并传递参数

    pthread_t workerTid1;
    pthread_t workerTid2;

    struct param param1;
    param1.start = 0;
    param1.end = LEN / 2;
    struct param param2;
    param2.start = LEN / 2;
    param2.end = LEN;

    pthread_create(&workerTid1, NULL, &work, &param1);
    pthread_create(&workerTid2, NULL, &work, &param2);

• 进行选择排序

void *work(void *arg)
{
    int maxNum;
    struct param *param;
    param = (struct param *)arg;
    for (int i = param->start; i < param->end; i++)
    {
        maxNum = i;
        for (int j = i; j < param->end; j++)
        {
            if (array[j] > array[maxNum])
            {
                maxNum = j;
            }
        }
        int c = array[maxNum];
        array[maxNum] = array[i];
        array[i] = c;
    }
    return NULL;
}

• 等待两个线程排序完成，在主线程进行归并排序

    //归并排序
    int newArray[10];
    int p = 0;
    int p1 = 0;
    int p2 = LEN / 2;
    for (p; p < LEN; p++)
    {
        if (p1 >= LEN / 2)
        {
            newArray[p] = array[p2];
            p2++;
        }
        else if (p2 >= LEN)
        {
            newArray[p] = array[p1];
            p1++;
        }
        else
        {
            if(array[p1] > array[p2])
            {
                newArray[p] = array[p1];
                p1++;
            }
            else
            {
                newArray[p] = array[p2];
                p2++;
            }
        }
    }

---

9. pc1.c

9.1. 实验内容

使用条件变量解决生产者、计算者、消费者问题

• 系统中有3个线程：生产者、计算者、消费者
• 系统中有2个容量为4的缓冲区：buffer1、buffer2
• 生产者生产’a’、‘b’、‘c’、‘d’、‘e’、‘f’、‘g’、'h’八个字符，放入到buffer1
• 计算者从buffer1取出字符，将小写字符转换为大写字符，放入到buffer2
• 消费者从buffer2取出字符，将其打印到屏幕上

9.2. 效果演示

pc$ gcc -o pc1 pc1.c -lpthread
pc$ ./pc1
生产者输出: a
生产者输出: b
生产者输出: c
    计算者得到: a
        计算者输出: A
    计算者得到: b
        计算者输出: B
    计算者得到: c
        计算者输出: C
            消费者得到: A
            消费者得到: B
            消费者得到: C
生产者输出: d
生产者输出: e
生产者输出: f
    计算者得到: d
        计算者输出: D
    计算者得到: e
        计算者输出: E
    计算者得到: f
        计算者输出: F
生产者输出: g
生产者输出: h
            消费者得到: D
            消费者得到: E
            消费者得到: F
    计算者得到: g
        计算者输出: G
    计算者得到: h
        计算者输出: H
            消费者得到: G
            消费者得到: H

9.3. 实验思路和关键代码

• 定义缓冲区大小、数量、缓冲区结构，缓冲区为全局变量

#define CAPACITY 4      //缓冲区大小
#define BUFFER_NUM 2    //缓冲区数量

struct Buffer
{
    int buffer[CAPACITY];
    int in;
    int out;
};

struct Buffer buffer[BUFFER_NUM];

• 对缓冲区的判断和操作代码与老师给出用例相似，这里不赘述
• 互斥变量和条件变量, 数量上和缓冲区数量一致

//互斥和同步
pthread_mutex_t mutex[BUFFER_NUM];
pthread_cond_t waitEmptyBuffer[BUFFER_NUM]; //条件变量
pthread_cond_t waitFullBuffer[BUFFER_NUM];  //条件变量

• 生产者、计算者、消费者的工作代码
  这里以计算者为例，同时涉及了两个缓冲区的操作，需要加两段锁

    for (i = 0; i < ITEM_COUNT; i++)
    {
        pthread_mutex_lock(&mutex[0]);
        //等待缓冲区填满
        while (BufferIsEmpty(0))
            pthread_cond_wait(&waitFullBuffer[0], &mutex[0]);

        //取值
        item = GetItem(0);
        printf("    计算者得到: %c\n", item);

        //唤醒等待缓冲区空的生产者
        pthread_cond_signal(&waitEmptyBuffer[0]);
        pthread_mutex_unlock(&mutex[0]);

        pthread_mutex_lock(&mutex[1]);
        //等待缓冲区为空
        while (BufferIsFull(1))
            pthread_cond_wait(&waitEmptyBuffer[1], &mutex[1]);

        //计算并将值放入缓冲区
        item -= 32;
        PutItem(1, item);
        printf("        计算者输出: %c\n", item);

        //唤醒等待缓冲区满的消费者
        pthread_cond_signal(&waitFullBuffer[1]);
        pthread_mutex_unlock(&mutex[1]);
    }

• 主线程中需要对互斥变量和条件变量初始化

    pthread_mutex_init(&mutex[0], NULL);
    pthread_cond_init(&waitEmptyBuffer[0], NULL);
    pthread_cond_init(&waitFullBuffer[0], NULL);

    pthread_mutex_init(&mutex[1], NULL);
    pthread_cond_init(&waitEmptyBuffer[1], NULL);
    pthread_cond_init(&waitFullBuffer[1], NULL);

---

10. pc2.c

10.1. 实验内容

使用信号量解决生产者、计算者、消费者问题

• 功能和实验9相同，使用信号量解决

10.2. 效果演示

pc$ gcc -o pc2 pc2.c -lpthread
pc$ ./pc2
生产者输出: a
生产者输出: b
生产者输出: c
        计算者得到: a
            计算者输出: A
生产者输出: d
                消费者得到: A
        计算者得到: b
            计算者输出: B
        计算者得到: c
                消费者得到: B
生产者输出: e
生产者输出: f
            计算者输出: C
        计算者得到: d
            计算者输出: D
        计算者得到: e
            计算者输出: E
        计算者得到: f
                消费者得到: C
                消费者得到: D
                消费者得到: E
            计算者输出: F
生产者输出: g
生产者输出: h
                消费者得到: F
        计算者得到: g
            计算者输出: G
        计算者得到: h
            计算者输出: H
                消费者得到: G
                消费者得到: H

10.3. 实验思路和关键代码

• 本次实验与上次实验类似, 把其中的互斥量和条件变量封装成了信号量, 其结构体为

typedef struct
{
    int value;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
} sema_t;

• 将对信号量的操作封装成函数, 有初始化/等待/唤醒三种操作

void SemaInit(sema_t *sema, int value)
{
    sema->value = value;
    pthread_mutex_init(&sema->mutex, NULL);
    pthread_cond_init(&sema->cond, NULL);
}

void SemaWait(sema_t *sema)
{
    pthread_mutex_lock(&sema->mutex);
    while (sema->value <= 0)
        pthread_cond_wait(&sema->cond, &sema->mutex);
    sema->value--;
    pthread_mutex_unlock(&sema->mutex);
}

void SemaSignal(sema_t *sema)
{
    pthread_mutex_lock(&sema->mutex);
    ++sema->value;
    pthread_cond_signal(&sema->cond);
    pthread_mutex_unlock(&sema->mutex);
}

• 每个缓冲区需要三个信号量

sema_t mutexSema[2];
sema_t emptyBufferSema[2];
sema_t fullBufferSema[2];

• 不同线程工作函数与上题类似, 这里以计算者为例

    for (i = 0; i < ITEM_COUNT; i++)
    {
        SemaWait(&fullBufferSema[0]);
        SemaWait(&mutexSema[0]);

        item = GetItem(0);
        printf("        计算者得到: %c\n", item);

        SemaSignal(&mutexSema[0]);
        SemaSignal(&emptyBufferSema[0]);

        SemaWait(&emptyBufferSema[1]);
        SemaWait(&mutexSema[1]);

        item -= 32;
        PutItem(1,item);
        printf("            计算者输出: %c\n", item);

        SemaSignal(&mutexSema[1]);
        SemaSignal(&fullBufferSema[1]);
    }

• 主线程需要对信号量初始化

    SemaInit(&mutexSema[0], 1);
    SemaInit(&emptyBufferSema[0], CAPACITY - 1);
    SemaInit(&fullBufferSema[0], 0);

    SemaInit(&mutexSema[1], 1);
    SemaInit(&emptyBufferSema[1], CAPACITY - 1);
    SemaInit(&fullBufferSema[1], 0);

---