Unix/Linux编程：通用的IO模型

刺骨的言语ヽ痛彻心扉 2022-10-14 14:57 184阅读 0赞

# 概述 #

*  所有执行IO操作的系统调用都以**文件描述符**，一个非负整数(通常是小整数)来指代打开的文件
 *  文件描述符用以表示所有类型的**已打开文件**，包括管道、FIFO、socket、终端、设备和普通文件
 *  针对每个进程，文件描述符都自成一套

按照管理，大多数程序都期望能够使用三种标准的文件描述符，如下表所示：

*  在程序开始运行前，shell代表程序打开这三个文件描述符。
 *  更确切地说，程序继承了shell文件描述符的副本-----在shell的日常操作中，这3个描述符始终是打开的(在交互式shell中，这3个文件描述符通常指向shell运行所在的终端)。
 *  如果命令行指定对输入/输出进行重定向操作，那么shell会对文件描述符做适当修改，然后再启动程序  
    ![在这里插入图片描述][20210522095526600.png]  
    在程序中指代这些文件描述符时，可以使用数字(0、1、2)表示，或者采用`<unistd.h>`所定义的POSIX标准名称-----更为可取。

> 总结

**文件描述符**

*  对于内核而言，所有打开的文件都通过**文件描述符**引用
    
     *  当打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符
     *  当读/写一个文件时，使用`open`或者`create`返回的文件描述符标识该文件,将其作为参数传递给`read`或者`write`
 *  文件描述符是一个非负整数
    
     *  文件描述符0（`STDIN_FILENO`）与**进程的标准输入**关联
     *  文件描述符1（`STDOUT_FILENO`）与**进程的标准输出**关联
     *  文件描述符2（`STDERR_FILENO`）与**进程的标准错误**关联

# API #

## 打开文件：open ##

这个系统调用在进程和文件之间建立一条连接，这个连接称为文件描述符，他就像一条有进程通往内核的管道：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

