【在Linux世界中追寻伟大的One Piece】IO基础

1 -> 回顾1.1 -> 回顾C文件接口

test.c写文件

代码语言：javascript代码运行次数：0运行复制

#define _CRT_SECURE_NO_WARNINGS 1#include #include int main(){FILE* fp = fopen("myfile", "w");if (!fp) {printf("fopen error!n");}const char* msg = "One Piece!n";int count = 5;while (count--) {fwrite(msg, strlen(msg), 1, fp);}fclose(fp);return 0;}

test.c读文件

代码语言：javascript代码运行次数：0运行复制

#include #include int main(){FILE* fp = fopen("myfile", "r");if (!fp) {printf("fopen error!n");}char buf[1024];const char* msg = "One Piece!n";while (1) {//注意返回值和参数，此处有坑，仔细查看man手册关于该函数的说明size_t s = fread(buf, 1, strlen(msg), fp);if (s > 0) {buf[s] = 0;printf("%s", buf);}if (feof(fp)) {break;}}fclose(fp);return 0;}

输出信息到显示器

代码语言：javascript代码运行次数：0运行复制

#include #include int main(){const char* msg = "hello fwriten";fwrite(msg, strlen(msg), 1, stdout);printf("hello printfn");fprintf(stdout, "hello fprintfn");return 0;}

stdin & stdout & stderr

C默认会打开三个输入输出流，分别是stdin，stdout，stderr。

仔细观察发现，这三个流的类型都是FILE*，fopen返回值类型，文件指针。

1.2 -> 总结

打开文件的方式：

2 -> 系统文件I/O

操作文件，除了上述C接口(当然，C++也有接口，其他语言也有)，我们还可以采用系统接口来进行文件访问，先来直接以代码的形式，实现和上面一模一样的代码：

test.c写文件

代码语言：javascript代码运行次数：0运行复制

#include #include #include #include #include #include int main(){umask(0);int fd = open("myfile", O_WRONLY | O_CREAT, 0644);if (fd < 0) {perror("open");return 1;}int count = 5;const char* msg = "One Piece!n";int len = strlen(msg);while (count--) {write(fd, msg, len);//msg：缓冲区首地址， len: 本次读取，期望写入多少个字节的数据。 返回值：实际写了多少字节数据}close(fd);return 0;}

test.c读文件

代码语言：javascript代码运行次数：0运行复制

#include #include #include #include #include #include int main(){int fd = open("myfile", O_RDONLY);if (fd  0) {printf("%s", buf);}else {break;}}close(fd);return 0;}

3 -> 接口介绍3.1 -> open代码语言：javascript代码运行次数：0运行复制

#include #include #include int open(const char* pathname, int flags);int open(const char* pathname, int flags, mode_t mode);

mode_t理解：直接 man 手册，比什么都清楚。open函数具体使用哪个，和具体应用场景相关，如目标文件不存在，需要open创建，则第三个参数表示创建文件的默认权限,否则，使用两个参数的open。write、read、close、lseek，类比C文件相关接口。3.2 -> open函数返回值

在认识返回值之前，先来认识一下两个概念：系统调用和库函数。

上面的fopen、fclose、fread、fwrite都是C标准库当中的函数，我们称之为库函数(libc)。而open、close、read、write、lseek都属于系统提供的接口，称之为系统调用接口。

系统调用接口和库函数的关系，一目了然。

所以，可以认为，f#系列的函数，都是对系统调用的封装，方便二次开发。

3.3 -> 文件描述符fd

通过对open函数的学习，可以知道文件描述符就是一个小整数。

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

所以输入输出还可以采用如下方式：

代码语言：javascript代码运行次数：0运行复制

#include #include #include #include #include int main(){char buf[1024];size_t s = read(0, buf, sizeof(buf));if (s > 0) {buf[s] = 0;write(1, buf, strlen(buf));write(2, buf, strlen(buf));}return 0;}

