《嵌入式linux应用程序开发标准教程》笔记——6.文件IO编程

　　前段时间看APUE，确实比较详细，不过过于详细了，当成工具书倒是比较合适，还是读一读这种培训机构的书籍，进度会比较快，遇到问题时再回去翻翻APUE，这样的效率可能更高一些。

　　《嵌入式linux应用程序开发标准教程》的前几章没必要看了，都是写浅显的知识点，从第六章文件IO编程开始记录笔记。后期再根据APUE的内容进行补充和扩展。

　一、linux系统调用及API

　　1. 系统调用

　　linux分为内核空间和用户空间，用户空间无法直接访问内核空间。内核通过系统调用为用户提供服务，很精简，大约250个左右。大致可分为：进程控制、进程间通信、文件系统控制、系统控制、存储管理、网络管理、socket控制、用户管理等几类。

　　2. C库API

　　C库提供若干API，遵循一定的标准，供用户使用。

　　用户可以直接调用系统调用，也可以调用C库提供的API。

　二、linux中文件及文件描述符概述

　　linux主要有4中文件：普通文件、目录文件、链接文件、设备文件。

　　linux使用文件描述符操作文件，尤其对于用户态来说更是如此，文件描述符是一个非负的整数，是个索引值，linux打开文件时动态分配，分配时，优先分配未使用的最小描述符。打开文件时，内核返回给进程1个文件描述符，读写时进程用此描述符操作文件。　

　　进程打开时，默认会打开三个文件描述符，三个文件默认均指向终端：

　　STDIN_FILENO: 0，标准输入

　　STDOUT_FILENO: 1，标准输出

　　STDERR_FILENO: 2，标准错误

　三、底层文件IO操作

　 3.1 基本文件操作

3.1.1 函数说明

　　5个基本函数，不带缓冲，不属于ANSI C，属于POSIX标准。

　　open、read、write、lseek、close, 见APUE相关笔记。

　 3.2 文件锁

　 3.2.1 共享问题

　　如上图，进程信息中包含“打开文件的当前文件偏移量”，由进程各自维护。若进程1打开了文件并定位到文件尾部——>切换到进程2，进程2定位到文件尾部并写了100个字节——>在回到进程1，写了10个字节——>则结果是该文件的最后100个字节中，前10个是进程1写的，并覆盖了原来进程2写的前10个字节，而后90个是进程2写的。

　　事与愿违，故有的场合期望对文件操作时独占的，所以引入的记录锁。

　　只要多个进程操作同一个文件，就应该上锁。

　　3.2.2 fcntl()

