数据中继引擎【有限状态机】-优快云博客

本文链接：https://blog.youkuaiyun.com/hdfinder/article/details/142930562

有两个设备A，B（进程），
需要接受输入（或其他），并且将彼此需要通信。
在阻塞状态下，通信效率将大打折扣。例如A在接受输入的时候被阻塞，就不能向B写数据。同理B。
这里我们用有限状态机的思想实现一个数据中继引擎。
使用状态机，虽然能够避免阻塞在某一环节，但是计算机仍然需要循环执行函数（read，write）。当数据未就绪时，IO不断返回EAGAIN。可以使用IO多路转接，高级IO，select，poll，epoll，来监视文件描述符的状态。避免计算机循环忙等。

数据中继引擎

在这里插入图片描述、
如果只有一个任务在执行两个设备的读写交互，阻塞将影响后续的操作。
开启两个任务，一个负责读左写右，一个负责读右写左。
用一个状态机来识别现在任务的状态，并且推动任务的执行。

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

//打开两个终端 TTY1，TTY2
#define TTY1 "/dev/tty11"
#define TTY2 "/dev/tty12"
#define BUFSIZE 1024

// 有限状态机的状态枚举
enum {
    STATE_R = 1, // 读
    STATE_W, // 写
    STATE_AUTO,//分界线
    STATE_Ex, // 异常
    STATE_T // 终止
    };
//有限状态机数据结构
struct fsm_st {
    int state;//状态机当前状态
    int sfd;//源描述符
    int dfd;//目标描述符
    int len; // 读取到的数据
    int pos; // buf的偏移量
    char buf[BUFSIZE]; // 缓冲区
    char *errstr; // 报错信息
};

/* 状态机驱动 */
static void fsm_driver(struct fsm_st *fsm) {
    int ret;
    // 根据当前状态，决定下一步动作
    switch(fsm->state) {
            // 当前状态为读状态
        case STATE_R:
            fsm->len = read(fsm->sfd, fsm->buf, BUFSIZE);//返回读取长度
            if(fsm->len == 0) { // 读完文件
                fsm->state = STATE_T;//继续置为中止状态
            }else if(fsm->len < 0) {//出错
                if(errno == EAGAIN) { // 数据没有准备好，非阻塞状态下数据准备未完成
                    fsm->state = STATE_R;//继续置为读取状态
                } else { // 其他的错误编号
                    fsm->errstr = "read()";//记录错误描述
                    fsm->state = STATE_Ex;//置为异常状态
                }
            }else { // 数据准备就绪，转换为写状态（返回文件长度大于0
                fsm->pos = 0;//位置初始化 0
                fsm->state = STATE_W;//置为写入状态
            }
            break;
            // 当前状态为写状态
        case STATE_W:
            ret = write(fsm->dfd, fsm->buf + fsm->pos, fsm->len);//写操作
            if(ret < 0) {//出错
                if(errno == EAGAIN) {//数据没有准备好，非阻塞状态一直返回errno = EAGAIN
                    fsm->state = STATE_W;//继续置为写入状态
                } else {// 其他的错误编号
                    fsm->errstr = "write()";//记录错误描述
                    fsm->state = STATE_Ex;//置为异常状态
                }
            }else {//写成功，需要查看是否写完指定长度，即读取的数据长度fsm->len
                fsm->pos += ret;
                fsm->len -= ret;
                if(fsm->len == 0) { // 写够len个字节，缓冲区buf中的数据已经被写完了，都写到了目标描述符中dfd
                    fsm->state = STATE_R;//置为读取状态
                } else { // 没有写够len个字节
                    fsm->state = STATE_W;//继续置为写入状态
                }
            }
            break;
        case STATE_Ex:
            perror(fsm->errstr);//显示错误信息
            fsm->state = STATE_T;//置为中止状态
            break;
        case STATE_T:
            break;
        default:
            abort();
            break;
    }
}

static void relay(int fd1, int fd2) {
    int fd1_save, fd2_save;
    struct fsm_st fsm12, fsm21;
    // 获取文件状态选项
    fd1_save = fcntl(fd1, F_GETFL);
    //为了防止用户没有添加非阻塞状态，在这里获取文件描述符，统一设置成非阻塞状态
    // 设置文件状态选项，添加非阻塞模式
    fcntl(fd1, F_SETFL, fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2, F_GETFL);
    fcntl(fd2, F_SETFL, fd2_save|O_NONBLOCK);
    // 设置状态机初始化
    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;

    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;
    // 轮询，推状态机
    while(fsm12.state != STATE_T || fsm21.state != STATE_T) {
        fsm_driver(&fsm12);
        fsm_driver(&fsm21);
    }

    // 恢复用户设置的文件状态
    fcntl(fd1, F_SETFL, fd1_save);
    fcntl(fd2, F_SETFL, fd2_save);
}

