深入理解计算机系统：系统IO

傷城~ 2022-12-30 13:36 290阅读 0赞

# 引入 #

输入/输出 (1 0) 是在**主存和外部设备**（例如磁盘驱动器、终端和网络）之间复制数据的过程

*  输入操作是从 设备复制数据到主存
 *  输出操作是从主存复制数据到 1/0 设备

所有语言的运行时系统都提供执行 的较高级别的工具 例如：

*  ANSI 提供标准库，包含像 printf scanf 这样执行带缓冲区的 函数。
 *  C++ 语言用它的重载操作符 ＜＜ （输入）和＞＞（输出）提供了类似的功能。
 *  在 Linux 系统中，是通过**使用由内核提供的系统级 UnixI/O 函数**来 实现这些较高级别的 I/0 函数的。

大多数时候，高级别函数工作良好，没有必要直接使用 Unix 。那么为什么还要麻烦地学习 Unix I/0 呢？

*  了解 Unix I/0 将帮助你理解其他的系统概念
 *  有时你除了使用 Unix 以外别无选择

## Unix IO ##

> 问： 是什么？

一个Linux文件就是一个m个字节的序列：  
 B 0 ， B 1 , . . . , B k , . . . B m − 1 B\_0，B\_1, ... , B\_k, ... B\_m-1 B0，B1,...,Bk,...Bm−1

所有IO设备（比如网络、磁盘和终端）都被模型化为文件，而所有的输入和输出都被当作对相应文件的读和写来执行。

这种**将设备映射为文件的方式，允许Linux内核引出一个简单、低级的应用接口，叫做Unix IO**。

> 问： 为什么要有**系统IO**？

这使得所有的输入和输出都能以一种统一且一致的方式来执行：

*  **打开文件**。
    
     *  一个应用程序通过要求内核打开相应的文件，来宣告它想要访间一个设备。
     *  内核返回一个小的非负整数，叫做描述符，它在后续对此文件的所有操作中标识这个文件。
     *  内核记录有关这个打开文件的所有信息。应用程序只需记住这个描述符。
     *  **Linux shell创建的每个进程开始时都有三个打开的文件：标准输入（描述符为 0) 、标准输出（描述符为 1) 和标准错误（描述符为 2)**， 头文件 unistd.h> 定义了常 STDIN\_FILENO STOOUT\_FILENO STDERR\_FILENO, 它们可用来代替显式的描述符值
 *  **关闭文件**
    
     *  当应用完成了对文件的访问之后，它就通知**内核**关闭这个文件。
     *  作为响应，**内核释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中**。
     *  无论 个进程因为何种原因终止时，内核都会关闭所有打开的文件并释放它们的内存资源。

## 文件 ##

每个Linux文件都有一个**类型**来表明它在系统中的角色：

*  **普通文件（regular file）**：包含任意数据，应用程序常常要区分**文本文件（text file）和二进制文件（binary file）**
    
     *  文本文件：只包含ASCII或者Unicode字符的普通文件
     *  二进制文件：所有其他的文件
 *  **目录文件(directory)**：包含一组**链接**的文件，其中每个连接都将一个文件名映射到一个文件，这个文件可能是另一个目录。  
    每个目录至少有两个条目：
    
     *  `.`： 该目录到自身的链接
     *  `..`：该目录到父目录的链接
 *  **套接字（socket）文件**：与另一个进程进行跨网络通信的文件
 *  **命名通道**
 *  **符号链接**
 *  **字符/块设备**

Linux内核将所有的文件都组织成一个目录层次结构，系统中的每个目录都是根目录的直接或者间接的后代  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
作为其上下文的一部分，每个进程都有一个**当前工作目录**来确定其在目录层次结构中的当前位置

# 操作 #

## 打开关闭文件 ##

进程是通过调用[open][]函数来打开一个已经存在的文件或者创建一个新文件的

#include <sys/types.h> 
    #include <sys/stat.h> 
    #include <fcntl.h> 	
    /*
    * 返回：若成功则为新文件描述符，若出错为-1
    */
    int open( const char * pathname, int oflags);			
    int open(char *filename, int flags, mode_t mode);

进程通过调用 close 函数关闭一个打开的文件。

#include <unistd.h> 
    int close(int fd);

## 读写文件 ##

应用程序通过调用[read、write][read_write]来执行输入输出

#include <unistd.h>
    /*
    * 功能 ： 从描述符为fd的当前文件位置复制最多n个字节到内存位置buf
    * 参数：
    * 	 fd        文件指针
    * 	 buf       读上来的数据保存在缓冲区buf中，同时文件的当前读写位置向后移
    *    __nbytes  是请求读取的字节数。若参数count 为0, 则read()不会有作用并返回0. 返回值为实际读取到的字节数, 如果返回0
    * 返回值：
    * （1）如果成功，返回读取的字节数；
    * （2）如果出错，返回-1并设置errno；
    * （3）如果在调read函数之前已是文件末尾，则返回0，表示EOF
    */
    ssize_t read (int __fd, void *__buf, size_t __nbytes)
    /*
    *功能： 从内存位置buf中复制最多n个字节到描述符fd的当前文件位置
    * 参数： fd  文件描述符
    * 		buf 指定的缓冲区
    * 		nbyte 要写入文件的指定字节数
    * 返回值： 
    *  (1)成功，返回写入的字节数
    *  (2)写入出错，返回-1
    *  (3)如果写的过程中遇到了中断（缓冲区满了），返回-1并且error=EINTR  （eintr）
    * 		  
    */
    ssize_t write (int __fd, const void *__buf, size_t __n)

## 读取文件元数据 ##