NAME
           open - 用来 打开一个 文件或设备
    
    SYNOPSIS 总览
           #include <sys/types.h>
           #include <sys/stat.h>
           #include <fcntl.h>
    
           int open(const char *pathname, int flags);
           int open(const char *pathname, int flags, mode_t mode)
           int openat (int __fd, const char *__file, int __oflag, ...)
           
    
    描述 (DESCRIPTION)
           open()通常用于将[路径名]转换为一个[文件描述符](一个非负的小整数, 在 read, write等[I/O操作中]将会被
                 使用). 当open()调用成功, 它会返回一个新的文件描述符(永远取未用描述符的最小值). 这个调用创建一个
                 新的打开文件, 即分配一个新的独一无 二的文件描述符, 不会与运行中的任何其他程序共享(但可以通过fork(2)
                 系统调用实现共享). 这个新的文件描述符在其后对打开文件操作的函数中使用.(参考 fcntl(2)).  文件的
                 读写指针被置于文件头
    	 
    参数：
    	  参数 pathname 用来标识要打开的文件. 
    	  		 如果 pathname 是一符号链接，会对其进行解引用。
    
          参数 flags 为位掩码，用于指定文件的访问模式
          		 是通过下面枚举值
    				    #include <fcntl.h>
    				    O_RDONLY   只读	     
    				    O_WRONLY   只写  
    				    O_RDWR	   可读可写  
    			 与可选的mode 按位-or 操作得到的：    
    				    O_SEARCH   只搜索（部分系统支持，仅用于目录： 目的在于在目录打开时验证它的搜索权限）
    				    O_CREAT   若文件不存在将 创建 一个 新文件.  当使用此选项时，必须指定第3(open)/4(openat)
    				    				个参数`mode`说明文件权限		
    				              新文件的属主 (用户ID) 被设置为 此程序的有效用户的ID.  
    				              新文件所属分组也被设置为 此程序的有效分组的ID 或者 上层目录的分组ID (这依赖 
    				                     文件系统类型,装载选项和上层目录的模式, 参考,在 mount(8)中描述的ext2
    				                     文件系统的装载选项 bsdgroups 和 sysvgroups )
    				    O_APPEND      文件以 追加  模式 打开 . 在 写 以前 , 文件 读写 指针 被 置 在 文件 的末尾。 
    				                  每次写的时候追加到文件末端
    					O_CLOEXEC     把FD_CLOEXEC常量设置位文件描述符标志    
    					O_DIRECTORY   如果path不是目录，则出错
    					O_EXCL        只执行， 如果同时制定了O_CREAT，而文件已经存在，则出错。用此可以判断文件是否存在 	
    					O_NOCTTY      如果path引用的是终端设备，则不将该设备作为此进程的控制终端
    					O_NOFOLLOW    如果path是一个符号链接，则出错
    					O_NONBLOCK    如果path引用的是一个FIFO，一个块特殊文件或者一个字符特殊文件，则将该文件的本次
    										打开操作以及后续IO操作设置为非阻塞方式	
    					O_NDELAY（不延迟） 和O_NONBLOCK类似，但是如果O_NONBLOCK不能从管道、设备或者FIFO中读（read）
    										取到数据，则立即返回0。 不建议使用，请用 O_NONBLOCK代替
    					O_RDWR		  每次写的时候追加到文件末尾
    					O_TRUNC       如果此文件存在，而且为只读或者读写成功打开，则将其长度截断为0
    					O_TTY_INIT   
    					
    					O_SYNC         使每次write等待物理IO操作完成
    					O_FSYNC      
    					O_ASYNC        使每一个以文件描述符作为参数进行的read操作等待，直到所有对文件同一部分挂起的写操作完成					
    	
    	参数 mode   当调用 open()创建新文件时，mode指定了文件的访问权限
    				注意：mode 只有当在flags中使用O_CREAT时才有效 , 否则 被 忽略
    				注意：新建文件的访问权限不仅仅依赖于参数mode，而且会受到进程的unmask值和(可能存在的)父目录的默认访问控制列表的影响。
    					   
    					   S_IRWXU
    		                     00700 允许 文件 的 属主 读 , 写 和 执行 文件
    	
    				       S_IRUSR (S_IREAD)
    				              00400 允许 文件 的 属主 读 文件
    				
    				       S_IWUSR (S_IWRITE)
    				              00200 允许 文件 的 属主 写 文件
    				
    				       S_IXUSR (S_IEXEC)
    				              00100 允许 文件 的 属主 执行 文件
    				
    				       S_IRWXG
    				              00070 允许 文件 所在 的 分组 读 , 写 和 执行 文件
    				
    				       S_IRGRP
    				              00040 允许 文件 所在 的 分组 读 文件
    				
    				       S_IWGRP
    				              00020 允许 文件 所在 的 分组 写 文件
    				
    				       S_IXGRP
    				              00010 允许 文件 所在 的 分组 执行 文件
    				
    				       S_IRWXO
    				              00007 允许 其他 用户 读 , 写 和 执行 文件
    				
    				       S_IROTH
    				              00004 允许 其他 用户 读 文件
    				
    				       S_IWOTH
    				              00002 允许 其他 用户 写 文件
    
    					   S_IXOTH
    				              00001 允许 其他 用户 执行 文件
    
    					   
    
    
    	参数fd
    		* 如果`path`是绝对路径名，那么不管`fd`填什么，`openat`相当于`open`
    		* 如果`path`是相对路径名，那么`fd`指出了相对路径在文件系统中的开始地址
    
    RETURN VALUE 返回值
            返回 一个 新的 文件描述符 (若是 有 错误 发生 返回 -1 ,并在 errno 设置 错误 信息). 
    	    由`open`和`openat`函数返回的文件描述符一定是最小的未用的描述符数值

### open返回的文件描述符 ###

SUSv3 规定，如果调用 open()成功，必须保证其返回值为进程未用文件描述符中数值最小者。可以利用该特性以特定文件描述符打开某一文件。例如，如下代码序列就会确保使用标准输入（文件描述符 0）打开一文件

int fd;
    
        if (close(STDIN_FILENO) == -1){
        
            perror("close");
            exit(0);
        }
        fd = open("/home/oceanstar/CLionProjects/web_camera/bin/log-2021-05-21.log", O_RDONLY);
        if(fd == -1){
        
            perror("close");
            exit(0);
        }
        printf("%d", fd);  // 0