// 模拟用户的设置
int main(void) {
    int fd1, fd2; // 左设备和右设备
    // 假设用户不以非阻塞的方式打开文件
    if((fd1 = open(TTY1, O_RDWR)) < 0) {
        perror("open()");
        exit(1);
    }
    write(fd1,"TTY1\n",5);
    // 假设用户以非阻塞的方式打开文件
    if((fd2 = open(TTY1, O_RDWR|O_NONBLOCK)) < 0) {
        perror("open()");
        exit(1);
    }
    write(fd2,"TTY2\n",5);
    relay(fd1, fd2);
    close(fd2);
    close(fd1);

    exit(0);
}

select()函数

根据select()函数重写状态机，使用阻塞IO来监视文件描述符的状态，以此降低CPU使用率。
使用每次select函数返回之后，文件描述符会丢失，因此需要重新设置现场，添加监视任务。
select(最大的文件描述符+1，读态监视集合，写态监视集合，异常监视结合，间隔时间)；
需要添加头文件#include<sys/select.h>

static void relay(int fd1, int fd2) {
    int fd1_save, fd2_save;
    fd_set rfds, wfds;
    struct fsm_st fsm12, fsm21;
    // 获取文件状态选项
    fd1_save = fcntl(fd1, F_GETFL);
    //为了防止用户没有添加非阻塞状态，在这里获取文件描述符，统一设置成非阻塞状态
    // 设置文件状态选项，添加非阻塞模式
    fcntl(fd1, F_SETFL, fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2, F_GETFL);
    fcntl(fd2, F_SETFL, fd2_save|O_NONBLOCK);
    // 设置状态机
    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;

    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;
    // 轮询，这里虽然也是轮询，但是会阻塞在select。
    while(fsm12.state != STATE_T || fsm21.state != STATE_T) {
        FD_ZERO(&rfds);
        FD_ZERO(&wfds);
        //布置监视任务
        if(fsm12.state==STATE_R)
        FD_SET(fsm12.sfd,&rfds);
        if(fsm12.state==STATE_W)
        FD_SET(fsm12.dfd,&wfds);
        if(fsm21.state==STATE_R)
        FD_SET(fsm21.sfd,&rfds);
        if(fsm21.state==STATE_W)
        FD_SET(fsm21.dfd,&wfds);
        //监视文件描述符集合中的文件描述符是否有改变（阻塞监视，直到有所改变
        if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)//只有在读写的情况下才调用select监视文件描述符
	    {
			if(select(max(fd1,fd2)+1,&rfds,&wfds,NULL,NULL)<0)
	        {
	            if(errno == EINTR)
	                continue;
	            perror("select()");
	            exit(1);
	        }		
	    }    
        //查看监视结果（文件描述符改动，或者状态机异常的时候），推状态机
        if(FD_ISSET(fd1,&rfds)||FD_ISSET(fd2,&wfds)||fsm21.state > STATE_AUTO)
        fsm_driver(&fsm12);
        if(FD_ISSET(fd2,&rfds)||FD_ISSET(fd1,&wfds)||fsm21.state > STATE_AUTO)
        fsm_driver(&fsm21);
    }

    // 恢复用户设置的文件状态
    fcntl(fd1, F_SETFL, fd1_save);
    fcntl(fd2, F_SETFL, fd2_save);
}

poll()函数

使用poll()来实现，需要将头文件#include<sys/select.h>换成#include<poll.h>
poll(结构体{文件描述符，感兴趣的时间，返回的事件});

