apache中的文件与目录(2)

3/23/2008来源:软件工程人气:6991

4.4 打开文件
文件打开应该是使用的最多的文件操作了,任何文件在使用之前都必须首先打开。ANSI C标准库和Unix系统库函数都提供对“打开文件”这个操作语义的支持。他们提供的接口很相似,参数一般都为“文件名+打开标志位+权限标志位”,Apache中提供了aPR_file_open函数来支持文件打开操作,该函数只是在原有的标准库的基础上进行了少许的封装。apr_file_open无法忽略习惯的巨大力量,它提供了与ANSI C以及Unix系统库函数类似的接口如下:
 APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new,
                                        const char *fname,
                                        apr_int32_t flag,
                                        apr_fileperms_t perm,
                                        apr_pool_t *pool);
其中fname、flag和perm三个参数与普通的open函数相同,fname分别表示打开的文件的路径名称,可以是相对路径,也可以是绝对路径。每个封装都有自定义的一些标志宏,这里也不例外,flag和perm参数都需要用户传入APR自定义的一些宏组合,不过由于这些宏的可读性都很好,不会成为你使用过程的绊脚石。flag是打开文件的标志,包括可读可写,Apache中打开标志可以概括为下面的几种:
打开标志
含义
APR_READ
打开文件为只读
0x00001
APR_WRITE
打开文件为只写
0x00002
APR_CREATE
假如文件不存在,创建一个新的文件
0x00004
APR_APPEND
答应将内容追加到文件的末尾,而不是重新覆盖
0x00008

APR_TRUNCATE
假如文件存在,将其长度设置为0
0x00010
APR_BINARY
打开的不是文本文件,而是二进制文件,在UNIX上,该标志将被忽略
0x00020
APR_BUFFERED
缓存数据,默认情况下不进行数据缓存
0x00040
APR_EXCL
return error if APR_CREATE and file exists
0x00080
APR_DELONCLOSE
关闭后删除该文件
0x00100
APR_XTHREAD
该标志依靠于具体的平台,用以确保文件在跨线程访问中的安全
0x00200
APR_SHARELOCK
平台依靠标记,用以支持上层的读写所访问从而支持跨进程或者跨机器访问
0x00400
APR_FILE_NOCLEANUP
通知系统不要在内池中注册文件清除函数,因此当内存池被销毁的时候,apr_file_t中的apr_os_file_t句柄将不会被销毁
0x00800
APR_SENDFILE_ENABLED 
Open with appropriate platform semantics
 for sendfile Operations. Advisory only,           apr_socket_sendfile does not check this flag.
0x01000
perm则是用以记录文件的存取权限,通常情况下是一个整数,比如0x777,0x666等等。Apache中支持的权限如表4-3所示。
文件的读取结果由指针apr_file_t返回。整个open过程可以分为四部分:
1)、“打开标志位”转换;
如前所述,APR定义了自己的“文件打开标志位”,所以在apr_file_open的开始需要将这些专有的“文件打开标志位”转换为Unix平台通用的“文件打开标志位”,对应的转换表如下:

