【Linux学习笔记】基础IO

这里写目录标题

1. 系统文件I/O
- 1.1. 接口介绍
- 1.2. 库函数接口与系统接口的关系
2. 文件描述符fd
- 2.1. 0&1&2文件描述符
- 2.2. 文件描述符的分配规则
- 2.3. 重定向
- 2.4. 重定向系统调用
- 2.5. 进程独立性
3. Linux下一切皆文件
4. 缓冲区
- 4.1. 缓冲区的理解
- 4.2. 缓冲区的位置
5. 理解文件系统
- 5.1. 认识磁盘
- 5.2. 文件管理
- 5.3. 分组的管理
6. 软硬连接
- 6.1. 软链接
- 6.2. 硬链接
7. 动静态库
- 7.1. 静态库
- 7.2. 动态库
- 7.3. 动静态库的加载

1. 系统文件I/O

1.1. 接口介绍

在Linux中操作文件，我们可以使用C接口操作，也可以用系统接口来进行文件访问。下面用一段代码介绍一下常见的访问文件的系统接口

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

#define FILE_NAME "log.txt"

int main()
{
    //该进程权限掩码更改为0000
    umask(0);

    //打开一个文件fd，读写，不存在则创建，追加，权限0666
    int fd = open(FILE_NAME, O_RDWR | O_CREAT | O_APPEND, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }

    int cnt = 5;
    char outBuffer[64];
    //向文件fd追加数据                                                                                                                                                                         
    while (cnt)
    {
        //向outBuffer以特定格式写入数据 "aaaa"
        sprintf(outBuffer, "%s:%d\n", "aaaa", cnt--);
        //向打开的文件fd写入
        write(fd, outBuffer, strlen(outBuffer));
    }
    //重置指针位置
    lseek(fd, 0, SEEK_SET);
    char buffer[1024];
    ssize_t num = read(fd, buffer, sizeof(buffer) - 1);
    if (num > 0) buffer[num] = 0; // 0, '\0', NULL -> 0
    printf("%s", buffer);

    close(fd);
    return 0;
}

运行结果：

open

man手册查找open的介绍：

参数：

返回值：

write

man手册查找write的介绍

参数：如上图所示

返回值：写入多少数据就返回多少。

read

1.2. 库函数接口与系统接口的关系

库函数接口与系统接口的关系，可以认为是库函数接口对系统接口做了一层封装，供用户使用。如下所示：

2. 文件描述符fd

2.1. 0&1&2文件描述符

Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入0，标准输出1，标准错误2. 0,1,2对应的物理设备一般是：键盘，显示器，显示器

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

#define FILE_NAME(number) "log.txt"#number

int main()
{
    //打印stdin的文件编号
    printf("stdin->fd: %d\n", stdin->_fileno);
    //打印stdout的文件编号
    printf("stdout->fd: %d\n", stdout->_fileno);
    //打印stderr的文件编号
    printf("stderr->fd: %d\n", stderr->_fileno);

    //打开5个文件
    int fd0 = open(FILE_NAME(1), O_WRONLY | O_CREAT | O_APPEND, 0666);
    int fd1 = open(FILE_NAME(2), O_WRONLY | O_CREAT | O_APPEND, 0666);
    int fd2 = open(FILE_NAME(3), O_WRONLY | O_CREAT | O_APPEND, 0666);
    int fd3 = open(FILE_NAME(4), O_WRONLY | O_CREAT | O_APPEND, 0666);
    int fd4 = open(FILE_NAME(5), O_WRONLY | O_CREAT | O_APPEND, 0666);

    //打印打开文件的文件描述符
    printf("fd: %d\n", fd0);
    printf("fd: %d\n", fd1);
    printf("fd: %d\n", fd2);
    printf("fd: %d\n", fd3);
    printf("fd: %d\n", fd4);

    //关闭文件
    close(fd0);
    close(fd1);
    close(fd2);
    close(fd3);
    close(fd4);

    return 0;
}