由于文件描述符 0 未用，所以 open()调用势必使用此描述符打开文件。dup2()和 fcntl()也可实现类似功能，但对于文件描述符的控制更加灵活。

## 创建文件：create ##

在早期的 UNIX 实现中，open()只有两个参数，无法创建新文件，而是使用 creat()系统调用来创建并打开一个新文件

NAME
           open - 用来 打开一个 文件或设备
    
    SYNOPSIS 总览
    		int create (const char *__file, mode_t __mode)
    
    RETURN VALUE 返回值
    		返回 一个 新的 文件描述符 (若是 有 错误 发生 返回 -1 ,并在 errno 设置 错误 信息).

creat()系统调用根据 pathname 参数创建并打开一个文件，若文件已存在，则打开文件，并清空文件内容，将其长度清 0。creat()返回一文件描述符，供后续系统调用使用。

第二个参数mode指定了文件的模式：

create("newfile", 0744);

这个参数只是请求不是命令。内核会通过“新建文件掩码”(file-creation-mask)来得到文件的最终模式。"新建文件掩码"指示哪些位需要被关闭。我们可以通过chmod来改变文件的模式：

chmod("newfile", 04773);
    chmod("newfile", S_ISUID | S_IRGRP);

creat()系统调用等价于如下 open()调用:

open(path, O_TRUNC | O_WRONLY  |O_CREAT, mode )

区别在于`create`只能以只写方式打开创建的文件，而 open()的 flags 参数能对文件打开方式提供更多控制，所以现在大多用open

## 关闭文件：close ##

*  close()系统调用关闭一个打开的文件描述符，并将其释放回调用进程，供该进程继续使用。

*  关闭一个文件时会自动释放该进程加在该文件上的所有记录锁

*  当一进程终止时，将自动关闭其已打开的所有文件描述符

NAME 名字
           close - 关闭一个文件描述符
    
    SYNOPSIS 总览
           #include <unistd.h>
    
           int close(int fd);
    
    DESCRIPTION 描述
           close  关闭 一个 文件 描述符 , 使它不再指向任何文件和可以在新的 文件 操作 中被 再次 使用.  任何 与 此 文件 相关联 的 以及 程序 所 拥有 的锁, 都会被删除 (忽略 那些持有 锁 的 文件描述符)
    
           假如 fd 是 最后 一个 文件描述符 与此 资源 相 关联 , 则 这个 资源 将 被 释放.  若此 描述符 是 最后 一个 引用 到 此 文件 上 的 , 则 文件 将 使用 unlink(2) 删除.
    
    RETURN VALUE 返回值
           close 返回 0 表示 成功 , 或者 -1 表示 有 错误 发生 .
    
    ERRORS 错误信息
           EBADF  fd 不是 一个 有效 的 已 被 打开 的 文件 的 描述符
    
           EINTR  The close() 调用 被 一 信号 中断.
    
           EIO    I/O 有 错误 发生
    
    
    
    NOTES 注意
           通常不检测返回值 , 除了发生严重的程序错误.  文件系统使用了"write-behind" 的 技术提高了执行write(2) 时 的 性能 . 即使 还 没有 被 写 , 写操作 也会 成功 . 错误 信息在 写操作 以后 报告 , 但是 这 保证 在 关闭 文件 时 报告 . 在 关闭 文件 时 不检测 返回值 可能 会 导致 数据 的 丢失 . 这 一点 在 NFS 和 磁盘 配额 上 比较 明显.
    
           由于 内核会延迟写 , 所以就算成功关闭一个文件不能保证数据被成功的写到磁盘上. 当文件流关闭时 , 对文件系统来说一般不去刷新缓冲区 . 如果你要保证数据写入磁盘等物理存贮器中就使用 fsync(2) 或 sync(2), 他们 会 做到 你想做的(对于这一点要依赖于磁盘设备).

显式关闭不再需要的文件描述符往往是良好的编程习惯，会使代码在后续修改时更具可读性，也更可靠。

*  文件描述符属于有限资源，因此文件描述符关闭失败可能会导致一个进程将文件描述符资源消耗殆尽。
 *  在编写需要长期运行并处理大量文件的程序时，比如 shell 或者网络服务器软件，需要特别加以关注。 在必要的时候，注意检测是否关闭成功

## 改变文件偏移量：lseek() ##

