UNIX高级环境编程 第14章

第14章 高级IO

14.1 引言

本章的概念和函数
1. 非阻塞I/O
2. 记录锁
3. I/O多路转接(select & poll)
4. 异步I/O
5. readv & writev函数
6. 存储映射I/O: mmap

14.2 非阻塞I/O

低速系统调用可能会使进程永久阻塞，包括:
--1. 如果数据并不存在，则读文件可能会使调用者永远阻塞·--例如读管道、终端设备和网络设备
--2. 如果数据不能立即被接受，则写这些同样的文件也会使调用者永远阻塞
--3. 在某些条件发生之前，打开文件会被阻塞·--例如以只写方式打开一个FIFO，
-----那么在没有其他进程已用读方式打开该FIFO时；
--4. 对已经加上强制性锁的文件进行读、写；
--5. 某些ioctl操作；
--6. 某些进程间通信函数；

非阻塞IO调用open、read和write等IO操作使上述的慢速系统调用在不能立即完成的情况下，立即出错返回。

设置非阻塞IO方法:

open(pathname, O_NONBLOCK | O_... , S_...)

int status;
status = fcntl(fd, GETFL, 0);
status |= O_NONBLOCK;
fcntl(fd, SETFL, status);

14.3 记录锁

记录锁的功能是：
一个进程正在读或修改文件的某个部分时，可以阻止其他进程修改同一文件区域.

int fcntl(int fd, int cmd,  struct flock *flockptr);

struct flock 结构如下：

struct flock{
    short l_type;
    short l_whence;
    off_t l_start;
    off_t l_len;
    pid_t l_pid;
};

结构说明

l_type:
F_RDLCK（共享读锁）、F_WRLCK（独占性写锁）或F_UNLCK（解锁一个区域）

加锁或解锁的区域:
l_whence : SEEK_SET, SEEK_CUR, SEEK_END
l_start: 相对于l_whence的起点
l_len: 区域的长度

注意
1. 该区域可以在当前文件尾端处开始或越过其尾端处开始，但是不能在文件起始位置之前开始或越过该起始位置。
2. 如若l_len为0，则表示锁的区域从其起点（由l_start和l_whence决定）开始直至最大可能位置为止。
---也就是不管添写到该文件中多少数据，它都处于锁的范围。
3. 为了锁整个文件，通常的方法是将l_start说明为0，l_whence说明为SEEK_SET，l_len说明为0

fcntl cmd类型

F_GETLK:
决定由flockptr所描述的锁是否被另外一把锁所排斥（阻塞）。
如果存在一把锁，它阻止创建由flockptr所描述的锁，则这把现存的锁的信息写到flockptr指向的结构中。
如果不存在这种情况，则除了将l_type设置为F_UNLCK之外，flockptr所指向结构中的其他信息保持不变。
这意味则利用F_GETLK不能获取由本进程维护的记录锁。

F_SETLK:
F_SETLK设置由flockptr所描述的锁。如果试图建立一把按上述兼容性规则并不允许的锁，则fcntl立即出错返回
此时errno设置为EACCES或EAGAIN。

F_SETLKW:
是F_SETLK的阻塞版本。如果由于存在其他锁，那么由flockptr所要求的锁不能被创建，则调用进程睡眠。如果捕捉到信号则睡眠中断。

注意
用F_GETLK测试能否建立一把锁，然后用F_SETLK和F_SETLKW企图建立一把锁，这两者不是一个原子操作。
在这两个操作之间可能会有另一个进程插入并建立一把相关的锁，使原来测试到的情况发生变化.
如果不希望在建立锁时可能产生的长期阻塞，则应使用F_SETLK，并对返回结果进行测试，以判别是否成功地建立了所要求的锁。

利用宏填充struct flock

int file_lock(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
    struct flock lock;
    lock.l_type = type;
    lock.l_whence = whence;
    lock.l_start = offset;
    lock.l_len =len;
    return (fcntl(fd,cmd,&lock));

}
#define file_read_lock(fd, offset, whence, len) \
           file_lock((fd),(F_SETLK),(F_RDLCK),(offset),(whence),(len))
#define file_readw_lock(fd, offset, whence, len) \
           file_lock((fd),(F_SETLKW),(F_RDLCK),(offset),(whence),(len))