运行结果：

一个进程可以打开很多文件，当文件被打开了，就需要被管理，管理的本质就是先描述，再组织。所以文件是这样被管理的。如下图所示：

2.2. 文件描述符的分配规则

如上图所示，默认打开的三个文件流，如果我关闭了0，那么新打开的文件就会从0开始打开。也就是说在files_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

2.3. 重定向

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int main()
{
    //关闭stdout
    close(1);
    //打开1个文件
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    //打印相关文件描述符
    printf("open fd: %d\n", fd); // printf -> stdout

    //刷新缓冲区
    fflush(stdout);

    //关闭文件
    close(fd);
    return 0;
}

运行结果：

原本是在文件描述符3打开的文件，却占用了文件描述符1打开。这种类似重新定义方向的做法，称为重定向。如下图所示：

就是原本1的位置的file* 被 3位置的file* 直接覆盖了，使得1位置的file* 改变了方向。

2.4. 重定向系统调用

输出重定向

操作系统提供了一个系统调用，可以直接实现重定向。

其中我们常用就是dup2接口。对应的参数理解，你可以认为是oldfd直接覆盖了newfd，也就是oldfd重新指定了方向。

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
    //打开1个文件
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }

    //调用系统重定向，把fd重定向到stdin
    //也就是原本显示到显示器上的数据，现在写入到fd中
    dup2(fd,1);
    //打印相关文件描述符
    printf("open fd: %d\n", fd); // printf -> stdout 
                                                                                                                                                                                               
    //刷新缓冲区
    fflush(stdout);

    //关闭文件
    close(fd);
    return 0;
}

运行结果：

这种从显示器到文件的重定向叫做输出重定向。

输入重定向

#include <stdio.h>                                                                                                                                                                             
#include <string.h>    
#include <unistd.h>    
#include <sys/types.h>    
#include <sys/stat.h>    
#include <fcntl.h>    
    
    
int main()    
{    
    //只读方式打开文件    
    int fd = open("log.txt", O_RDONLY);    
    //判断是否打开成功    
    if(fd < 0)    
    {    
        perror("open");    
        return 1;    
    }    
    //输入重定向，也就是说stdin直接读取到fd的内容    
    dup2(fd, 0);    
    
    char line[64];    
    //显示是否读取成功    
    while(1)    
    {    
        printf("> ");    
        if(fgets(line, sizeof(line), stdin) == NULL) break; //stdin->0    
        printf("%s", line);    
    }    
    return 0;    
}

这种从标准输入到文件的重定向叫做输入重定向。

追加重定向

在输入重定向的基础上，将文件打开的模式增加追加，就可以实现追加重定向。

#include <stdio.h>    
#include <string.h>    
#include <unistd.h>    
#include <sys/types.h>    
#include <sys/stat.h>    
#include <fcntl.h>    
    
    
int main()    
{    
    umask(0);    
    //只写方式，不存在则创建，追加，打开文件    
    int fd = open("log.txt", O_WRONLY | O_CREAT |  O_APPEND, 0666);    
    //判断是否打开成功    
    if(fd < 0)    
    {    
        perror("open");    
        return 1;    
    }    
    //输出重定向，也就是说stdout直接输出到fd    
    dup2(fd, 1);                                                                                                                                                                               
    printf("hello world!\n");    
    printf("hello world!\n");    
    printf("hello world!\n");    
    printf("hello world!\n");    
    fflush(stdout);    
    return 0;    
}

运行结果：

2.5. 进程独立性

子进程的重定向并不会影响父进程

有两个进程，一个父进程，一个子进程，操作系统维护着两个task_struct结构体，如上图所示。
每个进程的PCB中都有一个struct files_struct*的指针files。它们各自指向的struct files_struct结构体中都有一个文件描述符表。
两个文件描述符表中的内容在子进程刚创建时是一样的，所以它们都指向相同的被打开的文件。
当子进程将自己文件描述符表中下标为1的文件关闭以后，并不影响父进程文件描述符表中下标为1的数组中的内容。