Apache打开标志
UNIX库函数内部标志
APR_READ&&APR_WRITE
O_RDWR
APR_READ
O_RDONLY
APR_WRITE
O_WRONLY
APR_CREATE
O_CREAT
O_CREAT&&APR_EXCL
O_CREAT&O_EXCL
APR_EXCL&&!APR_CREATE
答应组成员读取
APR_APPEND
O_APPEND
APR_TRUNCATE
O_TRUNC
O_BINARY
O_BINARY
APR_BUFFERED&&APR_XTHREAD
答应其余成员读取
2)、权限标志位”转换;
同1)理,专有的APR“权限标志位”需要转换为Unix平台通用的“权限标志位”;转换使用函数apr_unix_perms2mode实现,转换根据表4-2的对应关系实现。函数返回的权限最终传递给open函数的标志位。
(3)、调用Unix的本地API打开文件;
(4)、设置apr_file_t变量相关属性值;
APR 文件I/O封装支持非阻塞I/O带超时等待以及缓冲I/O,默认情况下为阻塞的,即BLK_ON。
APR文件的另外一个非凡之处就是支持缓冲特性。由于磁盘读取的速度瓶颈,使得频繁的从磁盘读取文件在一定程度上会影响执行效率,因此为了提高读取效率,APR支持文件的缓存读写,即开辟一块大的缓冲内存区,用以保存实际从磁盘中读取得数据,这样用户每次就不需要读写磁盘,而只要读写内存,通过这种缓冲策略,可以改善一定的性能。是否缓冲可通过“文件打开标志位APR_BUFFERED”设置。一旦设置为缓冲读写,则apr_file_open会在pool中开辟大小为APR_FILE_BUFSIZE(4096)的缓冲区供使用。
创建函数中一个比较重要的就是内存池中apr_file_t类型的清除函数注册。当内存池被销毁的时候,对于所有的apr_file_t类型将调用apr_unix_file_cleanup函数进行清除。与创建类似,清除也包括四方面的工作:
(1)、
(2)、关闭文件描述符filedes,假如文件的打开标志是APR_DELONCLOSE,那么在关闭之后还得将该文件删除;假如文件可能跨进程使用,那么还得销毁互斥锁。
(3)、
 
4.5 文件读取

4.5.1普通文件读取
文件的读写操作定义在readwrite.c中。函数的原型与标准的接口非常类似:
APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes)
thefile是需要读取的文件的描述结构,而buf是文件读取保存的缓冲区。nbytes则是从文件中需要读取的字节数。Apache中的文件读取在内部分为两种机制:支持读写缓存的和不支持读写缓存的,读写是否需要支持缓存,有apr_file_t内部的buffered成员决定,buffered=1表示内部必须支持缓存,否则不需要使用缓存。
我们首先分析最普通的内部不使用缓存的读写情况,下面是读取的核心代码:
{
    apr_ssize_t rv;
    apr_size_t bytes_read;
 
    if (*nbytes <= 0) {
        *nbytes = 0;
        return APR_SUCCESS;
    }
 
    {
        bytes_read = 0;
        if (thefile->ungetchar != -1) {
            bytes_read = 1;
            *(char *)buf = (char)thefile->ungetchar;
            buf = (char *)buf + 1;
            (*nbytes)--;
            thefile->ungetchar = -1;
            if (*nbytes == 0) {
                *nbytes = bytes_read;
                return APR_SUCCESS;
            }
        }
 
        do {
            rv = read(thefile->filedes, buf, *nbytes);      u
        } while (rv == -1 && errno == EINTR);
#ifdef USE_WAIT_FOR_IO
        if (rv == -1 &&
            (errno == EAGAIN errno == EWOULDBLOCK) &&
            thefile->timeout != 0) {
            apr_status_t arv = apr_wait_for_io_or_timeout(thefile, NULL, 1);
            if (arv != APR_SUCCESS) {               v

                *nbytes = bytes_read;
                return arv;
            }
            else {
                do {
                    rv = read(thefile->filedes, buf, *nbytes);
                } while (rv == -1 && errno == EINTR);
            }
        } 
#endif
        *nbytes = bytes_read;
        if (rv == 0) {
            thefile->eof_hit = TRUE;                   w
            return APR_EOF;
        }
 
        if (rv > 0) {
            *nbytes += rv;                              x
            return APR_SUCCESS;
        }
        return errno;
    }
}
读取的主要操作就是调用标准的文件读操作read,文件中读取的数据直接保存到输出缓冲区buf中,确实没有进行任何的内部缓存。
第一次读取结束后,函数将根据读取的返回值做进一步的处理:
返回EINTR,见代码u
返回EINTR意味着读取操作被中断信号无意打断,而不是读取操作本身出现任何问题,因此此时必须无条件重新启动读操作,这就是将读操作放在循环中的原因之一,代码见。
返回EAGAIN或者EWOULDBLOCK,见代码v
读操作发生失败的另外一个可能性就是文件暂时不可用,因此此时应该稍等片刻再尝试,这种情况通常会返回EAGAIN错误码,对于GNU C库而言,EWOULDBLOCK与EAGAIN的含义完全相同,只是换了一个名字而已,不过对于早期的版本可能存在差异。因此稳妥的做法就是同时检测EAGAIN和EWOULDBLOCK错误码。
一般下面的两种情况可能返回这两个错误码:
(1)、对非阻塞模式的对象进行某个会阻塞的操作可能会返回该错误码,再次做同样的操作就会阻塞直到某种条件使它可以读写。
(2)、某个资源上的故障使操作不能进行。例如fork有可能返回着个错误,这也表示这个故障可以被克服,所以你的程序可以以后尝试这个操作。停几秒让其他进程释放资源然后再试也许是个好主意。这种故障可能很严重并会影响整个系统,所以通常交互式的程序会报告用户这个错误并返回命令循环。