而现在知道，文件描述符就是从0开始的小整数。当我们打开文件时，操作系统在内存中要创建相应的数据结构来描述目标文件。于是就有了file结构体。表示一个已经打开的文件对象。而进程执行open系统调用，所以必须让进程和文件关联起来。每个进程都有一个指针*files，指向一张表files_struct，该表最重要的部分就是包涵一个指针数组，每个元素都是一个指向打开文件的指针！所以，本质上，文件描述符就是该数组的下标。所以，只要拿着文件描述符，就可以找到对应的文件。

5 -> 文件描述符的分配规则代码语言：javascript代码运行次数：0运行复制

#include #include #include #include int main(){int fd = open("myfile", O_RDONLY);if (fd < 0) {perror("open");return 1;}printf("fd: %dn", fd);close(fd);return 0;}

输出发现是 fd: 3。

关闭0或者2，在看

代码语言：javascript代码运行次数：0运行复制

#include #include #include #include int main(){close(0);//close(2);int fd = open("myfile", O_RDONLY);if (fd < 0) {perror("open");return 1;}printf("fd: %dn", fd);close(fd);return 0;}

发现是结果是：fd: 0或者fd: 2可见，文件描述符的分配规则：在files_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

6 -> 重定向

那如果关闭1呢？看代码：

代码语言：javascript代码运行次数：0运行复制

#include #include #include #include #include int main(){close(1);int fd = open("myfile", O_WRONLY | O_CREAT, 00644);if (fd < 0) {perror("open");return 1;}printf("fd: %dn", fd);fflush(stdout);close(fd);exit(0);}

此时，我们发现，本来应该输出到显示器上的内容，输出到了文件 myfile 当中，其中，fd＝1。这种现象叫做输出重定向。常见的重定向有：>、>>、

那重定向的本质是什么呢？

7 -> 使用dup2系统调用

函数原型如下：

示例代码：

代码语言：javascript代码运行次数：0运行复制

#include #include #include int main() {int fd = open("./log", O_CREAT | O_RDWR);if (fd < 0) {perror("open");return 1;}close(1);dup2(fd, 1);for (;;) {char buf[1024] = { 0 };ssize_t read_size = read(0, buf, sizeof(buf) - 1);if (read_size < 0) {perror("read");break;}printf("%s", buf);fflush(stdout);}return 0;}

例子1. 在minishell中添加重定向功能：

代码语言：javascript代码运行次数：0运行复制

# include # include # include # include # include char command[MAX_CMD];int do_face(){memset(command, 0x00, MAX_CMD);printf("minishell$ ");fflush(stdout);if (scanf("%[^n]%*c", command) == 0) {getchar();return -1;}return 0;}char** do_parse(char* buff){int argc = 0;static char* argv[32];char* ptr = buff;while (*ptr != '') {if (!isspace(*ptr)) {argv[argc++] = ptr;while ((!isspace(*ptr)) && (*ptr) != '') {ptr++;}}else {while (isspace(*ptr)) {*ptr = '';ptr++;}}}argv[argc] = NULL;return argv;}int do_redirect(char* buff){char* ptr = buff, * file = NULL;int type = 0, fd, redirect_type = -1;while (*ptr != '') {if (*ptr == '>') {*ptr++ = '';redirect_type++;if (*ptr == '>') {*ptr++ = '';redirect_type++;}while (isspace(*ptr)) {ptr++;}file = ptr;while ((!isspace(*ptr)) && *ptr != '') {ptr++;}*ptr = '';if (redirect_type == 0) {fd = open(file, O_CREAT | O_TRUNC | O_WRONLY, 0664);}else {fd = open(file, O_CREAT | O_APPEND | O_WRONLY, 0664);}dup2(fd, 1);}ptr++;}return 0;}int do_exec(char* buff){char** argv = { NULL };int pid = fork();if (pid == 0) {do_redirect(buff);argv = do_parse(buff);if (argv[0] == NULL) {exit(-1);}execvp(argv[0], argv);}else {waitpid(pid, NULL, 0);}return 0;}int main(int argc, char* argv[]){while (1) {if (do_face() < 0)continue;do_exec(command);}return 0;}

