Linux进程编程

朴灿烈づ我的快乐病毒、 2022-05-28 11:52 253阅读 0赞

## Linux进程编程 ##

**Linux进程上下文**  
就是进程之间元素的集合，包括进程描述符task\_struct，正文段，数据段，栈，寄存器内容，页表等

*  task\_struct  
    是一种数据结构，存储进程的描述信息例如pid,uid，状态，信号项等。是进程管理和调度的重要依据。
 *  用户栈和核心栈  
    用户栈是进程运行在用户态的，含有用户态执行时函数调用的参数等。  
    核心栈是进程运行在核心态的，保存调用系统函数所用的参数和调用序列，这两个栈的指针都保存在task\_struct中。
 *  寄存器
 *  页表  
    线性地址到物理地址的映射
 *  正文段，数据段

**Linux进程的状态**  
共有5个状态：就绪、可中断睡眠、不可中断睡眠、暂停、僵死。统一叫做就绪态。所处的状态记录在task\_struct中

**Linux进程的控制**  
进程树的形成  
计算机启动后，BIOS从磁盘引导磁盘扇区加载系统引导程序，将Linux系统装入内存，并跳到内核处执行，Linux内核就执行初始化工作：初始化硬件、初始化内部数据结构、建立进程0。  
进程0创建进程1，进程1是以后所有创建的进程祖先，它负责初始化所有的用户进程。进程1创建shell进程，shell进程显示提示符，等待命令的输入。

进程的控制  
init进程

*  进程ID为1通常是init进程，在自举过程结束时由内核调用
 *  init进程绝不会终止
 *  它是一个普通的用户进程，但是以超级用户权限进行

**进程的创建**

*  任何一个用户进程的创建都是由现有的一个进程完成的，进程的创建要经过fork和exec两个过程。
 *  fork是为新进程分配相应的数据结构，并将父进程的相应上下文信息复制过来。
 *  Exec是将可执行文件的正文和数据转入内存覆盖它原来的（从父进程复制过来的），并开始执行正文段。（把当前进程替换成一个新进程）

1.fork系统调用

*  系统调用fork用来创建一个子线程
 *  vfork被调用后，将立即调用exec，这样就不需要拷贝父进程的所有页表，所以比fork调用快。
 *  系统调用fork和vfork的声明格式如下：  
    pid\_t fork(void);  
    pid\_t vfork(void);
 *  在使用该系统调用的程序中要加入以下头文件：

#include <unistd.h>

调用成功时，该调用对父进程的PID，对子进程返回0  
失败时，给父进程返回-1，没有子进程创建  
![这里写图片描述][70]

/* fork的典型用法*/
    pid_t new_pid;
    new pid = fork();
    switch(new_pid)
    {
        case -1://error
                break;
        case 0://child
                break;
        default://parent
                break;
    }

![这里写图片描述][70 1]  
2.exec系统调用  
![这里写图片描述][70 2]

系统调用execve中：

*  filename是将要执行的文件
 *  argv是要传递给文件的参数
 *  envp是要传递给文件的环境变量  
    当参数path所值的文件替换原进程的执行映像后，文件path开始执行，参数argv和envp便传递给进程

参数表的传递有关（l表示（list），v表示矢量（vector））；  
e：可传递新进程环境变量，execle，execve；  
p：可执行文件查找方式为文件名，execlp、execvp；

3.exit系统调用  
exit 和\_exit用于中止进程；

*  \_exit的作用：直接使进程停止运行清除使用的内存空间并清除内核中的数据结构  
    \- exit与\_exit不同，exit函数在调用exit系统之前要检测文件打开情况把文件缓冲区的内容写回文件，如printf()；  
    ![这里写图片描述][70 3]

4.wait系统调用  
wait函数用于是父进程阻塞，直到一个子进程结束或者该进程接收到一个指定信号为止。  
调用wait或waitpid的进程可能会：  
\- 阻塞（如果其所以子进程都还在运行）  
\- 带子进程的终止状态立即返回（如果一个子进程已终止，正等待父进程存取其终止状态）  
\- 出错立即返回（如果它没有任何子进程）

该调用的声明格式如下：
    pid_t wait(int *status);
    pid_t waitpid(pid_t pid, int &status, int options);
    在使用这些系统调用的程序中加入以下头文件
    #include <sys/types.h>
    #include <sys/wait.h>

两个函数返回：若成功则为子进程ID号，出错则为-1。  
status选项，代表子进程退出时的状态信息

wait和waitpid函数的区别：

*  在一个子进程终止前，wait使其调用者阻塞，而waitpid有一选择项可使调用者不阻塞。
 *  waitpid并不等待第一个终止的子进程——它有若干个选择项，可以控制它所等待的特定进程。
 *  实际上wait函数就是waitpid的一个特例