static void realy(int fd1,int fd2)
{
    int save_fd1,save_fd2;
    struct fsm_st fsm12,fsm21;
    //定义poll所需结构体数组：文件描述符，文件描述符的事件，返回的事件
    struct pollfd pdf[2];

    save_fd1=fcntl(fd1,F_GETFL);
    save_fd2=fcntl(fd2,F_GETFL);
    fcntl(fd1,F_SETFL,save_fd1|O_NONBLOCK);
    fcntl(fd2,F_SETFL,save_fd2|O_NONBLOCK);
    
    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;
//存储文件描述符
    pdf[0].fd=fd1;
    pdf[1].fd=fd2;

    while(fsm12.state!=STATE_T||fsm21.state!=STATE_T)
    {
    //定义文件描述符的事件初始化
        pdf[0].events=0;
    //fsm12 表示1可读，2可写的状态机
        if(fsm12.state==STATE_R)
            pdf[0].events|=POLLIN;
        if(fsm21.state==STATE_W)
            pdf[0].events|=POLLOUT;
            
        pdf[1].events=0;
        //fsm12 表示2可读，1可写的状态机
        if(fsm21.state==STATE_R)
            pdf[1].events|=POLLIN;
        if(fsm12.state==STATE_W)
            pdf[1].events|=POLLOUT;
        if(fsm12.state<STATE_AUTO||fsm21.state<STATE_AUTO)
            while(poll(pdf,2,-1)<0)
            {
                if(errno==EINTR)
                    continue;
                perror("poll()");
                exit(1);
            }
        //当1发生读事件，或者2发生写事件，或者状态机一场的时候，需要推动12状态机
        if(pdf[0].revents&POLLIN||pdf[1].revents&POLLOUT||fsm12.state>STATE_AUTO)
            fsm_driver(&fsm12);
        if(pdf[1].revents&POLLIN||pdf[0].revents&POLLOUT||fsm21.state>STATE_AUTO)
            fsm_driver(&fsm21);
    }
    
    fcntl(fd1,F_SETFL,save_fd1);
    fcntl(fd2,F_SETFL,save_fd2);

}

epoll() 函数

epoll_creat(int 关心的文件描述符数量)：初始化，返回一个epoll的文件描述符
epoll_ctl(epoll文件描述符，操作【ADD，MOD，DEL】，关心的文件描述符，事件结构体指针)：将关心的文件描述符和epoll文件描述符绑定，绑定事件结构体。可以用MOD，来修改事件结构体中的事件。
epoll_wait(epoll文件描述符，事件结构体（存储发生的事件），最大事件数量，时间【-1 非阻塞,0阻塞,num单位毫秒】)：等待文件描述符事件发生。

static void realy(int fd1,int fd2)
{
    int save_fd1,save_fd2;
    int epfd;
    struct epoll_event ev;
    struct fsm_st fsm12,fsm21;
    epfd = epoll_create(10);

    save_fd1=fcntl(fd1,F_GETFL);
    save_fd2=fcntl(fd2,F_GETFL);
    fcntl(fd1,F_SETFL,save_fd1|O_NONBLOCK);
    fcntl(fd2,F_SETFL,save_fd2|O_NONBLOCK);
    
    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;

    //初始化，添加感兴趣的文件描述符到epoll文件描述符中，任务为0
    ev.events = 0;
    ev.data.fd = fd1;
    epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&ev);

    ev.events = 0;
    ev.data.fd = fd2;
    epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&ev);

    while(fsm12.state!=STATE_T||fsm21.state!=STATE_T)
    {//任务初始化，设置感兴趣的任务
        ev.data.fd = fd1;
        ev.events = 0;
        if(fsm12.state==STATE_R)
        {
            ev.events |= EPOLLIN;       
        }
        if(fsm21.state==STATE_W)
        {
            ev.events |= EPOLLOUT;       
        }
        //将文件描述符中的任务修改成感兴趣的任务
        epoll_ctl(epfd,EPOLL_CTL_MOD,fd1,&ev);
        
        ev.data.fd = fd2;
        ev.events = 0;
        if(fsm21.state==STATE_R)
        {
            ev.events |= EPOLLIN;       
        }
        if(fsm12.state==STATE_W)
        {
            ev.events |= EPOLLOUT;       
        }
        //注册任务到文件描述符
        epoll_ctl(epfd,EPOLL_CTL_MOD,fd2,&ev);
        //布置监视任务
        if(fsm12.state<STATE_AUTO||fsm21.state<STATE_AUTO)
            while(epoll_wait(epfd,&ev,1,-1)<0)
            {
                if(errno==EINTR)
                    continue;
                perror("epoll_wait()");
                exit(1);
            }
        //查看监视结果
        if(ev.data.fd == fd1 && ev.events&EPOLLIN\
                || ev.data.fd == fd2 && ev.events&EPOLLOUT\
                ||fsm12.state>STATE_AUTO)
            fsm_driver(&fsm12);
        if(ev.data.fd == fd2 && ev.events&EPOLLIN\
                ||ev.data.fd == fd1 && ev.events&EPOLLOUT\
                ||fsm21.state>STATE_AUTO)
            fsm_driver(&fsm21);
    }
    
    fcntl(fd1,F_SETFL,save_fd1);
    fcntl(fd2,F_SETFL,save_fd2);
}