#define file_write_lock(fd, offset, whence, len) \
           file_lock((fd),(F_SETLK),(F_WRLCK),(offset),(whence),(len))
#define file_writew_lock(fd, offset, whence, len) \
           file_lock((fd),(F_SETLKW),(F_WRLCK),(offset),(whence),(len))

锁的隐含继承和释放

1. 当一个进程终止时，它所建立的锁全部释放；任何时候关闭一个描述符时，则该进程通过这一描述符可以存访的文件上的任何一把锁都被释放
2. 由fork产生的子程序不继承父进程所设置的锁。
3. 在执行exec后，新程序可以继承原执行程序的锁。

14.4 IO多路转接

14.4.1 函数select

---

#include 
int select(int maxfdp1, fd_set* readfds, fd_set* restrict writefds, 
                        fd_set* restrict exceptfds, struct timeval * restrict tvptr);

参数tvptr的含义
1. timeout == NULL，永远等待
2. timeout->tv_sec == 0 && timeout->tv_usec == 0，不等待
3. timeout->tv_sec != 0 || timeout->tv_usec != 0，等待指定时间

操作

void FD_CLR(fd, fd_set *fdset);
void FD_ISSET(fd, fd_set *fdset);
void FD_SET(fd, fd_set *fdset);

void FD_ZERO(fd_set *fdset); // 初始化

第一个参数maxfdp1的意思就是“最大文件描述符编号值+1”

int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, 
                      fd_set *restrict errorfds, const struct timespec *restrict timeout, 
                                                 const sigset_t *restrict sigmask);

pselect可使用可选信号屏蔽字，如果sigmask为null，则两者一样，但是sigmask指向屏蔽字的时候，将以原子操作形式安装屏蔽字

14.4.2 函数poll

int poll(struct pollfd fds[], nfds_t nfds, int timeout);

struct pollfd 结构体

struct pollfd {
    int    fd;       /* file descriptor */
    short  events;   /* events to look for */
    short  revents;  /* events returned */
};

events 和 revents 类型

14.5 异步I/O

异步IO使用AIO控制块来描述IO操作：

struct aiocb {
        int             aio_fildes;             /* File descriptor */
        off_t           aio_offset;             /* File offset */
        volatile void   *aio_buf;               /* Location of buffer */
        size_t          aio_nbytes;             /* Length of transfer */
        int             aio_reqprio;            /* Request priority offset */
        struct sigevent aio_sigevent;           /* Signal number and value */
        int             aio_lio_opcode;         /* Operation for list IO */
};

aio_fildes就是文件描述符
读写操作从aio_offset指定的偏移量位置开始，长度为aio_nbytes
aio_reqprio就是异步IO请求的顺序，当不一定遵守
aio_sigevent就是IO事件完成后如何通知

typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
    {
        int _pad[__SIGEV_PAD_SIZE];

        /* When SIGEV_SIGNAL and SIGEV_THREAD_ID set, LWP ID of the
        thread to receive the signal.  */
        __pid_t _tid;

        struct
        {
           void (*_function) (sigval_t);    /* Function to start.  */
           pthread_attr_t *_attribute;        /* Thread attributes.  */
        } _sigev_thread;
    } _sigev_un;
  } sigevent_t;

# define sigev_notify_function   _sigev_un._sigev_thread._function
# define sigev_notify_attributes _sigev_un._sigev_thread._attribute

APUE课本结构

struct sigevent {
        int  sigev_notify;                              /* Notification type */
        int  sigev_signo;                               /* Signal number */
        union sigval    sigev_value;                    /* Signal value */
        void (*sigev_notify_function)(union sigval);    /* Notification function */
        pthread_attr_t  *sigev_notify_attributes;       /* Notification attributes */
}

sigev_notify字段是通知类型
1. SIGEV_NONE 不通知进程
2. SIGEV_SIGNAL 异步IO完成后，产生sigev_signo指定的信号
3. SIGEV_THREAD 异步请求完成后，由sigev_notify_function指定的函数被调用

注意：异步操作不影响有操作系统维护的文件偏移量
注意：若以追加方式打开文件时，aio_offset被忽略

异步读写操作：

int aio_read(struct aiocb *aiocbp);
int aio_write(struct aiocb *aiocbp);