5.sleep函数调用  
函数调用sleep可以用来使进程挂起指定的秒数

#include <unistd.h>
    unsigned int sleep(unsigned int seconds);

**守护进程**

*  创建子进程，父进程退出

pc = fork;
    if(pc<0){
       printf("error fork\n");exit(1)}
    else if(pc>0){
       exit(0);}

*  在子进程中创建新会话setsid();
 *  改变目录为根目录 chdir(“/”);
 *  重设文件权限掩码umask(0);
 *  关闭文件描述符`for(i = 0;i<MAXFILE;i++){close(i);}`
 *  守护进程的工作  
    while(1)\{ \}

--------------------

例子

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/wait.h>
    
    #define MAXFILE 65535
    
    int main()
    {
        pid_t pc;
        int i,fd,len;
        char *buf = "this is a Dameon\n";
        len = strlen(buf);
        pc = fork();creat one kind of fork course 
        if(pc <0 )
        {
            printf("error fork\n");
            exit(1);
    
        }
        else if(pc>0)
        {
            exit(0);
        }
    
        setsid();//
        chdir("/");//根目录
        umask(0);
        for (i = 0; i < MAXFILE; ++i)//文件描述符
        {
            close(i);
        }
        while(1)
        {
            if((fd=open("/tmp/dameon.log",O_CREAT|O_WRONLY|O_APPEND,0600))<0)
            {
                perror("open");
                exit(1);
            }
            write(fd,buf,len+1);
            close(fd);
            sleep(10);//every 10 seconds open once
        }
    
    }

后台运行的 每10秒运行一次 查看时ps -x可查看后台运行的程序  
cat /tmp/dameon.log可查看写入的字符 每10秒多一条

--------------------

**进程间通信方式**

1.  管道（pipe）和有名管道（FIFO）
2.  信号（signal）
3.  消息队列
4.  共享内存
5.  信号量
6.  套接字（socket）

管道：可以用于有亲缘关系进程之间的通信。

命名管道：克服了管道没有名字的限制，因此允许无亲缘关系的进程通信。在文件系统中有对应的文件名。通过命令或系统调用mkfifo来创建。

信号：除了用于进程通信之外，还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外还支持语义符合Posix.1标准的信号函数sigaction（BSD为了实现可靠信号机制，又能统一信号接口，用sigaction函数重新实现了signal函数）

消息队列：是消息的链接表，包括Posix消息队列system V消息队列。可向队列中添加消息。客服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等。

共享内存：使多个进程可以访问同一块内存空间，是最快的可用IPC内存。是针对其他通信机制运行效率低而设计的。与信号量结合使用，来达到进程间的同步以及互斥。

## 1、管道 ##

普通的Linux shell都允许重定向，而重定向使用的就是管道。  
例如：ls > ls.txt

*  管道是单向的、先进先出的、无结构的、固定大小的字节流，把一个进程的标准输出和另一个进程的标准输入链接在一起。
 *  写进程在管道的尾端写入数据，读进程在首段读出数据。数据读出后从管道中移除。其他读进程都不能再读到这些数据。
 *  管道提供了简单的流控制机制。进程试图读空管道时，在有数据写入管道前进程将一直阻塞。管道满时同理。
 *  管道主要用于不同进程间的通信。
 *  创建一个简单的管道，可以使用系统调用pipe（）。它接受一个参数，也就是包括两个整数的数组。如调用成功，此数组将包括管道使用的两个文件描述符。创建一个管道之后，一般情况下进程将产生一个新的进程。errno=EMFILE（没有空闲的文件描述符）；ENFILE（系统文件表已满）；EFAULT（fd数组无效）
 *  fd\[0\]用于读取管道；fd\[1\]用于写入管道。

/父子进程的例子
    #include <string.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <errno.h>
    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        int fd[2];
        pid_t pid;
        char buf[100];//一定要在创建子进程前创建管道
    
        if(pipe(fd)<0)
        {
            printf("pipe create error\n");
            exit(0);
        }
        printf("fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);
        pid = fork();//创建子进程
        //子进程要执行的代码
    
        if(pid == 0)
        {
            close(fd[1]);//关闭写入端
            while(1)
            {
                if(read(fd[0],buf,1)>0)
                {
                    if(buf[0]%3==0 && buf[0]!=0)//如果是3的倍数就打印出来
                    {
       printf("%d\n",buf[0]);}
                    if(buf[0]==10)
                    {
       exit(0);}///退出当前进程
                }
            }
            close(fd[0]);
        }
    
        else///父进程执行的代码
        {
            close(fd[0]);//关闭读取端
            for(buf[0]=0;buf[0]<=10;buf[0]++)
            {
                write(fd[1],buf,1);
                sleep(2);
            }
            close(fd[1]);
            wait(NULL);//等待子进程退出
    
        }
        return 0;
    }