printf是C库当中的IO函数，一般往 stdout 中输出，但是stdout底层访问文件的时候，找的还是fd:1，但此时，fd:1下标所表示内容，已经变成了myfile的地址，不再是显示器文件的地址，所以，输出的任何消息都会往文件中写入，进而完成输出重定向。

8 -> FILE因为IO相关函数与系统调用接口对应，并且库函数封装系统调用，所以本质上，访问文件都是通过fd访问的。所以C库当中的FILE结构体内部，必定封装了fd。

来段代码在研究一下：

代码语言：javascript代码运行次数：0运行复制

#include #include int main(){const char* msg0 = "hello printfn";const char* msg1 = "hello fwriten";const char* msg2 = "hello writen";printf("%s", msg0);fwrite(msg1, strlen(msg0), 1, stdout);write(1, msg2, strlen(msg2));fork();return 0;}

运行结果

但如果对进程实现输出重定向呢？./hello > file， 我们发现结果变成了：

我们发现printf和fwrite(库函数)都输出了2次，而write只输出了一次(系统调用)。为什么呢？肯定和fork有关。

一般C库函数写入文件时是全缓冲的，而写入显示器是行缓冲。printf、fwrite库函数会自带缓冲区(进度条例子就可以说明)，当发生重定向到普通文件时，数据的缓冲方式由行缓冲变成了全缓冲。而我们放在缓冲区中的数据，就不会被立即刷新，甚至fork之后。但是进程退出之后，会统一刷新，写入文件当中。但是fork的时候，父子数据会发生写时拷贝，所以当你父进程准备刷新的时候，子进程也就有了同样的一份数据，随即产生两份数据。write没有变化，说明没有所谓的缓冲。

综上：printf、fwrite库函数会自带缓冲区，而 write 系统调用没有带缓冲区。另外，我们这里所说的缓冲区，都是用户级缓冲区。其实为了提升整机性能，OS也会提供相关内核级缓冲区，不过不再我们讨论范围之内。那这个缓冲区谁提供呢？ printf、fwrite是库函数， write是系统调用，库函数在系统调用的”上层”， 是对系统调用的”封装”，但是write没有缓冲区，而printf、fwrite有，足以说明，该缓冲区是二次加上的，又因为是C，所以由C标准库提供。

如果有兴趣，可以看看FILE结构体：

9 -> 理解文件系统

我们使用ls -l的时候看到的除了看到文件名，还看到了文件元数据。

万物追踪

AI 追踪任何你关心的信息

44 查看详情

每行包含7列：

模式硬连接数文件所有者组大小最后修改时间文件名

ls -l读取存储在磁盘上的文件信息，然后显示出来。

其实这个信息除了通过这种方式来读取，还有一个stat命令能够看到更多信息。

上面的执行结果有几个信息需要解释清楚。

inode

为了能解释清楚inode，先简单了解一下文件系统。

Linux ext2文件系统，上图为磁盘文件系统图(内核内存映像肯定有所不同)，磁盘是典型的块设备，硬盘分区被划分为一个个的block。一个block的大小是由格式化的时候确定的，并且不可以更改。例如mke2fs的-b选项可以设定block大小为1024、2048或4096字节。而上图中启动块(Boot Block)的大小是确定的。

Block Group：ext2文件系统会根据分区的大小划分为数个Block Group。而每个Block Group都有着相同的结构组成。超级块(Super Block)：存放文件系统本身的结构信息。记录的信息主要有：bolck 和 inode的总量，未使用的block和inode的数量，一个block和inode的大小，最近一次挂载的时间，最近一次写入数据的时间，最近一次检验磁盘的时间等其他文件系统的相关信息。Super Block的信息被破坏，可以说整个文件系统结构就被破坏了。GDT，Group Descriptor Table：块组描述符，描述块组属性信息。块位图(Block Bitmap)：Block Bitmap中记录着Data Block中哪个数据块已经被占用，哪个数据块没有被占用。inode位图(inode Bitmap)：每个bit表示一个inode是否空闲可用。i节点表：存放文件属性 如 文件大小，所有者，最近修改时间等。数据区：存放文件内容。