假如apr_file_t结构中设置了超时时间timeout,同时发现必须重新读取(返回码为EAGAIN或者EWOULDBLOCK),那么Apache将调用apr_wait_for_io_or_timeout函数等待重新读取文件。apr_wait_for_io_or_timeout函数内部使用了I/O的多路复用技术poll,具体的细节我们在网络I/O章节描述。假如在给定的超时时间内,文件还是不答应进行读取操作,那么此时函数将直接返回,否则函数将重新调用下面的语句:
do {
    rv = read(thefile->filedes, buf, *nbytes);
} while (rv == -1 && errno == EINTR);
由于此时文件的状态处于肯定答应进行操作状态,因此不再需要进行额外的异常处理,唯一的就是防止被信号无意打断。
到达文件末尾(rv==0),见代码w
假如read函数返回0,此时意味着已经读取到整个文件,此时设置文件的eof_hit=1,至此整个文件读取结束。
读取非空字节(rv>0),见代码x
此时累计读取的总字节数目。
上面的几个文件读取的处理步骤是大多数文件读取的标准的读取操作,因此非常的好理解。
事实上,对于文件读取分析的重点并不是上面的普通的读取,而是使用缓存的读取。一般情况下I/O操作是相当耗费时间的,因此仅仅一次从文件中直接读取数据保存到缓冲区中所花的时间可能答应忽略不计,但是假如文件读取操作非常的频繁的话,那么这将无疑是一个不小的时间耗费,甚至可能是性能瓶颈。因此为了有效地提高读写性能,Apache提供了缓存读取的策略。所谓缓存读取,就是先把文件中的数据读取到一个缓存中,然后以后再次需要读取数据的时候,不再从文件本身去读取,而是从缓存中去读取。通过这种策略使文件I/O读取变成内存读取,从而提高了读取速度。而写入时候也是类似,先写入到缓存中,然后在一次写入磁盘中,从而将多次磁盘写入变为多次内存写入。apr_file_t结构中的buffer结构的作用正是这个目的。缓存读取的策略可以用下面的示意图描述:
apache中的文件与目录(2)(图一)
使用了缓冲区后,文件操作者将通过缓冲区与磁盘文件打交道。整个缓冲区的实现机制,我们给出下面的一个更具体的图片,通过图示,我们可以理解apr_file_t中一些很晦涩的成员变量,事实上这些成员变量仅仅是配合缓冲区机制而使用的,而且仅仅使用缓冲区的时候才起作用。
apache中的文件与目录(2)(图二)
上面的图示被我们分为了三个层次:最底层的是进行文件读写的用户,它拥有自定义的缓冲区,我们称之为用户缓冲区;中间的是apr_file_t结构内的缓冲区,它用以保存读写缓存数据。事实上用户总是跟这个层次的缓冲区打交道;最上层的则是磁盘文件。在各个层次中我们用”////////”表示模拟当前的缓冲区大小。
从图示中我们可以看到至少存在四种缓冲区长度:
1)、磁盘文件的实际长度。当使用read在文件中读写的时候,文件内部会维护一个内部指针指示当前的读取位置,apr_file_t结构中使用filePtr模拟该内部指针,因此filePtr总是指向实际文件内部的当前读取位置。
2)、文件缓冲区中现有数据的长度,它的大小由apr_file_t结构内的dataRead指示。通常情况下,dataRead的大小与filePtr指向的位置偏移相等。
3)、最终用户在文件缓冲区中读取的数据的当前指针,由apr_file_t结构内的bufpos指针指示。
4)、用户缓冲区的长度,其最新读写位置由pos指示。
基于缓冲区,整个读取操作的流程发生了根本的变化。任何读取首先尝试从文件缓冲区中读取,假如请求读取的长度在文件缓冲区的长度范围之内,那么直接返回数据。假如需要读取的内容超出了文件缓冲区的范围,那么我们还必须再去实际的磁盘文件中去读取,并返回,同时更新缓存区中的数据。
    if (thefile->buffered) {
        char *pos = (char *)buf;
        apr_uint64_t blocksize;
        apr_uint64_t size = *nbytes;
 
#if APR_HAS_THREADS
        if (thefile->thlock) {
            apr_thread_mutex_lock(thefile->thlock);

        }
#endif
假如支持多线程的操作,那么在对文件进行操作之前必须互斥量锁定,确保操作的安全性。同样在读取结束后还必须是unlock该互斥变量。
        if (thefile->direction == 1) {
            apr_file_flush(thefile);
            thefile->bufpos = 0;
            thefile->direction = 0;
            thefile->dataRead = 0;
        }
 
        rv = 0;
        if (thefile->ungetchar != -1) {
            *pos = (char)thefile->ungetchar;
            ++pos;
            --size;
            thefile->ungetchar = -1;
        }
        while (rv == 0 && size > 0) {
            if (thefile->bufpos >= thefile->dataRead) {
                int bytesread = read(thefile->filedes, thefile->buffer, APR_FILE_BUFSIZE);
                if (bytesread == 0) {
                    thefile->eof_hit = TRUE;
                    rv = APR_EOF;
                    break;
                }

                else if (bytesread == -1) {
                    rv = errno;
                    break;
                }
                thefile->dataRead = bytesread;
                thefile->filePtr += thefile->dataRead;
                thefile->bufpos = 0;
            }
 
            blocksize = size > thefile->dataRead - thefile->bufpos ? thefile->dataRead - thefile->bufpos : size;
            memcpy(pos, thefile->buffer + thefile->bufpos, blocksize);
            thefile->bufpos += blocksize;
            pos += blocksize;
            size -= blocksize;
        }
while循环读取的核心代码就位于while循环中。dataRead是实际读取到缓冲区中的数据的长度,当然它肯定小于或者等于实际的文件的总长度。bufpos则是用户读取的缓冲区中的实际字节数目,当然bufpos肯定也是小于或者等于dataRead的。它们的关系如上图所示。用户假如从缓冲区中读取数据的话它最多只能读取到dataRead字节的长度。当用户从缓冲区中读取数据的时候,缓冲区的内部的指针变量bufpos不断往后移动。
函数将根据bufpos的位置做不同的策略:
(1)、起始的时候,bufpos=0,缓冲区中的数据为dataRead,用户请求的数据为size大小。此时将开始尝试读取缓冲区中的数据。假如请求的字节小于缓冲区的dataRead长度,那么直接将缓冲区中size大小的数据拷贝到输出缓冲区pos中。这种情况是最简单的一种。
由于filepos为0,这时候执行的代码将演变为如下:
            blocksize = size;//size > thefile->dataRead -0 ? thefile->dataRead: size;
            memcpy(pos, thefile->buffer + 0, blocksize);
            thefile->bufpos += blocksize;

            pos += size;
            size -= size;
(2)、当bufpos=0,即开始读取的时候,假如用户请求的数据长度超出了dataRead的长度,那么此时用户第一次读取只能读取到dataRead的数据,还剩余size-dataRead需要从文件中读取。因此,第一次的读取演变为如下的代码:
            blocksize = thefile->dataRead;//size > thefile->dataRead - 0 ? thefile->dataRead - 0 : size;
            memcpy(pos, thefile->buffer + 0, blocksize);
            thefile->bufpos += blocksize;
            pos += thefile->dataRead;
            size -= thefile->dataRead;
此时各个指针的位置如下图所示意
apache中的文件与目录(2)(图三)
从上图可以看到,第一次读取之后,各个指针都指向相应的缓冲区的末尾,pos指向用户缓冲区,随后的数据直接从pos位置往后拷贝;bufpos指向文件缓冲区的末尾。由于此时尚有size-dataRead大小的数据尚未读取,因此,函数将从thefile->filedes中去读取:
            if (thefile->bufpos >= thefile->dataRead) {
                int bytesread = read(thefile->filedes, thefile->buffer, APR_FILE_BUFSIZE);
                if (bytesread == 0) {
                    thefile->eof_hit = TRUE;
                    rv = APR_EOF;
                    break;
                }
                else if (bytesread == -1) {
                    rv = errno;

                    break;
                }
                thefile->dataRead = bytesread;
                thefile->filePtr += thefile->dataRead;
                thefile->bufpos = 0;
            }
但实际上,当Apache再次到磁盘文件中去读取的时候,它并不会吝啬的仅读取size-dataRead大小,相反它会调用read函数一次性的从文件中读取APR_FILE_BUFSIZE(4K)大小的数据到文件缓冲区中,然后设置dataRead为新的实际的读取字节长度。
        *nbytes = pos - (char *)buf;
        if (*nbytes) {
            rv = 0;
        }
#if APR_HAS_THREADS
        if (thefile->thlock) {
            apr_thread_mutex_unlock(thefile->thlock);
        }
#endif
        return rv;
    }
 
