嵌入式Linux学习（五）——进程处理

一、文件描述符

在Linux系统中，当我们打开或者创建一个文件时，操作系统会提供一个文件描述符（fd），这是一个非负整数，可以通过它来进行读写等操作。然而，文件描述符本身只是操作系统为应用程序操作底层资源（如文件、套接字等）所提供的一个引用或“句柄”。

在Linux中，文件描述符0、1、2是有特殊含义的。

• 0是标准输入（stdin）的文件描述符；
• 1是标准输出（stdout）的文件描述符；
• 2是标准错误（stderr）的文件描述符；

通过stdin用户可以从控制台输入信息，stdout、stderr可以输出对应的信息给用户，实现用户与控制台进行交互。

文件描述符与底层工作原理图示：

当使用open等系统调用时，内核会创建一个新的struct file（一般从3开始，因为0、1、2为系统自带的特殊的文件描述符），这个数据结构记录了文件的元数据（文件类型、权限等）、文件路径、支持的操作等，然后分配文件描述符，将struct file维护在文件描述符表中，最后将文件描述符返回给应用程序。我们可以通过后者对文件执行它所支持的各种函数操作，而这些函数的函数指针都维护在struct file_operations数据结构中。文件描述符实质上是底层数据结构struct file的一个引用或者句柄，它为用户提供了操作底层文件的入口。 

---

二、进程处理

1、创建子进程

1.1main的参数含义

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

• argc：传给程序命令的命令行参数的数量
• argv：指向字符串数组的指针，储存了命令行参数
• argv[0]：通常是程序的名称
• argv[1]到argv[argc-1]是实际的命令行参数

1.2 创建子进程函数

fork用于创建一个和父进程一样的子进程。当一个程序内有多个进程时，常使用各程序的进程号（pid）来区分不同进程，用pid_t定义各进程的进程号，类似于int。在fork之后的代码都是在父子进程中各执行一次。

pid_t fork(void);

在父进程中，返回子进程的pid号，在子进程中返回0，当发生错误时，函数返回-1。

1.3获取进程号

想获取当前程序的pid时，使用getpid，此函数不会失败，必然返回当前进程的pid。

#include <sys/types.h>
#include <unistd.h>

pid_t getpid(void);

在子进程中想获取父进程的pid可使用getppid，此函数不会失败，在子进程中必然返回父进程的pid。

#include <sys/types.h>
#include <unistd.h>

pid_t getppid(void);

1.4测试代码

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    //调用fork之前，代码都在父进程中运行
    printf("father %d \n",getpid());
    //使用fork创建子进程
    /**
     * 不需要传参
     * return：int 进程号
     * （1）：-1 出错
     * （2）：父进程中表示子进程的PID
     * （3）：子进程中显示为0
     * __pid_t fork(void)
     */
    pid_t pid = fork();
    //pid用于区分父进程与子进程

    //从fork之后所有的代码都是在父子进程中各自执行一次
    //printf("%d\n",pid);
    if (pid < 0)
    {
        perror("fork\n");
        exit(EXIT_FAILURE);
    }else if (pid == 0)
    {
        //子进程中pid=0
        //执行单独子进程代码
        printf("son %d father %d \n",getpid(),getppid());
    }else{

        //父进程中pid表示子进程id号
        //执行单独父进程代码
        printf("father %d son %d \n",getpid(),pid);
    }
    //在所有进程中想调自己的进程号都用getpid
    //在父进程想调用子进程的进程号直接调用pid
    //（注：父子进程中虽然使用同一变量的pid，但实际不是同一变量）
    //在子进程中想调用父进程的进程号用getppid

    return 0;
}

运行结果如下

2、文件描述符的引用计数和close

使用公共资源时，父子进程同时使用可能会导致程序混乱可使用sleep使进程休眠，避免发生冲突。测试案例：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    //fork之前
    //打开文件
    int fd = open("io.txt",O_CREAT|O_WRONLY|O_APPEND,0644);

    if (fd == -1)
    {
        perror("open");
        exit(EXIT_FAILURE);
    }

    char buffer[1024];//缓冲区存放写出的数据

    pid_t pid = fork();//fork子进程复制父进程资源
    if (pid < 0)
    {
        perror("fork");
        exit(EXIT_FAILURE);

    }else if (pid == 0)
    {
        //子进程代码
        strcpy(buffer,"子进程写入的数据\n");

    }else
    {
        //父进程代码
        sleep(1);//休眠一秒
        strcpy(buffer,"父进程写入的数据\n");
    }
    
    //父子并程
    ssize_t bytes_write = write(fd,buffer,strlen(buffer));
    if (bytes_write ==-1)
    {
        perror("write");
        close(fd);
        exit(EXIT_FAILURE);
    }
    printf("xierucg\n");

    close(fd);//使用完毕之后关闭
    
    if (pid == 0)
    {
        printf("子进程写入完毕，并释放文件描述符\n");
    }else
    {
        printf("父进程写入完毕，并释放文件描述符\n");
    }
    

    return 0;
}

上述程序逻辑为打开io.txt文件，获取文件描述符后，执行fork创建子进程。分别在父子进程中向文件追加写，并在写入后关闭。为了区分父子进程的操作，在父进程中sleep休眠1秒，运行结果如下：

 子进程复制了父进程的文件描述符 fd，二者指向的应是同一个底层文件描述（structfile 结构体）。子进程通过close0释放文件描述符之后，父进程对于相同的文件描述符执行 write操作仍然成功，是因为struct file 结构体中有一个属性为引用计数，记录的是与当前 struct file 绑定的文件描述符数量。close（系统调用的作用是将当前进程中的文件描述符和对应的 struct file 结构体解绑，使得引用计数减一。如果 close（）执行之后，引用计数变为0，则会释放 struct file 相关的所有资源。

