Unix文件IO，阻塞IO

文件I/O

（不带缓冲的I/O,系统调用：针对文件描述符，低级I/O）

      

　　不带缓冲指：每个read和write都调用内核的一个系统调用。这些不带缓冲I/O函数不是ISO C组成部分，是POSIX.1和Single UNIX Specification组成部分。

 

1. #include <unistd.h>

 

　　STDIN_FILENO:   文件描述符0，标准输入。

　　STDOUT_FILENO:文件描述符1，标准输出。

　　STDERR_FILENO:文件描述符2，标准出错。

　　文件描述符0..OPEN_MAX之间,早期最大19，现在很多系统增至63。对于FreeBSD5.2.1,Mac OS X10.3和Solaris9,文件描述符实际上无上限，只受系统配置存储器容量，整形字长，系统管理员配置的软硬限制的约束。Linux系统每个进程文件描述符硬限制为1048576

 

2. 打开或创建文件

 

　　#include<fcntl.h>

　　int open(const char *pathname, into flag, …/* mode_t mode */);

                             返回值：成功返回文件描述符，出错-1

　　oflag: 必须选一个的为：

　　O_RDONLY 只读打开，大多数实现定义为0，与早期程序兼容

　　O_WRONLY 只写打开，                      1

　　O_RDWR    读写打开                          2

　　其它一些都为可选，常用：

　　　　O_APPEND:每次写时都追加到文件的尾端。

　　　　O_CREAT:  若此文件不存在，就创建它。需要指定新的文件的访问权限。

　　　　O_TRUNC: 若文件存在，而且为只写或读写成功打开，则将其长度截短为0。

　　mode： 为文件访问权限中的模式，常用的(用户可读写，组其它可读)S_IRUSR | S_WUSR | S_IRGRP | S_IROTH

　　　　　　可以不指定而采用默认模式，可用umask查看。

 

3. 创建新文件

 

　　#include<fcntl.h>

　　int create(const char *pathname, mode_t mode);

                      返回值：成功返回只写打开的文件描述符，出错-1

　　等效于：

        　　open(pathname, O_WRONLY | O_CREAT | O＿TRUNC,  mode);

 

4. 关闭打开的文件

 

　　#include <unistd.h>

　　int close(int filedes);

        　　返回值：成功返回0，出错-1

　　关闭一个文件只是减少该文件的一个引用计数。当应用计数为0时才会真正关闭该文件，此时会释放该进程加载文件上的所有记录锁。

　　进程终止时，内核会关闭所有打开的文件，很多程序不显示close打开的文件。

 

5. 文件查找

 

　　为打开的文件设置偏移量

　　#include<unistd.h>

　　off_t lseek(int filedes, off_t offset, int whence);

                             返回值：成功返回新的文件偏移量，出错-1

　　每个打开的文件都有一个当前文件偏移量。除非设定O_APPEND, 否则默认偏移量为0。

　　whence: 指定offset(有符号整数)的含义。

　　　　　　  whence == SEEK_SET, offset为相对文件开始的偏移量。

　　　　　　  whence == SEEK_CUR, offset为相对当前位置的偏移量, 可正可负。

　　　　　　  whence == SEEK_END, offset为相对文件长度的偏移量，可正负。

 

6. 打开文件中读数据

 

 　 #include <unistd.h>

　　ssize_t read(int filedes, void *buf, size_t nbytes);

     　　　　   返回值：成功返回已读字节数，到文件结尾0，出错-1

 　　注：nbytes=4096性能经常最好。

 

7. 向打开文件中写数据

 

     #include<unistd.h>

     ssize_t write(int filedes, const void *buf, size_t nbytes);

                     返回值：成功已写的字节数，出错-1

　　注：nbytes=4096性能经常最好。

 

8. 文件共享

9. 原子操作

 

10. 复制现存文件描述符

 

　   #include <unistd.h>

　　int dup(int filedes);

      int dup2(int filedes,  int filedes2);

              返回值：成功返回新的文件描述符，出错-1

      dup返回的一定是当前可用最小文件描述符

      dup2使用filedes2指定新描述符数值（将filedes2重定向到filedes）。filedes2已打开，先关闭。若filedes=filedes2, dup2 返回filedes2,但是不关闭它。

      函数返回的新文件描述符与参数filedes共享一个文件表项。

　　注：每个文件描述符都有自己的一套文件描述符标志。新描述符的执行时关闭（close-on-exec）标志（文件描述符标志）都由dup(2)函数清除。

 

　　函数理解：

　　(1)  文件描述符在内核中数据结构