需要头文件	#include <sys/types.h> #include <unistd.h> #include <fcnt1.h> #include <sys/select.h>
原型	int fcnt1(int filedes, int cmd,.../* struct flock * flockptr * / ) ;
描述	除了记录锁以外，还有好多其他的功能
形参	filedes	文件描述符
	cmd	记录锁相关的 F_GETLK:根据第三个参数的情况，测试是否可以上锁，要上的锁由flockptr描述.决定由f l o c k p t r所描述的锁是否被另外一把锁所排斥（阻塞）。如果存在一把锁，它阻止创建由 f l o c k p t r所描述的锁，则这把现存的锁的信息写到 f l o c k p t r指向的结构中。如果不存在这种情况，则除了将 l _ t y p e设置为F _ U N L C K之外， f l o c k p t r所指向结构中的其他信息保持不变。若该文件可以上锁(当前未上锁),则flockptr->l_type为F_UNLK, flockptr的其他项不变; 若不能上锁，则将该文件已经上锁的信息通过flockptr返回。此时不返回错误。若flockptr->l_type为F_UNLCK（要上的锁，不能使这个），则返回错误。 F_SETLK:根据flockptr设置锁。如果试图建立一把按上述兼容性规则并不允许的锁，则f c n t l立即出错返回，此时e r r n o设置为E A C C E S或E A G A I N F_SETLKW: F_SETLK的阻塞版.
	flockptr	l_type: F_RDLCK:读取锁，共享锁，加读锁时，文件必须包含读打开 F_WRLCK：写入锁，排斥锁，加写锁时，文件必须包含写打开 F_UNCLK：解锁写入锁是互斥锁，读取锁是共享锁。如果在一个给定字节上已经有一把或多把读锁，则不能在该字节上再加写锁；如果在一个字节上已经有一把独占性的写锁，则不能再对它加任何读锁 l_start和l_whence:其实保护位置（文件偏移）和相对位置（SEEK_CUR/SET/END）。与，lseek相同。 len想保护的长度，若len=0，则表示从l_start和l_whence决定的位置开始，到文件结尾的最大长度。若想保护整个文件，则可以l_start = 0，l_whence=SEEK_SET, len=0。保护区域可以超过尾部，但不能在起始位置之前。
返回值	若成功则依赖于c m d，若出错则为- 1时
注意事项	用F_GETLK测试，再用F_ SETLK或F_ SETLKW上锁不是原子操作，可能会有问题！应该用F_ SETLK直接上，并查询结果，确定是否上锁成功。

【注意】：

！记录锁继承性等问题

进程、文件关闭与锁的关系 由于锁是在进程信息里存放的，故关闭进程或者关闭文件，该文件的锁有自动关闭。
由fork产生的子进程不继承父进程的锁。
执行exec后，新进程可以继承原来的锁。默认继承

死锁举例

如图，进程1锁文件1，进程2锁文件2。若进程1想锁文件2，且选择了阻塞方式，则进程1会处于阻塞状态，同理进程2也是。这样就构成了死锁。　

　　使用方法：

　　　使用F_GETLK后再F_SETLK，不是原子操作，可能会出问题。可以直接用F_SETLK，然后判断返回值。

　　3.2.3 例程

/* 6-2,fcntl test */

#include <stdio.h>    // printf
#include <stdlib.h>    // exit
#include <unistd.h>
#include <fcntl.h>    // open,fcntl


void lock_set(int fd, short lock_type)
{
    struct     flock st_lock;

    st_lock.l_type = lock_type;
    st_lock.l_whence = SEEK_SET;
    st_lock.l_start = 0;
    st_lock.l_len = 0;
    st_lock.l_pid = -1;
    if( fcntl(fd,F_GETLK,&st_lock) < 0 )        // 判断st_lock类型的锁能否上，测试类型，用F_GETLK然后再F_SETLCK,不是原子原子操作，会有问题，例程这么设计，主要是为了方便理解读写锁的互斥性
        printf("\r\nfcntl GETLK err.");
    // 如果能上，则l_type返回F_UNLCK，st_lock的其他域不变
    // 如果不能上，则l_type返回目前的上锁状态，同时l_pid返回对该文件上锁的进程pid
    if( st_lock.l_type !=  F_UNLCK )        
    {
        if( st_lock.l_type == F_RDLCK )
            printf("\r\nRead lock is already locked by pid %d",st_lock.l_pid );
        if( st_lock.l_type == F_WRLCK )
            printf("\r\nWrite lock is already locked by pid %d",st_lock.l_pid );
    }

    printf("\r\nst_lock.l_type:%d",st_lock.l_type);    
    printf("\r\nst_lock.l_whence:%d",st_lock.l_whence);    
    printf("\r\nst_lock.l_start:%d",st_lock.l_start);    
    printf("\r\nst_lock.l_len:%d",st_lock.l_len);    
    printf("\r\nst_lock.l_pid:%d",st_lock.l_pid);    

    
    st_lock.l_type = lock_type;
    if( fcntl(fd,F_SETLKW,&st_lock) < 0 )        
        printf("\r\nfcntl SETLK err.");    
    switch( st_lock.l_type )
    {
    case F_RDLCK:
        printf("\r\nRead lock is set by pid %d",getpid() );
        break;
    case F_WRLCK:
        printf("\r\Write lock is set by pid %d",getpid() );
        break;
    case F_UNLCK:
        printf("\r\nUn lock is set by pid %d",getpid() );
        break;
    defualt:
        break;
    }
}


int main(int args, char *argv[])
{
    int fd;

    // open file
    fd=open("hello",O_RDWR|O_CREAT,0644);
    if( fd<0 )    
        printf("\r\nopen file err");
    
    //lock_set(fd,F_RDLCK);        // 读锁
    lock_set(fd,F_WRLCK);        // 写锁
    getchar();            // 等待终端输入
    lock_set(fd,F_UNLCK);
    printf("\r\nFINISH\r\n");
    exit(0);
}

终端窗口运行加读锁：
st_lock.l_type:2　　　　　　　　　　//  可上读锁，所以F_GETLCK返回F_UNLCK,其他域不变
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
st_lock.l_pid:-1
Read lock is set by pid 7377

fcntl GETLK err.　　　　　　　　　　// F_GETLCK+F_UNLCK会返回错误
st_lock.l_type:2
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
st_lock.l_pid:-1
Un lock is set by pid 7377
FINISH

另一个终端窗口运行加读锁：

　　st_lock.l_type:2　　　　　　　　　　　　// 读锁是共享锁，可以随便加，不受影响
　　st_lock.l_whence:0
　　st_lock.l_start:0
　　st_lock.l_len:0
　　st_lock.l_pid:-1
　　Read lock is set by pid 7426　　　　　

　　fcntl GETLK err.
　　st_lock.l_type:2
　　st_lock.l_whence:0
　　st_lock.l_start:0
　　st_lock.l_len:0
　　st_lock.l_pid:-1
　　Un lock is set by pid 7426
　　FINISH

// 终端1先运行

st_lock.l_type:2
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
Write lock is set by pid 7517

fcntl GETLK err.
st_lock.l_type:2
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
st_lock.l_pid:-1
Un lock is set by pid 7517
FINISH

// 终端2后运行

Write lock is already locked by pid 7517　　　// 写锁互斥，释放后才能加锁
st_lock.l_type:1
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
Write lock is set by pid 7518　　　　　　　　　　// 阻塞加锁，所以终端1释放后，马上加上了

fcntl GETLK err.
st_lock.l_type:2
st_lock.l_whence:0
st_lock.l_start:0
st_lock.l_len:0
st_lock.l_pid:-1
Un lock is set by pid 7518
FINISH

3.3 多路复用

3.3.1 IO模型

阻塞IO,若IO没有完成相关功能，则进程挂起，直到相关数据到达后才返回。管道、终端、网络设备的读写经常出现这种情况。
非阻塞IO，IO操作不能完成，理解返回，该进程不睡眠
多路转换，轮训各IO，超时等待，select和poll就属于此类
信号驱动IO，signal

3.3.2 函数说明

需要头文件	#include <sys/types.h> #include <sys/time.h> #include <unistd.h>
原型	int select(int numfds, fd_set readfds, fd_set writefds，fd_set exeptfds, struct timeval timeout)
描述	监测多个文件，这就是多路IO的由来
形参	numfds	该参数值为需要监视的文件描述符的最大值加 1
	readfds	由 select()监视的读文件描述符集合
	writefds	由 select()监视的写文件描述符集合
	exeptfds	由 select()监视的异常处理文件描述符集合
	timeout	NULL：永远等待，直到捕捉到信号或文件描述符已准备好为止具体值：struct timeval 类型的指针，若等待了 timeout 时间还没有检测到任何文件描符准备好，就立即返回 struct timeval { long tv_sec; /* 秒 / long tv_unsec; / 微秒 */ }
返回值	大于 0：成功，返回准备好的文件描述符的数目 0：超时；-1：出错
注意事项	监视的文件发生变化，就会返回>0的数注意：select会改变要监视的文件描述符集，如果需要连续监测，需要注意重新初始化该集合

select函数期望对文件描述符分类处理，处理的对象是描述符的集合，需要使用相关宏定义

FD_ZERO(fd_set *set) 清除一个文件描述符集
FD_SET(int fd, fd_set *set) 将一个文件描述符加入文件描述符集中
FD_CLR(int fd, fd_set *set) 将一个文件描述符从文件描述符集中清除
FD_ISSET(int fd, fd_set*set)如果文件描述符 fd 为 fd_set 集中的一个元素，则返回非零值，可以用于调用 select()之后测试文件描述符集中的文件描述符是否有变化#include <sys/types.h>

#include <poll.h>

int poll( struct pollfd * fds, int numfds, int timerout );
参数：
　　fds：描述需要对哪些文件的哪种类型操作进行监控。
　　　　  struct pollfd
　　　　  {
　　　　　　　　int fd;　　　　　　// 需要监听的文件描述符　　
　　　　　　　　short events;　　 // 需要监听的事件
　　　　　　　　short revents;　　// 监听到的事件/已发生的事件
　　　　　}
　　　　　events可由若干定义好的宏定义描述：

　　　　　　　　/* Event types that can be polled for. These bits may be set in `events'
　　　　　　　　　　to indicate the interesting event types; they will appear in `revents'
　　　　　　　　　　to indicate the status of the file descriptor. */
　　　　　　　　#define POLLIN 0x001 /* There is data to read. */　　　　　　　　文件中有数据可读
　　　　　　　　#define POLLPRI 0x002 /* There is urgent data to read. */　　　文件中有紧急数据可读
　　　　　　　　#define POLLOUT 0x004 /* Writing now will not block. */　　　　可以向文件中写入数据

　　　　　　　　#ifdef __USE_GNU
　　　　　　　　/* These are extensions for Linux. */
　　　　　　　　# define POLLMSG 0x400
　　　　　　　　# define POLLREMOVE 0x1000
　　　　　　　　# define POLLRDHUP 0x2000
　　　　　　　　#endif

　　　　　　　　/* Event types always implicitly polled for. These bits need not be set in
　　　　　　　　　　`events', but they will appear in `revents' to indicate the status of
　　　　　　　　　　the file descriptor. */
　　　　　　　　#define POLLERR 0x008 /* Error condition. */　　　　　　　　　　　文件中出现错误
　　　　　　　　#define POLLHUP 0x010 /* Hung up. */　　　　　　　　　　　　　　　　与文件的链接被断开
　　　　　　　　#define POLLNVAL 0x020 /* Invalid polling request. */　　　　　　文件描述符非法　　

　　numfds：需要监听的文件个数，即第一个参数fds的个数
　　timeout:超时时间，ms。如果<0，表示无限等待

返回值：
　　成功：大于0，表示事件发生的pollfd个数
　　0：超时
　　-1:出错

注意事项：
　　其实select在系统内部，也是由poll实现的，poll貌似更简单易用一些。

3.3.3 例程

用两个终端创建两个FIFO，第三个终端运行程序，监测两个FIFO的输入。

select：

/* 6-3,select */

#include <stdio.h>    // printf
#include <stdlib.h>    // exit
#include <unistd.h>
#include <fcntl.h>    // open,fcntl
#include <sys/time.h>    // struct timeval
#include <sys/select.h>
#include <sys/param.h>    // MAX()

#define BUFF_SIZE    1024

int main(int args, char *argv[])
{
    int fd_max,fd_in1,fd_in2,fd_read;
    fd_set readfds;
    struct timeval timeout;
    char buf[BUFF_SIZE];
    int  read_len;

    // open in1&in2
    if( (fd_in1=open("in1",O_RDWR|O_NONBLOCK)) < 0 )
        printf("\r\n open in1 err");    
    if( (fd_in2=open("in2",O_RDWR|O_NONBLOCK)) < 0 )
        printf("\r\n open in1 err");

    printf("\r\nin1 %d,in2 %d, STDIN_FILENO %d",fd_in1,fd_in2,STDIN_FILENO);
    fflush(stdout);        // 把流flush，printf才能及时打印
    // select 
    FD_ZERO(&readfds);
    FD_SET(fd_in1,&readfds);
    FD_SET(fd_in2,&readfds);
    FD_SET(STDIN_FILENO,&readfds);
    fd_max = MAX(MAX(fd_in1,fd_in2),STDIN_FILENO);
    timeout.tv_sec = 60;
    timeout.tv_usec = 0;
    while( select(fd_max+1, &readfds,NULL,NULL,&timeout) > 0 )
    {
        if( FD_ISSET(fd_in1, &readfds) )
            fd_read = fd_in1;
        if( FD_ISSET(fd_in2, &readfds) )
            fd_read = fd_in2;    
        if( FD_ISSET(STDIN_FILENO, &readfds) )    
            fd_read = STDIN_FILENO;    

        read_len = read(fd_read,buf,BUFF_SIZE);
        if( read_len < 0 )
            printf("\r\nread %d err",fd_read);
        else
        {
            printf("\r\nrcv something from %d",fd_read);
            if( fd_read == STDIN_FILENO )
            {
                if(buf[0] == 'q')
                {
                    printf("\r\nquit by user.");
                    break;
                }
            }
            else
            {
                buf[read_len] = '\0';
                printf( "\r\nRcv data from %d:%s",fd_read,buf )    ;
            }
        }
        // 因为select会改变readfds的值，所以想连续监测，要及时重新设置要监视的fd
        FD_ZERO(&readfds);        
        FD_SET(fd_in1,&readfds);
        FD_SET(fd_in2,&readfds);
        FD_SET(STDIN_FILENO,&readfds);
        fd_max = MAX(MAX(fd_in1,fd_in2),STDIN_FILENO);
    }
        
    printf("\r\n job done");
    exit(0);
}

终端1：
mknod in1 p
cat > in1
1111
2222
3333

终端2：
mknod in2 p
cat > in2
4444
5555
6666

终端3运行上述程序，会显示终端1/2的输入，'q'则退出

poll实现相同的功能，执行效果与select差不多。

/* 6-4,poll */
#include <stdio.h>    // printf
#include <stdlib.h>    // exit
#include <unistd.h>
#include <fcntl.h>    // open,fcntl
#include <sys/time.h>    // struct timeval
#include <sys/select.h>
#include <sys/param.h>    // MAX()
#include <poll.h>

#define BUFF_SIZE    1024

int main(int args, char *argv[])
{
    int fd_in1,fd_in2,fd_read;
    struct pollfd st_pollfd[3];
    char buf[BUFF_SIZE];
    int  read_len;
    char i;

    // open in1&in2
    if( (fd_in1=open("in1",O_RDWR|O_NONBLOCK)) < 0 )
        printf("\r\n open in1 err");    
    if( (fd_in2=open("in2",O_RDWR|O_NONBLOCK)) < 0 )
        printf("\r\n open in1 err");

    printf("\r\nin1 %d,in2 %d, STDIN_FILENO %d",fd_in1,fd_in2,STDIN_FILENO);
    fflush(stdout);        // 把流flush，printf才能及时打印
    // poll 
    st_pollfd[0].fd = fd_in1;
    st_pollfd[0].events = POLLIN;
    st_pollfd[1].fd = fd_in2;
    st_pollfd[1].events = POLLIN;
    st_pollfd[2].fd = STDIN_FILENO;
    st_pollfd[2].events = POLLIN;

    while( poll (&st_pollfd, 3, 60*1000) > 0 )
    {
        if( st_pollfd[0].revents&POLLIN == POLLIN )
            fd_read = fd_in1;
        if( FD_ISSET(fd_in2, &readfds) )
            fd_read = fd_in2;    
        if( FD_ISSET(STDIN_FILENO, &readfds) )    
            fd_read = STDIN_FILENO;    

        for(i=0;i<3;i++)
        {
            if( st_pollfd[i].revents&POLLIN == POLLIN )
            {
                read_len = read(st_pollfd[i].fd,buf,BUFF_SIZE);
                if( read_len < 0 )
                    printf("\r\nread %d err",st_pollfd[i].fd);
                else
                {
                    printf("\r\nrcv something from %d",st_pollfd[i].fd);
                    if( st_pollfd[i].fd == STDIN_FILENO )
                    {
                        if(buf[0] == 'q')
                        {
                            printf("\r\nquit by user.");
                            break;
                        }
                    }
                    else
                    {
                        buf[read_len] = '\0';
                        printf( "\r\nRcv data from %d:%s",st_pollfd[i].fd,buf )    ;
                    }
                }                
            }
                            
        }
    }
        
    printf("\r\n job done");
    exit(0);
}

posted @ 2017-03-23 09:04 liuwanpeng 阅读(4113) 评论(0) 编辑收藏举报

刷新页面返回顶部

liuwanpeng

《嵌入式linux应用程序开发标准教程》笔记——6.文件IO编程

一、linux系统调用及API

二、linux中文件及文件描述符概述

三、底层文件IO操作

3.1 基本文件操作

3.1.1 函数说明

3.2 文件锁

3.2.1 共享问题

3.2.2 fcntl()

！记录锁继承性等问题

死锁举例

使用方法：

3.2.3 例程

3.3 多路复用

3.3.1 IO模型

3.3.2 函数说明

3.3.3 例程

公告

　一、linux系统调用及API

　二、linux中文件及文件描述符概述

　三、底层文件IO操作

　 3.1 基本文件操作

　 3.2 文件锁

　 3.2.1 共享问题

　　3.2.2 fcntl()

　　使用方法：

　　3.2.3 例程