3、程序跳转

3.1单独测试execve

exec系列函数可一在同一个进程中跳转执行另一个程序，先准备一个可执行程序erlou，通过编译erlou.c获得。

erlou.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    if (argc < 2)
    {
        printf("参数不够，无法跳转\n");
        return 1;
    }
    
    printf("我是%s,编号%d",argv[1],getpid());

    return 0;
}

 execve_test.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    //跳转之前
    char *name =  "banzhang";
    printf("woshi%s,bianhao%d,weitiaozhuan\n",name,getpid());

    //执行跳转
    /**
     * const char *__path:执行的程序路径
     * char *const __argv[]：传入的参数 -> 对于执行程序main方法的第二个参数
     * （跳转的程序需要什么参数就传什么参数）
     * （1）第一个参数固定是程序的名称 -> 执行程序的路径
     * （2）执行程序需要传入的参数
     * （3）最后一个参数一定是NULL
     * char *const __envp[]：传递的环境变量
     * （1）环境变量参数:key=value
     * （2）最后一个参数一定是NULL
     * return:成功没办法返回 下面代码没有意义 失败返回-1
     * 跳转前后只有进程号没变 别的变量都删除了
     * int execve (const char *__path, char *const __argv[],char *const __envp[])
     */
    char *args[] = {"/home/wuu/process_test/erlou",name,NULL};
    char *envs[] = {NULL};
    int re = execve(args[0],args,envs);
    if (re == -1)
    {
        perror("execve\n");
        return 1;
    }
    
    //此处代码没有意义 程序跳转无法执行

    return 0;
}

输出结果：

3.2 execve+fork

fork_execve_test.c 逻辑为子进程student2跳转进erlou程序，父进程student1不跳转。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(int argc, char const *argv[])
{
    //跳转之前
    char *name = "student1";
    printf("%s %d study in this\n",name,getpid());

    //准备跳转（创建子进程）
    __pid_t pid = fork();
    if (pid == -1)
    {
        perror("fork\n");
        exit(EXIT_FAILURE);
    }else if (pid == 0)
    {
        //new student跳转（子进程执行）
        char *new_name = "student2";
        char *args[] = {"/home/wuu/process_test/erlou",new_name,NULL};
        char *envs[] = {NULL};
        int exR = execve(args[0],args,envs);
        if (exR == -1)
        {
            perror("execve\n");
            exit(EXIT_FAILURE);
        }
        //跳转成功 子进程结束 此处代码不执行 
    }else{

        //student1还是在这(父进程)
        sleep(1);
        printf("%d还是在此处 %d跳转\n",getpid(),pid);
    }
 
    return 0;
}

输出结果为

 3.3 waitpid

Linux 中父进程除了可以启动子进程，还要负责回收子进程的状态。如果子进程结束后父进程没有正常回收，那么子进程就会变成一个僵尸进程——即程序执行完成，但是进程没有完全结束，其内核中PCB结构体（下文介绍）没有释放。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc,char const *argv[])
{
    int *subprocess_status;
    //fork之前
    printf("student1\n");

    pid_t pid = fork();
    if (pid == -1)
    {
        perror("fork");
        exit(EXIT_FAILURE);
    }else if (pid == 0)
    {
        //执行子进程
        char *args[] = {"/usr/bin/ping","-c","50","www.wuu.com",NULL};
        char *envs[] = {NULL};
        printf("%d执行50次\n",getpid());
        int exR = execve(args[0],args,envs);
        if (exR == -1)
        {
            perror("execve\n");
            exit(EXIT_FAILURE);
        }
    }else{
        //student1(father)
        printf("student1%d wait%d\n",getpid(),pid);
        /**
         * 功能灵活 可以设置不同的模式 可以等待特定的子进程
        * pid：等待的模式
        * （1）小于-1 例如 -1*pgid，则等待进程组 ID 等于pgid 的所有进程终止
        * （2） 等于-1 会等待任何子进程终止，并返回最先终止的那个子进程的进程 ID->儿孙都算
        *（3） 等于② 等待同一进程组中任何子进程终止（但不包括组领导进程）->只算儿子
        *（4）大于9 仅等待指定进程 ID 的子进程终止
        * wstatus：整数指针，子进程返回的状态码会保存到该 int
        * options：选项的值是以下常量之一或多个的按位或（OR）运算的结果；二进制对应选项，可多选：
        *（1）WNOHANG 如果没有子进程终止，也立即返回；用于查看子进程状态而非等待
        （2） WUNTRACED 收到子进程处于收到信号停止的状态，也返回。
        （3） WCONTINUED（自 Linux 2.6.10 起）如果通过发送 SIGCONT 信号恢复了一个已停止的子进程，则也返回。
        * return:（1） 成功等到子进程停止 返回 pid
                （2）没等到并且没有设置 WNOHANG 一直等
                （3）没等到设置WNOHANG 返回0
                （4）出错返回-1
         */
        waitpid(pid,subprocess_status,0);
    }

    printf("student1 wait %d finish\n",getpid());

    return 0;
}

 运行结果：

等待命令完成后才打印

 

本文所有内容基于B站up主尚硅谷。