在apr_file_read函数的基础之上,APR提供了额外的几个辅助函数:
■ APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile);
用以从文件中获取一个字符
■ APR_DECLARE(apr_status_t) apr_file_read_full(apr_file_t *thefile, void *buf,
                                             apr_size_t nbytes,
                                             apr_size_t *bytes_read)

apr_file_read函数通常用于读取指定字节的数据,并且永远不会超过这个指定值,但是实际的读取字节数则可以少于这个值。
而apr_file_read_full与apr_file_read非常类似,主要的区别就是,对于指定的字节数nbytes,函数必须全部读取完毕才肯罢休,任何时候假如发现读取得字节数小于nbytes,函数都将继续等待。这种读取方式我们称之为“全字节读取方式”。
4.5.2字符串读取
 
4.5.3文件写入
文件写入通过函数apr_file_write实现,与标准的写入函数相同,它也具有三个参数:
APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
thefile是写入的文件描述符,buf是写入的源目标字符串,nbytes是需要写入的字节总数目。
与读取类似,写入也分为缓冲写入和非缓冲写入两种。对于非缓冲写入,所有的数据是直接写入到文件中,而对于缓冲写入,所有的数据先写入到文件缓冲区中,然后再从缓冲区中写入到文件中。
对于非缓冲写入的核心代码如下所示:
        apr_size_t rv;
 
        do {
            rv = write(thefile->filedes, buf, *nbytes);
        } while (rv == (apr_size_t)-1 && errno == EINTR);