将属性和数据分开存放的想法看起来很简单，但实际上是如何工作的呢？我们通过touch一个新文件来看看如何工作。

为了说明问题，将上图简化一下。

创建一个新文件主要有一下4个操作：

1. 存储属性

内核先找到一个空闲的i节点(这里是263466)。内核把文件信息记录到其中。

2. 存储数据

该文件需要存储在三个磁盘块，内核找到了三个空闲块：300，500，800。将内核缓冲区的第一块数据复制到300，下一块复制到500，以此类推。

3. 记录分配情况

文件内容按顺序300，500，800存放。内核在inode上的磁盘分布区记录了上述块列表。

4. 添加文件名到目录

新的文件名abc。linux如何在当前的目录中记录这个文件？内核将入口(263466，abc)添加到目录文件。文件名和inode之间的对应关系将文件名和文件的内容及属性连接起来。

9.1 -> 硬链接

我们看到，真正找到磁盘上文件的并不是文件名，而是inode。 其实在linux中可以让多个文件名对应于同一个inode。 [root@localhost linux]# touch abc [root@localhost linux]# ln abc def [root@localhost linux]# ls -1iabc def 263466 abc 263466 def

abc和def的链接状态完全相同，他们被称为指向文件的硬链接。内核记录了这个连接数，inode 263466 的硬连接数为2。我们在删除文件时干了两件事情：1. 在目录中将对应的记录删除，2. 将硬连接数-1，如果为0，则将对应的磁盘释放。9.2 -> 软链接

硬链接是通过inode引用另外一个文件，软链接是通过名字引用另外一个文件，在shell中的做法。

下面解释一下文件的三个时间：

Access 最后访问时间。Modify 文件内容最后修改时间。Change 属性最后修改时间。10 -> 动态库和静态库 10.1 -> 概念静态库(.a)：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库。动态库(.so)：程序在运行的时候才去链接动态库的代码，多个程序共享使用库的代码。一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码。在可执行文件开始运行以前，外部函数的机器码由操作系统从磁盘上的该动态库中复制到内存中，这个过程称为动态链接(dynamic linking)。动态库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有进程共用，节省了内存和磁盘空间。10.2 -> 生成静态库10.3 -> 库搜索路径从左到右搜索-L指定的目录。由环境变量指定的目录(LIBRARY_PATH)。由系统指定的目录 /usr/lib/usr/local/lib10.4 -> 生成动态库shared：表示生成共享库格式。fPIC：产生位置无关码(position independent code)。库名规则：libxxx.so。

示例： [root@localhost linux]# gcc -fPIC -c sub.c add.c [root@localhost linux]# gcc -shared -o libmymath.so*.o [root@localhost linux]# ls add.c add.h add.o libmymath.so main.c sub.c sub.h sub.o

10.5 -> 使用动态库

编译选项

l：链接动态库，只要库名即可(去掉lib以及版本号)。L：链接库所在的路径。

示例： gcc main.o -o main –L. -lhello

10.6 -> 运行动态库

1. 拷贝.so文件到系统共享库路径下, 一般指/usr/lib。

2. 更改LD_LIBRARY_PATH。

3. ldconfig配置/etc/ld.so.conf.d/，ldconfig更新。

10.7 -> 使用外部库

系统中其实有很多库，它们通常由一组互相关联的用来完成某项常见工作的函数构成。比如用来处理屏幕显示情况的函数(ncurses库)。

-lm表示要链接libm.so或者libm.a库文件。

库文件名称和引入库的名称

如：libc.so -> c库，去掉前缀lib，去掉后缀.so，.a。

以上就是【在Linux世界中追寻伟大的One Piece】IO基础的详细内容，更多请关注创想鸟其它相关文章！