当两个函数返回时，异步IO请求被放在了等待处理队列中。但返回值与实际IO操作的结果没有任何关系。
如果想要强制所有等待中的异步操作不等待直接写入存储，则调用aio_fsync函数 :

int aio_fsync(int op, struct aiocb *aiocb);

注意： aio_fsync的返回时，读写操作也可能并未完成

获取一个异步读写的完成状态，调用aio_error函数 :

int aio_error(const struct aiocb *aiocbp);

返回值 :
0, 　　 　异步操作成功，使用aio_return函数获得返回值
-1, 　　　对aio_error操作失败
EINPROGRESS,　　读写操作仍处于等待状态

异步操作完成后，调用aio_return :

ssize_t aio_return(struct aiocb *aiocbp);

注意：记住在aio_error检查成功之前，不要使用aio_return函数
注意：每个异步操作只能调用一次aio_return函数。

aio_suspend函数会阻塞当前进程直到list中的 任意一个 操作完成 :

int aio_suspend(const struct aiocb *const list[], int nent, const struct timespec *timeout);

返回值 :
0, 　　 　操作成功，某个异步操作完成
-1, 　　　信号中断，设置errno为EINTR；超时，设置errno为EAGAIN

取消已经处于进行中的异步操作:

int aio_cancel(int fildes, struct aiocb *aiocbp);

返回值：
AIO_ALLDONE，所有操作已经完成
AIO_CANCELED，所有操作已经取消
AIO_NOtCANCELED，至少有一个请求没有取消
-1，对aio_cancel调用失败

把多个异步操作 集中处理 :

int lio_listio(int mode, struct aiocb* restrict const list[restrict], 
                int nent, struct sigevent *restrict sigev);

struct aiocb中的成员aio_lio_opcode指定了操作类型

14.6 函数readv和writev

两个函数用于在一次函数调用中读写多个非连续缓冲区

ssize_t readv(int d, const struct iovec *iov, int iovcnt); // iovcnt 为数组长度

ssize_t writev(int fildes, const struct iovec *iov, int iovcnt);

struct iovec结构体 :

struct iovec {
    char   *iov_base;  /* Base address. */
    size_t iov_len;    /* Length. */
};

14.7 函数readn和writen

ssize_t readn(int fd, void* buf, size_t nbytes);
ssize_t writen(int fd, void* buf, size_t nbytes);

两个函数按需多次调用read和write直至读或写N字节数据

14.8 存储映射I/O

存储映射IO能将一个磁盘文件映射到存储空间中的一个缓冲区上，于是，当从缓冲区中读取数据的时候，就等同于读取文件。

void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);

// 创建匿名存储映射，对存储区的读写不涉及磁盘的读写，但是只能在相关进程之间进行通信
mmap(0, SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONUMOUS, 0, 0);

内存地址空间： [addr, addr + len)
addr 默认指定为0，有系统指定内存区域

描述符为fd的文件被映射区域: [offset, offset + len)

参数prot：映射区域的读写执行特性

参数flag :
MAP_FIXED
返回值必须等于addr。因为这不利于可移植性，所以不鼓励使用此标志。
如果未指定此标志，而且addr非0，则内核只把addr视为何处设置映射区的一种建议。
通过将addr指定为0可获得最大可移植性。

MAP_SHARED
这一标志说明了本进程对映射区所进行的存储操作的配置。
此标志指定存储操作修改映射文件—也就是，存储操作相当于对该文件write。
必须指定本标志或下一个标志（MAP_PRIVATE）。

MAP_PRIVATE
本标志说明，对映射区的存储操作导致创建该映射文件的一个副本。
所有后来对该映射区的存访都是存访该副本，而不是原始文件。

注意：不能将数据添加（不是修改）到文件中。必须先加长文件。

理解与映射区相关的信号有SIGSEGV和SIGBUS

更改现有映射的权限:

int mprotect(void *addr, size_t len, int prot); // addr页长的整数倍

当页已经修改完毕，可以调用msync函数冲洗到被映射的文件中。

int msync(void *addr, size_t len, int flags);

手动解除存储区的映射

int munmap(void *addr, size_t len);

该函数删除了指定地址的映射，如果继续对其进行读写会导致无效内存引用。并且这个函数不会冲洗缓冲区内容到文件。