#ifdef USE_WAIT_FOR_IO
        if (rv == (apr_size_t)-1 &&
            (errno == EAGAIN errno == EWOULDBLOCK) &&
            thefile->timeout != 0) {
            apr_status_t arv = apr_wait_for_io_or_timeout(thefile, NULL, 0);
            if (arv != APR_SUCCESS) {
                *nbytes = 0;
                return arv;
            }
            else {
                do {
                    do {
                        rv = write(thefile->filedes, buf, *nbytes);
                    } while (rv == (apr_size_t)-1 && errno == EINTR);
                    if (rv == (apr_size_t)-1 &&
                        (errno == EAGAIN errno == EWOULDBLOCK)) {

                        *nbytes /= 2;
                    }
                    else {
                        break;
                    }
                } while (1);
            }
        } 
#endif
        if (rv == (apr_size_t)-1) {
            (*nbytes) = 0;
           return errno;
        }
        *nbytes = rv;
        return APR_SUCCESS;
 
对于缓冲写入,其实现代码如下所示:
    apr_size_t rv;
 
    if (thefile->buffered) {
        char *pos = (char *)buf;
        int blocksize;
        int size = *nbytes;
 
        if ( thefile->direction == 0 ) {
            apr_int64_t offset = thefile->filePtr - thefile->dataRead + thefile->bufpos;
            if (offset != thefile->filePtr)
                lseek(thefile->filedes, offset, SEEK_SET);                  u
            thefile->bufpos = thefile->dataRead = 0;
            thefile->direction = 1;
        }
 
        rv = 0;
        while (rv == 0 && size > 0) {
            if (thefile->bufpos == thefile->bufsize)   /* write buffer is full*/

                rv = apr_file_flush(thefile);                v
 
            blocksize = size > thefile->bufsize - thefile->bufpos ?
                        thefile->bufsize - thefile->bufpos : size;
            memcpy(thefile->buffer + thefile->bufpos, pos, blocksize);                     
            thefile->bufpos += blocksize;                  w
            pos += blocksize;
            size -= blocksize;
        }
 
        return rv;
    }