每个进程都会维护自己的文件描述符表，所以多个进程就会存在多个文件描述符表，但是这些表中的指针指向的被打开文件只有一套。

某个进程进行文件的打开与关闭操作时，只需要修改自己的文件描述符表就可以，不会对其他进程造成任何影响。

3. Linux下一切皆文件

在Linux下一切皆文件，怎么理解呢？先讲讲硬件，如果把硬件看作文件，又该如何理解呢？来看下图：

每一个硬件，操作系统都会维护一个struct file类型的结构体，硬件的各种信息都在这个结构体中，并且还有对应读写函数指针(对硬件的操作主要就是读写)。
每个硬件的具体读写函数的实现方式都在驱动层中，使用到相应的硬件时，操作系统会通过维护的结构体中的函数指针调用相应的读写函数。

站在操作系统的角度来看下层，无论驱动层和硬件层中有什么，在它看来都是struct file结构体，都是通过维护这个结构体来控制各种硬件。
站在操作系统的角度来看上层，无论用户层以及系统调用有什么，在它看来都是一个个进程，都是一个个的task_struct结构体，都是通过维护这个结构体来调度各个进程的。

真正的文件在操作系统中的体现也是结构体，操作系统维护的同样是被打开文件的结构体而不是文件本身。

一切皆文件是指：在操作系统中一切都是结构体。

4. 缓冲区

4.1. 缓冲区的理解

A在海南，B在黑龙江。A想把自己用过的键盘给B用，那么此时有2种方法可以实现。

A自己一路奔波把键盘给到B手上
A选择一家快递公司，把键盘寄给B

很显然，在现实生活中，绝大多数人都会选择2方案，选择一家快递公司进行邮寄。那么同样的，在计算机世界里，道理也是如此。

当你把快递放到快递站的时候，快递站并不会立马就给你寄送过去，而是等到一定的货物量，快递站才会一起寄送快递。这样A就可以在寄送快递这一段时间干自己的事，不用说专门为了给B寄送快递而浪费了自己本来的时间。同样的，计算机世界也是如此，进程给文件发送数据，CPU并不会说专门给文件去发送数据，而其他进程就不管。当进程发送数据给文件时，数据会存放到缓冲区，然后等缓冲区刷新或者缓冲区满发送。

从上面的分析可以得出结论，缓冲区的存在是为了给发送方节省时间。

既然缓冲区的存在是为了给CPU节省时间，那么它的访问速度肯定是比文件要快的多的，所以它只能是内存。所以说，缓冲区本质上就是一段内存。

4.2. 缓冲区的位置

上面讲了缓冲区是一段内存，那么这段内存是谁申请的，它是属于谁的？下面来看一段代码。

运行结果：

首先可以看到父子进程运行同一段代码，但是只有C接口的代码运行了两次，系统接口的代码只运行了一次。那么就是说缓冲区并不在操作系统内核种。

在C语言中，文件相关的接口都涉及到一个FILE*，那么我们就可以猜测缓冲区就在其中。

在Linux源码中，可以看到FILE这个结构体的成员，很多都是在维护缓冲区。所以我们所说的缓冲区都是用户级的缓冲区，都是在用户层面体现出来的。

5. 理解文件系统

5.1. 认识磁盘

如果大家对电脑有过了解，都会知道电脑有个硬件设备叫磁盘，今天我们就来浅浅的认识一下磁盘。

物理结构

磁盘是电脑的外设，是一个机械结构，相对于CPU而言，它是比较慢的。下图是生活中常见的磁盘。

可以看到磁盘好似一个圆柱体，其中这个圆柱体是一片一片摞起来的。

存储结构