　　在具体说dup /dup 2之前，　我认为有必要先了解一下文件描述符在内核中的形态。
　　一个进程在此存在期间，会有一些文件被打开，从而会返回一些文件描述符，从shell中运行一个进程，默认会有3个文件描述符存在(0、１、2), 0与进程的标准输入相关联，
１与进程的标准输出相关联，2与进程的标准错误输出相关联，一个进程当前有哪些打开的文件描述符可以通过/proc/进程ID/fd目录查看。　下图可以清楚的说明问题：

　　进程表项
————————————————

　　　fd标志　    文件指针
      _____________________
fd 0:|________|____________|------------> 文件表
fd 1:|________|____________|
fd 2:|________|____________|
fd 3:|________|____________|
     |     .......         |
     |_____________________|

                图１
　　　　　　　
　　文件表中包含:文件状态标志、当前文件偏移量、v节点指针，这些不是本文讨论的重点，我们只需要知道每个打开的文件描述符(fd标志)在进程表中都有自己的文件表项，由文件指针指向。

　　(2) dup /dup 2函数

　　APUE和man文档都用一句话简明的说出了这两个函数的 作用 ：复制一个现存的文件描述符。
　　#include <unistd.h>
　　int dup (int oldfd);
　　int dup 2(int oldfd, int newfd);

　　从图１来分析这个过程，当调用dup 函数时，内核在进程中创建一个新的文件描述符，此描述符是当前可用文件描述符的最小数值，这个文件描述符指向oldfd所拥有的文件表项。

　　进程表项
————————————————

　　　fd标志　   文件指针
      _____________________
fd 0:|________|____________|                         ______
fd 1:|________|____________|----------------> |          |
fd 2:|________|____________|                         |文件表|
fd 3:|________|____________|----------------> |______|
     |     .......         |
     |_____________________|

                图2：调用dup 后的示意图

　　如图2 所示，假如oldfd的值为1, 当前文件描述符的最小值为3,　那么新描述符3指向描述符１所拥有的文件表项。
　　dup 2和dup 的区别就是可以用newfd参数指定新描述符的数值，如果newfd已经打开，则先将其关闭。如果newfd等于oldfd，则dup 2返回newfd, 而不关闭它。dup 2函数返回的新文件描述符同样与参数oldfd共享同一文件表项。

　　APUE用另外一个种方法说明了这个问题：
　　实际上，调用dup (oldfd)；等效与
        　　fcntl(oldfd, F_DUPFD, 0)

　　而调用dup 2(oldfd, newfd)；等效与
        　　close(oldfd)；
        　　fcntl(oldfd, F_DUPFD, newfd)；

 

　　printf －> stdout －> STDOUT_FILENO(1) －> 终端(tty)

　　重拾终端输出方法

　　ttyfd = open("/dev/tty", O_RDWR);
　　dup 2(ttyfd, STDOUT_FILENO);
　　close(ttyfd);

 

　　dup和dup2也是两个非常有用的调用，它们的作用都是用来复制一个文件的描述符。它们经常用来重定向进程的stdin、stdout和stderr。这两个函数的原形如下：

　　C代码                          

1. #include <unistd.h>  
2. int dup( int oldfd );  
3. int dup2( int oldfd, int targetfd );  

　　#include <unistd.h>

　　int dup( int oldfd );

　　int dup2( int oldfd, int targetfd );

 

　　dup()函数

　　利用函数dup，我们可以复制一个描述符。传给该函数一个既有的描述符，它就会返回一个新的描述符，这个新的描述符是传给它的描述符的拷贝。这意味着，这两个描述符共享同一个数据结构。例如，如果我们对一个文件描述符执行lseek操作，得到的第一个文件的位置和第二个是一样的。下面是用来说明dup函数使用方法的代码片段：

　　C代码  

1. int fd1, fd2;  
2. ...  
3. fd2 = dup( fd1 );  

　　int fd1, fd2;

　　...

　　fd2 = dup( fd1 );

　　需要注意的是，我们可以在调用fork之前建立一个描述符，这与调用dup建立描述符的效果是一样的，子进程也同样会收到一个复制出来的描述符。 

 

　　dup2()函数

　　dup2函数跟dup函数相似，但dup2函数允许调用者规定一个有效描述符和目标描述符的id。dup2函数成功返回时，目标描述符（dup2函数的第二个参数）将变成源描述符（dup2函数的第一个参数）的复制品，换句话说，两个文件描述符现在都指向同一个文件，并且是函数第一个参数指向的文件。下面我们用一段代码加以说明：

　　C代码  