在分析文件缓冲写之前,我们先看一下实际的文件系统的读写情况。在文件系统内部始终维持一个内部位置指针,该指针随着当前读取和写入的位置的改变而不停的改变,同时任何一次读取和写入都是在内部指针指向的位置基础上进行的,因此假如在写之前,文件内部的指针偏移为offset,则写入的数据将插入到offset之后。
这种情况对于APR文件缓冲而言也必须实现同样的效果。不过,假如文件thefile在写之前刚被读过,则存在两个offset偏移位置:
1)、filePtr。任何时候,实际文件内部的指针用filePtr进行模拟指示,它始终与内部指针保持同步。
2)、bufpos。该位置指示用户实际已经读取的缓冲区位置,它在实际文件内部的偏移量为filePtr-(dataRead-bufpos)。
那么在写入时候,新的数据是插入到filePtr之后还是filePtr-(dataRead-bufpos)之后呢?答案只有一个:一切从用户的角度出发。对于最终用户而言,它能够观察到的现象是:数据刚被读取到bufpos位置,至于文件缓冲区的文件长度多少用户根本无法了解到。因此对于用户而言,文件的偏移量应该是filePtr-(dataRead-bufpos),而不是filePtr,即使实际的内部文件指针偏移量确实是filePtr。
因此假如filePtr和filePtr-(dataRead-bufpos)不一致的时候,必须调整文件内部的实际偏移指针为filePtr-(dataRead-bufpos),以保证正确的写入位置。另外必要的工作就是初始化写入缓冲区,这正是代码u所实现的任务。
一旦定位完毕,那么就可以进行数据写入了。用户缓冲区中所有的数据首先都立即写入到文件缓冲区中,写入的时候可能发生的情况包括下面几种:
1)、缓冲区已满。apr_file_t中缓冲区的大小由bufsize确定,默认大小为4K。一旦缓冲区已满,那么缓冲区中的数据将使用apr_file_flush一次性写入到实际的文件中,同时再次初始化缓冲区。Apr_file_flush函数的实现非常简单,顺便一看:
APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile)
{
    if (thefile->buffered) {
        if (thefile->direction == 1 && thefile->bufpos) {
            apr_ssize_t written;
 
            do {
                written = write(thefile->filedes, thefile->buffer, thefile->bufpos);

            } while (written == -1 && errno == EINTR);
            if (written == -1) {
                return errno;
            }
            thefile->filePtr += written;
            thefile->bufpos = 0;
        }
    }
    return APR_SUCCESS;
}
函数中所作的无非就是不断调用write写入。写入成功后filePtr和缓冲区的开始位置,这两个步骤都被隐藏在该函数中,因此你在写入函数中看不到也就不希奇了。
2)、缓冲区的空闲空间足够写入,即size <= thefile->bufsize - thefile->bufpos。此时,直接调用memcpy将用户缓冲区中的数据拷贝到文件缓冲区中,并调整用户缓冲区pos和文件缓冲区bufpos的位置。
3)、用户要求写入的数据空闲空间不够一次写入,此时将分为多次写入。假如写入过程中空间已满,使用1)的方法,否则使用2)的方法。
 