磁头：向磁盘中读写数据，如上图中有三个盘片，那么就有六个磁头，给它编号从0到5。
柱面：从俯视图中来看，一个盘面可以看做是多个同心圆，每一个同心圆被叫做一个磁道，一叠盘片中的相同磁道所组成的圆柱就这里的柱面，从内到外给柱面编号从0到3。
扇区：在俯视图中，以相同圆心角将盘片分为多个扇形，每个扇形和每个磁道相交产生的区域就被叫做扇区。一个盘面上每个磁道所包含的扇区个数是相同的，同样给每个扇区编号。

每个扇区的大小可以认为是512KB，看似扇区的面积不同，靠近圆心的较小，但是密度大，远离圆心的面积较大，但是密度较小。

这样一来，我们就可以定位任意一个扇区，然后进行读写数据。比如，0号磁头，0号柱面，0号扇区，此时，磁头就会摆动到0号柱面处，当0号磁头对应的盘面中的0号磁道里的0号扇区旋转到磁头位置时，就可以向磁盘中读写数据。

这种定位方法称为CHS定位法。

逻辑结构

上面的图是不是看起来就像一盘蚊香，假设这个蚊香是可以任意拉伸的。那么我们将这个磁盘拉伸成一条直线，然后将这条直线看成一个数组，数组中的每一个元素就是扇区。

此时，磁盘就被我们抽象成了上图所示的数组，并且给每一个扇区进行编号。站在操作系统的角度，操作系统访问这个数组就是在访问磁盘。

那么这个数组的下标是怎么和磁盘的CHS对应起来的呢？

如上图所示，可以根据给定的逻辑数组下标转换成CHS定位法，定位到磁盘上具体的某个扇区。

5.2. 文件管理

操作系统看到的磁盘就是一个数组，这个数组每个元素的大小是512K字节(一个扇区)，同样我们也知道，每次向磁盘中读写数据都很耗费时间。

为了提高效率，磁头每次访问磁盘的基本单位是4KB(绝大多数情况下)。
即使访问磁盘的一个bit，磁头也是将包过这一个bit在内的周围4KB大小的数据加载到内存。

正因为磁头每次访问的是4KB大小的数据块，所以内存也被划分成了多个4KB大小的空间，每一个空间被叫做页框。

同样的，磁盘中的文件，尤其是可执行文件，也被划分成了多个4KB大小的数据块，每一个块被叫做页帧。

假设现在有一个500GB大小的磁盘，操作系统如果统一管理的话成本会很高，所以采用分治的思想来管理整个磁盘。

将500GB的磁盘分成4个区，只需要管理好一个区，其他三个区便可以复用这套方法。
再将每个区分为多个组，只需要管理好一个组，其他剩下的组便可以复用这套方法，从而管理好这个区。
每个分区以及每个分组是多大要看具体情况。

这种思想有点像递归的思想，所以我们要学习到重点就是如何管理好一个组。

5.3. 分组的管理

每个分组中又分为这6个区域。主要了解5个区域

inode Table：存放了这个分组中所有的inode(已经使用的和没有使用的)，每个分组中inode的个数是确定的。
inode Bitmap：inode位图，该分组中有多少个inode，这个位图就有多少个bit，并且每一个比特位都与一个inode一一对应。每使用一个inode，对应的位图就会被置1。
Data blocks：保存这该分组内，所有文件的内容，该块区又被分为多个数据块。
Block Bitmap：数据块位图，该分组的Data blocks中有多少个数据块，这个位图就有多少个bit，并且每一个比特位都和一个数据块一一对应。每使用一个数据块，对应的位图就会被置1。
GDT描述表：记录该分组中inode和数据块的使用率等宏观属性。

最主要的是inode这个编号，实际上inode是一个结构体，一个文件的所有属性都在inode中。当创建一个文件的时候，就会在inode Table中申请一个未被使用的inode，并且将对应的位图置1.