Unix每次打开一个文件都会保存一个指针来记录文件的当前位置：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

*  当文件读取数据时，内核从指针所标明的地方开始，读取指定的字节，然后内核会自动移动位置指针，指向下一个未被读取的数据，写操作也是类似的
 *  指针是于文件描述符相关联的，而不是和文件相关联，所以如果两个程序同时打开一个文件，也时会有两个指针，两个程序对文件的读操作不会相互干扰

lseek()可以改变已打开文件的当前位置，新的位置由参数offset 和 whence 指定

### 理论 ###

每个打开文件都有一个与其相关联的”当前文件偏移量“，由系统内核记录

*  它通常是一个非负整数。会以相对于文件头部的起始点的文件当前位置来表示
 *  通常，下一个read()或者write()操作都从当前文件偏移量处开始，并使偏移量增加所读写的字节数
 *  文件第一个字节的偏移量为0
 *  当打开一个文件时，除非指定`O_APPEND`，否则该偏移量设置为0

当然，我们可以显式的设置一个文件偏移量

__off_t lseek (int __fd, __off_t __offset, int __whence)

\_\_offset与\_\_whence有关：

*  如果`__whence`是`SEEK_SET`，则该文件偏移量为距文件开始处`offset`个字节，`offset`可正不可负
 *  如果`__whence`是`SEEK_CUR`，则该文件偏移量为当前值+`offset`，`offset`可正可负
 *  如果`__whence`是`SEEK_END`，则该文件偏移量为距文件结尾处`offset`个字节。也就是说，\_\_offset 参数应该从文件最后一个字节之后的下一个字节算起，`offset`可正可负  
    ![在这里插入图片描述][20210522194541502.png]

返回值：

*  如果`lseek`成功执行，则返回新的文件偏移量。
 *  如果文件描述符指向一个管道、FIFO或者网络套接字，则`lseek`返回-1， 并将`errno`设置为`ESPIPE`

文件打开时，会将文件偏移量设置为指向文件的开始，以后每次read()或者write()调用将自动对其进行调整，以指向已读或者已写数据后的下一字节。因此，连续的read()和write()调用将按照顺序递进，对文件进行操作。

lseek()调用成功会返回新的文件偏移量。下面的调用只是获取文件偏移量的当前位置，并  
没有修改它。

curr = lseek(fd, 0, SEEK_CUR);

> 有些 UNIX 系统（Linux 不在此列）实现了非标准的 tell(fd)函数，其调用目的与上述lseek()相同

![在这里插入图片描述][20210522194842761.png]  
**lseek()调用只是调整内核中与文件描述符相关的文件偏移量记录，并没有引起任何物理设备的访问**。

lseek()并不适用于所有类型的文件。不允许将lseek()应用于管道、FIFO、socket或者终端。一旦如此，调用就会失败，并将errno置为ESPIPE。另一方面，只要合情合理，也可以将lseek()应用于设备。比如，在磁盘或者磁带上查找一处具体位置。

> lseek()调用名中的1源于这样一个事实：offset参数和调用返回值的类型起初都是long型。早期的Unix系统还提供了seek()系统调用，当时这两个值的类型为 int 型。

### 文件空洞 ###

如果程序的文件偏移量已经跨越了文件结尾，然后再执行IO操作，将会发生什么情况？read()调用将返回0，表示文件结尾。有些令人惊讶的是，write()函数可以在文件结尾后的任意位置写入数据。

**从文件结尾后到新写入数据间的这段空洞叫做文件空洞**。从编程的角度来看，文件空洞中是存在字节的，读取空洞将返回以0(空字节)填充的缓冲区

然而，**文件空洞不占用任何磁盘空间。直到后继某个时点，在文件空洞中写入了数据，文件系统才会为之分配磁盘块**。文件空洞的优势在于，与为实际需要的空字节分配磁盘块相比，稀疏填充的文件会占用较少的磁盘空间，核心转储文件(core dump)是包含空洞文件的常见例子。

> 对于文件空洞不占用磁盘空间的说法需要稍微限定一下。在大多数文件系统中，文件空间的分配是以块为单位的。块的大小取决于文件系统，通常是1024字节、2028字节、4096字节。如果空洞的边界落在块内，而非恰好落在块边界上，则会分配一个完整的块来存储数据。块中与空洞相关的部分以空字节填充。