应用程序能够通过[stat、fstat][stat_fstat]，检测到文件的信息(也叫做**文件元数据**)

#include<unistd.h>
    #include<sys/stat.h>
    #include<sys/types.h>
    
    
    struct stat {
        
        dev_t     st_dev;      文件的设备编号
        ino_t     st_ino;      节点
        mode_t    st_mode;     文件的类型和权限
        nlink_t   st_nlink;    连到该文件的硬链接数目，刚建立的文件值为1
        uid_t     st_uid;      用户ID
        gid_t     st_gid;      组ID
        dev_t     st_rdev;     设备类型）若此文件为设备文件，则为其设备编号
        off_t     st_size;     文件字节数（文件大小）
        blksize_t st_blksize;  块大小（文件I/O缓冲区的大小）
        blkcnt_t  st_blocks;   块数
        time_t    st_atime;    最后一次访问时间
        time_t    st_mtime;    最后一次修改时间
        time_t    st_ctime;    最后一次改变时间（指属性）
    };
    
    
    /*
    * 返回值：成功0，失败-1
    */
    int fstat(int fildes, struct stat *buf);
    
    int lstat(const char *pathname, struct stat *buf);
    
    int stat(const char *pathname, struct stat *buf);
    
    int fstat64(int fildes, struct stat64 *buf);
    
    int lstat64(const char *pathname, struct stat64 *buf);
    
    int stat64(const char *pathname, struct stat64 *buf);

## 读取目录内容 ##

进程通过[readdir、opendir 等][readdir_opendir]API操作文件

DIR *opendir (const char *__name)
    struct dirent *readdir (DIR *__dirp)
    int closedir (DIR *__dirp)

## 共享文件 ##

内核用三个相关的数据结构来表示打开的文件：

*  **描述符表(descriptor table)**：每个进程都有它独立的描述符表，它的表项是由进程打开的文件描述符来索引的，每个打开的描述符都指向文件表中的一个表项。
 *  **文件表**：打开文件的集合是由一张文件表来表示的，是由的进程共享这张表。每个文件表的表项组成包括当前的文件位置，**引用计数(即当前指向该表项的描述符表项数)**，以及一个指向v-node表中对应表项的指针。关闭一个描述符会减少相应的文件表表项中的引用计数。内核不会删除这个文件表项，知道它的引用计数为0
 *  **v-node表**：所有进程共享这张表，每个表项包含stat函数的大多数信息。

例子1：描述符0和4通过不同的文件表表项来引用不同的文件，这里没有共享文件，而且每个描述符对应一个不同的文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]  
例子2：多个描述符可以通过不同的文件表表项来引用同一个文件，比如open(同一个文件名)两次。关键思想是每个描述符都有自己的文件位置，所以**对不同描述符的读操作可以从文件的不同位置获取数据**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <zconf.h>
    
    
    int main(int argc, char **argv)
    {
        
        int fd1, fd2;
        char buf1[10], buf2[10];
    
        memset(buf1, 0, 10);
        memset(buf2, 0, 10);
        fd1 = open("b.txt", O_RDONLY);
        fd2 = open("b.txt", O_RDONLY);
        lseek(fd1, -5, SEEK_END);
        read(fd1, buf1, 5);
        read(fd2, buf2, 5);
    
        printf("%s\n", buf1);
        printf("%s\n", buf2);
    
        exit(0);
    }

![在这里插入图片描述][20201228103747161.png]

例子3：父子进程是如何共享文件的。

假设在调用fock之前，父进程有如下所示的打开文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]  
父进程fork之后，子进程有一个父进程描述符的副本，父子进程共享相同的打开文件表集合，因此共享相同的位置  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]  
已知b.txt内容为：foobar

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <zconf.h>
    #include <wait.h>
    
    
    int main(int argc, char **argv)
    {
        
        char *c;
        int fd;
    
        fd = open("b.txt", O_RDONLY, 0);
        if(fork() == 0){
        
            read(fd, &c, 1);
            exit(0);
        }
    
        wait(NULL);
        read(fd, &c, 1);
        printf("c = %c\n", c);
        exit(0);
    }

![在这里插入图片描述][20201228104443670.png]

## IO重定向 ##

如果我们想要进行IO重定向，可以使用[dup][]函数

#include <unistd.h>
    /*
    * 功能：复制一个现有的文件描述符
    * 返回值：失败，返回-1；成功，返回新的文件描述符（当前可用的最小文件描述符）
    */
    /* Duplicate FD, returning a new file descriptor on the same file.  */
    int dup (int __fd)
    /*
    * 功能：复制描述符表项oldfd到newfd，原来newfd会被覆盖。
    * 		如果之前newfd被打开了，dup会先关闭newfd在覆盖
    */
    int dup2 (int oldfd, int newfd2)

[源码][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221120/1a9dae6ba944488ab2eeae8af536f69f.png
[open]: https://blog.csdn.net/zhizhengguan/article/details/111693888
[read_write]: https://blog.csdn.net/zhizhengguan/article/details/111830392
[stat_fstat]: https://blog.csdn.net/zhizhengguan/article/details/111607310
[readdir_opendir]: https://blog.csdn.net/zhizhengguan/article/details/111831355
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201228102242743.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020122810240563.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[20201228103747161.png]: https://img-blog.csdnimg.cn/20201228103747161.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201228103937686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201228104059965.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[20201228104443670.png]: https://img-blog.csdnimg.cn/20201228104443670.png
[dup]: https://blog.csdn.net/zhizhengguan/article/details/110088856
[Link 1]: http://csapp.cs.cmu.edu/3e/code.html