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、1、2), 0与进程的标准输入相关联,
1与进程的标准输出相关联,2与进程的标准错误输出相关联,一个进程当前有哪些打开的文件描述符可以通过/proc/进程ID/fd目录查看。 下图可以清楚的说明问题:

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

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

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

  (2) dup /dup 2函数


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

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

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

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

                图2:调用dup 后的示意图

  如图2 所示,假如oldfd的值为1, 当前文件描述符的最小值为3, 那么新描述符3指向描述符1所拥有的文件表项。
  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共享一个文件表项。

 

posted on 2014-04-16 12:59  hancmhi  阅读(343)  评论(0编辑  收藏  举报