大多数“原生”UNIX 文件系统都支持文件空洞的概念，但很多“非原生”文件系统（比  
如，微软的 VFAT）并不支持这一概念。不支持文件空洞的文件系统会显式的将空字节写入文件。

空洞的存在意味着一个文件名义上的大小可能要比其占用的磁盘空间的存储总量要大(有时会大出很多)。向文件空洞写入字节，内核需要为其分配存储单元，即使文件大小不变，系统的可用磁盘空间也将减少。这种情况并不常见，但也需要了解。

>  *  SUSv3 的函数 posix\_ fallocate(fd, offset, len)规定，针对文件描述符 fd 所指代的文件，  
>     能确保按照由 offset 参数和 len 参数所确定的字节范围为其在磁盘上分配存储空间。这样，  
>     应用程序对文件的后续 write()调用不会因磁盘空间耗尽而失败（否则，当文件中一个空洞  
>     被填满后，或者因其他应用程序消耗了磁盘空间时，都可能因磁盘空间耗尽而引发此类错  
>     误）。
>  *  在过去，glibc 库在实现 posix\_ fallocate()函数时，通过向指定范围内的每个块写入一个值为 0 的字节以达到预期结果。自内核版本 2.6.23 开始，Linux 系统提供了 fallocate()系统调用，能更为高效地确保所需存储空间的分配。当 fallocate()调用可用时，glibc 库会利用其来实现 posix\_ fallocate()函数的功能
>  *  stat()系统调用能够提供文件当前大小和实际分配给文件的块数量等信息

### 实践 ###

#### 测试标准输入被设置偏移量 ####

#include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
        
        if (lseek(STDIN_FILENO, 0, SEEK_CUR) == -1)
            printf("cannot seek\n");
        else
            printf("seek OK\n");
        exit(0);
    }

调用

$ ./apud < /etc/passwd
    seek OK
    $ cat < /etc/passwd | ./apud 
    cannot seek

注意：

*  某些设备可能会有负的偏移量，因此比较lseek的返回值要测试它是否等于-1

#### 创建一个具有空洞的文件 ####

#include "apue.h"
    #include <fcntl.h>
    
    char	buf1[] = "abcdefghij";
    char	buf2[] = "ABCDEFGHIJ";
    
    int
    main(void)
    {
        
        int		fd;
    
        if ((fd = creat("file.hole", FILE_MODE)) < 0)
            err_sys("creat error");
    
        if (write(fd, buf1, 10) != 10)
            err_sys("buf1 write error");
        /* offset now = 10 */
    
        if (lseek(fd, 16384, SEEK_SET) == -1)  // 文件开头0 + 16384
            err_sys("lseek error");
        /* offset now = 16384 */
    
        if (write(fd, buf2, 10) != 10)
            err_sys("buf2 write error");
        /* offset now = 16394 */
    
        exit(0);
    }

运行：

$ ./apud 
    $ od -c file.hole 
    0000000   a   b   c   d   e   f   g   h   i   j  \0  \0  \0  \0  \0  \0
    0000020  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
    *
    0040000   A   B   C   D   E   F   G   H   I   J
    0040012

说明：

*  `lseek`仅将当前的文件偏移量记录在内核中，并不引起任何IO操作，然后，就可以用这个偏移量于下一个读/写操作啦

#### 注销用户 ####