1. int oldfd;  
2. oldfd = open("app_log", (O_RDWR | O_CREATE), 0644 );  
3. dup2( oldfd, 1 );  
4. close( oldfd );  

    在本例中，我们打开了一个新文件，称为“app_log”，并收到一个文件描述符，该描述符叫做fd1。我们调用dup2函数，参数为oldfd和1，这会导致用我们新打开的文件描述符替换掉由1代表的文件描述符（即stdout，因为标准输出文件的id为1）。任何写到stdout的东西，现在都将改为写入名为“app_log”的文件中。需要注意的是，dup2函数在复制了oldfd之后，会立即将其关闭，但不会关掉新近打开的文件描述符，因为文件描述符1现在也指向它。 

　　例子

　　下面我们介绍一个更加深入的示例代码。回忆一下命令行管道，我们可以将ls –l命令的标准输出作为标准输入连接到wc –l命令。接下来，我们就用一个C程序来加以说明这个过程的实现。代码如下所示。 

C代码  

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4.   
5. int main()  
6. {  
7.     int pfds[2];  
8.   
9.     if ( pipe(pfds) == 0 ) {  
10.   
11.     if ( fork() == 0 ) {  
12.   
13.         close(1);  
14.         dup2( pfds[1], 1 );  
15.         close( pfds[0] );  
16.         execlp( "ls", "ls", "-l", NULL );  
17.   
18.     } else {  
19.   
20.         close(0);  
21.         dup2( pfds[0], 0 );  
22.         close( pfds[1] );  
23.         execlp( "wc", "wc", "-l", NULL );  
24.   
25.     }  
26.   
27.     return 0;  
28. }  #include <stdio.h>

　　#include <stdlib.h>

　　#include <unistd.h>

int main()

{

    int pfds[2];

 

    if ( pipe(pfds) == 0 ) {

 

    if ( fork() == 0 ) {

 

        close(1);

        dup2( pfds[1], 1 );

        close( pfds[0] );

        execlp( "ls", "ls", "-l", NULL );

 

    } else {

 

        close(0);

        dup2( pfds[0], 0 );

        close( pfds[1] );

        execlp( "wc", "wc", "-l", NULL );

 }

   　return 0;

}

　　在示例代码中，首先在第9行代码中建立一个管道，然后将应用程序分成两个进程：一个子进程（第13–16行）和一个父进程（第20–23行）。接下来，在子进程中首先关闭stdout描述符（第13行），然后提供了ls –l命令功能，不过它不是写到stdout（第13行），而是写到我们建立的管道的输出端，这是通过dup2函数来完成重定向的。在第14行，使用dup2 函数把stdout重定向到管道（pfds[1]）。之后，马上关掉管道的输入端。然后，使用execlp函数把子进程的映像替换为命令ls –l的进程映像，一旦该命令执行，它的任何输出都将发给管道的输入端。 

　　现在来研究一下管道的接收端。从代码中可以看出，管道的接收端是由父进程来担当的。首先关闭stdin描述符（第20行），因为我们不会从机器的键盘等标准设备文件来接收数据的输入，而是从其它程序的输出中接收数据。然后，再一次用到dup2函数（第21行），让管道的输入端作为输入，这是通过让文件描述符0（即常规的stdin）重定向到pfds[0]实现的。关闭管道的stdout端（pfds[1]），因为在这里用不到它。最后，使用 execlp函数把父进程的映像替换为命令wc -l的进程映像，命令wc -l把管道的内容作为它的输入（第23行）。

　　常用于输入输出重定向：

　　if (dup2(filedes, STDOUT_FILENO) != STDOUT_FILENO)

　　close(filedes);

　　dup2返回值为STDOUT_FILENO, 但是它的文件指针指向了filedes的文件表项，因此，标准输出被重定向到filedes。即向标准输出输入的东西不再输出到屏幕（默认），而是到filedes文件中。

 

11. sysnc, fsync和fdatasync函数

 

12. 改变已打开的文件性质

 

       #include <fcntl.h>

       int fcntl(int filedes, int cmd, …/* int arg */);

                     返回值：成功依赖于cmd，出错返回-1

　　注：太重要了，另作叙述

 

13. ioctl函数

 

 　　注：另作叙述

 

14. /dev/fd

 

       打开/dev/fd/n = 复制描述符n。

       fd = open(“/dev/fd/0”, mode);

       大多数系统忽略mode，一些系统要求mode是涉及的文件（这里是/dev/fd/0）的mode的子集。

       上面等效于：

       fd = dup(0);

       描述符0和fd共享一个文件表项。