*  可以通过打开两个管道来创建一个双向通道，但需要在子进程中正确地设置文件描述符。
 *  必须在系统调用fork（）前调用pipe（），否则子进程将不会继承文件描述符。
 *  当使用半双工管道时，任何关联的进程都必须共享一个相关的祖先进程。因为管道存在于系统内核中，所以任何不在创建管道的进程之中都将无法寻址它。而在命名管道中不是这样。

## 2、命名管道 ##

*  命名管道和一般的管道基本相同，但也有一些显著的不同
 *  命名管道是在文件系统中作为一个特殊的设备文件而存在的
 *  不同祖先的进程之间可以通过管道共享数据
 *  当共享管道的进程执行完所有的I/O操作之后，命名管道将继续保存在文件系统中以便以后使用
 *  管道只能由相关进程使用，它们共同的祖先进程创建了管道。但是通过FIFO不相干的进程也能交换数据。

///命名管道创建
    int mkfifo(const char *pathname,mode_t mode);
    //mode传入值：O_RDONLY:读管道；O_WRONLY：写管道；O_RDWR：读写管道；O_NONBLOCK：非阻塞；O_CREAT：如果该文件不存在，就创建一个新的文件，并用第三的参数为其设置权限；O_EXCL：如果使用时文件存在，那么返回错误消息。这一参数可以测试文件是否存在

一旦用这个mkfifo创建了一个FIFO，就可以用open打开它。一般的文件I/O函数（close、read、write、unlink）都可以用于FIFO。

FIFO相关出错信息：

*  EACCES（无存取权限）
 *  EEXIST（指定文件不存在）
 *  ENAMETOOLONG（路径名太长）
 *  ENOENT（包含的目录不存在）
 *  ENOSPC（文件系统剩余空间不足）
 *  ENOTDIR（文件路径无效）
 *  EROFS（指定的文件存在于只读文件系统中）

//fifo_read.c
    #include <string.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <errno.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <fcntl.h>
    #define FIFO "/tmp/myfifo"//命名管道设备文件名
    int main()
    {
        int fd;
        int nread;
        char r_buf[100];
    
        if((mkfifo(FIFO,O_CREAT|O_EXCL)<0) && (errno!=EEXIST))///文件名，模式
        {
            printf("cannot create fifo\n");
            exit(0);
        }
        printf("preparing for reading bytes...\n");
    
        fd = open(FIFO,O_RDONLY,0);
        fd = open(FIFO,O_RDONLY|O_NONBLOCK,0);
        if(fd == -1)
        {
            printf("fifo open error\n");
            exit(1);
        }
    
        while(1)
        {
          memset(r_buf,0,sizeof(r_buf));
          if((nread=read(fd,r_buf,10))==-1)
          {
            if(errno==EAGAIN)
                printf("no data yet\n");
          } 
          printf("read len=%d str=%s from FIFO,nread=%d\n",strlen(r_buf),r_buf,nread);
          sleep(1);
    
        }
        return 0;
    
    }

///fifo_write.c
    #include <string.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <errno.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <fcntl.h>
    #define FIFO "/tmp/myfifo"//命名管道设备文件名
    
    int main(int argc,char** argv)//个数（包含名称），参数
    {
        int fd,i;
        int nwrite;
        char w_buf[100];
        char ww_buf[1024];
    
        if(argc ==1)///文件名，模式
        {
            printf("arg error\n");
            exit(0);
        }
    
    
        fd = open(FIFO,O_WRONLY,0);
    
        if(fd == -1)
        {
            if(errno==ENXIO)
    
           { printf("open error\n");}
            exit(1);
        }
    
        strcpy(w_buf,argv[1]);
    
        while(1)
        {
    
          if((nwrite=write(fd,w_buf,strlen(w_buf)))==-1)
          {
            if(errno==EAGAIN)
                printf("fifo not yet\n");
          }else 
          printf("write %s to,fifon",(w_buf));
          sleep(1);
    
        }
        close(fd);
    
    }

[70]: /images/20220528/4293e7c73adc41488e5a7a9339cf81da.png
[70 1]: /images/20220528/42371bd0aacd4b2bba15c6f48bf8c523.png
[70 2]: /images/20220528/adbf60b0d4ba437199fcfffe9fc59b3e.png
[70 3]: /images/20220528/837157d7dfb6482a85dac8fb55137161.png