在该函数的基础之上,APR还提供了一些辅助扩充函数:
■ APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile);
用以向文件中写入一个字符。
■ APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile)
用以向文件中写入一个字符串。
■ APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec,
                                          apr_size_t nvec, apr_size_t *nbytes)
批量文件写入。需要批量写入的数据保存在vec中。假如系统中定义了writev函数,则调用writev函数批量写入。假如系统不支持writev函数,那么假如要写入整个iovec数组,可以使用两种变通策略:
第一种就是逐一遍历iovec数组中的每一个元素并将其写入到文件中。这种做法存在一个问题,就是原子性写入。Writev函数写入所有数据的时候是保持原子性的。而迭代则明显无法保持这种特性。
另一种可选策略就是首先将iovec数组中的数据集中写入到一个缓冲区中,然后再将该缓冲区写入到文件中。这种策略也是不合理的,因此你根本就不知道一个iovec数组中会包含多少数据,你也就无法确定缓冲区的大小。
为了保持writev的真正语义,最合理的策略就是仅写入iovec数组中的第一个数据,即vec[0]。Callers of file_writev() must deal with partial writes as they normally would. If you want to ensure an entire iovec is written, use apr_file_writev_full()。
■APR_DECLARE(apr_status_t) apr_file_write_full(apr_file_t *thefile,
                                              const void *buf,
                                              apr_size_t nbytes,

                                              apr_size_t *bytes_written)
与apr_file_read_full类似,该函数使得写入的字符串必须达到指定的nbytes,任何时候假如写入的字符数小于nbytes,函数都将等待。这种方式我们称之为“全字节写入方式”。
¢ APR_DECLARE(apr_status_t) apr_file_writev_full(apr_file_t *thefile,
                                               const struct iovec *vec,
                                               apr_size_t nvec,
                                               apr_size_t *bytes_written)
apr_file_writev_full是apr_file_writev函数的全字节写入方式的版本。该函数定义在fullrw.c中。
文件打开、文件读取以及文件写入是最普通三种文件操作,也是APR中使用的最多的操作,APR中相当一部分的文件操作函数都是基于这三个函数构建起来的,最典型的就是文件内容拷贝和追加。在接下来的部分我们在分析文件内容拷贝和追加的时候更应该关注的是这三个函数的使用。
关于作者
张中庆,目前主要的研究方向是嵌入式浏览器,移动中间件以及大规模服务器设计。目前正在进行Apache的源代码分析,计划出版《Apache源代码全景分析》上下册。Apache系列文章为本书的草案部分,对Apache感爱好的朋友可以通过flydish1234 at sina.com.cn与之联系!

假如你觉得本文不错,请点击文后的“推荐本文”链接!!