/*logou_tty.c 
     *注销用户，在utemp文件中将指定的tty注销。
     */
    #include <stdio.h>
    #include <utmp.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <time.h>
    #include <sys/types.h>
    #include <string.h>
     
    int logout_tty(char *);
     
    int main(int argc, char **argv)
    {
        
        if (argc==1){
        
            printf("Errro: no tty.\n");
            exit(1);
        }
        else{
        
            while(--argc){
        
                if(logout_tty(*++argv) != -1)
                    printf("Logout:%s\n",*argv);
                else
                    printf("Fail to logout:%s\n",*argv);
            }
        }
        return 0;
    }
     
     
    int logout_tty( char *line )
    {
        
        int         fd;
        struct utmp rec;
        int         len = sizeof(struct utmp);
        int         retval = -1;
     
        if(( fd = open(UTMP_FILE,O_RDWR)) == -1)
            return -1;
     
        while(read(fd, &rec, len) == len){
        
            if(strncmp(rec.ut_line, line, sizeof(rec.ut_line)) == 0) //比较终端名是否相同
            {
        
                rec.ut_type = DEAD_PROCESS; //修改用户为注销的类型DEAD_PROCESS
                /* 将rec.ut_time long 强制转换为time函数接受的time_t类型 */
                if(time((time_t*)(&rec.ut_time)) != -1) //ut_time 时间改为注销时间，即当前时间
                    if(lseek(fd, -len, SEEK_CUR) != -1) //回退： read完了以后fd自动指向下一个utmp，所以要回退一个len
                        if(write(fd, &rec, len) == len) //将修改写入文件
                            retval = 0;
                break;
            }
        }
     
        if(close(fd) == -1)
            retval = -1;
        return retval;
    }

## freopen ##

> 虽然stdin、stdout、stderr变量在程序初始化时用于指代进程的标准输入、标准输出和标准错误，但是调用freopen()库函数可以使这些变量指代其他任何文件对象。这为其标准操作的一部分，freopen()可以将流(stream)重新打开之际一并更换隐匿其中的文件描述符。也就是说，针对stdout调用freopen()函数后，无法保证stdout变量值仍未。

# 应用：cp命令 #

#include <sys/stat.h>
    #include <fcntl.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <zconf.h>
    
    #ifndef BUF_SIZE
    #define BUF_SIZE 1024
    #endif
    
    int main(int argc, char *argv[]){
        
        int inputFd, outputFd, openFlags;
        mode_t filePerms;
        ssize_t numRead;
        char buf[BUF_SIZE];
    
        if(argc != 3 || strcmp(argv[1], "--help") == 0){
        
            fprintf(stderr, "%s old-file new-file\n", argv[0]);
            exit(0);
        }
    
        inputFd = open(argv[1], O_RDONLY);
        if (inputFd == -1){
        
            fprintf(stderr, "opening file %s \n", argv[1]);
            exit(0);
        }
    
        openFlags = O_CREAT | O_WRONLY | O_TRUNC;
        filePerms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
        outputFd = open(argv[2], openFlags, filePerms);
        if (outputFd == -1){
        
            fprintf(stderr, "opening file %s \n", argv[2]);
            exit(0);
        }
    
        while ((numRead = read(inputFd, buf, BUF_SIZE)) > 0){
        
            if (write(outputFd, buf, numRead) != numRead){
        
                fprintf(stderr, "fatal:  couldn't write whole buffer!\n");
                goto _endl;
            }
        }
    
        if(numRead == -1){
        
            fprintf(stderr, "read !\n");
        }
    
    _endl:
        close(inputFd);
        close(outputFd);
    }

使用：

./copy oldfile newfile

UNIX IO模型最显著的特点之一是其输入/输出的通用性概念。这意味着使用4个同样的系统调用open()、read()、write()和close()可以对所有类型的文件执行IO操作，包括终端之类的设备。也就是说，仅使用系统调用编写的程序，对任何类型的文件都是有效的。也就是说：  
![在这里插入图片描述][20210522103637893.png]  
要实现通用IO：

*  必须确保每一个文件系统和设备驱动程序中都实现了相同的IO系统调用集。
 *  由于文件系统或者设备所特有的操作细节都在内核中处理，在编程中通常可以忽略设备专有的因素。
 *  一旦应用程序需要访问文件系统或者设备的专有功能时，可以选择选择瑞士军刀般的ioctl()系统调用，该调用为每一个通用IO模型之外的专有特性提供了访问接口。

[20210522095526600.png]: /images/20221014/a52a9f7c01fe4dc089ffe045621af17c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221014/d17586d699454a4cb08bf35b6f359ebd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20221014/2f91a22f53ba44c38492de8cb069ee7a.png
[20210522194541502.png]: /images/20221014/8b37262af526426f9b7334c42043dcc9.png
[20210522194842761.png]: /images/20221014/dbc224ac0128412c892449098aceae7c.png
[20210522103637893.png]: /images/20221014/49f9554db821472187cb2af485533c29.png